qiskit 1.3.0b1__cp39-abi3-win32.whl → 1.3.0rc2__cp39-abi3-win32.whl

qiskit/synthesis/evolution/suzuki_trotter.py

@@ -15,16 +15,19 @@
 from __future__ import annotations
 
 import inspect
+import typing
 from collections.abc import Callable
-
-import numpy as np
+from itertools import chain
 
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.quantum_info.operators import SparsePauliOp, Pauli
 from qiskit.utils.deprecation import deprecate_arg
 
+from .product_formula import ProductFormula, reorder_paulis
 
-from .product_formula import ProductFormula
+if typing.TYPE_CHECKING:
+    from qiskit.circuit.quantumcircuit import ParameterValueType
+    from qiskit.circuit.library.pauli_evolution import PauliEvolutionGate
 
 
 class SuzukiTrotter(ProductFormula):
@@ -44,7 +47,7 @@ class SuzukiTrotter(ProductFormula):
 
     .. math::
 
-        e^{-it(XX + ZZ)} = e^{-it/2 ZZ}e^{-it XX}e^{-it/2 ZZ} + \mathcal{O}(t^3).
+        e^{-it(XI + ZZ)} = e^{-it/2 XI}e^{-it ZZ}e^{-it/2 XI} + \mathcal{O}(t^3).
 
     References:
         [1]: D. Berry, G. Ahokas, R. Cleve and B. Sanders,
@@ -82,6 +85,7 @@ class SuzukiTrotter(ProductFormula):
             | None
         ) = None,
         wrap: bool = False,
+        preserve_order: bool = True,
     ) -> None:
         """
         Args:
@@ -101,55 +105,111 @@ class SuzukiTrotter(ProductFormula):
                 built.
             wrap: Whether to wrap the atomic evolutions into custom gate objects. This only takes
                 effect when ``atomic_evolution is None``.
+            preserve_order: If ``False``, allows reordering the terms of the operator to
+                potentially yield a shallower evolution circuit. Not relevant
+                when synthesizing operator with a single term.
         Raises:
             ValueError: If order is not even
         """
 
-        if order % 2 == 1:
+        if order > 1 and order % 2 == 1:
             raise ValueError(
                 "Suzuki product formulae are symmetric and therefore only defined "
-                "for even orders."
+                f"for when the order is 1 or even, not {order}."
             )
-        super().__init__(order, reps, insert_barriers, cx_structure, atomic_evolution, wrap)
+        super().__init__(
+            order,
+            reps,
+            insert_barriers,
+            cx_structure,
+            atomic_evolution,
+            wrap,
+            preserve_order=preserve_order,
+        )
+
+    def expand(
+        self, evolution: PauliEvolutionGate
+    ) -> list[tuple[str, list[int], ParameterValueType]]:
+        """Expand the Hamiltonian into a Suzuki-Trotter sequence of sparse gates.
+
+        For example, the Hamiltonian ``H = IX + ZZ`` for an evolution time ``t`` and
+        1 repetition for an order 2 formula would get decomposed into a list of 3-tuples
+        containing ``(pauli, indices, rz_rotation_angle)``, that is:
+
+        .. code-block:: text
+
+            ("X", [0], t), ("ZZ", [0, 1], 2t), ("X", [0], 2)
+
+        Note that the rotation angle contains a factor of 2, such that that evolution
+        of a Pauli :math:`P` over time :math:`t`, which is :math:`e^{itP}`, is represented
+        by ``(P, indices, 2 * t)``.
+
+        For ``N`` repetitions, this sequence would be repeated ``N`` times and the coefficients
+        divided by ``N``.
 
-    def synthesize(self, evolution):
-        # get operators and time to evolve
-        operators = evolution.operator
+        Args:
+            evolution: The evolution gate to expand.
+
+        Returns:
+            The Pauli network implementing the Trotter expansion.
+        """
+        operators = evolution.operator  # type: SparsePauliOp | list[SparsePauliOp]
         time = evolution.time
 
