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

qiskit/synthesis/arithmetic/adders/vbe_ripple_carry_adder.py

@@ -1,161 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2017, 2021.
-#
-# 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.
-
-"""Compute the sum of two qubit registers using Classical Addition."""
-
-from __future__ import annotations
-from qiskit.circuit.bit import Bit
-
-from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister, AncillaRegister
-
-
-def adder_ripple_v95(num_state_qubits: int, kind: str = "half") -> QuantumCircuit:
-    r"""The VBE ripple carry adder [1].
-
-    This method uses :math:`4n + O(1)` CCX gates and :math:`4n + 1` CX gates at a depth
-    of :math:`6n - 2` [2].
-
-    This circuit performs inplace addition of two equally-sized quantum registers.
-    As an example, a classical adder circuit that performs full addition (i.e. including
-    a carry-in bit) on two 2-qubit sized registers is as follows:
-
-    .. parsed-literal::
-
-                  ┌────────┐                       ┌───────────┐┌──────┐
-           cin_0: ┤0       ├───────────────────────┤0          ├┤0     ├
-                  │        │                       │           ││      │
-             a_0: ┤1       ├───────────────────────┤1          ├┤1     ├
-                  │        │┌────────┐     ┌──────┐│           ││  Sum │
-             a_1: ┤        ├┤1       ├──■──┤1     ├┤           ├┤      ├
-                  │        ││        │  │  │      ││           ││      │
-             b_0: ┤2 Carry ├┤        ├──┼──┤      ├┤2 Carry_dg ├┤2     ├
-                  │        ││        │┌─┴─┐│      ││           │└──────┘
-             b_1: ┤        ├┤2 Carry ├┤ X ├┤2 Sum ├┤           ├────────
-                  │        ││        │└───┘│      ││           │
-          cout_0: ┤        ├┤3       ├─────┤      ├┤           ├────────
-                  │        ││        │     │      ││           │
-        helper_0: ┤3       ├┤0       ├─────┤0     ├┤3          ├────────
-                  └────────┘└────────┘     └──────┘└───────────┘
-
-
-    Here *Carry* and *Sum* gates correspond to the gates introduced in [1].
-    *Carry_dg* correspond to the inverse of the *Carry* gate. Note that
-    in this implementation the input register qubits are ordered as all qubits from
-    the first input register, followed by all qubits from the second input register.
-    This is different ordering as compared to Figure 2 in [1], which leads to a different
-    drawing of the circuit.
-
-    Args:
-        num_state_qubits: The size of the register.
-        kind: The kind of adder, can be ``"full"`` for a full adder, ``"half"`` for a half
-            adder, or ``"fixed"`` for a fixed-sized adder. A full adder includes both carry-in
-            and carry-out, a half only carry-out, and a fixed-sized adder neither carry-in
-            nor carry-out.
-
-    Raises:
-        ValueError: If ``num_state_qubits`` is lower than 1.
-
-    **References:**
-
-    [1] Vedral et al., Quantum Networks for Elementary Arithmetic Operations, 1995.
-    `arXiv:quant-ph/9511018 <https://arxiv.org/pdf/quant-ph/9511018.pdf>`_
-
-    [2] Cuccaro et al., A new quantum ripple-carry addition circuit, 2004.
-    `arXiv:quant-ph/0410184 <https://arxiv.org/pdf/quant-ph/0410184.pdf>`_
-
-    """
-    if num_state_qubits < 1:
-        raise ValueError("The number of qubits must be at least 1.")
-
-    # define the input registers
-    registers: list[QuantumRegister | list[Bit]] = []
-    if kind == "full":
-        qr_cin = QuantumRegister(1, name="cin")
-        registers.append(qr_cin)
-    else:
-        qr_cin = QuantumRegister(0)
-
-    qr_a = QuantumRegister(num_state_qubits, name="a")
-    qr_b = QuantumRegister(num_state_qubits, name="b")
-
-    registers += [qr_a, qr_b]
-
-    if kind in ["half", "full"]:
-        qr_cout = QuantumRegister(1, name="cout")
-        registers.append(qr_cout)
-    else:
-        qr_cout = QuantumRegister(0)
-
-    if num_state_qubits > 1:
-        qr_help = AncillaRegister(num_state_qubits - 1, name="helper")
-        registers.append(qr_help)
-    else:
-        qr_help = AncillaRegister(0)
-
-    circuit = QuantumCircuit(*registers)
-
-    # the code is simplified a lot if we create a list of all carries and helpers
-    carries = qr_cin[:] + qr_help[:] + qr_cout[:]
-
-    # corresponds to Carry gate in [1]
-    qc_carry = QuantumCircuit(4, name="Carry")
-    qc_carry.ccx(1, 2, 3)
-    qc_carry.cx(1, 2)
-    qc_carry.ccx(0, 2, 3)
-    carry_gate = qc_carry.to_gate()
-    carry_gate_dg = carry_gate.inverse()
-
-    # corresponds to Sum gate in [1]
-    qc_sum = QuantumCircuit(3, name="Sum")
-    qc_sum.cx(1, 2)
-    qc_sum.cx(0, 2)
-    sum_gate = qc_sum.to_gate()
-
-    # handle all cases for the first qubits, depending on whether cin is available
-    i = 0
-    if kind == "half":
-        i += 1
-        circuit.ccx(qr_a[0], qr_b[0], carries[0])
-    elif kind == "fixed":
-        i += 1
-        if num_state_qubits == 1:
-            circuit.cx(qr_a[0], qr_b[0])
-        else:
-            circuit.ccx(qr_a[0], qr_b[0], carries[0])
-
-    for inp, out in zip(carries[:-1], carries[1:]):
-        circuit.append(carry_gate, [inp, qr_a[i], qr_b[i], out])
-        i += 1
-
-    if kind in ["full", "half"]:  # final CX (cancels for the 'fixed' case)
-        circuit.cx(qr_a[-1], qr_b[-1])
-
-    if len(carries) > 1:
-        circuit.append(sum_gate, [carries[-2], qr_a[-1], qr_b[-1]])
-
-    i -= 2
-    for j, (inp, out) in enumerate(zip(reversed(carries[:-1]), reversed(carries[1:]))):
-        if j == 0:
-            if kind == "fixed":
-                i += 1
-            else:
-                continue
-        circuit.append(carry_gate_dg, [inp, qr_a[i], qr_b[i], out])
-        circuit.append(sum_gate, [inp, qr_a[i], qr_b[i]])
-        i -= 1
-
-    if kind in ["half", "fixed"] and num_state_qubits > 1:
-        circuit.ccx(qr_a[0], qr_b[0], carries[0])
-        circuit.cx(qr_a[0], qr_b[0])
-
-    return circuit

