qiskit 2.0.3__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/transpiler/passes/optimization/remove_identity_equiv.py

@@ -0,0 +1,70 @@
+# 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 a global phase
+    and up to the specified tolerance. Parameterized gates 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 + d 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 the 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``. In case no ``target`` is set
+                we approximate up to ``16 * machine_eps`` as default to account for accumulations
+                on few-qubit systems.
+
+            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

qiskit/transpiler/passes/optimization/remove_reset_in_zero_state.py

@@ -0,0 +1,37 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# 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.
+
+"""Remove reset gate when the qubit is in zero state."""
+
+from qiskit.circuit import Reset
+from qiskit.dagcircuit import DAGInNode
+from qiskit.transpiler.basepasses import TransformationPass
+
+
+class RemoveResetInZeroState(TransformationPass):
+    """Remove reset gate when the qubit is in zero state."""
+
+    def run(self, dag):
+        """Run the RemoveResetInZeroState pass on `dag`.
+
+        Args:
+            dag (DAGCircuit): the DAG to be optimized.
+
+        Returns:
+            DAGCircuit: the optimized DAG.
+        """
+        resets = dag.op_nodes(Reset)
+        for reset in resets:
+            predecessor = next(dag.predecessors(reset))
+            if isinstance(predecessor, DAGInNode):
+                dag.remove_op_node(reset)
+        return dag

qiskit/transpiler/passes/optimization/reset_after_measure_simplification.py

@@ -0,0 +1,50 @@
+# 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.
+
+"""Replace resets after measure with a conditional XGate."""
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.passes.utils import control_flow
+from qiskit.circuit import QuantumCircuit
+from qiskit.circuit import IfElseOp
+from qiskit.circuit.reset import Reset
+from qiskit.circuit.measure import Measure
+from qiskit.dagcircuit.dagcircuit import DAGCircuit
+from qiskit.dagcircuit.dagnode import DAGOpNode
+
+
+class ResetAfterMeasureSimplification(TransformationPass):
+    """This pass replaces reset after measure with a conditional X gate.
+
+    This optimization is suitable for use on IBM Quantum systems where the
+    reset operation is performed by a measurement followed by a conditional
+    x-gate. It might not be desirable on other backends if reset is implemented
+    differently.
+    """
+
+    @control_flow.trivial_recurse
+    def run(self, dag):
+        """Run the pass on a dag."""
+        for node in dag.op_nodes(Measure):
+            succ = next(dag.quantum_successors(node))
+            if isinstance(succ, DAGOpNode) and isinstance(succ.op, Reset):
+                x_body = QuantumCircuit(1)
+                x_body.x(0)
+                new_x = IfElseOp((node.cargs[0], 1), x_body)
+                new_dag = DAGCircuit()
+                new_dag.add_qubits(node.qargs)
+                new_dag.add_clbits(node.cargs)
+                new_dag.apply_operation_back(node.op, node.qargs, node.cargs)
+                new_dag.apply_operation_back(new_x, node.qargs)
+                dag.remove_op_node(succ)
+                dag.substitute_node_with_dag(node, new_dag)
+        return dag

qiskit/transpiler/passes/optimization/split_2q_unitaries.py

@@ -0,0 +1,63 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+"""Splits each two-qubit gate in the `dag` into two single-qubit gates, if possible without error."""
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.layout import Layout
+from qiskit.dagcircuit.dagcircuit import DAGCircuit
+from qiskit._accelerate.split_2q_unitaries import split_2q_unitaries
+
+
+class Split2QUnitaries(TransformationPass):
+    """Attempt to splits two-qubit unitaries in a :class:`.DAGCircuit` into two single-qubit gates.
+
+    This pass will analyze all :class:`.UnitaryGate` instances and determine whether the
+    matrix is actually a product of 2 single qubit gates. In these cases the 2q gate can be
+    simplified into two single qubit gates and this pass will perform this optimization and will
+    replace the two qubit gate with two single qubit :class:`.UnitaryGate`.
+
+    If some of the gates can be viewed as a swap joined by the product of 2 single qubit gates,
+    the pass will recreate the DAG, permuting the swapped qubits similar
+    to how it's done in :class:`ElidePermutations`.
+    """
+
+    def __init__(self, fidelity: float = 1.0 - 1e-16, split_swap: bool = False):
+        """
+        Args:
+            fidelity: Allowed tolerance for splitting two-qubit unitaries and gate decompositions.
+            split_swap: Whether to attempt to split swap gates, resulting in a permutation of the qubits.
+        """
+        super().__init__()
+        self.requested_fidelity = fidelity
+        self.split_swap = split_swap
+
+    def run(self, dag: DAGCircuit) -> DAGCircuit:
+        """Run the Split2QUnitaries pass on `dag`."""
+        result = split_2q_unitaries(dag, self.requested_fidelity, self.split_swap)
+        if result is None:
+            return dag
+
+        (new_dag, qubit_mapping) = result
+        input_qubit_mapping = {qubit: index for index, qubit in enumerate(dag.qubits)}
+        self.property_set["original_layout"] = Layout(input_qubit_mapping)
+        if self.property_set["original_qubit_indices"] is None:
+            self.property_set["original_qubit_indices"] = input_qubit_mapping
+
+        new_layout = Layout({dag.qubits[out]: idx for idx, out in enumerate(qubit_mapping)})
+        if current_layout := self.property_set["virtual_permutation_layout"]:
+            self.property_set["virtual_permutation_layout"] = new_layout.compose(
+                current_layout, dag.qubits
+            )
+        else:
+            self.property_set["virtual_permutation_layout"] = new_layout
+        return new_dag

qiskit/transpiler/passes/optimization/template_matching/__init__.py

@@ -0,0 +1,19 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020.
+#
+# 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.
+
+"""Module containing template matching methods."""
+
+from .forward_match import ForwardMatch
+from .backward_match import BackwardMatch, Match, MatchingScenarios, MatchingScenariosList
+from .template_matching import TemplateMatching
+from .maximal_matches import MaximalMatches
+from .template_substitution import SubstitutionConfig, TemplateSubstitution