qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/circuit/classical/types/ordering.py

@@ -0,0 +1,229 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+
+"""Tools for working with the partial ordering of the type system."""
+
+from __future__ import annotations
+
+__all__ = [
+    "Ordering",
+    "is_subtype",
+    "is_supertype",
+    "order",
+    "greater",
+    "CastKind",
+    "cast_kind",
+]
+
+import enum
+
+from .types import Type, Bool, Duration, Float, Uint
+
+
+# While the type system is simple, it's overkill to represent the complete partial ordering graph of
+# the set of types in an explicit graph form.  The strategy here is to assume that two types have no
+# ordering between them, and an ordering is defined by putting a function `Type * Type -> Ordering`
+# into the `_ORDERERS`.
+
+
+class Ordering(enum.Enum):
+    """Enumeration listing the possible relations between two types.  Types only have a partial
+    ordering, so it's possible for two types to have no sub-typing relationship.
+
+    Note that the sub-/supertyping relationship is not the same as whether a type can be explicitly
+    cast from one to another."""
+
+    LESS = enum.auto()
+    """The left type is a strict subtype of the right type."""
+    EQUAL = enum.auto()
+    """The two types are equal."""
+    GREATER = enum.auto()
+    """The left type is a strict supertype of the right type."""
+    NONE = enum.auto()
+    """There is no typing relationship between the two types."""
+
+    def __repr__(self):
+        return str(self)
+
+
+def _order_uint_uint(left: Uint, right: Uint, /) -> Ordering:
+    if left.width < right.width:
+        return Ordering.LESS
+    if left.width == right.width:
+        return Ordering.EQUAL
+    return Ordering.GREATER
+
+
+_ORDERERS = {
+    (Bool, Bool): lambda _a, _b, /: Ordering.EQUAL,
+    (Uint, Uint): _order_uint_uint,
+    (Float, Float): lambda _a, _b, /: Ordering.EQUAL,
+    (Duration, Duration): lambda _a, _b, /: Ordering.EQUAL,
+}
+
+
+def order(left: Type, right: Type, /) -> Ordering:
+    """Get the ordering relationship between the two types as an enumeration value.
+
+    Examples:
+        Compare two :class:`Uint` types of different widths::
+
+            >>> from qiskit.circuit.classical import types
+            >>> types.order(types.Uint(8), types.Uint(16))
+            Ordering.LESS
+
+        Compare two types that have no ordering between them::
+
+            >>> types.order(types.Uint(8), types.Bool())
+            Ordering.NONE
+    """
+    if (orderer := _ORDERERS.get((left.kind, right.kind))) is None:
+        return Ordering.NONE
+    return orderer(left, right)
+
+
+def is_subtype(left: Type, right: Type, /, strict: bool = False) -> bool:
+    r"""Does the relation :math:`\text{left} \le \text{right}` hold?  If there is no ordering
+    relation between the two types, then this returns ``False``.  If ``strict``, then the equality
+    is also forbidden.
+
+    Examples:
+        Check if one type is a subclass of another::
+
+            >>> from qiskit.circuit.classical import types
+            >>> types.is_subtype(types.Uint(8), types.Uint(16))
+            True
+
+        Check if one type is a strict subclass of another::
+
+            >>> types.is_subtype(types.Bool(), types.Bool())
+            True
+            >>> types.is_subtype(types.Bool(), types.Bool(), strict=True)
+            False
+    """
+    order_ = order(left, right)
+    return order_ is Ordering.LESS or (not strict and order_ is Ordering.EQUAL)
+
+
+def is_supertype(left: Type, right: Type, /, strict: bool = False) -> bool:
+    r"""Does the relation :math:`\text{left} \ge \text{right}` hold?  If there is no ordering
+    relation between the two types, then this returns ``False``.  If ``strict``, then the equality
+    is also forbidden.
+
+    Examples:
+        Check if one type is a superclass of another::
+
+            >>> from qiskit.circuit.classical import types
+            >>> types.is_supertype(types.Uint(8), types.Uint(16))
+            False
+
+        Check if one type is a strict superclass of another::
+
+            >>> types.is_supertype(types.Bool(), types.Bool())
+            True
+            >>> types.is_supertype(types.Bool(), types.Bool(), strict=True)
+            False
+    """
+    order_ = order(left, right)
+    return order_ is Ordering.GREATER or (not strict and order_ is Ordering.EQUAL)
+
+
+def greater(left: Type, right: Type, /) -> Type:
+    """Get the greater of the two types, assuming that there is an ordering relation between them.
+    Technically, this is a slightly restricted version of the concept of the 'meet' of the two
+    types in that the return value must be one of the inputs. In practice in the type system there
+    is no concept of a 'sum' type, so the 'meet' exists if and only if there is an ordering between
+    the two types, and is equal to the greater of the two types.
+
+    Returns:
+        The greater of the two types.
+
+    Raises:
+        TypeError: if there is no ordering relation between the two types.
+
+    Examples:
+        Find the greater of two :class:`Uint` types::
+
+            >>> from qiskit.circuit.classical import types
+            >>> types.greater(types.Uint(8), types.Uint(16))
+            types.Uint(16)
+    """
+    order_ = order(left, right)
+    if order_ is Ordering.NONE:
+        raise TypeError(f"no ordering exists between '{left}' and '{right}'")
+    return left if order_ is Ordering.GREATER else right
+
+
+class CastKind(enum.Enum):
+    """A return value indicating the type of cast that can occur from one type to another."""
+
+    EQUAL = enum.auto()
+    """The two types are equal; no cast node is required at all."""
+    IMPLICIT = enum.auto()
+    """The 'from' type can be cast to the 'to' type implicitly.  A :class:`~.expr.Cast` node with
+    ``implicit==True`` is the minimum required to specify this."""
+    LOSSLESS = enum.auto()
+    """The 'from' type can be cast to the 'to' type explicitly, and the cast will be lossless.  This
+    requires a :class:`~.expr.Cast`` node with ``implicit=False``, but there's no danger from
+    inserting one."""
+    DANGEROUS = enum.auto()
+    """The 'from' type has a defined cast to the 'to' type, but depending on the value, it may lose
+    data.  A user would need to manually specify casts."""
+    NONE = enum.auto()
+    """There is no casting permitted from the 'from' type to the 'to' type."""
+
+
+def _uint_cast(from_: Uint, to_: Uint, /) -> CastKind:
+    if from_.width == to_.width:
+        return CastKind.EQUAL
+    if from_.width < to_.width:
+        return CastKind.LOSSLESS
+    return CastKind.DANGEROUS
+
+
+_ALLOWED_CASTS = {
+    (Bool, Bool): lambda _a, _b, /: CastKind.EQUAL,
+    (Bool, Uint): lambda _a, _b, /: CastKind.LOSSLESS,
+    (Bool, Float): lambda _a, _b, /: CastKind.LOSSLESS,
+    (Uint, Bool): lambda _a, _b, /: CastKind.IMPLICIT,
+    (Uint, Uint): _uint_cast,
+    (Uint, Float): lambda _a, _b, /: CastKind.DANGEROUS,
+    (Float, Float): lambda _a, _b, /: CastKind.EQUAL,
+    (Float, Uint): lambda _a, _b, /: CastKind.DANGEROUS,
+    (Float, Bool): lambda _a, _b, /: CastKind.DANGEROUS,
+    (Duration, Duration): lambda _a, _b, /: CastKind.EQUAL,
+}
+
+
+def cast_kind(from_: Type, to_: Type, /) -> CastKind:
+    """Determine the sort of cast that is required to move from the left type to the right type.
+
+    Examples:
+
+        .. plot::
+           :include-source:
+           :nofigs:
+
+
+            >>> from qiskit.circuit.classical import types
+            >>> types.cast_kind(types.Bool(), types.Bool())
+            <CastKind.EQUAL: 1>
+            >>> types.cast_kind(types.Uint(8), types.Bool())
+            <CastKind.IMPLICIT: 2>
+            >>> types.cast_kind(types.Bool(), types.Uint(8))
+            <CastKind.LOSSLESS: 3>
+            >>> types.cast_kind(types.Uint(16), types.Uint(8))
+            <CastKind.DANGEROUS: 4>
+    """
+    if (coercer := _ALLOWED_CASTS.get((from_.kind, to_.kind))) is None:
+        return CastKind.NONE
+    return coercer(from_, to_)