qiskit/synthesis/arithmetic/multipliers/__init__.py

@@ -1,16 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2017, 2021.
-#
-# 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.
-
-"""The multiplier circuit library."""
-
-from .hrs_cumulative_multiplier import multiplier_cumulative_h18
-from .rg_qft_multiplier import multiplier_qft_r17

qiskit/synthesis/arithmetic/multipliers/hrs_cumulative_multiplier.py

@@ -1,102 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2017, 2021.
-#
-# 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.
-
-"""Compute the product of two qubit registers using classical multiplication approach."""
-
-from __future__ import annotations
-
-from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister
-
-
-def multiplier_cumulative_h18(
-    num_state_qubits: int, num_result_qubits: int | None = None
-) -> QuantumCircuit:
-    r"""A multiplication circuit to store product of two input registers out-of-place.
-
-    The circuit uses the approach from Ref. [1]. As an example, a multiplier circuit that
-    performs a non-modular multiplication on two 3-qubit sized registers is:
-
-    .. plot::
-        :include-source:
-
-        from qiskit.synthesis.arithmetic import multiplier_cumulative_h18
-
-        num_state_qubits = 3
-        circuit = multiplier_cumulative_h18(num_state_qubits)
-        circuit.draw("mpl")
-
-    Multiplication in this circuit is implemented in a classical approach by performing
-    a series of shifted additions using one of the input registers while the qubits
-    from the other input register act as control qubits for the adders.
-
-    Args:
-        num_state_qubits: The number of qubits in either input register for
-            state :math:`|a\rangle` or :math:`|b\rangle`. The two input
-            registers must have the same number of qubits.
-        num_result_qubits: The number of result qubits to limit the output to.
-            If number of result qubits is :math:`n`, multiplication modulo :math:`2^n` is performed
-            to limit the output to the specified number of qubits. Default
-            value is ``2 * num_state_qubits`` to represent any possible
-            result from the multiplication of the two inputs.
-
-    Raises:
-        ValueError: If ``num_result_qubits`` is given and not valid, meaning not
-            in ``[num_state_qubits, 2 * num_state_qubits]``.
-
-    **References:**
-
-    [1] Häner et al., Optimizing Quantum Circuits for Arithmetic, 2018.
-    `arXiv:1805.12445 <https://arxiv.org/pdf/1805.12445.pdf>`_
-
-    """
-    if num_result_qubits is None:
-        num_result_qubits = 2 * num_state_qubits
-    elif num_result_qubits < num_state_qubits or num_result_qubits > 2 * num_state_qubits:
-        raise ValueError(
-            f"num_result_qubits ({num_result_qubits}) must be in between num_state_qubits "
-            f"({num_state_qubits}) and 2 * num_state_qubits ({2 * num_state_qubits})"
-        )
-
-    # define the registers
-    qr_a = QuantumRegister(num_state_qubits, name="a")
-    qr_b = QuantumRegister(num_state_qubits, name="b")
-    qr_out = QuantumRegister(num_result_qubits, name="out")
-
-    circuit = QuantumCircuit(qr_a, qr_b, qr_out)
-
-    # prepare adder as controlled gate
-    # pylint: disable=cyclic-import
-    from qiskit.circuit.library.arithmetic import HalfAdderGate, ModularAdderGate
-
-    adder = HalfAdderGate(num_state_qubits)
-    controlled_adder = adder.control(annotated=True)
-
-    # build multiplication circuit
-    for i in range(num_state_qubits):
-        excess_qubits = max(0, num_state_qubits + i + 1 - num_result_qubits)
-        if excess_qubits == 0:
-            num_adder_qubits = num_state_qubits
-            this_controlled = controlled_adder
-        else:
-            num_adder_qubits = num_state_qubits - excess_qubits + 1
-            modular = ModularAdderGate(num_adder_qubits)
-            this_controlled = modular.control(annotated=True)
-
-        qr_list = (
-            [qr_a[i]]
-            + qr_b[:num_adder_qubits]
-            + qr_out[i : num_state_qubits + i + 1 - excess_qubits]
-        )
-        circuit.append(this_controlled, qr_list)
-
-    return circuit