-        if not isinstance(operators, list):
-            pauli_list = [(Pauli(op), np.real(coeff)) for op, coeff in operators.to_list()]
-        else:
-            pauli_list = [(op, 1) for op in operators]
+        def to_sparse_list(operator):
+            paulis = (time * (2 / self.reps) * operator).to_sparse_list()
+            if not self.preserve_order:
+                return reorder_paulis(paulis)
 
-        ops_to_evolve = self._recurse(self.order, time / self.reps, pauli_list)
+            return paulis
 
         # construct the evolution circuit
-        single_rep = QuantumCircuit(operators[0].num_qubits)
+        if isinstance(operators, list):  # already sorted into commuting bits
+            non_commuting = [to_sparse_list(operator) for operator in operators]
+        else:
+            # Assume no commutativity here. If we were to group commuting Paulis,
+            # here would be the location to do so.
+            non_commuting = [[op] for op in to_sparse_list(operators)]
+
+        # normalize coefficients, i.e. ensure they are float or ParameterExpression
+        non_commuting = self._normalize_coefficients(non_commuting)
 
-        for i, (op, coeff) in enumerate(ops_to_evolve):
-            self.atomic_evolution(single_rep, op, coeff)
-            if self.insert_barriers and i != len(ops_to_evolve) - 1:
-                single_rep.barrier()
+        # we're already done here since Lie Trotter does not do any operator repetition
+        product_formula = self._recurse(self.order, non_commuting)
+        flattened = self.reps * list(chain.from_iterable(product_formula))
 
-        return single_rep.repeat(self.reps, insert_barriers=self.insert_barriers).decompose()
+        return flattened
 
     @staticmethod
-    def _recurse(order, time, pauli_list):
+    def _recurse(order, grouped_paulis):
         if order == 1:
-            return pauli_list
+            return grouped_paulis
 
         elif order == 2:
-            halves = [(op, coeff * time / 2) for op, coeff in pauli_list[:-1]]
-            full = [(pauli_list[-1][0], time * pauli_list[-1][1])]
+            halves = [
+                [(label, qubits, coeff / 2) for label, qubits, coeff in paulis]
+                for paulis in grouped_paulis[:-1]
+            ]
+            full = [grouped_paulis[-1]]
             return halves + full + list(reversed(halves))
 
         else:
             reduction = 1 / (4 - 4 ** (1 / (order - 1)))
             outer = 2 * SuzukiTrotter._recurse(
-                order - 2, time=reduction * time, pauli_list=pauli_list
+                order - 2,
+                [
+                    [(label, qubits, coeff * reduction) for label, qubits, coeff in paulis]
+                    for paulis in grouped_paulis
+                ],
             )
             inner = SuzukiTrotter._recurse(
-                order - 2, time=(1 - 4 * reduction) * time, pauli_list=pauli_list
+                order - 2,
+                [
+                    [
+                        (label, qubits, coeff * (1 - 4 * reduction))
+                        for label, qubits, coeff in paulis
+                    ]
+                    for paulis in grouped_paulis
+                ],
             )
             return outer + inner + outer

qiskit/synthesis/multi_controlled/__init__.py

@@ -12,6 +12,7 @@
 
 """Module containing multi-controlled circuits synthesis"""
 
