black

Author: rsln-s

qokit/fur/__init__.py

@@ -82,12 +82,14 @@ def choose_simulator(name="auto", **kwargs):
 
     return get_available_simulators("x")[0]
 
+
 def choose_simulator_xz(name="auto", **kwargs):
     if name != "auto":
         return SIMULATORS["xz"][name]
 
     return get_available_simulators("xz")[0]
 
+
 def choose_simulator_xyring(name="auto", **kwargs):
     if name != "auto":
         return SIMULATORS["xyring"][name]

qokit/fur/c/csim/wrapper.py

@@ -61,6 +61,7 @@ def apply_qaoa_furx(
         n_layers,
     )
 
+
 def apply_qaoa_furxz(
     sv_real: np.ndarray,
     sv_imag: np.ndarray,
@@ -80,13 +81,14 @@ def apply_qaoa_furxz(
         sv_imag,
         np.asarray(gammas, dtype="float"),
         np.asarray(betas, dtype="float"),
-        np.asarray(init_rots, dtype="float"), 
+        np.asarray(init_rots, dtype="float"),
         hc_diag,
         n_qubits,
         n_states,
         n_layers,
     )
 
+
 def furxy(
     sv_real: np.ndarray,
     sv_imag: np.ndarray,

qokit/fur/c/gates.py

@@ -24,6 +24,7 @@ def furx(sv: ComplexArray | np.ndarray, theta: float, q: int) -> ComplexArray:
     csim.furx(sv.real, sv.imag, 0.5 * theta, q)
     return sv
 
+
 def furxz(sv: ComplexArray | np.ndarray, theta: float, init_rots: np.ndarray, q: int) -> ComplexArray:
     """
     apply to a statevector a single-qubit Pauli-XZ rotation defined by
@@ -40,6 +41,7 @@ def furxz(sv: ComplexArray | np.ndarray, theta: float, init_rots: np.ndarray, q:
     csim.furxz(sv.real, sv.imag, 0.5 * theta, init_rots, q)
     return sv
 
+
 def furxy(sv: ComplexArray | np.ndarray, theta: float, q1: int, q2: int) -> ComplexArray:
     """
     apply to a statevector a two-qubit XX+YY rotation defined by

qokit/fur/c/qaoa_simulator.py

@@ -31,24 +31,26 @@ def default_sv0(self):
             np.full(self.n_states, 1.0 / np.sqrt(self.n_states), dtype="float"),
             np.zeros(self.n_states, dtype="float"),
         )
-    
+
     def warmstart_sv0(self, init_rots):
         state = 1.0
-        
+
         for init_rot in init_rots:
-            qubit_state = np.array([
-                np.cos(init_rot/2),
-                np.sin(init_rot/2)
-                # np.exp(-1j * np.pi/2) * np.sin(init_rot/2)
-            ])
+            qubit_state = np.array(
+                [
+                    np.cos(init_rot / 2),
+                    np.sin(init_rot / 2),
+                    # np.exp(-1j * np.pi/2) * np.sin(init_rot/2)
+                ]
+            )
             # state = np.kron(state, qubit_state) #original as GW
             state = np.kron(qubit_state, state)
-        
+
         return ComplexArray(state.real.astype("float"), state.imag.astype("float"))
 
     def _apply_qaoa(self, sv: ComplexArray, gammas: Sequence[float], betas: Sequence[float], **kwargs):
         raise NotImplementedError
-    
+
     def simulate_ws_qaoa(
         self,
         gammas: ParamType,
@@ -67,7 +69,7 @@ def simulate_ws_qaoa(
         sv = ComplexArray(sv0.real.astype("float"), sv0.imag.astype("float")) if sv0 is not None else self.warmstart_sv0(init_rots)
         self._apply_qaoa(sv, list(gammas), list(betas), init_rots, **kwargs)
         return sv
-    
+
     def simulate_qaoa(
         self,
         gammas: ParamType,
@@ -91,13 +93,13 @@ def get_expectation(self, result: ComplexArray, costs: np.ndarray | None = None,
         if optimization_type == "max":
             costs = -1 * np.asarray(costs)
         return np.dot(costs, self.get_probabilities(result, **kwargs))
-    
+
     def get_std(self, result: ComplexArray, costs: np.ndarray | None = None, **kwargs) -> float:
         if costs is None:
             costs = self._hc_diag
         probs = self.get_probabilities(result)
         return np.sqrt(max(np.dot(costs**2, probs) - np.dot(costs, probs) ** 2, 0))
-    
+
     def get_overlap(
         self, result: ComplexArray, costs: CostsType | None = None, indices: np.ndarray | Sequence[int] | None = None, optimization_type="min", **kwargs
     ) -> float:
@@ -135,6 +137,7 @@ def _apply_qaoa(self, sv: ComplexArray, gammas: Sequence[float], betas: Sequence
             self.n_qubits,
         )
 
+
 class QAOAFURXZSimulatorC(QAOAFastSimulatorCBase):
     def _apply_qaoa(self, sv: ComplexArray, gammas: Sequence[float], betas: Sequence[float], init_rots: Sequence[float], **kwargs):
         csim.apply_qaoa_furxz(
@@ -146,7 +149,7 @@ def _apply_qaoa(self, sv: ComplexArray, gammas: Sequence[float], betas: Sequence
             self._hc_diag,
             self.n_qubits,
         )
-        
+
 
 class QAOAFURXYRingSimulatorC(QAOAFastSimulatorCBase):
     def _apply_qaoa(self, sv: ComplexArray, gammas: Sequence[float], betas: Sequence[float], **kwargs):

qokit/fur/python/fur.py

@@ -38,6 +38,7 @@ def furx_all(x: np.ndarray, theta: float, n_qubits: int) -> np.ndarray:
         furx(x, theta, i)
     return x
 
+
 def furxz(x: np.ndarray, theta: float, init_rot: float, q: int) -> np.ndarray:
     """
     Applies e^{-i theta (sin(init_rot) X + cos(init_rot)Z) } on qubit indexed by q
@@ -48,32 +49,35 @@ def furxz(x: np.ndarray, theta: float, init_rot: float, q: int) -> np.ndarray:
     mask1 = (1 << q) - 1
     mask2 = mask1 ^ ((n_states - 1) >> 1)
 
-    cos_beta = math.cos(theta) 
-    sin_beta = math.sin(theta) 
-    
+    cos_beta = math.cos(theta)
+    sin_beta = math.sin(theta)
+
     sin_rot = math.sin(init_rot)
     cos_rot = math.cos(init_rot)
-    
-    
+
     for i in range(n_groups):
         ia = (i & mask1) | ((i & mask2) << 1)
         ib = ia | (1 << q)
         # when phi = 0
-        x[ia], x[ib] = (cos_beta - 1j * cos_rot*sin_beta ) * x[ia] - 1j*sin_rot * sin_beta * x[ib], -1j*sin_rot * sin_beta * x[ia] +  (cos_beta + 1j * cos_rot*sin_beta )* x[ib]
-        
+        x[ia], x[ib] = (cos_beta - 1j * cos_rot * sin_beta) * x[ia] - 1j * sin_rot * sin_beta * x[ib], -1j * sin_rot * sin_beta * x[ia] + (
+            cos_beta + 1j * cos_rot * sin_beta
+        ) * x[ib]
+
         # when phi = -pi/2
         # x[ia], x[ib] = (cos_beta - 1j * cos_rot*sin_beta ) * x[ia] + sin_rot * sin_beta * x[ib], -sin_rot * sin_beta * x[ia] +  (cos_beta + 1j * cos_rot*sin_beta )* x[ib]
-        
+
     return x
-    
-        
+
+
 def furxz_all(x: np.ndarray, theta: float, init_rots: list, n_qubits: int) -> np.ndarray:
     """
     Applies e^{-i theta X} on all qubits
     """
     for i in range(n_qubits):
         furxz(x, theta, init_rots[i], i)
     return x
+
+
 ########################################
 # two-qubit XX+YY rotation
 ########################################

qokit/fur/python/qaoa_fur.py

@@ -22,6 +22,7 @@ def apply_qaoa_furx(sv: np.ndarray, gammas: Sequence[float], betas: Sequence[flo
         sv *= np.exp(-0.5j * np.array(gamma * hc_diag))
         furx_all(sv, beta, n_qubits)
 
+
 def apply_qaoa_furxz(sv: np.ndarray, gammas: Sequence[float], betas: Sequence[float], init_rots: Sequence[float], hc_diag: np.ndarray, n_qubits: int) -> None:
     """
     apply a QAOA with the X mixer defined by
@@ -35,9 +36,10 @@ def apply_qaoa_furxz(sv: np.ndarray, gammas: Sequence[float], betas: Sequence[fl
     """
     for gamma, beta in zip(gammas, betas):
         sv *= np.exp(-0.5j * gamma * hc_diag)
-        assert np.isclose(np.sum(np.abs(sv ** 2)), 1)
+        assert np.isclose(np.sum(np.abs(sv**2)), 1)
         furxz_all(sv, beta, init_rots, n_qubits)
-        
+
+
 def apply_qaoa_furxy_ring(sv: np.ndarray, gammas: Sequence[float], betas: Sequence[float], hc_diag: np.ndarray, n_qubits: int, n_trotters: int = 1) -> None:
     """
     apply a QAOA with the XY-ring mixer defined by

qokit/fur/python/qaoa_simulator.py

@@ -36,23 +36,25 @@ def get_cost_diagonal(self) -> np.ndarray:
     @property
     def default_sv0(self):
         return np.full(self.n_states, 1.0 / np.sqrt(self.n_states), dtype="complex")
-    
+
     def warmstart_sv0(self, init_rots):
         state = 1.0
         for init_rot in init_rots:
-            qubit_state = np.array([
-                np.cos(init_rot/2),
-                # np.exp(-1j*np.pi/2)*np.sin(init_rot/2)
-                np.sin(init_rot/2)
-            ])
+            qubit_state = np.array(
+                [
+                    np.cos(init_rot / 2),
+                    # np.exp(-1j*np.pi/2)*np.sin(init_rot/2)
+                    np.sin(init_rot / 2),
+                ]
+            )
             # state = np.kron(state, qubit_state) #original as GW
             state = np.kron(qubit_state, state)
-            
+
         return state
 
     def _apply_qaoa(self, sv: np.ndarray, gammas: Sequence[float], betas: Sequence[float], **kwargs):
         raise NotImplementedError
-    
+
     def simulate_ws_qaoa(
         self,
         gammas: ParamType,
@@ -69,11 +71,11 @@ def simulate_ws_qaoa(
         @return statevector or vector of probabilities
         """
         sv = sv0.astype("complex") if sv0 is not None else self.warmstart_sv0(init_rots).astype("complex")
-        assert np.isclose(np.sum(np.abs(sv ** 2)), 1)
+        assert np.isclose(np.sum(np.abs(sv**2)), 1)
         self._apply_qaoa(sv, list(gammas), list(betas), init_rots, **kwargs)
-        assert np.isclose(np.sum(np.abs(sv ** 2)), 1)
+        assert np.isclose(np.sum(np.abs(sv**2)), 1)
         return sv
-    
+
     def simulate_qaoa(
         self,
         gammas: ParamType,
@@ -106,14 +108,13 @@ def get_expectation(self, result: np.ndarray, costs: np.ndarray | None = None, o
         if optimization_type == "max":
             return -1 * np.dot(costs, np.abs(result) ** 2)
         return np.dot(costs, np.abs(result) ** 2)
-    
+
     def get_std(self, result: np.ndarray, costs: np.ndarray | None = None, **kwargs) -> float:
         if costs is None:
             costs = self._hc_diag
         probs = np.abs(result) ** 2
         return np.sqrt(max(np.dot(costs**2, probs) - np.dot(costs, probs) ** 2, 0))
 
-
     def get_overlap(
         self, result: np.ndarray, costs: CostsType | None = None, indices: np.ndarray | Sequence[int] | None = None, optimization_type="min", **kwargs
     ) -> float:
@@ -145,10 +146,12 @@ class QAOAFURXSimulator(QAOAFastSimulatorPythonBase):
     def _apply_qaoa(self, sv: np.ndarray, gammas: Sequence[float], betas: Sequence[float], **kwargs):
         apply_qaoa_furx(sv, gammas, betas, self._hc_diag, self.n_qubits)
 
+
 class QAOAFURXZSimulator(QAOAFastSimulatorPythonBase):
     def _apply_qaoa(self, sv: np.ndarray, gammas: Sequence[float], betas: Sequence[float], init_rots: Sequence[float], **kwargs):
         apply_qaoa_furxz(sv, gammas, betas, init_rots, self._hc_diag, self.n_qubits)
 
+
 class QAOAFURXYRingSimulator(QAOAFastSimulatorPythonBase):
     def _apply_qaoa(self, sv: np.ndarray, gammas: Sequence[float], betas: Sequence[float], **kwargs):
         n_trotters = kwargs.get("n_trotters", 1)

qokit/qaoa_circuit.py

@@ -127,8 +127,16 @@ def get_qaoa_circuit_from_terms(
         qc.save_statevector()
     return qc
 
+
 def get_ws_qaoa_circuit_from_terms(
-    N: int, terms: Sequence, gammas: Sequence, betas: Sequence, thetas: Sequence, save_statevector: bool = True, qr: QuantumRegister = None, cr: ClassicalRegister = None
+    N: int,
+    terms: Sequence,
+    gammas: Sequence,
+    betas: Sequence,
+    thetas: Sequence,
+    save_statevector: bool = True,
+    qr: QuantumRegister = None,
+    cr: ClassicalRegister = None,
 ):
     """Generates a Qiskit circuit from Hamiltonian terms
 
@@ -189,6 +197,7 @@ def get_ws_qaoa_circuit_from_terms(
         qc.save_statevector()
     return qc
 
+
 def get_parameterized_qaoa_circuit_from_terms(
     N: int,
     terms: Sequence,

qokit/qaoa_circuit_maxcut.py

@@ -40,7 +40,10 @@ def get_qaoa_circuit(G: nx.Graph, gammas: Sequence, betas: Sequence, save_statev
     N = G.number_of_nodes()
     return get_qaoa_circuit_from_terms(N=N, terms=terms[:-1], gammas=gammas, betas=betas, save_statevector=save_statevector, qr=qr, cr=cr)
 
-def get_ws_qaoa_circuit(G: nx.Graph, gammas: Sequence, betas: Sequence, thetas: Sequence, save_statevector: bool = True, qr: QuantumRegister = None, cr: ClassicalRegister = None):
+
+def get_ws_qaoa_circuit(
+    G: nx.Graph, gammas: Sequence, betas: Sequence, thetas: Sequence, save_statevector: bool = True, qr: QuantumRegister = None, cr: ClassicalRegister = None
+):
     """Generates a circuit for weighted MaxCut on graph G.
     Parameters
     ----------