qiskit/synthesis/arithmetic/multipliers/rg_qft_multiplier.py

@@ -1,99 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2017, 2021.
-#
-# 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.
-
-"""Compute the product of two qubit registers using QFT."""
-
-from __future__ import annotations
-
-import numpy as np
-
-from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister
-from qiskit.circuit.library.standard_gates import PhaseGate
-from qiskit.circuit.library.basis_change import QFTGate
-
-
-def multiplier_qft_r17(
-    num_state_qubits: int, num_result_qubits: int | None = None
-) -> QuantumCircuit:
-    r"""A QFT multiplication circuit to store product of two input registers out-of-place.
-
-    Multiplication in this circuit is implemented using the procedure of Fig. 3 in [1], where
-    weighted sum rotations are implemented as given in Fig. 5 in [1]. QFT is used on the output
-    register and is followed by rotations controlled by input registers. The rotations
-    transform the state into the product of two input registers in QFT base, which is
-    reverted from QFT base using inverse QFT.
-    For example, on 3 state qubits, a full multiplier is given by:
-
-    .. plot::
-        :include-source:
-
-        from qiskit.synthesis.arithmetic import multiplier_qft_r17
-
-        num_state_qubits = 3
-        circuit = multiplier_qft_r17(num_state_qubits)
-        circuit.draw("mpl")
-
-    Args:
-        num_state_qubits: The number of qubits in either input register for
-            state :math:`|a\rangle` or :math:`|b\rangle`. The two input
-            registers must have the same number of qubits.
-        num_result_qubits: The number of result qubits to limit the output to.
-            If number of result qubits is :math:`n`, multiplication modulo :math:`2^n` is performed
-            to limit the output to the specified number of qubits. Default
-            value is ``2 * num_state_qubits`` to represent any possible
-            result from the multiplication of the two inputs.
-
-    Raises:
-        ValueError: If ``num_result_qubits`` is given and not valid, meaning not
-            in ``[num_state_qubits, 2 * num_state_qubits]``.
-
-    **References:**
-
-    [1] Ruiz-Perez et al., Quantum arithmetic with the Quantum Fourier Transform, 2017.
-    `arXiv:1411.5949 <https://arxiv.org/pdf/1411.5949.pdf>`_
-
-    """
-    # define the registers
-    if num_result_qubits is None:
-        num_result_qubits = 2 * num_state_qubits
-    elif num_result_qubits < num_state_qubits or num_result_qubits > 2 * num_state_qubits:
-        raise ValueError(
-            f"num_result_qubits ({num_result_qubits}) must be in between num_state_qubits "
-            f"({num_state_qubits}) and 2 * num_state_qubits ({2 * num_state_qubits})"
-        )
-
-    qr_a = QuantumRegister(num_state_qubits, name="a")
-    qr_b = QuantumRegister(num_state_qubits, name="b")
-    qr_out = QuantumRegister(num_result_qubits, name="out")
-
-    # build multiplication circuit
-    circuit = QuantumCircuit(qr_a, qr_b, qr_out)
-    qft = QFTGate(num_result_qubits)
-
-    circuit.append(qft, qr_out[:])
-
-    for j in range(1, num_state_qubits + 1):
-        for i in range(1, num_state_qubits + 1):
-            for k in range(1, num_result_qubits + 1):
-                lam = (2 * np.pi) / (2 ** (i + j + k - 2 * num_state_qubits))
-
-                # note: if we can synthesize the QFT without swaps, we can implement this circuit
-                # more efficiently and just apply phase gate on qr_out[(k - 1)] instead
-                circuit.append(
-                    PhaseGate(lam).control(2),
-                    [qr_a[num_state_qubits - j], qr_b[num_state_qubits - i], qr_out[~(k - 1)]],
-                )
-
-    circuit.append(qft.inverse(), qr_out[:])
-
-    return circuit

