qiskit 1.3.0__cp39-abi3-win32.whl

qiskit/transpiler/passes/optimization/__init__.py

@@ -0,0 +1,43 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2018.
+#
+# 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 transpiler optimization passes."""
+
+from .optimize_1q_gates import Optimize1qGates
+from .optimize_1q_decomposition import Optimize1qGatesDecomposition
+from .collect_2q_blocks import Collect2qBlocks
+from .collect_multiqubit_blocks import CollectMultiQBlocks
+from .consolidate_blocks import ConsolidateBlocks
+from .commutation_analysis import CommutationAnalysis
+from .commutative_cancellation import CommutativeCancellation
+from .commutative_inverse_cancellation import CommutativeInverseCancellation
+from .cx_cancellation import CXCancellation
+from .optimize_1q_commutation import Optimize1qGatesSimpleCommutation
+from .optimize_swap_before_measure import OptimizeSwapBeforeMeasure
+from .remove_reset_in_zero_state import RemoveResetInZeroState
+from .remove_final_reset import RemoveFinalReset
+from .remove_diagonal_gates_before_measure import RemoveDiagonalGatesBeforeMeasure
+from .hoare_opt import HoareOptimizer
+from .template_optimization import TemplateOptimization
+from .inverse_cancellation import InverseCancellation
+from .collect_1q_runs import Collect1qRuns
+from .echo_rzx_weyl_decomposition import EchoRZXWeylDecomposition
+from .collect_linear_functions import CollectLinearFunctions
+from .reset_after_measure_simplification import ResetAfterMeasureSimplification
+from .optimize_cliffords import OptimizeCliffords
+from .collect_cliffords import CollectCliffords
+from .elide_permutations import ElidePermutations
+from .normalize_rx_angle import NormalizeRXAngle
+from .optimize_annotated import OptimizeAnnotated
+from .remove_identity_equiv import RemoveIdentityEquivalent
+from .split_2q_unitaries import Split2QUnitaries
+from .collect_and_collapse import CollectAndCollapse

qiskit/transpiler/passes/optimization/_gate_extension.py

@@ -0,0 +1,80 @@
+# 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.
+
+"""
+Dynamically extend Gate classes with functions required for the Hoare
+optimizer, namely triviality-conditions and post-conditions.
+If `_trivial_if` returns `True` and the qubit is in a classical state
+then the gate is trivial.
+If a gate has no `_trivial_if`, then is assumed to be non-trivial.
+If a gate has no `_postconditions`, then is assumed to have unknown post-conditions.
+"""
+from qiskit.circuit.library.standard_gates import IGate, XGate, YGate, ZGate
+from qiskit.circuit.library.standard_gates import CXGate, CCXGate, CYGate, CZGate
+from qiskit.circuit.library.standard_gates import TGate, TdgGate, SGate, SdgGate, RZGate, U1Gate
+from qiskit.circuit.library.standard_gates import SwapGate, CSwapGate, CRZGate, CU1Gate, MCU1Gate
+from qiskit.utils import optionals as _optionals
+
+if _optionals.HAS_Z3:
+    import z3
+
+    # FLIP GATES #
+    # XGate
+    XGate._postconditions = lambda self, x1, y1: y1 == z3.Not(x1)
+    CXGate._postconditions = lambda self, x1, y1: y1 == z3.Not(x1)
+    CCXGate._postconditions = lambda self, x1, y1: y1 == z3.Not(x1)
+
+    # YGate
+    YGate._postconditions = lambda self, x1, y1: y1 == z3.Not(x1)
+    CYGate._postconditions = lambda self, x1, y1: y1 == z3.Not(x1)
+
+    # PHASE GATES #
+    # IdGate
+    IGate._postconditions = lambda self, x1, y1: y1 == x1
+
+    # ZGate
+    ZGate._trivial_if = lambda self, x1: True
+    ZGate._postconditions = lambda self, x1, y1: y1 == x1
+    CZGate._trivial_if = lambda self, x1: True
+    CZGate._postconditions = lambda self, x1, y1: y1 == x1
+
+    # SGate
+    SGate._trivial_if = lambda self, x1: True
+    SGate._postconditions = lambda self, x1, y1: y1 == x1
+    SdgGate._trivial_if = lambda self, x1: True
+    SdgGate._postconditions = lambda self, x1, y1: y1 == x1
+
+    # TGate
+    TGate._trivial_if = lambda self, x1: True
+    TGate._postconditions = lambda self, x1, y1: y1 == x1
+    TdgGate._trivial_if = lambda self, x1: True
+    TdgGate._postconditions = lambda self, x1, y1: y1 == x1
+
+    # RzGate
+    RZGate._trivial_if = lambda self, x1: True
+    RZGate._postconditions = lambda self, x1, y1: y1 == x1
+    CRZGate._postconditions = lambda self, x1, y1: y1 == x1
+
+    #  U1Gate
+    U1Gate._trivial_if = lambda self, x1: True
+    U1Gate._postconditions = lambda self, x1, y1: y1 == x1
+    CU1Gate._trivial_if = lambda self, x1: True
+    CU1Gate._postconditions = lambda self, x1, y1: y1 == x1
+    MCU1Gate._trivial_if = lambda self, x1: True
+    MCU1Gate._postconditions = lambda self, x1, y1: y1 == x1
+
+    # MULTI-QUBIT GATES #
+    # SwapGate
+    SwapGate._trivial_if = lambda self, x1, x2: x1 == x2
+    SwapGate._postconditions = lambda self, x1, x2, y1, y2: z3.And(x1 == y2, x2 == y1)
+    CSwapGate._trivial_if = lambda self, x1, x2: x1 == x2
+    CSwapGate._postconditions = lambda self, x1, x2, y1, y2: z3.And(x1 == y2, x2 == y1)

