qiskit 1.3.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/circuit/classicalregister.py

@@ -0,0 +1,57 @@
+# 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 .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(
+                f"Clbit needs a ClassicalRegister and {type(register).__name__} was provided"
+            )
+
+
+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

qiskit/circuit/commutation_checker.py

@@ -0,0 +1,106 @@
+# 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 typing import List, Union, Set, Optional
+
+from qiskit.circuit.operation import Operation
+from qiskit._accelerate.commutation_checker import CommutationChecker as RustChecker
+
+
+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,
+        standard_gate_commutations: dict = None,
+        cache_max_entries: int = 10**6,
+        *,
+        gates: Optional[Set[str]] = None,
+    ):
+        self.cc = RustChecker(standard_gate_commutations, cache_max_entries, gates)
+
+    def commute_nodes(
+        self,
+        op1,
+        op2,
+        max_num_qubits: int = 3,
+    ) -> bool:
+        """Checks if two DAGOpNodes commute."""
+        return self.cc.commute_nodes(op1, op2, max_num_qubits)
+
+    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.
+        """
+        return self.cc.commute(op1, qargs1, cargs1, op2, qargs2, cargs2, max_num_qubits)
+
+    def num_cached_entries(self):
+        """Returns number of cached entries"""
+        return self.cc.num_cached_entries()
+
+    def clear_cached_commutations(self):
+        """Clears the dictionary holding cached commutations"""
+        self.cc.clear_cached_commutations()
+
+    def check_commutation_entries(
+        self,
+        first_op: Operation,
+        first_qargs: List,
+        second_op: Operation,
+        second_qargs: List,
+    ) -> Union[bool, None]:
+        """Returns stored commutation relation if any
+
+        Args:
+            first_op: first operation.
+            first_qargs: first operation's qubits.
+            second_op: second operation.
+            second_qargs: second operation's qubits.
+
+        Return:
+            bool: True if the gates commute and false if it is not the case.
+        """
+        return self.cc.library.check_commutation_entries(
+            first_op, first_qargs, second_op, second_qargs
+        )

qiskit/circuit/commutation_library.py

@@ -0,0 +1,20 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2023.
+#
+# 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 commutation checker that caches the determined commutation results during this session """
+
+from qiskit.circuit import CommutationChecker
+
+from qiskit.circuit._standard_gates_commutations import standard_gates_commutations
+
+StandardGateCommutations = standard_gates_commutations
+SessionCommutationChecker = CommutationChecker(StandardGateCommutations)

qiskit/circuit/controlflow/__init__.py

@@ -0,0 +1,28 @@
+# 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"))
+"""Set of the instruction names of Qiskit's known control-flow operations."""

qiskit/circuit/controlflow/_builder_utils.py

@@ -0,0 +1,207 @@
+# 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* behavior 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,
+            inputs=circuit.iter_input_vars(),
+            captures=circuit.iter_captured_vars(),
+        )
+        for var in circuit.iter_declared_vars():
+            out.add_uninitialized_var(var)
+        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,56 @@
+# 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.
+    Can only be used inside loops.
+    """
+
+    def __init__(self, num_qubits: int, num_clbits: int, label: Optional[str] = None):
+        """
+        Args:
+            num_qubits: the number of qubits this affects.
+            num_clbits: the number of qubits this affects.
+            label: an optional string label for the instruction.
+        """
+        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()