qiskit 1.1.1__cp38-abi3-macosx_11_0_arm64.whl → 1.2.0__cp38-abi3-macosx_11_0_arm64.whl

qiskit/synthesis/stabilizer/stabilizer_circuit.py

@@ -68,8 +68,8 @@ def synth_circuit_from_stabilizers(
     circuit = QuantumCircuit(num_qubits)
 
     used = 0
-    for i in range(len(stabilizer_list)):
-        curr_stab = stabilizer_list[i].evolve(Clifford(circuit), frame="s")
+    for i, stabilizer in enumerate(stabilizer_list):
+        curr_stab = stabilizer.evolve(Clifford(circuit), frame="s")
 
         # Find pivot.
         pivot = used
@@ -81,17 +81,17 @@ def synth_circuit_from_stabilizers(
         if pivot == num_qubits:
             if curr_stab.x.any():
                 raise QiskitError(
-                    f"Stabilizer {i} ({stabilizer_list[i]}) anti-commutes with some of "
+                    f"Stabilizer {i} ({stabilizer}) anti-commutes with some of "
                     "the previous stabilizers."
                 )
             if curr_stab.phase == 2:
                 raise QiskitError(
-                    f"Stabilizer {i} ({stabilizer_list[i]}) contradicts "
+                    f"Stabilizer {i} ({stabilizer}) contradicts "
                     "some of the previous stabilizers."
                 )
             if curr_stab.z.any() and not allow_redundant:
                 raise QiskitError(
-                    f"Stabilizer {i} ({stabilizer_list[i]}) is a product of the others "
+                    f"Stabilizer {i} ({stabilizer}) is a product of the others "
                     "and allow_redundant is False. Add allow_redundant=True "
                     "to the function call if you want to allow redundant stabilizers."
                 )
@@ -133,7 +133,7 @@ def synth_circuit_from_stabilizers(
             circuit.swap(pivot, used)
 
         # fix sign
-        curr_stab = stabilizer_list[i].evolve(Clifford(circuit), frame="s")
+        curr_stab = stabilizer.evolve(Clifford(circuit), frame="s")
         if curr_stab.phase == 2:
             circuit.x(used)
         used += 1

qiskit/synthesis/stabilizer/stabilizer_decompose.py

@@ -143,7 +143,7 @@ def _calc_pauli_diff_stabilizer(cliff, cliff_target):
     phase.extend(phase_stab)
     phase = np.array(phase, dtype=int)
 
-    A = cliff.symplectic_matrix.astype(int)
+    A = cliff.symplectic_matrix.astype(bool, copy=False)
     Ainv = calc_inverse_matrix(A)
 
     # By carefully writing how X, Y, Z gates affect each qubit, all we need to compute
@@ -166,7 +166,7 @@ def _calc_pauli_diff_stabilizer(cliff, cliff_target):
 
 
 def synth_stabilizer_depth_lnn(stab: StabilizerState) -> QuantumCircuit:
-    """Synthesis of an n-qubit stabilizer state for linear-nearest neighbour connectivity,
+    """Synthesis of an n-qubit stabilizer state for linear-nearest neighbor connectivity,
     in 2-qubit depth :math:`2n+2` and two distinct CX layers, using :class:`.CXGate`\\ s and phase gates
     (:class:`.SGate`, :class:`.SdgGate` or :class:`.ZGate`).
 

qiskit/synthesis/two_qubit/local_invariance.py

@@ -15,17 +15,9 @@
 of two-qubit unitary operators.
 """
 from __future__ import annotations
-from math import sqrt
 import numpy as np
-
-INVARIANT_TOL = 1e-12
-
-# Bell "Magic" basis
-MAGIC = (
-    1.0
-    / sqrt(2)
-    * np.array([[1, 0, 0, 1j], [0, 1j, 1, 0], [0, 1j, -1, 0], [1, 0, 0, -1j]], dtype=complex)
-)
+from qiskit._accelerate.two_qubit_decompose import two_qubit_local_invariants as tqli_rs
+from qiskit._accelerate.two_qubit_decompose import local_equivalence as le_rs
 
 
 def two_qubit_local_invariants(U: np.ndarray) -> np.ndarray:
@@ -44,28 +36,11 @@ def two_qubit_local_invariants(U: np.ndarray) -> np.ndarray:
         Y. Makhlin, Quant. Info. Proc. 1, 243-252 (2002).
         Zhang et al., Phys Rev A. 67, 042313 (2003).
     """
-    U = np.asarray(U)
+    U = np.asarray(U, dtype=complex)
     if U.shape != (4, 4):
         raise ValueError("Unitary must correspond to a two-qubit gate.")
-
-    # Transform to bell basis
-    Um = MAGIC.conj().T.dot(U.dot(MAGIC))
-    # Get determinate since +- one is allowed.
-    det_um = np.linalg.det(Um)
-    M = Um.T.dot(Um)
-    # trace(M)**2
-    m_tr2 = M.trace()
-    m_tr2 *= m_tr2
-
-    # Table II of Ref. 1 or Eq. 28 of Ref. 2.
-    G1 = m_tr2 / (16 * det_um)
-    G2 = (m_tr2 - np.trace(M.dot(M))) / (4 * det_um)
-
-    # Here we split the real and imag pieces of G1 into two so as
-    # to better equate to the Weyl chamber coordinates (c0,c1,c2)
-    # and explore the parameter space.
-    # Also do a FP trick -0.0 + 0.0 = 0.0
-    return np.round([G1.real, G1.imag, G2.real], 12) + 0.0
+    (a, b, c) = tqli_rs(U)
+    return np.array([round(a, 12), round(b, 12), round(c, 12)])
 
 
 def local_equivalence(weyl: np.ndarray) -> np.ndarray:
@@ -83,11 +58,6 @@ def local_equivalence(weyl: np.ndarray) -> np.ndarray:
         but we multiply weyl coordinates by 2 since we are
         working in the reduced chamber.
     """
-    g0_equiv = np.prod(np.cos(2 * weyl) ** 2) - np.prod(np.sin(2 * weyl) ** 2)
-    g1_equiv = np.prod(np.sin(4 * weyl)) / 4
-    g2_equiv = (
-        4 * np.prod(np.cos(2 * weyl) ** 2)
-        - 4 * np.prod(np.sin(2 * weyl) ** 2)
-        - np.prod(np.cos(4 * weyl))
-    )
-    return np.round([g0_equiv, g1_equiv, g2_equiv], 12) + 0.0
+    mat = np.asarray(weyl, dtype=float)
+    (a, b, c) = le_rs(mat)
+    return np.array([round(a, 12), round(b, 12), round(c, 12)])

qiskit/synthesis/two_qubit/two_qubit_decompose.py

@@ -35,7 +35,7 @@ import logging
 
 import numpy as np
 
-from qiskit.circuit import QuantumRegister, QuantumCircuit, Gate
+from qiskit.circuit import QuantumRegister, QuantumCircuit, Gate, CircuitInstruction
 from qiskit.circuit.library.standard_gates import (
     CXGate,
     U3Gate,
@@ -60,7 +60,7 @@ from qiskit.utils.deprecation import deprecate_func
 from qiskit._accelerate import two_qubit_decompose
 
 if TYPE_CHECKING:
-    from qiskit.dagcircuit.dagcircuit import DAGCircuit
+    from qiskit.dagcircuit.dagcircuit import DAGCircuit, DAGOpNode
 
 logger = logging.getLogger(__name__)
 
@@ -116,7 +116,7 @@ def decompose_two_qubit_product_gate(special_unitary_matrix: np.ndarray):
     if deviation > 1.0e-13:
         raise QiskitError(
             "decompose_two_qubit_product_gate: decomposition failed: "
-            "deviation too large: {}".format(deviation)
+            f"deviation too large: {deviation}"
         )
 
     return L, R, phase
@@ -230,13 +230,10 @@ class TwoQubitWeylDecomposition:
         self, *, euler_basis: str | None = None, simplify: bool = False, atol: float = DEFAULT_ATOL
     ) -> QuantumCircuit:
         """Returns Weyl decomposition in circuit form."""
-        circuit_sequence = self._inner_decomposition.circuit(
+        circuit_data = self._inner_decomposition.circuit(
             euler_basis=euler_basis, simplify=simplify, atol=atol
         )
-        circ = QuantumCircuit(2, global_phase=circuit_sequence.global_phase)
-        for name, params, qubits in circuit_sequence:
-            getattr(circ, name)(*params, *qubits)
-        return circ
+        return QuantumCircuit._from_circuit_data(circuit_data)
 
     def actual_fidelity(self, **kwargs) -> float:
         """Calculates the actual fidelity of the decomposed circuit to the input unitary."""
@@ -641,47 +638,58 @@ class TwoQubitBasisDecomposer:
             QiskitError: if ``pulse_optimize`` is True but we don't know how to do it.
         """
 
-        sequence = self._inner_decomposer(
-            np.asarray(unitary, dtype=complex),
-            basis_fidelity,
-            approximate,
-            _num_basis_uses=_num_basis_uses,
-        )
-        q = QuantumRegister(2)
         if use_dag:
-            from qiskit.dagcircuit.dagcircuit import DAGCircuit
+            from qiskit.dagcircuit.dagcircuit import DAGCircuit, DAGOpNode
+
+            sequence = self._inner_decomposer(
+                np.asarray(unitary, dtype=complex),
+                basis_fidelity,
+                approximate,
+                _num_basis_uses=_num_basis_uses,
+            )
+            q = QuantumRegister(2)
 
             dag = DAGCircuit()
             dag.global_phase = sequence.global_phase
             dag.add_qreg(q)
-            for name, params, qubits in sequence:
-                if name == "USER_GATE":
+            for gate, params, qubits in sequence:
+                if gate is None:
                     dag.apply_operation_back(self.gate, tuple(q[x] for x in qubits), check=False)
                 else:
-                    gate = GATE_NAME_MAP[name](*params)
-                    dag.apply_operation_back(gate, tuple(q[x] for x in qubits), check=False)
+                    op = CircuitInstruction.from_standard(
+                        gate, qubits=tuple(q[x] for x in qubits), params=params
+                    )
+                    node = DAGOpNode.from_instruction(op, dag=dag)
+                    dag._apply_op_node_back(node)
             return dag
         else:
-            circ = QuantumCircuit(q, global_phase=sequence.global_phase)
-            for name, params, qubits in sequence:
-                try:
-                    getattr(circ, name)(*params, *qubits)
-                except AttributeError as exc:
-                    if name == "USER_GATE":
-                        circ.append(self.gate, qubits)
-                    elif name == "u3":
-                        gate = U3Gate(*params)
-                        circ.append(gate, qubits)
-                    elif name == "u2":
-                        gate = U2Gate(*params)
-                        circ.append(gate, qubits)
-                    elif name == "u1":
-                        gate = U1Gate(*params)
-                        circ.append(gate, qubits)
+            if getattr(self.gate, "_standard_gate", None):
+                circ_data = self._inner_decomposer.to_circuit(
+                    np.asarray(unitary, dtype=complex),
+                    self.gate,
+                    basis_fidelity,
+                    approximate,
+                    _num_basis_uses=_num_basis_uses,
+                )
+                return QuantumCircuit._from_circuit_data(circ_data)
+            else:
+                sequence = self._inner_decomposer(
+                    np.asarray(unitary, dtype=complex),
+                    basis_fidelity,
+                    approximate,
+                    _num_basis_uses=_num_basis_uses,
+                )
+                q = QuantumRegister(2)
+                circ = QuantumCircuit(q, global_phase=sequence.global_phase)
+                for gate, params, qubits in sequence:
+                    if gate is None:
+                        circ._append(self.gate, qargs=tuple(q[x] for x in qubits))
                     else:
-                        raise QiskitError(f"Unknown gate {name}") from exc
-
-            return circ
+                        inst = CircuitInstruction.from_standard(
+                            gate, qubits=tuple(q[x] for x in qubits), params=params
+                        )
+                        circ._append(inst)
+                return circ
 
     def traces(self, target):
         r"""
@@ -691,98 +699,9 @@ class TwoQubitBasisDecomposer:
         return self._inner_decomposer.traces(target._inner_decomposition)
 
 
-class TwoQubitDecomposeUpToDiagonal:
-    """
-    Class to decompose two qubit unitaries into the product of a diagonal gate
-    and another unitary gate which can be represented by two CX gates instead of the
-    usual three. This can be used when neighboring gates commute with the diagonal to
-    potentially reduce overall CX count.
-    """
-
-    def __init__(self):
-        sy = np.array([[0, -1j], [1j, 0]])
-        self.sysy = np.kron(sy, sy)
-
-    def _u4_to_su4(self, u4):
-        phase_factor = np.conj(np.linalg.det(u4) ** (-1 / u4.shape[0]))
-        su4 = u4 / phase_factor
-        return su4, cmath.phase(phase_factor)
-
-    def _gamma(self, mat):
-        """
-        proposition II.1: this invariant characterizes when two operators in U(4),
-        say u, v, are equivalent up to single qubit gates:
-
-           u ≡ v -> Det(γ(u)) = Det(±(γ(v)))
-        """
-        sumat, _ = self._u4_to_su4(mat)
-        sysy = self.sysy
-        return sumat @ sysy @ sumat.T @ sysy
-
-    def _cx0_test(self, mat):
-        # proposition III.1: zero cx sufficient
-        gamma = self._gamma(mat)
-        evals = np.linalg.eigvals(gamma)
-        return np.all(np.isclose(evals, np.ones(4)))
-
-    def _cx1_test(self, mat):
-        # proposition III.2: one cx sufficient
-        gamma = self._gamma(mat)
-        evals = np.linalg.eigvals(gamma)
-        uvals, ucnts = np.unique(np.round(evals, 10), return_counts=True)
-        return (
-            len(uvals) == 2
-            and all(ucnts == 2)
-            and all((np.isclose(x, 1j)) or np.isclose(x, -1j) for x in uvals)
-        )
-
-    def _cx2_test(self, mat):
-        # proposition III.3: two cx sufficient
-        gamma = self._gamma(mat)
-        return np.isclose(np.trace(gamma).imag, 0)
-
-    def _real_trace_transform(self, mat):
-        """
-        Determine diagonal gate such that
-
-        U3 = D U2
-
-        Where U3 is a general two-qubit gate which takes 3 cnots, D is a
-        diagonal gate, and U2 is a gate which takes 2 cnots.
-        """
-        a1 = (
-            -mat[1, 3] * mat[2, 0]
-            + mat[1, 2] * mat[2, 1]
-            + mat[1, 1] * mat[2, 2]
-            - mat[1, 0] * mat[2, 3]
-        )
-        a2 = (
-            mat[0, 3] * mat[3, 0]
-            - mat[0, 2] * mat[3, 1]
-            - mat[0, 1] * mat[3, 2]
-            + mat[0, 0] * mat[3, 3]
-        )
-        theta = 0  # arbitrary
-        phi = 0  # arbitrary
-        psi = np.arctan2(a1.imag + a2.imag, a1.real - a2.real) - phi
-        diag = np.diag(np.exp(-1j * np.array([theta, phi, psi, -(theta + phi + psi)])))
-        return diag
-
-    def __call__(self, mat):
-        """do the decomposition"""
-        su4, phase = self._u4_to_su4(mat)
-        real_map = self._real_trace_transform(su4)
-        mapped_su4 = real_map @ su4
-        if not self._cx2_test(mapped_su4):
-            warnings.warn("Unitary decomposition up to diagonal may use an additionl CX gate.")
-        circ = two_qubit_cnot_decompose(mapped_su4)
-        circ.global_phase += phase
-        return real_map.conj(), circ
-
-
 # This weird duplicated lazy structure is for backwards compatibility; Qiskit has historically
 # always made ``two_qubit_cnot_decompose`` available publicly immediately on import, but it's quite
-# expensive to construct, and we want to defer the obejct's creation until it's actually used.  We
+# expensive to construct, and we want to defer the object's creation until it's actually used.  We
 # only need to pass through the public methods that take `self` as a parameter.  Using `__getattr__`
 # doesn't work because it is only called if the normal resolution methods fail.  Using
 # `__getattribute__` is too messy for a simple one-off use object.

qiskit/synthesis/unitary/aqc/cnot_structures.py

@@ -133,7 +133,7 @@ def _get_connectivity(num_qubits: int, connectivity: str) -> dict:
         links = {i: list(range(num_qubits)) for i in range(num_qubits)}
 
     elif connectivity == "line":
-        # Every qubit is connected to its immediate neighbours only.
+        # Every qubit is connected to its immediate neighbors only.
         links = {i: [i - 1, i, i + 1] for i in range(1, num_qubits - 1)}
 
         # first qubit

qiskit/synthesis/unitary/qsd.py

@@ -30,6 +30,7 @@ from qiskit.circuit.library.standard_gates import CXGate
 from qiskit.circuit.library.generalized_gates.uc_pauli_rot import UCPauliRotGate, _EPS
 from qiskit.circuit.library.generalized_gates.ucry import UCRYGate
 from qiskit.circuit.library.generalized_gates.ucrz import UCRZGate
+from qiskit._accelerate.two_qubit_decompose import two_qubit_decompose_up_to_diagonal
 
 
 def qs_decomposition(
@@ -253,7 +254,7 @@ def _apply_a2(circ):
     from qiskit.quantum_info import Operator
     from qiskit.circuit.library.generalized_gates.unitary import UnitaryGate
 
-    decomposer = two_qubit_decompose.TwoQubitDecomposeUpToDiagonal()
+    decomposer = two_qubit_decompose_up_to_diagonal
     ccirc = transpile(circ, basis_gates=["u", "cx", "qsd2q"], optimization_level=0)
     ind2q = []
     # collect 2q instrs
@@ -269,13 +270,14 @@ def _apply_a2(circ):
     # rolling over diagonals
     ind2 = None  # lint
     for ind1, ind2 in zip(ind2q[0:-1:], ind2q[1::]):
-        # get neigboring 2q gates separated by controls
+        # get neighboring 2q gates separated by controls
         instr1 = ccirc.data[ind1]
         mat1 = Operator(instr1.operation).data
         instr2 = ccirc.data[ind2]
         mat2 = Operator(instr2.operation).data
         # rollover
-        dmat, qc2cx = decomposer(mat1)
+        dmat, qc2cx_data = decomposer(mat1)
+        qc2cx = QuantumCircuit._from_circuit_data(qc2cx_data)
         ccirc.data[ind1] = instr1.replace(operation=qc2cx.to_gate())
         mat2 = mat2 @ dmat
         ccirc.data[ind2] = instr2.replace(UnitaryGate(mat2))

qiskit/transpiler/__init__.py

@@ -650,8 +650,6 @@ manner to the "physical" qubits in an actual quantum device.
 .. image:: /source_images/mapping.png
 
 
-
-
 By default, qiskit will do this mapping for you.  The choice of mapping depends on the
 properties of the circuit, the particular device you are targeting, and the optimization
 level that is chosen. The choice of initial layout is extremely important for minimizing the
@@ -684,10 +682,12 @@ Next, for the heuristic stage, 2 passes are used by default:
   :class:`~.SabreLayout` is used to select a layout if a perfect layout isn't found for
   optimization levels 1, 2, and 3.
 - :class:`~.TrivialLayout`: Always used for the layout at optimization level 0.
+
+There are other passes than can be used for the heuristic stage, but are not included in the default
+pipeline, such as:
+
 - :class:`~.DenseLayout`: Finds the sub-graph of the device with greatest connectivity
-  that has the same number of qubits as the circuit. Used for
-  optimization level 1 if there are control flow operations (such as
-  :class:`~.IfElseOp`) present in the circuit.
+  that has the same number of qubits as the circuit.
 
 Let's see what layouts are automatically picked at various optimization levels.  The circuits
 returned by :func:`qiskit.compiler.transpile` are annotated with this initial layout information,
@@ -1277,6 +1277,7 @@ from .basepasses import AnalysisPass, TransformationPass
 from .coupling import CouplingMap
 from .layout import Layout, TranspileLayout
 from .instruction_durations import InstructionDurations
+from .preset_passmanagers import generate_preset_pass_manager
 from .target import Target
 from .target import InstructionProperties
 from .target import QubitProperties

qiskit/transpiler/basepasses.py

@@ -87,7 +87,7 @@ class BasePass(GenericPass, metaclass=MetaPass):
         return hash(self) == hash(other)
 
     @abstractmethod
-    def run(self, dag: DAGCircuit):  # pylint: disable=arguments-differ
+    def run(self, dag: DAGCircuit):  # pylint:disable=arguments-renamed
         """Run a pass on the DAGCircuit. This is implemented by the pass developer.
 
         Args:

qiskit/transpiler/coupling.py

@@ -101,7 +101,7 @@ class CouplingMap:
             raise CouplingError("Physical qubits should be integers.")
         if physical_qubit in self.physical_qubits:
             raise CouplingError(
-                "The physical qubit %s is already in the coupling graph" % physical_qubit
+                f"The physical qubit {physical_qubit} is already in the coupling graph"
             )
         self.graph.add_node(physical_qubit)
         self._dist_matrix = None  # invalidate
@@ -188,9 +188,9 @@ class CouplingMap:
             CouplingError: if the qubits do not exist in the CouplingMap
         """
         if physical_qubit1 >= self.size():
-            raise CouplingError("%s not in coupling graph" % physical_qubit1)
+            raise CouplingError(f"{physical_qubit1} not in coupling graph")
         if physical_qubit2 >= self.size():
-            raise CouplingError("%s not in coupling graph" % physical_qubit2)
+            raise CouplingError(f"{physical_qubit2} not in coupling graph")
         self.compute_distance_matrix()
         res = self._dist_matrix[physical_qubit1, physical_qubit2]
         if res == math.inf:

qiskit/transpiler/instruction_durations.py

@@ -15,8 +15,7 @@ from __future__ import annotations
 from typing import Optional, List, Tuple, Union, Iterable
 
 import qiskit.circuit
-from qiskit.circuit import Barrier, Delay
-from qiskit.circuit import Instruction, ParameterExpression
+from qiskit.circuit import Barrier, Delay, Instruction, ParameterExpression
 from qiskit.circuit.duration import duration_in_dt
 from qiskit.providers import Backend
 from qiskit.transpiler.exceptions import TranspilerError

qiskit/transpiler/layout.py

@@ -98,8 +98,8 @@ class Layout:
             virtual = value1
         else:
             raise LayoutError(
-                "The map (%s -> %s) has to be a (Bit -> integer)"
-                " or the other way around." % (type(value1), type(value2))
+                f"The map ({type(value1)} -> {type(value2)}) has to be a (Bit -> integer)"
+                " or the other way around."
             )
         return virtual, physical
 
@@ -137,7 +137,7 @@ class Layout:
         else:
             raise LayoutError(
                 "The key to remove should be of the form"
-                " Qubit or integer) and %s was provided" % (type(key),)
+                f" Qubit or integer) and {type(key)} was provided"
             )
 
     def __len__(self):
@@ -454,7 +454,7 @@ class TranspileLayout:
     qubits in the circuit as it fits the circuit to the target backend. For example,
     let the input circuit be:
 
-    .. plot:
+    .. plot::
        :include-source:
 
        from qiskit.circuit import QuantumCircuit, QuantumRegister
@@ -469,7 +469,7 @@ class TranspileLayout:
 
     Suppose that during the layout stage the transpiler reorders the qubits to be:
 
-    .. plot:
+    .. plot::
        :include-source:
 
        from qiskit import QuantumCircuit
@@ -497,7 +497,7 @@ class TranspileLayout:
     the transpiler needs to insert swap gates, and the output circuit
     becomes:
 
-    .. plot:
+    .. plot::
        :include-source:
 
        from qiskit import QuantumCircuit

qiskit/transpiler/passes/__init__.py

@@ -91,6 +91,7 @@ Optimizations
    ElidePermutations
    NormalizeRXAngle
    OptimizeAnnotated
+   Split2QUnitaries
 
 Calibration
 =============
@@ -244,6 +245,7 @@ from .optimization import OptimizeCliffords
 from .optimization import ElidePermutations
 from .optimization import NormalizeRXAngle
 from .optimization import OptimizeAnnotated
+from .optimization import Split2QUnitaries
 
 # circuit analysis
 from .analysis import ResourceEstimation