qiskit/transpiler/passes/optimization/collect_1q_runs.py

@@ -0,0 +1,31 @@
+# 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.
+
+"""Collect sequences of uninterrupted gates acting on 1 qubit."""
+
+from qiskit.transpiler.basepasses import AnalysisPass
+
+
+class Collect1qRuns(AnalysisPass):
+    """Collect one-qubit subcircuits."""
+
+    def run(self, dag):
+        """Run the Collect1qBlocks pass on `dag`.
+
+        The blocks contain "op" nodes in topological order such that all gates
+        in a block act on the same qubits and are adjacent in the circuit.
+
+        After the execution, ``property_set['run_list']`` is set to a list of
+        tuples of "op" node.
+        """
+        self.property_set["run_list"] = dag.collect_1q_runs()
+        return dag

qiskit/transpiler/passes/optimization/collect_2q_blocks.py

@@ -0,0 +1,35 @@
+# 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.
+
+"""Collect sequences of uninterrupted gates acting on 2 qubits."""
+
+from collections import defaultdict
+
+from qiskit.transpiler.basepasses import AnalysisPass
+
+
+class Collect2qBlocks(AnalysisPass):
+    """Collect two-qubit subcircuits."""
+
+    def run(self, dag):
+        """Run the Collect2qBlocks pass on `dag`.
+
+        The blocks contain "op" nodes in topological order such that all gates
+        in a block act on the same qubits and are adjacent in the circuit.
+
+        After the execution, ``property_set['block_list']`` is set to a list of
+        tuples of "op" node.
+        """
+        self.property_set["commutation_set"] = defaultdict(list)
+        self.property_set["block_list"] = dag.collect_2q_runs()
+
+        return dag

qiskit/transpiler/passes/optimization/collect_and_collapse.py

