qiskit 1.4.2__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/circuit/instruction.py

@@ -34,21 +34,17 @@ The circuit itself keeps this context.
 from __future__ import annotations
 
 import copy
-import warnings
 from itertools import zip_longest
 import math
-from typing import List, Type
+from typing import Type
 
 import numpy
 
 from qiskit.circuit.exceptions import CircuitError
-from qiskit.circuit.classicalregister import ClassicalRegister, Clbit
-from qiskit.qobj.qasm_qobj import QasmQobjInstruction
 from qiskit.circuit.parameter import ParameterExpression
 from qiskit.circuit.operation import Operation
 
 from qiskit.circuit.annotated_operation import AnnotatedOperation, InverseModifier
-from qiskit.utils import deprecate_func
 
 _CUTOFF_PRECISION = 1e-10
 
@@ -61,7 +57,7 @@ class Instruction(Operation):
     _directive = False
     _standard_gate = None
 
-    def __init__(self, name, num_qubits, num_clbits, params, duration=None, unit="dt", label=None):
+    def __init__(self, name, num_qubits, num_clbits, params, label=None):
         """Create a new instruction.
 
         .. deprecated:: 1.3
@@ -75,9 +71,6 @@ class Instruction(Operation):
             num_clbits (int): instruction's clbit width
             params (list[int|float|complex|str|ndarray|list|ParameterExpression]):
                 list of parameters
-            duration (int|float): (DEPRECATED) instruction's duration. it must be
-                an integer if ``unit`` is ``'dt'``
-            unit (str): (DEPRECATED) time unit of duration
             label (str or None): An optional label for identifying the instruction.
 
         Raises:
@@ -103,30 +96,9 @@ class Instruction(Operation):
             if label is not None and not isinstance(label, str):
                 raise TypeError("label expects a string or None")
             self._label = label
-        # tuple (ClassicalRegister, int), tuple (Clbit, bool) or tuple (Clbit, int)
-        # when the instruction has a conditional ("if")
-        self._condition = None
         # list of instructions (and their contexts) that this instruction is composed of
         # empty definition means opaque or fundamental instruction
         self._definition = None
-        if duration is not None:
-            warnings.warn(
-                "Setting a custom duration per instruction is deprecated as of Qiskit "
-                "1.3.0. It will be removed in Qiskit 2.0.0. An instruction's duration "
-                "is defined in a backend's Target object.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-        self._duration = duration
-        if unit is not None and unit != "dt":
-            warnings.warn(
-                "Setting a custom unit for duration per instruction is deprecated as of Qiskit "
-                "1.3.0. It will be removed in Qiskit 2.0.0. An instruction's duration "
-                "is defined in a backend's Target object which has a fixed unit in seconds.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-        self._unit = unit
 
         self.params = params  # must be at last (other properties may be required for validation)
 
@@ -181,16 +153,6 @@ class Instruction(Operation):
         """
         return self.copy()
 
-    @property
-    @deprecate_func(since="1.3.0", removal_timeline="in 2.0.0", is_property=True)
-    def condition(self):
-        """The classical condition on the instruction."""
-        return self._condition
-
-    @condition.setter
-    def condition(self, condition):
-        self._condition = condition
-
     def __eq__(self, other):
         """Two instructions are the same if they have the same name,
         same dimensions, and same params.
@@ -363,64 +325,6 @@ class Instruction(Operation):
 
         sel.add_equivalence(self, decomposition)
 
-    @property
-    @deprecate_func(since="1.3.0", removal_timeline="in Qiskit 2.0.0", is_property=True)
-    def duration(self):
-        """Get the duration."""
-        return self._duration
-
-    @duration.setter
-    def duration(self, value):
-        """Set the duration."""
-        self._duration = value
-
-    @property
-    @deprecate_func(since="1.3.0", removal_timeline="in Qiskit 2.0.0", is_property=True)
-    def unit(self):
-        """Get the time unit of duration."""
-        return self._unit
-
-    @unit.setter
-    def unit(self, value):
-        """Set the time unit of duration."""
-        self._unit = value
-
-    @deprecate_func(
-        since="1.2",
-        removal_timeline="in the 2.0 release",
-        additional_msg="The `Qobj` class and related functionality are part of the deprecated "
-        "`BackendV1` workflow,  and no longer necessary for `BackendV2`. If a user "
-        "workflow requires `Qobj` it likely relies on deprecated functionality and "
-        "should be updated to use `BackendV2`.",
-    )
-    def assemble(self):
-        """Assemble a QasmQobjInstruction"""
-        return self._assemble()
-
-    def _assemble(self):
-        with warnings.catch_warnings():
-            # The class QasmQobjInstruction is deprecated
-            warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
-            instruction = QasmQobjInstruction(name=self.name)
-        # Evaluate parameters
-        if self.params:
-            params = [x.evalf(x) if hasattr(x, "evalf") else x for x in self.params]
-            instruction.params = params
-        # Add placeholder for qarg and carg params
-        if self.num_qubits:
-            instruction.qubits = list(range(self.num_qubits))
-        if self.num_clbits:
-            instruction.memory = list(range(self.num_clbits))
-        # Add label if defined
-        if self.label:
-            instruction.label = self.label
-        # Add condition parameters for assembler. This is needed to convert
-        # to a qobj conditional instruction at assemble time and after
-        # conversion will be deleted by the assembler.
-        if self._condition:
-            instruction._condition = self._condition
-        return instruction
-
     @property
     def label(self) -> str:
         """Return instruction label"""
@@ -524,27 +428,6 @@ class Instruction(Operation):
         inverse_gate.definition = inverse_definition
         return inverse_gate
 
-    @deprecate_func(since="1.3.0", removal_timeline="in 2.0.0")
-    def c_if(self, classical, val):
-        """Set a classical equality condition on this instruction between the register or cbit
-        ``classical`` and value ``val``.
-
-        .. note::
-
-            This is a setter method, not an additive one.  Calling this multiple times will silently
-            override any previously set condition; it does not stack.
-        """
-        if not isinstance(classical, (ClassicalRegister, Clbit)):
-            raise CircuitError("c_if must be used with a classical register or classical bit")
-        if val < 0:
-            raise CircuitError("condition value should be non-negative")
-        if isinstance(classical, Clbit):
-            # Casting the conditional value as Boolean when
-            # the classical condition is on a classical bit.
-            val = bool(val)
-        self._condition = (classical, val)
-        return self
-
     def copy(self, name=None):
         """
         Copy of the instruction.
