qiskit 2.0.3__cp39-abi3-macosx_11_0_arm64.whl → 2.1.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/circuit/classical/types/types.py

@@ -12,12 +12,6 @@
 
 """Type-system definition for the expression tree."""
 
-# Given the nature of the tree representation and that there are helper functions associated with
-# many of the classes whose arguments naturally share names with themselves, it's inconvenient to
-# use synonyms everywhere.  This goes for the builtin 'type' as well.
-# pylint: disable=redefined-builtin,redefined-outer-name
-
-from __future__ import annotations
 
 __all__ = [
     "Type",
@@ -27,127 +21,10 @@ __all__ = [
     "Uint",
 ]
 
-import typing
-
-
-class _Singleton(type):
-    """Metaclass to make the child, which should take zero initialization arguments, a singleton
-    object."""
-
-    def _get_singleton_instance(cls):
-        return cls._INSTANCE
-
-    @classmethod
-    def __prepare__(mcs, name, bases):  # pylint: disable=unused-argument
-        return {"__new__": mcs._get_singleton_instance}
-
-    @staticmethod
-    def __new__(cls, name, bases, namespace):
-        out = super().__new__(cls, name, bases, namespace)
-        out._INSTANCE = object.__new__(out)  # pylint: disable=invalid-name
-        return out
-
-
-class Type:
-    """Root base class of all nodes in the type tree.  The base case should never be instantiated
-    directly.
-
-    This must not be subclassed by users; subclasses form the internal data of the representation of
-    expressions, and it does not make sense to add more outside of Qiskit library code."""
-
-    __slots__ = ()
-
-    @property
-    def kind(self):
-        """Get the kind of this type.  This is exactly equal to the Python type object that defines
-        this type, that is ``t.kind is type(t)``, but is exposed like this to make it clear that
-        this a hashable enum-like discriminator you can rely on."""
-        return self.__class__
-
-    # Enforcement of immutability.  The constructor methods need to manually skip this.
-
-    def __setattr__(self, _key, _value):
-        raise AttributeError(f"'{self.kind.__name__}' instances are immutable")
-
-    def __copy__(self):
-        return self
-
-    def __deepcopy__(self, _memo):
-        return self
-
-    def __setstate__(self, state):
-        _dict, slots = state
-        for slot, value in slots.items():
-            # We need to overcome the type's enforcement of immutability post initialization.
-            super().__setattr__(slot, value)
-
-
-@typing.final
-class Bool(Type, metaclass=_Singleton):
-    """The Boolean type.  This has exactly two values: ``True`` and ``False``."""
-
-    __slots__ = ()
-
-    def __repr__(self):
-        return "Bool()"
-
-    def __hash__(self):
-        return hash(self.__class__)
-
-    def __eq__(self, other):
-        return isinstance(other, Bool)
-
-
-@typing.final
-class Uint(Type):
-    """An unsigned integer of fixed bit width."""
-
-    __slots__ = ("width",)
-
-    def __init__(self, width: int):
-        if isinstance(width, int) and width <= 0:
-            raise ValueError("uint width must be greater than zero")
-        super(Type, self).__setattr__("width", width)
-
-    def __repr__(self):
-        return f"Uint({self.width})"
-
-    def __hash__(self):
-        return hash((self.__class__, self.width))
-
-    def __eq__(self, other):
-        return isinstance(other, Uint) and self.width == other.width
-
-
-@typing.final
-class Float(Type, metaclass=_Singleton):
-    """An IEEE-754 double-precision floating point number.
-    In the future, this may also be used to represent other fixed-width floats.
-    """
-
-    __slots__ = ()
-
-    def __repr__(self):
-        return "Float()"
-
-    def __hash__(self):
-        return hash(self.__class__)
-
-    def __eq__(self, other):
-        return isinstance(other, Float)
-
-
-@typing.final
-class Duration(Type, metaclass=_Singleton):
-    """A length of time, possibly negative."""
-
-    __slots__ = ()
-
-    def __repr__(self):
-        return "Duration()"
-
-    def __hash__(self):
-        return hash(self.__class__)
-
-    def __eq__(self, other):
-        return isinstance(other, Duration)
+from qiskit._accelerate.circuit.classical.types import (
+    Type,
+    Bool,
+    Uint,
+    Float,
+    Duration,
+)  # pylint: disable=unused-import

qiskit/circuit/controlflow/box.py

@@ -16,11 +16,12 @@ from __future__ import annotations
 
 import typing
 
+from qiskit.circuit.delay import Delay
 from qiskit.circuit.exceptions import CircuitError
 from .control_flow import ControlFlowOp
 
 if typing.TYPE_CHECKING:
-    from qiskit.circuit import QuantumCircuit
+    from qiskit.circuit import QuantumCircuit, Annotation
 
 
 class BoxOp(ControlFlowOp):
@@ -31,6 +32,11 @@ class BoxOp(ControlFlowOp):
     commute operations "all the way" through the box.  The box is also an explicit scope for the
     purposes of variables, stretches and compiler passes.
 
+    A box may be "annotated" with arbitrary user-defined custom :class:`.Annotation` objects.  In
+    cases where order is important, these should be interpreted by applying the first annotation in
+    the list first, then the second, and so on.  It is generally recommended that annotations should
+    not be order-dependent, wherever possible.
+
     Typically you create this by using the builder-interface form of :meth:`.QuantumCircuit.box`.
     """
 
@@ -38,8 +44,9 @@ class BoxOp(ControlFlowOp):
         self,
         body: QuantumCircuit,
         duration: None = None,
-        unit: typing.Literal["dt", "s", "ms", "us", "ns", "ps"] = "dt",
+        unit: typing.Literal["dt", "s", "ms", "us", "ns", "ps", "expr"] | None = None,
         label: str | None = None,
+        annotations: typing.Iterable[Annotation] = (),
     ):
         """
         Default constructor of :class:`BoxOp`.
@@ -52,10 +59,13 @@ class BoxOp(ControlFlowOp):
             duration: an optional duration for the box as a whole.
             unit: the unit of the ``duration``.
             label: an optional string label for the instruction.
+            annotations: any :class:`.Annotation`\\ s to apply to the box.  In cases where order
+                is important, annotations are to be interpreted in the same order they appear in
+                the iterable.
         """
         super().__init__("box", body.num_qubits, body.num_clbits, [body], label=label)
-        self.duration = duration
-        self.unit = unit
+        self.annotations = list(annotations)
+        self.duration, self.unit = Delay._validate_arguments(duration, unit)
 
     @property
     def params(self):
@@ -100,13 +110,20 @@ class BoxOp(ControlFlowOp):
 
     def replace_blocks(self, blocks):
         (body,) = blocks
-        return BoxOp(body, duration=self.duration, unit=self.unit, label=self.label)
+        return BoxOp(
+            body,
+            duration=self.duration,
+            unit=self.unit,
+            label=self.label,
+            annotations=self.annotations,
+        )
 
     def __eq__(self, other):
         return (
             isinstance(other, BoxOp)
             and self.duration == other.duration
             and self.unit == other.unit
+            and self.annotations == other.annotations
             and super().__eq__(other)
         )
 
@@ -117,7 +134,7 @@ class BoxContext:
     This is not part of the public interface, and should not be instantiated by users.
     """
 
-    __slots__ = ("_circuit", "_duration", "_unit", "_label")
+    __slots__ = ("_circuit", "_duration", "_unit", "_label", "_annotations")
 
     def __init__(
         self,
@@ -126,6 +143,7 @@ class BoxContext:
         duration: None = None,
         unit: typing.Literal["dt", "s", "ms", "us", "ns", "ps"] = "dt",
         label: str | None = None,
+        annotations: typing.Iterable[Annotation] = (),
     ):
         """
         Args:
@@ -138,6 +156,7 @@ class BoxContext:
         self._duration = duration
         self._unit = unit
         self._label = label
+        self._annotations = annotations
 
     def __enter__(self):
         # For a box to have the semantics of internal qubit alignment with a resolvable duration, we
@@ -156,7 +175,13 @@ class BoxContext:
         # `box` permitted.
         body = scope.build(scope.qubits(), scope.clbits())
         self._circuit.append(
-            BoxOp(body, duration=self._duration, unit=self._unit, label=self._label),
+            BoxOp(
+                body,
+                duration=self._duration,
+                unit=self._unit,
+                label=self._label,
+                annotations=self._annotations,
+            ),
             body.qubits,
             body.clbits,
         )

qiskit/circuit/delay.py

@@ -44,6 +44,13 @@ class Delay(Instruction):
             CircuitError: A ``duration`` expression was specified with a resolved
                 type that is not timing-based, or the ``unit`` was improperly specified.
         """
+        duration, self._unit = self._validate_arguments(duration, unit)
+        super().__init__("delay", 1, 0, params=[duration])
+
+    @staticmethod
+    def _validate_arguments(duration, unit):
+        # This method is a centralization of the unit-handling logic, so used elsewhere in Qiskit
+        # (e.g. in `BoxOp`).
         if isinstance(duration, expr.Expr):
             if unit is not None and unit != "expr":
                 raise CircuitError(
@@ -60,12 +67,7 @@ class Delay(Instruction):
             unit = "dt"
         elif unit not in {"s", "ms", "us", "ns", "ps", "dt"}:
             raise CircuitError(f"Unknown unit {unit} is specified.")
-        # Double underscore to differentiate from the private attribute in
-        # `Instruction`. This can be changed to `_unit` in 2.0 after we
-        # remove `unit` and `duration` from the standard instruction model
-        # as it only will exist in `Delay` after that point.
-        self.__unit = unit
-        super().__init__("delay", 1, 0, params=[duration])
+        return duration, unit
 
     broadcast_arguments = Gate.broadcast_arguments
 
@@ -76,13 +78,13 @@ class Delay(Instruction):
     @property
     def unit(self):
         """The unit for the duration of the delay in :attr`.params`"""
-        return self.__unit
+        return self._unit
 
     @unit.setter
     def unit(self, value):
         if value not in {"s", "ms", "us", "ns", "ps", "dt"}:
             raise CircuitError(f"Unknown unit {value} is specified.")
-        self.__unit = value
+        self._unit = value
 
     @property
     def duration(self):
@@ -126,7 +128,7 @@ class Delay(Instruction):
                 raise CircuitError(
                     f"Duration for Delay instruction must be positive. Found {parameter}"
                 )
-            if self.__unit == "dt":
+            if self._unit == "dt":
                 parameter_int = int(parameter)
                 if parameter != parameter_int:
                     raise CircuitError("Integer duration is expected for 'dt' unit.")

qiskit/circuit/library/arithmetic/adders/adder.py

@@ -43,14 +43,14 @@ class Adder(QuantumCircuit):
     """
 
     @deprecate_func(
-        since="1.3",
+        since="2.1",
         additional_msg=(
             "Use the adder gates provided in qiskit.circuit.library.arithmetic instead. "
             "The gate type depends on the adder kind: fixed, half, full are represented by "
             "ModularAdderGate, HalfAdderGate, FullAdderGate, respectively. For different adder "
             "implementations, see https://quantum.cloud.ibm.com/docs/api/qiskit/synthesis.",
         ),
-        pending=True,
+        removal_timeline="in Qiskit 3.0",
     )
     def __init__(self, num_state_qubits: int, name: str = "Adder") -> None:
         """
@@ -118,12 +118,12 @@ class HalfAdderGate(Gate):
 
     def _define(self):
         """Populates self.definition with some decomposition of this gate."""
-        from qiskit.synthesis.arithmetic import adder_qft_d00
+        from qiskit.synthesis.arithmetic import adder_ripple_r25
 
         # This particular decomposition does not use any ancilla qubits.
         # Note that the transpiler may choose a different decomposition
         # based on the number of ancilla qubits available.
-        self.definition = adder_qft_d00(self.num_state_qubits, kind="half")
+        self.definition = adder_ripple_r25(self.num_state_qubits)
 
 
 class ModularAdderGate(Gate):

qiskit/circuit/library/arithmetic/multipliers/multiplier.py

@@ -47,13 +47,13 @@ class Multiplier(QuantumCircuit):
     """
 
     @deprecate_func(
-        since="1.3",
+        since="2.1",
         additional_msg=(
             "Use the MultiplierGate provided in qiskit.circuit.library.arithmetic instead. "
             "For different multiplier implementations, see "
             "https://quantum.cloud.ibm.com/docs/api/qiskit/synthesis.",
         ),
-        pending=True,
+        removal_timeline="in Qiskit 3.0",
     )
     def __init__(
         self,

qiskit/circuit/library/arithmetic/piecewise_chebyshev.py

@@ -13,6 +13,7 @@
 """Piecewise polynomial Chebyshev approximation to a given f(x)."""
 
 from __future__ import annotations
+import warnings
 from typing import Callable
 import numpy as np
 from numpy.polynomial.chebyshev import Chebyshev
@@ -345,9 +346,12 @@ class PiecewiseChebyshev(BlueprintCircuit):
 
         super()._build()
 
-        poly_r = PiecewisePolynomialPauliRotations(
-            self.num_state_qubits, self.breakpoints, self.polynomials, name=self.name
-        )
+        # the class itself is deprecated, no need to raise additional warnings during runtime
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+            poly_r = PiecewisePolynomialPauliRotations(
+                self.num_state_qubits, self.breakpoints, self.polynomials, name=self.name
+            )
 
         # Apply polynomial approximation
         self.append(poly_r.to_gate(), self.qubits)
@@ -373,7 +377,7 @@ class PiecewiseChebyshevGate(Gate):
             from qiskit import QuantumCircuit
             from qiskit.circuit.library.arithmetic import PiecewiseChebyshevGate
 
-            f_x, num_state_qubits, degree, breakpoints = lambda x: np.arcsin(1 / x), 2, 2, [2, 4]
+            f_x, num_state_qubits, degree, breakpoints = lambda x: np.sin(1 / x), 2, 2, [2, 4]
             pw_approximation = PiecewiseChebyshevGate(f_x, num_state_qubits, degree, breakpoints)
 
             qc = QuantumCircuit(pw_approximation.num_qubits)

qiskit/circuit/library/arithmetic/piecewise_linear_pauli_rotations.py

@@ -14,6 +14,7 @@
 """Piecewise-linearly-controlled rotation."""
 
 from __future__ import annotations
+import warnings
 from collections.abc import Sequence
 import numpy as np
 
@@ -244,32 +245,39 @@ class PiecewiseLinearPauliRotations(FunctionalPauliRotations):
         # apply comparators and controlled linear rotations
         for i, point in enumerate(self.breakpoints):
             if i == 0 and self.contains_zero_breakpoint:
-                # apply rotation
-                lin_r = LinearPauliRotations(
-                    num_state_qubits=self.num_state_qubits,
-                    slope=self.mapped_slopes[i],
-                    offset=self.mapped_offsets[i],
-                    basis=self.basis,
-                )
+                # deprecation warning is already triggered upon init, filter the rest
+                with warnings.catch_warnings():
+                    warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+                    # apply rotation
+                    lin_r = LinearPauliRotations(
+                        num_state_qubits=self.num_state_qubits,
+                        slope=self.mapped_slopes[i],
+                        offset=self.mapped_offsets[i],
+                        basis=self.basis,
+                    )
                 circuit.append(lin_r.to_gate(), qr_state[:] + qr_target)
 
             else:
                 qr_compare = [qr_ancilla[0]]
                 qr_helper = qr_ancilla[1:]
 
-                # apply Comparator
-                comp = IntegerComparator(num_state_qubits=self.num_state_qubits, value=point)
+                with warnings.catch_warnings():
+                    warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+                    # apply Comparator
+                    comp = IntegerComparator(num_state_qubits=self.num_state_qubits, value=point)
                 qr = qr_state[:] + qr_compare[:]  # add ancilla as compare qubit
 
                 circuit.append(comp.to_gate(), qr[:] + qr_helper[: comp.num_ancillas])
 
                 # apply controlled rotation
-                lin_r = LinearPauliRotations(
-                    num_state_qubits=self.num_state_qubits,
-                    slope=self.mapped_slopes[i],
-                    offset=self.mapped_offsets[i],
-                    basis=self.basis,
-                )
+                with warnings.catch_warnings():
+                    warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+                    lin_r = LinearPauliRotations(
+                        num_state_qubits=self.num_state_qubits,
+                        slope=self.mapped_slopes[i],
+                        offset=self.mapped_offsets[i],
+                        basis=self.basis,
+                    )
                 circuit.append(lin_r.to_gate().control(), qr_compare[:] + qr_state[:] + qr_target)
 
                 # uncompute comparator

qiskit/circuit/library/arithmetic/piecewise_polynomial_pauli_rotations.py

@@ -13,6 +13,7 @@
 """Piecewise-polynomially-controlled Pauli rotations."""
 
 from __future__ import annotations
+import warnings
 from typing import List, Optional
 import numpy as np
 
@@ -271,17 +272,22 @@ class PiecewisePolynomialPauliRotations(FunctionalPauliRotations):
         # apply comparators and controlled linear rotations
         for i, point in enumerate(self.breakpoints[:-1]):
             if i == 0 and self.contains_zero_breakpoint:
-                # apply rotation
-                poly_r = PolynomialPauliRotations(
-                    num_state_qubits=self.num_state_qubits,
-                    coeffs=self.mapped_coeffs[i],
-                    basis=self.basis,
-                )
+                # the class itself is deprecated, no need to raise additional warnings during runtime
+                with warnings.catch_warnings():
+                    warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+                    poly_r = PolynomialPauliRotations(
+                        num_state_qubits=self.num_state_qubits,
+                        coeffs=self.mapped_coeffs[i],
+                        basis=self.basis,
+                    )
                 circuit.append(poly_r.to_gate(), qr_state[:] + qr_target)
 
             else:
-                # apply Comparator
-                comp = IntegerComparator(num_state_qubits=self.num_state_qubits, value=point)
+                # the class itself is deprecated, no need to raise additional warnings during runtime
+                with warnings.catch_warnings():
+                    warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+                    comp = IntegerComparator(num_state_qubits=self.num_state_qubits, value=point)
+
                 qr_state_full = qr_state[:] + [qr_ancilla[0]]  # add compare qubit
                 qr_remaining_ancilla = qr_ancilla[1:]  # take remaining ancillas
 
@@ -289,12 +295,14 @@ class PiecewisePolynomialPauliRotations(FunctionalPauliRotations):
                     comp.to_gate(), qr_state_full[:] + qr_remaining_ancilla[: comp.num_ancillas]
                 )
 
-                # apply controlled rotation
-                poly_r = PolynomialPauliRotations(
-                    num_state_qubits=self.num_state_qubits,
-                    coeffs=self.mapped_coeffs[i],
-                    basis=self.basis,
-                )
+                # the class itself is deprecated, no need to raise additional warnings during runtime
+                with warnings.catch_warnings():
+                    warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+                    poly_r = PolynomialPauliRotations(
+                        num_state_qubits=self.num_state_qubits,
+                        coeffs=self.mapped_coeffs[i],
+                        basis=self.basis,
+                    )
                 circuit.append(
                     poly_r.to_gate().control(), [qr_ancilla[0]] + qr_state[:] + qr_target
                 )

qiskit/circuit/library/arithmetic/quadratic_form.py

@@ -21,6 +21,7 @@ from collections.abc import Sequence
 import numpy as np
 
 from qiskit.circuit import QuantumCircuit, QuantumRegister, ParameterExpression, Gate, CircuitError
+from qiskit.utils.deprecation import deprecate_func
 from ..basis_change import QFT, QFTGate
 
 _ValueType = Union[int, float, np.integer, np.floating, ParameterExpression]
@@ -64,6 +65,11 @@ class QuadraticForm(QuantumCircuit):
 
     """
 
+    @deprecate_func(
+        since="2.1",
+        additional_msg="Use the QuadraticFormGate instead.",
+        removal_timeline="Qiskit 3.0",
+    )
     def __init__(
         self,
         num_result_qubits: Optional[int] = None,

qiskit/circuit/library/arithmetic/weighted_adder.py

@@ -14,6 +14,7 @@
 
 from __future__ import annotations
 
+import warnings
 from typing import List, Optional
 import numpy as np
 
@@ -263,12 +264,18 @@ class WeightedAdder(BlueprintCircuit):
                         # - controlled by q_state[i]
                         circuit.x(qr_sum[j])
                         circuit.x(qr_carry[j - 1])
-                        circuit.mcx(
-                            [q_state, qr_sum[j], qr_carry[j - 1]],
-                            qr_carry[j],
-                            qr_control,
-                            mode="v-chain",
-                        )
+
+                        with warnings.catch_warnings():
+                            warnings.filterwarnings(
+                                "ignore", category=DeprecationWarning, module="qiskit"
+                            )
+                            circuit.mcx(
+                                [q_state, qr_sum[j], qr_carry[j - 1]],
+                                qr_carry[j],
+                                qr_control,
+                                mode="v-chain",
+                            )
+
                         circuit.cx(q_state, qr_carry[j])
                         circuit.x(qr_sum[j])
                         circuit.x(qr_carry[j - 1])
@@ -287,12 +294,16 @@ class WeightedAdder(BlueprintCircuit):
                     else:
                         # compute (q_sum[j] + q_carry[j-1]) into (q_sum[j], q_carry[j])
                         # - controlled by q_state[i]
-                        circuit.mcx(
-                            [q_state, qr_sum[j], qr_carry[j - 1]],
-                            qr_carry[j],
-                            qr_control,
-                            mode="v-chain",
-                        )
+                        with warnings.catch_warnings():
+                            warnings.filterwarnings(
+                                "ignore", category=DeprecationWarning, module="qiskit"
+                            )
+                            circuit.mcx(
+                                [q_state, qr_sum[j], qr_carry[j - 1]],
+                                qr_carry[j],
+                                qr_control,
+                                mode="v-chain",
+                            )
                         circuit.ccx(q_state, qr_carry[j - 1], qr_sum[j])
 
             # uncompute carry qubits
@@ -309,12 +320,16 @@ class WeightedAdder(BlueprintCircuit):
                         pass
                     else:
                         circuit.x(qr_carry[j - 1])
-                        circuit.mcx(
-                            [q_state, qr_sum[j], qr_carry[j - 1]],
-                            qr_carry[j],
-                            qr_control,
-                            mode="v-chain",
-                        )
+                        with warnings.catch_warnings():
+                            warnings.filterwarnings(
+                                "ignore", category=DeprecationWarning, module="qiskit"
+                            )
+                            circuit.mcx(
+                                [q_state, qr_sum[j], qr_carry[j - 1]],
+                                qr_carry[j],
+                                qr_control,
+                                mode="v-chain",
+                            )
                         circuit.cx(q_state, qr_carry[j])
                         circuit.x(qr_carry[j - 1])
                 else:
@@ -328,12 +343,16 @@ class WeightedAdder(BlueprintCircuit):
                         # compute (q_sum[j] + q_carry[j-1]) into (q_sum[j], q_carry[j])
                         # - controlled by q_state[i]
                         circuit.x(qr_sum[j])
-                        circuit.mcx(
-                            [q_state, qr_sum[j], qr_carry[j - 1]],
-                            qr_carry[j],
-                            qr_control,
-                            mode="v-chain",
-                        )
+                        with warnings.catch_warnings():
+                            warnings.filterwarnings(
+                                "ignore", category=DeprecationWarning, module="qiskit"
+                            )
+                            circuit.mcx(
+                                [q_state, qr_sum[j], qr_carry[j - 1]],
+                                qr_carry[j],
+                                qr_control,
+                                mode="v-chain",
+                            )
                         circuit.x(qr_sum[j])
 
         self.append(circuit.to_gate(), self.qubits)

qiskit/circuit/library/basis_change/qft.py

@@ -76,12 +76,12 @@ class QFT(BlueprintCircuit):
     """
 
     @deprecate_func(
-        since="1.3",
+        since="2.1",
         additional_msg=(
             "Use qiskit.circuit.library.QFTGate or qiskit.synthesis.qft.synth_qft_full instead, "
             "for access to all previous arguments.",
         ),
-        pending=True,
+        removal_timeline="in Qiskit 3.0",
     )
     def __init__(
         self,