qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/circuit/classicalregister.py

@@ -0,0 +1,71 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017.
+#
+# 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.
+
+# pylint: disable=bad-docstring-quotes
+
+"""
+Classical register reference object.
+"""
+import itertools
+
+from qiskit.circuit.exceptions import CircuitError
+
+from qiskit.utils.deprecation import deprecate_func
+from .register import Register
+from .bit import Bit
+
+
+class Clbit(Bit):
+    """Implement a classical bit."""
+
+    __slots__ = ()
+
+    def __init__(self, register=None, index=None):
+        """Creates a classical bit.
+
+        Args:
+            register (ClassicalRegister): Optional. A classical register containing the bit.
+            index (int): Optional. The index of the bit in its containing register.
+
+        Raises:
+            CircuitError: if the provided register is not a valid :class:`ClassicalRegister`
+        """
+
+        if register is None or isinstance(register, ClassicalRegister):
+            super().__init__(register, index)
+        else:
+            raise CircuitError(
+                "Clbit needs a ClassicalRegister and %s was provided" % type(register).__name__
+            )
+
+
+class ClassicalRegister(Register):
+    """Implement a classical register."""
+
+    # Counter for the number of instances in this class.
+    instances_counter = itertools.count()
+    # Prefix to use for auto naming.
+    prefix = "c"
+    bit_type = Clbit
+
+    @deprecate_func(
+        additional_msg=(
+            "Correct exporting to OpenQASM 2 is the responsibility of a larger exporter; it cannot "
+            "safely be done on an object-by-object basis without context. No replacement will be "
+            "provided, because the premise is wrong."
+        ),
+        since="0.23.0",
+        package_name="qiskit-terra",
+    )
+    def qasm(self):
+        """Return OPENQASM string for this register."""
+        return "creg %s[%d];" % (self.name, self.size)

qiskit/circuit/commutation_checker.py