@@ -0,0 +1,115 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2022.
+#
+# 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.
+
+
+"""Provides a general transpiler pass for collecting and consolidating blocks of nodes
+in a circuit."""
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.converters import dag_to_dagdependency, dagdependency_to_dag
+from qiskit.dagcircuit.collect_blocks import BlockCollector, BlockCollapser
+from qiskit.transpiler.passes.utils import control_flow
+
+
+class CollectAndCollapse(TransformationPass):
+    """A general transpiler pass to collect and to consolidate blocks of nodes
+    in a circuit.
+
+    This transpiler pass depends on two functions: the collection function and the
+    collapsing function. The collection function ``collect_function`` takes a DAG
+    and returns a list of blocks. The collapsing function ``collapse_function``
+    takes a DAG and a list of blocks, consolidates each block, and returns the modified
+    DAG.
+
+    The input and the output DAGs are of type :class:`~qiskit.dagcircuit.DAGCircuit`,
+    however when exploiting commutativity analysis to collect blocks, the
+    :class:`~qiskit.dagcircuit.DAGDependency` representation is used internally.
+    To support this, the ``collect_function`` and ``collapse_function`` should work
+    with both types of DAGs and DAG nodes.
+
+    Other collection and consolidation transpiler passes, for instance
+    :class:`~.CollectLinearFunctions`, may derive from this pass, fixing
+    ``collect_function`` and ``collapse_function`` to specific functions.
+    """
+
+    def __init__(
+        self,
+        collect_function,
+        collapse_function,
+        do_commutative_analysis=False,
+    ):
+        """
+        Args:
+            collect_function (callable): a function that takes a DAG and returns a list
+                of "collected" blocks of nodes
+            collapse_function (callable): a function that takes a DAG and a list of
+                "collected" blocks, and consolidates each block.
+            do_commutative_analysis (bool): if True, exploits commutativity relations
+                between nodes.
+        """
+        self.collect_function = collect_function
+        self.collapse_function = collapse_function
+        self.do_commutative_analysis = do_commutative_analysis
+
+        super().__init__()
+
+    @control_flow.trivial_recurse
+    def run(self, dag):
+        """Run the CollectLinearFunctions pass on `dag`.
+        Args:
+            dag (DAGCircuit): the DAG to be optimized.
+        Returns:
+            DAGCircuit: the optimized DAG.
+        """
+
+        # If the option commutative_analysis is set, construct DAGDependency from the given DAGCircuit.
+        if self.do_commutative_analysis:
+            dag = dag_to_dagdependency(dag)
+
+        # call collect_function to collect blocks from DAG
+        blocks = self.collect_function(dag)
+
+        # call collapse_function to collapse each block in the DAG
+        self.collapse_function(dag, blocks)
+
+        # If the option commutative_analysis is set, construct back DAGCircuit from DAGDependency.
+        if self.do_commutative_analysis:
+            dag = dagdependency_to_dag(dag)
+
+        return dag
+
+
+def collect_using_filter_function(
+    dag,
+    filter_function,
+    split_blocks,
+    min_block_size,
+    split_layers=False,
+    collect_from_back=False,
+):
+    """Corresponds to an important block collection strategy that greedily collects
+    maximal blocks of nodes matching a given ``filter_function``.
+    """
+    return BlockCollector(dag).collect_all_matching_blocks(
+        filter_fn=filter_function,
+        split_blocks=split_blocks,
+        min_block_size=min_block_size,
+        split_layers=split_layers,
+        collect_from_back=collect_from_back,
+    )
+
+
+def collapse_to_operation(dag, blocks, collapse_function):
+    """Corresponds to an important block collapsing strategy that collapses every block
+    to a specific object as specified by ``collapse_function``.
+    """
+    return BlockCollapser(dag).collapse_to_operation(blocks, collapse_function)

qiskit/transpiler/passes/optimization/collect_cliffords.py