+from .mcmt_vchain import synth_mcmt_vchain
 from .mcx_synthesis import (
     synth_mcx_n_dirty_i15,
     synth_mcx_n_clean_m15,

qiskit/synthesis/multi_controlled/mcmt_vchain.py

@@ -0,0 +1,52 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2024.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Synthesis for multiple-control, multiple-target Gate."""
+
+from __future__ import annotations
+
+from qiskit.circuit import QuantumCircuit, Gate
+from qiskit._accelerate.synthesis.multi_controlled import mcmt_v_chain
+
+
+def synth_mcmt_vchain(
+    gate: Gate, num_ctrl_qubits: int, num_target_qubits: int, ctrl_state: int | None = None
+) -> QuantumCircuit:
+    """Synthesize MCMT using a V-chain.
+
+    This uses a chain of CCX gates, using ``num_ctrl_qubits - 1`` auxiliary qubits.
+
+    For example, a 3-control and 2-target H gate will be synthesized as::
+
+        q_0: ──■────────────────────────■──
+               │                        │
+        q_1: ──■────────────────────────■──
+               │                        │
+        q_2: ──┼────■──────────────■────┼──
+               │    │  ┌───┐       │    │
+        q_3: ──┼────┼──┤ H ├───────┼────┼──
+               │    │  └─┬─┘┌───┐  │    │
+        q_4: ──┼────┼────┼──┤ H ├──┼────┼──
+             ┌─┴─┐  │    │  └─┬─┘  │  ┌─┴─┐
+        q_5: ┤ X ├──■────┼────┼────■──┤ X ├
+             └───┘┌─┴─┐  │    │  ┌─┴─┐└───┘
+        q_6: ─────┤ X ├──■────■──┤ X ├─────
+                  └───┘          └───┘
+
+    """
+    if gate.num_qubits != 1:
+        raise ValueError("Only single qubit gates are supported as input.")
+
+    circ = QuantumCircuit._from_circuit_data(
+        mcmt_v_chain(gate.control(), num_ctrl_qubits, num_target_qubits, ctrl_state)
+    )
+    return circ

qiskit/synthesis/qft/qft_decompose_full.py

@@ -14,6 +14,7 @@ Circuit synthesis for a QFT circuit.
 """
 
 from __future__ import annotations
+import warnings
 import numpy as np
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 
@@ -54,7 +55,7 @@ def synth_qft_full(
         A circuit implementing the QFT operation.
 
     """
-
+    _warn_if_precision_loss(num_qubits - approximation_degree - 1)
     circuit = QuantumCircuit(num_qubits, name=name)
 
     for j in reversed(range(num_qubits)):
@@ -77,3 +78,20 @@ def synth_qft_full(
         circuit = circuit.inverse()
 
     return circuit
+
+
+def _warn_if_precision_loss(max_num_entanglements):
+    """Issue a warning if constructing the circuit will lose precision.
+
+    If we need an angle smaller than ``pi * 2**-1022``, we start to lose precision by going into
+    the subnormal numbers.  We won't lose _all_ precision until an exponent of about 1075, but
+    beyond 1022 we're using fractional bits to represent leading zeros.
+    """
+    if max_num_entanglements > -np.finfo(float).minexp:  # > 1022 for doubles.
+        warnings.warn(
+            "precision loss in QFT."
+            f" The rotation needed to represent {max_num_entanglements} entanglements"
+            " is smaller than the smallest normal floating-point number.",
+            category=RuntimeWarning,
+            stacklevel=4,
+        )

qiskit/synthesis/qft/qft_decompose_lnn.py

@@ -16,6 +16,7 @@ Circuit synthesis for a QFT circuit.
 import numpy as np
 from qiskit.circuit import QuantumCircuit
 from qiskit.synthesis.permutation.permutation_reverse_lnn import _append_reverse_permutation_lnn_kms
+from .qft_decompose_full import _warn_if_precision_loss
 
 
 def synth_qft_line(
@@ -51,7 +52,7 @@ def synth_qft_line(
            Quantum Info. Comput. 4, 4 (July 2004), 237–251.
            `arXiv:quant-ph/0402196 [quant-ph] <https://arxiv.org/abs/quant-ph/0402196>`_
     """
-
+    _warn_if_precision_loss(num_qubits - approximation_degree - 1)
     qc = QuantumCircuit(num_qubits)
 
     for i in range(num_qubits):

qiskit/synthesis/stabilizer/stabilizer_decompose.py

@@ -46,7 +46,8 @@ def synth_stabilizer_layers(
 
     For example, a 5-qubit stabilizer state is decomposed into the following layers:
 
-    .. parsed-literal::
+    .. code-block:: text
+
              ┌─────┐┌─────┐┌─────┐┌─────┐┌────────┐
         q_0: ┤0    ├┤0    ├┤0    ├┤0    ├┤0       ├
              │     ││     ││     ││     ││        │

qiskit/synthesis/two_qubit/two_qubit_decompose.py

@@ -24,8 +24,6 @@ Gambetta, J. M. Validating quantum computers using randomized model circuits.
 arXiv:1811.12926 [quant-ph] (2018).
 """
 from __future__ import annotations
-import cmath
-import math
 import io
 import base64
 import warnings
@@ -91,41 +89,18 @@ def decompose_two_qubit_product_gate(special_unitary_matrix: np.ndarray):
         QiskitError: if decomposition isn't possible.
     """
     special_unitary_matrix = np.asarray(special_unitary_matrix, dtype=complex)
-    # extract the right component
-    R = special_unitary_matrix[:2, :2].copy()
-    detR = R[0, 0] * R[1, 1] - R[0, 1] * R[1, 0]
-    if abs(detR) < 0.1:
-        R = special_unitary_matrix[2:, :2].copy()
-        detR = R[0, 0] * R[1, 1] - R[0, 1] * R[1, 0]
-    if abs(detR) < 0.1:
-        raise QiskitError("decompose_two_qubit_product_gate: unable to decompose: detR < 0.1")
-    R /= np.sqrt(detR)
-
-    # extract the left component
-    temp = np.kron(np.eye(2), R.T.conj())
-    temp = special_unitary_matrix.dot(temp)
-    L = temp[::2, ::2]
-    detL = L[0, 0] * L[1, 1] - L[0, 1] * L[1, 0]
-    if abs(detL) < 0.9:
-        raise QiskitError("decompose_two_qubit_product_gate: unable to decompose: detL < 0.9")
-    L /= np.sqrt(detL)
-    phase = cmath.phase(detL) / 2
+    (L, R, phase) = two_qubit_decompose.decompose_two_qubit_product_gate(special_unitary_matrix)
 
     temp = np.kron(L, R)
     deviation = abs(abs(temp.conj().T.dot(special_unitary_matrix).trace()) - 4)
+
     if deviation > 1.0e-13:
         raise QiskitError(
             "decompose_two_qubit_product_gate: decomposition failed: "
             f"deviation too large: {deviation}"
         )
 
-    return L, R, phase
-
-
-_ipx = np.array([[0, 1j], [1j, 0]], dtype=complex)
-_ipy = np.array([[0, 1], [-1, 0]], dtype=complex)
-_ipz = np.array([[1j, 0], [0, -1j]], dtype=complex)
-_id = np.array([[1, 0], [0, 1]], dtype=complex)
+    return (L, R, phase)
 
 
 class TwoQubitWeylDecomposition:
@@ -239,7 +214,7 @@ class TwoQubitWeylDecomposition:
         """Calculates the actual fidelity of the decomposed circuit to the input unitary."""
         circ = self.circuit(**kwargs)
         trace = np.trace(Operator(circ).data.T.conj() @ self.unitary_matrix)
-        return trace_to_fid(trace)
+        return two_qubit_decompose.trace_to_fid(trace)
 
     def __repr__(self):
         """Represent with enough precision to allow copy-paste debugging of all corner cases"""
@@ -460,40 +435,6 @@ class TwoQubitControlledUDecomposer:
         return circ
 
 
-def Ud(a, b, c):
-    r"""Generates the array :math:`e^{(i a XX + i b YY + i c ZZ)}`"""
-    return np.array(
-        [
-            [cmath.exp(1j * c) * math.cos(a - b), 0, 0, 1j * cmath.exp(1j * c) * math.sin(a - b)],
-            [0, cmath.exp(-1j * c) * math.cos(a + b), 1j * cmath.exp(-1j * c) * math.sin(a + b), 0],
-            [0, 1j * cmath.exp(-1j * c) * math.sin(a + b), cmath.exp(-1j * c) * math.cos(a + b), 0],
-            [1j * cmath.exp(1j * c) * math.sin(a - b), 0, 0, cmath.exp(1j * c) * math.cos(a - b)],
-        ],
-        dtype=complex,
-    )
-
-
-def trace_to_fid(trace):
-    r"""Average gate fidelity is
-
-    .. math::
-
-        \bar{F} = \frac{d + |\mathrm{Tr} (U_\text{target} \cdot U^{\dag})|^2}{d(d+1)}
-
-    M. Horodecki, P. Horodecki and R. Horodecki, PRA 60, 1888 (1999)"""
-    return (4 + abs(trace) ** 2) / 20
-
-
-def rz_array(theta):
-    """Return numpy array for Rz(theta).
-
-    Rz(theta) = diag(exp(-i*theta/2),exp(i*theta/2))
-    """
-    return np.array(
-        [[cmath.exp(-1j * theta / 2.0), 0], [0, cmath.exp(1j * theta / 2.0)]], dtype=complex
-    )
-
-
 class TwoQubitBasisDecomposer:
     """A class for decomposing 2-qubit unitaries into minimal number of uses of a 2-qubit
     basis gate.

qiskit/synthesis/unitary/qsd.py

@@ -47,7 +47,8 @@ def qs_decomposition(
 
     This decomposition is described in Shende et al. [1].
 
-    .. parsed-literal::
+    .. code-block:: text
+
           ┌───┐               ┌───┐     ┌───┐     ┌───┐
          ─┤   ├─       ───────┤ Rz├─────┤ Ry├─────┤ Rz├─────
           │   │    ≃     ┌───┐└─┬─┘┌───┐└─┬─┘┌───┐└─┬─┘┌───┐
@@ -250,14 +251,13 @@ def _get_ucry_cz(nqubits, angles):
 
 
 def _apply_a2(circ):
-    from qiskit.compiler import transpile
     from qiskit.quantum_info import Operator
     from qiskit.circuit.library.generalized_gates.unitary import UnitaryGate
+    from qiskit.transpiler.passes.synthesis import HighLevelSynthesis
 
     decomposer = two_qubit_decompose_up_to_diagonal
-    ccirc = transpile(
-        circ, basis_gates=["u", "cx", "qsd2q"], optimization_level=0, qubits_initially_zero=False
-    )
+    hls = HighLevelSynthesis(basis_gates=["u", "cx", "qsd2q"], qubits_initially_zero=False)
+    ccirc = hls(circ)
     ind2q = []
     # collect 2q instrs
     for i, instruction in enumerate(ccirc.data):

qiskit/transpiler/__init__.py

@@ -106,8 +106,9 @@ also add initial logical optimization prior to routing, you would do something l
 .. code-block:: python
 
     import numpy as np
+    from qiskit.providers.fake_provider import GenericBackendV2
     from qiskit.circuit.library import HGate, PhaseGate, RXGate, TdgGate, TGate, XGate
-    from qiskit.transpiler import PassManager
+    from qiskit.transpiler import PassManager, generate_preset_pass_manager
     from qiskit.transpiler.passes import (
         ALAPScheduleAnalysis,
         CXCancellation,
@@ -115,6 +116,7 @@ also add initial logical optimization prior to routing, you would do something l
         PadDynamicalDecoupling,
     )
 
+    backend = GenericBackendV2(num_qubits=5)
     dd_sequence = [XGate(), XGate()]
     scheduling_pm = PassManager(
         [
@@ -135,6 +137,9 @@ also add initial logical optimization prior to routing, you would do something l
         ]
     )
 
+    pass_manager = generate_preset_pass_manager(
+        optimization_level=0
+    )
 
     # Add pre-layout stage to run extra logical optimization
     pass_manager.pre_layout = logical_opt
@@ -253,7 +258,7 @@ descriptions of the instructions it supports:
     )
     print(target)
 
-.. parsed-literal::
+.. code-block:: text
 
     Target
     Number of qubits: 3
@@ -578,7 +583,7 @@ original.  This can be verified by checking the depth of both circuits:
 
    print('Original depth:', qc.depth(), 'Decomposed Depth:', qc_basis.depth())
 
-.. parsed-literal::
+.. code-block:: text
 
     Original depth: 4 Decomposed Depth: 10
 
@@ -598,7 +603,7 @@ It is important to highlight two special cases:
 
       print(backend.operation_names)
 
-   .. parsed-literal::
+   .. code-block:: text
 
       ['id', 'rz', 'sx', 'x', 'cx', 'measure', 'delay']
 
@@ -1017,7 +1022,7 @@ classical register wires, though theoretically two conditional instructions
 conditioned on the same register could commute, i.e. read-access to the
 classical register doesn't change its state.
 
-.. parsed-literal::
+.. code-block:: text
 
     qc = QuantumCircuit(2, 1)
     qc.delay(100, 0)
@@ -1028,7 +1033,7 @@ The scheduler SHOULD comply with the above topological ordering policy of the
 DAG circuit.
 Accordingly, the `asap`-scheduled circuit will become
 
-.. parsed-literal::
+.. code-block:: text
 
          ┌────────────────┐   ┌───┐
     q_0: ┤ Delay(100[dt]) ├───┤ X ├──────────────
@@ -1055,7 +1060,7 @@ then a discriminated (D) binary value is moved to the classical register (C).
 A sequence from t0 to t1 of the measure instruction interval could be
 modeled as follows:
 
-.. parsed-literal::
+.. code-block:: text
 
     Q ░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░
     B ░░▒▒▒▒▒▒▒▒░░░░░░░░░
@@ -1070,7 +1075,7 @@ and the :class:`.Clbit` is only occupied at the very end of the interval.
 The lack of precision representing the physical model may induce
 edge cases in the scheduling:
 
-.. parsed-literal::
+.. code-block:: text
 
             ┌───┐
     q_0: ───┤ X ├──────
@@ -1089,7 +1094,7 @@ is unchanged during the application of the stimulus, so two nodes are
 simultaneously operated.
 If one tries to `alap`-schedule this circuit, it may return following circuit:
 
-.. parsed-literal::
+.. code-block:: text
 
          ┌────────────────┐   ┌───┐
     q_0: ┤ Delay(500[dt]) ├───┤ X ├──────
@@ -1105,7 +1110,7 @@ It looks like the topological ordering between the nodes is flipped in the
 scheduled view.
 This behavior can be understood by considering the control flow model described above,
 
-.. parsed-literal::
+.. code-block:: text
 
     : Quantum Circuit, first-measure
     0 ░░░░░░░░░░░░▒▒▒▒▒▒░
@@ -1137,7 +1142,7 @@ be copied to the pass manager property set before the pass is called.
 
 Due to default latencies, the `alap`-scheduled circuit of above example may become
 
-.. parsed-literal::
+.. code-block:: text
 
             ┌───┐
     q_0: ───┤ X ├──────
@@ -1151,7 +1156,8 @@ If the backend microarchitecture supports smart scheduling of the control flow
 instructions, such as separately scheduling qubits and classical registers,
 the insertion of the delay yields an unnecessarily longer total execution time.
 
-.. parsed-literal::
+.. code-block:: text
+
     : Quantum Circuit, first-XGate
     0 ░▒▒▒░░░░░░░░░░░░░░░
     1 ░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░
@@ -1168,7 +1174,7 @@ However, this result is much more intuitive in the topological ordering view.
 If a finite conditional latency value is provided, for example, 30 dt, the circuit
 is scheduled as follows:
 
-.. parsed-literal::
+.. code-block:: text
 
          ┌───────────────┐   ┌───┐
     q_0: ┤ Delay(30[dt]) ├───┤ X ├──────
@@ -1180,7 +1186,8 @@ is scheduled as follows:
 
 with the timing model:
 
-.. parsed-literal::
+.. code-block:: text
+
     : Quantum Circuit, first-xgate
     0 ░░▒▒▒░░░░░░░░░░░░░░░
     1 ░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░

qiskit/transpiler/basepasses.py

@@ -201,7 +201,7 @@ class TransformationPass(BasePass):  # pylint: disable=abstract-method
         if state.workflow_status.previous_run == RunState.SUCCESS:
             if isinstance(new_dag, DAGCircuit):
                 # Copy calibration data from the original program
-                new_dag.calibrations = passmanager_ir.calibrations
+                new_dag._calibrations_prop = passmanager_ir._calibrations_prop
             else:
                 raise TranspilerError(
                     "Transformation passes should return a transformed dag."

qiskit/transpiler/passes/__init__.py

@@ -93,6 +93,7 @@ Optimizations
    NormalizeRXAngle
    OptimizeAnnotated
    Split2QUnitaries
+   RemoveIdentityEquivalent
 
 Calibration
 =============
@@ -247,6 +248,7 @@ from .optimization import OptimizeCliffords
 from .optimization import ElidePermutations
 from .optimization import NormalizeRXAngle
 from .optimization import OptimizeAnnotated
+from .optimization import RemoveIdentityEquivalent
 from .optimization import Split2QUnitaries
 
 # circuit analysis