@@ -611,12 +494,6 @@ class Instruction(Operation):
     def repeat(self, n):
         """Creates an instruction with ``self`` repeated :math`n` times.
 
-        If this operation has a conditional, the output instruction will have the same conditional
-        and the inner repeated operations will be unconditional; instructions within a compound
-        definition cannot be conditioned on registers within Qiskit's data model.  This means that
-        it is not valid to apply a repeated instruction to a clbit that it both writes to and reads
-        from in its condition.
-
         Args:
             n (int): Number of times to repeat the instruction
 
@@ -640,28 +517,12 @@ class Instruction(Operation):
             qargs = tuple(qc.qubits)
             cargs = tuple(qc.clbits)
             base = self.copy()
-            if self._condition:
-                # Condition is handled on the outer instruction.
-                base = base.to_mutable()
-                base.condition = None
             for _ in [None] * n:
                 qc._append(CircuitInstruction(base, qargs, cargs))
 
             instruction.definition = qc
-        if self._condition:
-            instruction = instruction.c_if(*self._condition)
         return instruction
 
-    @property
-    @deprecate_func(since="1.3.0", removal_timeline="in 2.0.0", is_property=True)
-    def condition_bits(self) -> List[Clbit]:
-        """Get Clbits in condition."""
-        from qiskit.circuit.controlflow import condition_resources  # pylint: disable=cyclic-import
-
-        if self._condition is None:
-            return []
-        return list(condition_resources(self._condition).clbits)
-
     @property
     def name(self):
         """Return the name."""

qiskit/circuit/instructionset.py

@@ -17,14 +17,15 @@ Instruction collection.
 from __future__ import annotations
 
 from collections.abc import MutableSequence
-from typing import Callable
+from typing import Callable, TYPE_CHECKING
 
 from qiskit.circuit.exceptions import CircuitError
-from qiskit.utils import deprecate_func
-from .classicalregister import Clbit, ClassicalRegister
 from .operation import Operation
 from .quantumcircuitdata import CircuitInstruction
 
+if TYPE_CHECKING:
+    from qiskit.circuit import Clbit, ClassicalRegister
+
 
 class InstructionSet:
     """Instruction collection, and their contexts."""
@@ -50,9 +51,9 @@ class InstructionSet:
 
                 .. note::
 
-                    The callback ``resource_requester`` is called once for each call to
-                    :meth:`.c_if`, and assumes that a call implies that the resource will now be
-                    used.  It may throw an error if the resource is not valid for usage.
+                    The callback ``resource_requester`` assumes that a call implies that the
+                    resource will now be used.  It may throw an error if the resource is not valid
+                    for usage.
 
         """
         self._instructions: list[
@@ -106,54 +107,6 @@ class InstructionSet:
                 )
         return self
 
-    @deprecate_func(since="1.3.0", removal_timeline="in 2.0.0")
-    def c_if(self, classical: Clbit | ClassicalRegister | int, val: int) -> "InstructionSet":
-        """Set a classical equality condition on all the instructions in this set between the
-        :obj:`.ClassicalRegister` or :obj:`.Clbit` ``classical`` and value ``val``.
-
-        .. note::
-            You should prefer to use the :meth:`.QuantumCircuit.if_test` builder interface, rather
-            than using this method.
-
-        .. note::
-
-            This is a setter method, not an additive one.  Calling this multiple times will silently
-            override any previously set condition on any of the contained instructions; it does not
-            stack.
-
-        Args:
-            classical: the classical resource the equality condition should be on.  If this is given
-                as an integer, it will be resolved into a :obj:`.Clbit` using the same conventions
-                as the circuit these instructions are attached to.
-            val: the value the classical resource should be equal to.
-
-        Returns:
-            This same instance of :obj:`.InstructionSet`, but now mutated to have the given equality
-            condition.
-
-        Raises:
-            CircuitError: if the passed classical resource is invalid, or otherwise not resolvable
-                to a concrete resource that these instructions are permitted to access.
-        """
-        if self._requester is None and not isinstance(classical, (Clbit, ClassicalRegister)):
-            raise CircuitError(
-                "Cannot pass an index as a condition variable without specifying a requester"
-                " when creating this InstructionSet."
-            )
-        if self._requester is not None:
-            classical = self._requester(classical)
-        for idx, instruction in enumerate(self._instructions):
-            if isinstance(instruction, CircuitInstruction):
-                updated = instruction.operation.c_if(classical, val)
-                self._instructions[idx] = instruction.replace(operation=updated)
-            else:
-                data, idx = instruction
-                instruction = data[idx]
-                data[idx] = instruction.replace(
-                    operation=instruction.operation.c_if(classical, val)
-                )
-        return self
-
     # Legacy support for properties.  Added in Terra 0.21 to support the internal switch in
     # `QuantumCircuit.data` from the 3-tuple to `CircuitInstruction`.