qiskit/synthesis/evolution/pauli_network.py

@@ -1,80 +0,0 @@
-# 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.
-
-"""Circuit synthesis for pauli evolution gates."""
-
-from __future__ import annotations
-
-from qiskit.circuit import QuantumCircuit
-
-from qiskit._accelerate.synthesis.evolution import (
-    pauli_network_synthesis as pauli_network_synthesis_inner,
-)
-
-
-def synth_pauli_network_rustiq(
-    num_qubits: int,
-    pauli_network: list,
-    optimize_count: bool = True,
-    preserve_order: bool = True,
-    upto_clifford: bool = False,
-    upto_phase: bool = False,
-    resynth_clifford_method: int = 0,
-) -> QuantumCircuit:
-    """
-    Calls Rustiq's pauli network synthesis algorithm.
-
-    The algorithm is described in [1]. The source code (in Rust) is available at
-    https://github.com/smartiel/rustiq-core.
-
-    Args:
-        num_qubits: the number of qubits over which the pauli network is defined.
-        pauli_network: a list of pauli rotations, represented in sparse format: a list of
-            triples such as `[("XX", [0, 3], theta), ("ZZ", [0, 1], 0.1)]`.
-        optimize_count: if `True` the synthesis algorithm will try to optimize the 2-qubit
-            gate count; and if `False` then the 2-qubit depth.
-        preserve_order: whether the order of paulis should be preserved, up to
-            commutativity. If the order is not preserved, the returned circuit will
-            generally not be equivalent to the given pauli network.
-        upto_clifford: if `True`, the final Clifford operator is not synthesized
-            and the returned circuit will generally not be equivalent to the given
-            pauli network. In addition, the argument `upto_phase` would be ignored.
-        upto_phase: if `True`, the global phase of the returned circuit may differ
-             from the global phase of the given pauli network. The argument is ignored
-             when `upto_clifford` is `True`.
-        resynth_clifford_method: describes the strategy to synthesize the final Clifford
-            operator. If `0` a naive approach is used, which doubles the number of gates
-            but preserves the global phase of the circuit. If `1`, the Clifford is
-            resynthesized using Qiskit's greedy Clifford synthesis algorithm. If `2`, it
-            is resynthesized by Rustiq itself. If `upto_phase` is `False`, the naive
-            approach is used, as neither synthesis method preserves the global phase.
-
-    Returns:
-        A circuit implementation of the pauli network.
-
-    References:
-        1. Timothée Goubault de Brugière and Simon Martiel,
-           *Faster and shorter synthesis of Hamiltonian simulation circuits*,
-           `arXiv:2404.03280 [quant-ph] <https://arxiv.org/abs/2404.03280>`_
-
-    """
-    out = pauli_network_synthesis_inner(
-        num_qubits=num_qubits,
-        pauli_network=pauli_network,
-        optimize_count=optimize_count,
-        preserve_order=preserve_order,
-        upto_clifford=upto_clifford,
-        upto_phase=upto_phase,
-        resynth_clifford_method=resynth_clifford_method,
-    )
-    circuit = QuantumCircuit._from_circuit_data(out, add_regs=True)
-    return circuit