qiskit/circuit/classical/types/types.py

@@ -0,0 +1,30 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+
+"""Type-system definition for the expression tree."""
+
+
+__all__ = [
+    "Type",
+    "Bool",
+    "Duration",
+    "Float",
+    "Uint",
+]
+
+from qiskit._accelerate.circuit.classical.types import (
+    Type,
+    Bool,
+    Uint,
+    Float,
+    Duration,
+)  # pylint: disable=unused-import

qiskit/circuit/commutation_checker.py

@@ -0,0 +1,133 @@
+# 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 __future__ import annotations
+from typing import List, Union, Set, Optional
+
+from qiskit.circuit.operation import Operation
+from qiskit._accelerate.commutation_checker import CommutationChecker as RustChecker
+
+
+class CommutationChecker:
+    r"""Check commutations of two operations.
+
+    Two unitaries :math:`A` and :math:`B` on :math:`n` qubits commute if
+
+    .. math::
+
+        \frac{2^n F_{\text{process}}(AB, BA) + 1}{2^n + 1} > 1 - \varepsilon,
+
+    where
+
+    .. math::
+
+        F_{\text{process}}(U_1, U_2) = \left|\frac{\mathrm{Tr}(U_1 U_2^\dagger)}{2^n} \right|^2,
+
+    and we set :math:`\varepsilon` to :math:`10^{-12}` to account for round-off errors on
+    few-qubit systems. This metric is chosen for consistency with other closeness checks in
+    Qiskit.
+
+    When possible, commutation relations are queried from a lookup table. This is the case
+    for standard gates without parameters (such as :class:`.XGate` or :class:`.HGate`) or
+    gates with free parameters (such as :class:`.RXGate` with a :class:`.ParameterExpression` as
+    angle). Otherwise, a matrix-based check is performed, where two operations are said to
+    commute, if the average gate fidelity of performing the commutation is above a certain threshold
+    (see ``approximation_degree``). The result of this commutation is then added to the
+    cached lookup table.
+    """
+
+    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,
+        approximation_degree: float = 1.0,
+    ) -> bool:
+        """Checks if two DAGOpNodes commute."""
+        return self.cc.commute_nodes(op1, op2, max_num_qubits, approximation_degree)
+
+    def commute(
+        self,
+        op1: Operation,
+        qargs1: List,
+        cargs1: List,
+        op2: Operation,
+        qargs2: List,
+        cargs2: List,
+        max_num_qubits: int = 3,
+        approximation_degree: float = 1.0,
+    ) -> 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.
+            approximation_degree: If the average gate fidelity in between the two operations
+                is above this number (up to ``1e-12``) they are assumed to commute.
+
+        Returns:
+            bool: whether two operations commute.
+        """
+        return self.cc.commute(
+            op1, qargs1, cargs1, op2, qargs2, cargs2, max_num_qubits, approximation_degree
+        )
+
+    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,59 @@
+# 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 .box import BoxOp
+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", "box"))
+"""Set of the instruction names of Qiskit's known control-flow operations."""
+
+
+def get_control_flow_name_mapping():
+    """Return a dictionary mapping the names of control-flow operations
+    to their corresponding classes."
+
+    Examples:
+
+        .. code-block:: python
+
+            from qiskit.circuit import get_control_flow_name_mapping
+
+            ctrl_flow_name_map = get_control_flow_name_mapping()
+            if_else_object = ctrl_flow_name_map["if_else"]
+
+            print(if_else_object)
+
+        .. code-block:: text
+
+            <class 'qiskit.circuit.controlflow.if_else.IfElseOp'>
+    """
+
+    name_mapping = {
+        "if_else": IfElseOp,
+        "while_loop": WhileLoopOp,
+        "for_loop": ForLoopOp,
+        "switch_case": SwitchCaseOp,
+        "box": BoxOp,
+    }
+    return name_mapping

qiskit/circuit/controlflow/_builder_utils.py

@@ -0,0 +1,211 @@
+# 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 import (  # pylint: disable=cyclic-import
+    ClassicalRegister,
+    Clbit,
+    QuantumRegister,
+)
+from qiskit.circuit.classical import expr, types
+from qiskit.circuit.exceptions import CircuitError
+
+if TYPE_CHECKING:
+    from qiskit.circuit import QuantumCircuit, Register
+
+_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_captures(),
+        )
+        for var in circuit.iter_declared_vars():
+            out.add_uninitialized_var(var)
+        for stretch in circuit.iter_declared_stretches():
+            out.add_stretch(stretch)
+        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