@@ -0,0 +1,104 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2022.
+#
+# 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 each sequence of Clifford gates by a single Clifford gate."""
+
+from functools import partial
+
+from qiskit.exceptions import QiskitError
+from qiskit.transpiler.passes.optimization.collect_and_collapse import (
+    CollectAndCollapse,
+    collect_using_filter_function,
+    collapse_to_operation,
+)
+
+from qiskit.quantum_info.operators import Clifford
+from qiskit.quantum_info.operators.symplectic.clifford_circuits import _BASIS_1Q, _BASIS_2Q
+
+
+class CollectCliffords(CollectAndCollapse):
+    """Collects blocks of Clifford gates and replaces them by a :class:`~qiskit.quantum_info.Clifford`
+    object.
+    """
+
+    def __init__(
+        self,
+        do_commutative_analysis=False,
+        split_blocks=True,
+        min_block_size=2,
+        split_layers=False,
+        collect_from_back=False,
+        matrix_based=False,
+    ):
+        """CollectCliffords initializer.
+
+        Args:
+            do_commutative_analysis (bool): if True, exploits commutativity relations
+                between nodes.
+            split_blocks (bool): if True, splits collected blocks into sub-blocks
+                over disjoint qubit subsets.
+            min_block_size (int): specifies the minimum number of gates in the block
+                for the block to be collected.
+            split_layers (bool): if True, splits collected blocks into sub-blocks
+                over disjoint qubit subsets.
+            collect_from_back (bool): specifies if blocks should be collected started
+                from the end of the circuit.
+            matrix_based (bool): specifies whether to collect unitary gates
+               which are Clifford gates only for certain parameters (based on their unitary matrix).
+        """
+
+        collect_function = partial(
+            collect_using_filter_function,
+            filter_function=partial(_is_clifford_gate, matrix_based=matrix_based),
+            split_blocks=split_blocks,
+            min_block_size=min_block_size,
+            split_layers=split_layers,
+            collect_from_back=collect_from_back,
+        )
+        collapse_function = partial(collapse_to_operation, collapse_function=_collapse_to_clifford)
+
+        super().__init__(
+            collect_function=collect_function,
+            collapse_function=collapse_function,
+            do_commutative_analysis=do_commutative_analysis,
+        )
+
+
+clifford_gate_names = (
+    list(_BASIS_1Q.keys())
+    + list(_BASIS_2Q.keys())
+    + ["clifford", "linear_function", "pauli", "permutation"]
+)
+
+
+def _is_clifford_gate(node, matrix_based=False):
+    """Specifies whether a node holds a clifford gate."""
+    if getattr(node.op, "_condition", None) is not None:
+        return False
+    if node.op.name in clifford_gate_names:
+        return True
+
+    if not matrix_based:
+        return False
+
+    try:
+        Clifford(node.op)
+        return True
+    except QiskitError:
+        return False
+
+
+def _collapse_to_clifford(circuit):
+    """Specifies how to construct a ``Clifford`` from a quantum circuit (that must
+    consist of Clifford gates only)."""
+    return Clifford(circuit)

qiskit/transpiler/passes/optimization/collect_linear_functions.py

@@ -0,0 +1,80 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2022.
+#
+# 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 each sequence of CX and SWAP gates by a single LinearFunction gate."""
+
+from functools import partial
+
+from qiskit.circuit.library.generalized_gates import LinearFunction
+from qiskit.transpiler.passes.optimization.collect_and_collapse import (
+    CollectAndCollapse,
+    collect_using_filter_function,
+    collapse_to_operation,
+)
+
+
+class CollectLinearFunctions(CollectAndCollapse):
+    """Collect blocks of linear gates (:class:`.CXGate` and :class:`.SwapGate` gates)
+    and replaces them by linear functions (:class:`.LinearFunction`)."""
+
+    def __init__(
+        self,
+        do_commutative_analysis=False,
+        split_blocks=True,
+        min_block_size=2,
+        split_layers=False,
+        collect_from_back=False,
+    ):
+        """CollectLinearFunctions initializer.
+
+        Args:
+            do_commutative_analysis (bool): if True, exploits commutativity relations
+                between nodes.
+            split_blocks (bool): if True, splits collected blocks into sub-blocks
+                over disjoint qubit subsets.
+            min_block_size (int): specifies the minimum number of gates in the block
+                for the block to be collected.
+            split_layers (bool): if True, splits collected blocks into sub-blocks
+                over disjoint qubit subsets.
+            collect_from_back (bool): specifies if blocks should be collected started
+                from the end of the circuit.
+        """
+
+        collect_function = partial(
+            collect_using_filter_function,
+            filter_function=_is_linear_gate,
+            split_blocks=split_blocks,
+            min_block_size=min_block_size,
+            split_layers=split_layers,
+            collect_from_back=collect_from_back,
+        )
+        collapse_function = partial(
+            collapse_to_operation, collapse_function=_collapse_to_linear_function
+        )
+
+        super().__init__(
+            collect_function=collect_function,
+            collapse_function=collapse_function,
+            do_commutative_analysis=do_commutative_analysis,
+        )
+
+
+def _is_linear_gate(node):
+    """Specifies whether a node holds a linear gate."""
+    return node.op.name in ("cx", "swap") and getattr(node, "condition", None) is None
+
+
+def _collapse_to_linear_function(circuit):
+    """Specifies how to construct a ``LinearFunction`` from a quantum circuit (that must
+    consist of linear gates only)."""
+    return LinearFunction(circuit)