@@ -0,0 +1,176 @@
+# 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.
+
+"""Code from commutative_analysis pass that checks commutation relations between DAG nodes."""
+
+from functools import lru_cache
+from typing import List
+import numpy as np
+
+from qiskit.circuit.operation import Operation
+from qiskit.circuit.controlflow import ControlFlowOp
+from qiskit.quantum_info.operators import Operator
+
+
+@lru_cache(maxsize=None)
+def _identity_op(num_qubits):
+    """Cached identity matrix"""
+    return Operator(
+        np.eye(2**num_qubits), input_dims=(2,) * num_qubits, output_dims=(2,) * num_qubits
+    )
+
+
+class CommutationChecker:
+    """This code is essentially copy-pasted from commutative_analysis.py.
+    This code cleverly hashes commutativity and non-commutativity results between DAG nodes and seems
+    quite efficient for large Clifford circuits.
+    They may be other possible efficiency improvements: using rule-based commutativity analysis,
+    evicting from the cache less useful entries, etc.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.cache = {}
+
+    def _hashable_parameters(self, params):
+        """Convert the parameters of a gate into a hashable format for lookup in a dictionary.
+
+        This aims to be fast in common cases, and is not intended to work outside of the lifetime of a
+        single commutation pass; it does not handle mutable state correctly if the state is actually
+        changed."""
+        try:
+            hash(params)
+            return params
+        except TypeError:
+            pass
+        if isinstance(params, (list, tuple)):
+            return tuple(self._hashable_parameters(x) for x in params)
+        if isinstance(params, np.ndarray):
+            # We trust that the arrays will not be mutated during the commutation pass, since nothing
+            # would work if they were anyway. Using the id can potentially cause some additional cache
+            # misses if two UnitaryGate instances are being compared that have been separately
+            # constructed to have the same underlying matrix, but in practice the cost of string-ifying
+            # the matrix to get a cache key is far more expensive than just doing a small matmul.
+            return (np.ndarray, id(params))
+        # Catch anything else with a slow conversion.
+        return ("fallback", str(params))
+
+    def commute(
+        self,
+        op1: Operation,
+        qargs1: List,
+        cargs1: List,
+        op2: Operation,
+        qargs2: List,
+        cargs2: List,
+        max_num_qubits: int = 3,
+    ) -> bool:
+        """
+        Checks if two Operations commute. The return value of `True` means that the operations
+        truly commute, and the return value of `False` means that either the operations do not
+        commute or that the commutation check was skipped (for example, when the operations
+        have conditions or have too many qubits).
+
+        Args:
+            op1: first operation.
+            qargs1: first operation's qubits.
+            cargs1: first operation's clbits.
+            op2: second operation.
+            qargs2: second operation's qubits.
+            cargs2: second operation's clbits.
+            max_num_qubits: the maximum number of qubits to consider, the check may be skipped if
+                the number of qubits for either operation exceeds this amount.
+
+        Returns:
+            bool: whether two operations commute.
+        """
+        # pylint: disable=too-many-return-statements
+
+        # We don't support commutation of conditional gates for now due to bugs in
+        # CommutativeCancellation.  See gh-8553.
+        if (
+            getattr(op1, "condition", None) is not None
+            or getattr(op2, "condition", None) is not None
+        ):
+            return False
+
+        # Commutation of ControlFlow gates also not supported yet. This may be
+        # pending a control flow graph.
+        if isinstance(op1, ControlFlowOp) or isinstance(op2, ControlFlowOp):
+            return False
+
+        # These lines are adapted from dag_dependency and say that two gates over
+        # different quantum and classical bits necessarily commute. This is more
+        # permissive that the check from commutation_analysis, as for example it
+        # allows to commute X(1) and Measure(0, 0).
+        # Presumably this check was not present in commutation_analysis as
+        # it was only called on pairs of connected nodes from DagCircuit.
+        intersection_q = set(qargs1).intersection(set(qargs2))
+        intersection_c = set(cargs1).intersection(set(cargs2))
+        if not (intersection_q or intersection_c):
+            return True
+
+        # Skip the check if the number of qubits for either operation is too large
+        if len(qargs1) > max_num_qubits or len(qargs2) > max_num_qubits:
+            return False
+
+        # These lines are adapted from commutation_analysis, which is more restrictive than the
+        # check from dag_dependency when considering nodes with "_directive".  It would be nice to
+        # think which optimizations from dag_dependency can indeed be used.
+        for op in [op1, op2]:
+            if (
+                getattr(op, "_directive", False)
+                or op.name in {"measure", "reset", "delay"}
+                or (getattr(op, "is_parameterized", False) and op.is_parameterized())
+            ):
+                return False
+
+        # The main code is adapted from commutative analysis.
+        # Assign indices to each of the qubits such that all `node1`'s qubits come first, followed by
+        # any _additional_ qubits `node2` addresses.  This helps later when we need to compose one
+        # operator with the other, since we can easily expand `node1` with a suitable identity.
+        qarg = {q: i for i, q in enumerate(qargs1)}
+        num_qubits = len(qarg)
+        for q in qargs2:
+            if q not in qarg:
+                qarg[q] = num_qubits
+                num_qubits += 1
+        qarg1 = tuple(qarg[q] for q in qargs1)
+        qarg2 = tuple(qarg[q] for q in qargs2)
+
+        node1_key = (op1.name, self._hashable_parameters(op1.params), qarg1)
+        node2_key = (op2.name, self._hashable_parameters(op2.params), qarg2)
+        try:
+            # We only need to try one orientation of the keys, since if we've seen the compound key
+            # before, we've set it in both orientations.
+            return self.cache[node1_key, node2_key]
+        except KeyError:
+            pass
+
+        operator_1 = Operator(op1, input_dims=(2,) * len(qarg1), output_dims=(2,) * len(qarg1))
+        operator_2 = Operator(op2, input_dims=(2,) * len(qarg2), output_dims=(2,) * len(qarg2))
+
+        if qarg1 == qarg2:
+            # Use full composition if possible to get the fastest matmul paths.
+            op12 = operator_1.compose(operator_2)
+            op21 = operator_2.compose(operator_1)
+        else:
+            # Expand operator_1 to be large enough to contain operator_2 as well; this relies on qargs1
+            # being the lowest possible indices so the identity can be tensored before it.
+            extra_qarg2 = num_qubits - len(qarg1)
+            if extra_qarg2:
+                id_op = _identity_op(extra_qarg2)
+                operator_1 = id_op.tensor(operator_1)
+            op12 = operator_1.compose(operator_2, qargs=qarg2, front=False)
+            op21 = operator_1.compose(operator_2, qargs=qarg2, front=True)
+        self.cache[node1_key, node2_key] = self.cache[node2_key, node1_key] = ret = op12 == op21
+        return ret

qiskit/circuit/controlflow/__init__.py

@@ -0,0 +1,27 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+
+"""Instruction sub-classes for dynamic circuits."""
+
+
+from ._builder_utils import condition_resources, node_resources, LegacyResources
+from .control_flow import ControlFlowOp
+from .continue_loop import ContinueLoopOp
+from .break_loop import BreakLoopOp
+
+from .if_else import IfElseOp
+from .while_loop import WhileLoopOp
+from .for_loop import ForLoopOp
+from .switch_case import SwitchCaseOp, CASE_DEFAULT
+
+
+CONTROL_FLOW_OP_NAMES = frozenset(("for_loop", "while_loop", "if_else", "switch_case"))

qiskit/circuit/controlflow/_builder_utils.py

@@ -0,0 +1,199 @@
+# 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.
+
+"""Private utility functions that are used by the builder interfaces."""
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Iterable, Tuple, Set, Union, TypeVar, TYPE_CHECKING
+
+from qiskit.circuit.classical import expr, types
+from qiskit.circuit.exceptions import CircuitError
+from qiskit.circuit.register import Register
+from qiskit.circuit.classicalregister import ClassicalRegister, Clbit
+from qiskit.circuit.quantumregister import QuantumRegister
+
+if TYPE_CHECKING:
+    from qiskit.circuit import QuantumCircuit
+
+_ConditionT = TypeVar(
+    "_ConditionT", bound=Union[Tuple[ClassicalRegister, int], Tuple[Clbit, int], expr.Expr]
+)
+
+
+def validate_condition(condition: _ConditionT) -> _ConditionT:
+    """Validate that a condition is in a valid format and return it, but raise if it is invalid.
+
+    Args:
+        condition: the condition to be tested for validity.  Must be either the legacy 2-tuple
+            format, or a :class:`~.expr.Expr` that has `Bool` type.
+
+    Raises:
+        CircuitError: if the condition is not in a valid format.
+
+    Returns:
+        The same condition as passed, if it was valid.
+    """
+    if isinstance(condition, expr.Expr):
+        if condition.type.kind is not types.Bool:
+            raise CircuitError(
+                "Classical conditions must be expressions with the type 'Bool()',"
+                f" not '{condition.type}'."
+            )
+        return condition
+    try:
+        bits, value = condition
+        if isinstance(bits, (ClassicalRegister, Clbit)) and isinstance(value, int):
+            return (bits, value)
+    except (TypeError, ValueError):
+        pass
+    raise CircuitError(
+        "A classical condition should be a 2-tuple of `(ClassicalRegister | Clbit, int)`,"
+        f" but received '{condition!r}'."
+    )
+
+
+@dataclasses.dataclass
+class LegacyResources:
+    """A pair of the :class:`.Clbit` and :class:`.ClassicalRegister` resources used by some other
+    object (such as a legacy condition or :class:`.expr.Expr` node)."""
+
+    clbits: tuple[Clbit, ...]
+    cregs: tuple[ClassicalRegister, ...]
+
+
+def node_resources(node: expr.Expr) -> LegacyResources:
+    """Get the legacy classical resources (:class:`.Clbit` and :class:`.ClassicalRegister`)
+    referenced by an :class:`~.expr.Expr`."""
+    # It's generally convenient for us to ensure that the resources are returned in some
+    # deterministic order.  This uses the ordering of 'dict' objects to fake out an ordered set.
+    clbits = {}
+    cregs = {}
+    for var in expr.iter_vars(node):
+        if isinstance(var.var, Clbit):
+            clbits[var.var] = None
+        elif isinstance(var.var, ClassicalRegister):
+            clbits.update((bit, None) for bit in var.var)
+            cregs[var.var] = None
+    return LegacyResources(tuple(clbits), tuple(cregs))
+
+
+def condition_resources(
+    condition: tuple[ClassicalRegister, int] | tuple[Clbit, int] | expr.Expr
+) -> LegacyResources:
+    """Get the legacy classical resources (:class:`.Clbit` and :class:`.ClassicalRegister`)
+    referenced by a legacy condition or an :class:`~.expr.Expr`."""
+    if isinstance(condition, expr.Expr):
+        return node_resources(condition)
+    target, _ = condition
+    if isinstance(target, ClassicalRegister):
+        return LegacyResources(tuple(target), (target,))
+    return LegacyResources((target,), ())
+
+
+def partition_registers(
+    registers: Iterable[Register],
+) -> Tuple[Set[QuantumRegister], Set[ClassicalRegister]]:
+    """Partition a sequence of registers into its quantum and classical registers."""
+    qregs = set()
+    cregs = set()
+    for register in registers:
+        if isinstance(register, QuantumRegister):
+            qregs.add(register)
+        elif isinstance(register, ClassicalRegister):
+            cregs.add(register)
+        else:
+            # Purely defensive against Terra expansion.
+            raise CircuitError(f"Unknown register: {register}.")
+    return qregs, cregs
+
+
+def unify_circuit_resources(circuits: Iterable[QuantumCircuit]) -> Iterable[QuantumCircuit]:
+    """
+    Ensure that all the given ``circuits`` have all the same qubits, clbits and registers, and
+    that they are defined in the same order.  The order is important for binding when the bodies are
+    used in the 3-tuple :obj:`.Instruction` context.
+
+    This function will preferentially try to mutate its inputs if they share an ordering, but if
+    not, it will rebuild two new circuits.  This is to avoid coupling too tightly to the inner
+    class; there is no real support for deleting or re-ordering bits within a :obj:`.QuantumCircuit`
+    context, and we don't want to rely on the *current* behaviour of the private APIs, since they
+    are very liable to change.  No matter the method used, circuits with unified bits and registers
+    are returned.
+    """
+    circuits = tuple(circuits)
+    if len(circuits) < 2:
+        return circuits
+    qubits = []
+    clbits = []
+    for circuit in circuits:
+        if circuit.qubits[: len(qubits)] != qubits:
+            return _unify_circuit_resources_rebuild(circuits)
+        if circuit.clbits[: len(qubits)] != clbits:
+            return _unify_circuit_resources_rebuild(circuits)
+        if circuit.num_qubits > len(qubits):
+            qubits = list(circuit.qubits)
+        if circuit.num_clbits > len(clbits):
+            clbits = list(circuit.clbits)
+    for circuit in circuits:
+        circuit.add_bits(qubits[circuit.num_qubits :])
+        circuit.add_bits(clbits[circuit.num_clbits :])
+    return _unify_circuit_registers(circuits)
+
+
+def _unify_circuit_resources_rebuild(  # pylint: disable=invalid-name  # (it's too long?!)
+    circuits: Tuple[QuantumCircuit, ...]
+) -> Tuple[QuantumCircuit, QuantumCircuit]:
+    """
+    Ensure that all the given circuits have all the same qubits and clbits, and that they
+    are defined in the same order.  The order is important for binding when the bodies are used in
+    the 3-tuple :obj:`.Instruction` context.
+
+    This function will always rebuild the objects into new :class:`.QuantumCircuit` instances.
+    """
+    # pylint: disable=cyclic-import
+    from qiskit.circuit import QuantumCircuit
+
+    qubits, clbits = set(), set()
+    for circuit in circuits:
+        qubits.update(circuit.qubits)
+        clbits.update(circuit.clbits)
+    qubits, clbits = list(qubits), list(clbits)
+
+    # We use the inner `_append` method because everything is already resolved in the builders.
+    out_circuits = []
+    for circuit in circuits:
+        out = QuantumCircuit(
+            qubits, clbits, *circuit.qregs, *circuit.cregs, global_phase=circuit.global_phase
+        )
+        for instruction in circuit.data:
+            out._append(instruction)
+        out_circuits.append(out)
+    return _unify_circuit_registers(out_circuits)
+
+
+def _unify_circuit_registers(circuits: Iterable[QuantumCircuit]) -> Iterable[QuantumCircuit]:
+    """
+    Ensure that ``true_body`` and ``false_body`` have the same registers defined within them.  These
+    do not need to be in the same order between circuits.  The two input circuits are returned,
+    mutated to have the same registers.
+    """
+    circuits = tuple(circuits)
+    total_registers = set()
+    for circuit in circuits:
+        total_registers.update(circuit.qregs)
+        total_registers.update(circuit.cregs)
+    for circuit in circuits:
+        for register in total_registers - set(circuit.qregs) - set(circuit.cregs):
+            circuit.add_register(register)
+    return circuits

qiskit/circuit/controlflow/break_loop.py

@@ -0,0 +1,70 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+
+"Circuit operation representing a ``break`` from a loop."
+
+from typing import Optional
+
+from qiskit.circuit.instruction import Instruction
+from .builder import InstructionPlaceholder, InstructionResources
+
+
+class BreakLoopOp(Instruction):
+    """A circuit operation which, when encountered, jumps to the end of
+    the nearest enclosing loop.
+
+    .. note:
+
+        Can be inserted only within the body of a loop op, and must span
+        the full width of that block.
+
+    **Circuit symbol:**
+
+    .. parsed-literal::
+
+             ┌──────────────┐
+        q_0: ┤0             ├
+             │              │
+        q_1: ┤1             ├
+             │  break_loop  │
+        q_2: ┤2             ├
+             │              │
+        c_0: ╡0             ╞
+             └──────────────┘
+
+    """
+
+    def __init__(self, num_qubits: int, num_clbits: int, label: Optional[str] = None):
+        super().__init__("break_loop", num_qubits, num_clbits, [], label=label)
+
+
+class BreakLoopPlaceholder(InstructionPlaceholder):
+    """A placeholder instruction for use in control-flow context managers, when the number of qubits
+    and clbits is not yet known.
+
+    .. warning::
+
+        This is an internal interface and no part of it should be relied upon outside of Qiskit
+        Terra.
+    """
+
+    def __init__(self, *, label: Optional[str] = None):
+        super().__init__("break_loop", 0, 0, [], label=label)
+
+    def concrete_instruction(self, qubits, clbits):
+        return (
+            self._copy_mutable_properties(BreakLoopOp(len(qubits), len(clbits), label=self.label)),
+            InstructionResources(qubits=tuple(qubits), clbits=tuple(clbits)),
+        )
+
+    def placeholder_resources(self):
+        return InstructionResources()