qiskit/synthesis/multi_controlled/mcmt_vchain.py

@@ -1,52 +0,0 @@
-# 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/transpiler/passes/optimization/remove_identity_equiv.py

@@ -1,69 +0,0 @@
-# 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.
-
-"""Transpiler pass to drop gates with negligible effects."""
-
-from __future__ import annotations
-
-from qiskit.dagcircuit import DAGCircuit
-from qiskit.transpiler.target import Target
-from qiskit.transpiler.basepasses import TransformationPass
-from qiskit._accelerate.remove_identity_equiv import remove_identity_equiv
-
-
-class RemoveIdentityEquivalent(TransformationPass):
-    r"""Remove gates with negligible effects.
-
-    Removes gates whose effect is close to an identity operation, up to the specified
-    tolerance. Zero qubit gates such as :class:`.GlobalPhaseGate` are not considered
-    by this pass.
-
-    For a cutoff fidelity :math:`f`, this pass removes gates whose average
-    gate fidelity with respect to the identity is below :math:`f`. Concretely,
-    a gate :math:`G` is removed if :math:`\bar F < f` where
-
-    .. math::
-
-        \bar{F} = \frac{1 + F_{\text{process}}}{1 + d},\ 
-
-        F_{\text{process}} = \frac{|\mathrm{Tr}(G)|^2}{d^2}
-
-    where :math:`d = 2^n` is the dimension of the gate for :math:`n` qubits.
-    """
-
-    def __init__(
-        self, *, approximation_degree: float | None = 1.0, target: None | Target = None
-    ) -> None:
-        """Initialize the transpiler pass.
-
-        Args:
-            approximation_degree: The degree to approximate for the equivalence check. This can be a
-                floating point value between 0 and 1, or ``None``. If the value is 1 this does not
-                approximate above floating point precision. For a value < 1 this is used as a scaling
-                factor for the cutoff fidelity. If the value is ``None`` this approximates up to the
-                fidelity for the gate specified in ``target``.
-
-            target: If ``approximation_degree`` is set to ``None`` and a :class:`.Target` is provided
-                for this field the tolerance for determining whether an operation is equivalent to
-                identity will be set to the reported error rate in the target. If
-                ``approximation_degree`` (the default) this has no effect, if
-                ``approximation_degree=None`` it uses the error rate specified in the ``Target`` for
-                the gate being evaluated, and a numeric value other than 1 with ``target`` set is
-                used as a scaling factor of the target's error rate.
-        """
-        super().__init__()
-        self._approximation_degree = approximation_degree
-        self._target = target
-
-    def run(self, dag: DAGCircuit) -> DAGCircuit:
-        remove_identity_equiv(dag, self._approximation_degree, self._target)
-        return dag