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

qiskit/circuit/controlflow/builder.py

@@ -25,13 +25,13 @@ import typing
 from typing import Collection, Iterable, FrozenSet, Tuple, Union, Optional, Sequence
 
 from qiskit._accelerate.circuit import CircuitData
+from qiskit.circuit import Register
 from qiskit.circuit.classical import expr
-from qiskit.circuit.classicalregister import Clbit, ClassicalRegister
+from qiskit.circuit import Clbit, ClassicalRegister
 from qiskit.circuit.exceptions import CircuitError
 from qiskit.circuit.instruction import Instruction
 from qiskit.circuit.quantumcircuitdata import CircuitInstruction
-from qiskit.circuit.quantumregister import Qubit, QuantumRegister
-from qiskit.circuit.register import Register
+from qiskit.circuit import Qubit, QuantumRegister
 
 from ._builder_utils import condition_resources, node_resources
 
@@ -121,6 +121,18 @@ class CircuitScopeInterface(abc.ABC):
                 redefines an existing name.
         """
 
+    @abc.abstractmethod
+    def add_stretch(self, stretch: expr.Stretch):
+        """Add a stretch to the circuit scope.
+
+        Args:
+            stretch: the stretch to add, if valid.
+
+        Raises:
+            CircuitError: if the stretch cannot be added, such as because it invalidly shadows or
+                redefines an existing name.
+        """
+
     @abc.abstractmethod
     def remove_var(self, var: expr.Var):
         """Remove a variable from the locals of this scope.
@@ -133,6 +145,18 @@ class CircuitScopeInterface(abc.ABC):
                 :meth:`add_uninitialized_var` call.
         """
 
+    @abc.abstractmethod
+    def remove_stretch(self, stretch: expr.Stretch):
+        """Remove a stretch from the locals of this scope.
+
+        This is only called in the case that an exception occurred while initializing the stretch,
+        and is not exposed to users.
+
+        Args:
+            stretch: the stretch to remove.  It can be assumed that this was already the subject of an
+                :meth:`add_stretch` call.
+        """
+
     @abc.abstractmethod
     def use_var(self, var: expr.Var):
         """Called for every standalone classical real-time variable being used by some circuit
@@ -145,13 +169,21 @@ class CircuitScopeInterface(abc.ABC):
         Args:
             var: the variable to validate.
 
-        Returns:
-            the same variable.
-
         Raises:
             CircuitError: if the variable is not valid for this scope.
         """
 
+    @abc.abstractmethod
+    def use_stretch(self, stretch: expr.Stretch):
+        """Called for every stretch being used by some circuit instruction.
+
+        Args:
+            stretch: the stretch to validate.
+
+        Raises:
+            CircuitError: if the stretch is not valid for this scope.
+        """
+
     @abc.abstractmethod
     def get_var(self, name: str) -> Optional[expr.Var]:
         """Get the variable (if any) in scope with the given name.
@@ -166,6 +198,27 @@ class CircuitScopeInterface(abc.ABC):
             the variable if it is found, otherwise ``None``.
         """
 
+    @abc.abstractmethod
+    def get_stretch(self, name: str) -> Optional[expr.Stretch]:
+        """Get the stretch (if any) in scope with the given name.
+
+        This should call up to the parent scope if in a control-flow builder scope, in case the
+        stretch exists in an outer scope.
+
+        Args:
+            name: the name of the symbol to lookup.
+
+        Returns:
+            the stretch if it is found, otherwise ``None``.
+        """
+
+    @abc.abstractmethod
+    def use_qubit(self, qubit: Qubit):
+        """Called to mark that a :class:`~.circuit.Qubit` should be considered "used" by this scope,
+        without appending an explicit instruction.
+
+        The subclass may assume that the ``qubit`` is valid for the root scope."""
+
 
 class InstructionResources(typing.NamedTuple):
     """The quantum and classical resources used within a particular instruction.
@@ -198,10 +251,12 @@ class InstructionPlaceholder(Instruction, abc.ABC):
         with qc.for_loop(range(5)):
             qc.h(0)
             qc.measure(0, 0)
-            qc.break_loop().c_if(0, 0)
+            with qc.if_test((0, 0)):
+                qc.break_loop()
 
-    since ``qc.break_loop()`` needs to return a (mostly) functional
-    :obj:`~qiskit.circuit.Instruction` in order for :meth:`.InstructionSet.c_if` to work correctly.
+    ``qc.break_loop()`` needed to return a (mostly) functional
+    :obj:`~qiskit.circuit.Instruction` in order for the historical ``.InstructionSet.c_if``
+    to work correctly.
 
     When appending a placeholder instruction into a circuit scope, you should create the
     placeholder, and then ask it what resources it should be considered as using from the start by
@@ -234,9 +289,6 @@ class InstructionPlaceholder(Instruction, abc.ABC):
             The caller of this function is responsible for ensuring that the inputs to this function
             are non-strict supersets of the bits returned by :meth:`placeholder_resources`.
 
-        Any condition added in by a call to :obj:`.Instruction.c_if` will be propagated through, but
-        set properties like ``duration`` will not; it doesn't make sense for control-flow operations
-        to have pulse scheduling on them.
 
         Args:
             qubits: The qubits the created instruction should be defined across.
@@ -265,34 +317,9 @@ class InstructionPlaceholder(Instruction, abc.ABC):
         """
         raise NotImplementedError
 
-    def _copy_mutable_properties(self, instruction: Instruction) -> Instruction:
-        """Copy mutable properties from ourselves onto a non-placeholder instruction.
-
-        The mutable properties are expected to be things like ``condition``, added onto a
-        placeholder by the :meth:`c_if` method.  This mutates ``instruction``, and returns the same
-        instance that was passed.  This is mostly intended to make writing concrete versions of
-        :meth:`.concrete_instruction` easy.
-
-        The complete list of mutations is:
-
-        * ``condition``, added by :meth:`c_if`.
-
-        Args:
-            instruction: the concrete instruction instance to be mutated.
-
-        Returns:
-            The same instruction instance that was passed, but mutated to propagate the tracked
-            changes to this class.
-        """
-        instruction._condition = self._condition
-        return instruction
-
     # Provide some better error messages, just in case something goes wrong during development and
     # the placeholder type leaks out to somewhere visible.
 
-    def assemble(self):
-        raise CircuitError("Cannot assemble a placeholder instruction.")
-
     def repeat(self, n):
         raise CircuitError("Cannot repeat a placeholder instruction.")
 
@@ -336,6 +363,8 @@ class ControlFlowBuilderBlock(CircuitScopeInterface):
         "_forbidden_message",
         "_vars_local",
         "_vars_capture",
+        "_stretches_local",
+        "_stretches_capture",
     )
 
     def __init__(
@@ -378,6 +407,8 @@ class ControlFlowBuilderBlock(CircuitScopeInterface):
         self.global_phase = 0.0
         self._vars_local = {}
         self._vars_capture = {}
+        self._stretches_local = {}
+        self._stretches_capture = {}
         self._allow_jumps = allow_jumps
         self._parent = parent
         self._built = False
@@ -467,25 +498,64 @@ class ControlFlowBuilderBlock(CircuitScopeInterface):
             raise CircuitError("Cannot add resources after the scope has been built.")
         # We can shadow a name if it was declared in an outer scope, but only if we haven't already
         # captured it ourselves yet.
+        if (previous := self._stretches_local.get(var.name)) is not None:
+            raise CircuitError(f"cannot add '{var}' as its name shadows the existing '{previous}'")
         if (previous := self._vars_local.get(var.name)) is not None:
             if previous == var:
                 raise CircuitError(f"'{var}' is already present in the scope")
             raise CircuitError(f"cannot add '{var}' as its name shadows the existing '{previous}'")
-        if var.name in self._vars_capture:
+        if var.name in self._vars_capture or var.name in self._stretches_capture:
             raise CircuitError(f"cannot add '{var}' as its name shadows the existing '{previous}'")
         self._vars_local[var.name] = var
 
+    def add_stretch(self, stretch: expr.Stretch):
+        if self._built:
+            raise CircuitError("Cannot add resources after the scope has been built.")
+        # We can shadow a name if it was declared in an outer scope, but only if we haven't already
+        # captured it ourselves yet.
+        if (previous := self._vars_local.get(stretch.name)) is not None:
+            raise CircuitError(
+                f"cannot add '{stretch}' as its name shadows the existing '{previous}'"
+            )
+        if (previous := self._stretches_local.get(stretch.name)) is not None:
+            if previous == stretch:
+                raise CircuitError(f"'{stretch}' is already present in the scope")
+            raise CircuitError(
+                f"cannot add '{stretch}' as its name shadows the existing '{previous}'"
+            )
+        if stretch.name in self._vars_capture or stretch.name in self._stretches_capture:
+            raise CircuitError(
+                f"cannot add '{stretch}' as its name shadows the existing '{previous}'"
+            )
+        self._stretches_local[stretch.name] = stretch
+
     def remove_var(self, var: expr.Var):
         if self._built:
             raise RuntimeError("exception handler 'remove_var' called after scope built")
         self._vars_local.pop(var.name)
 
+    def remove_stretch(self, stretch: expr.Stretch):
+        if self._built:
+            raise RuntimeError("exception handler 'remove_stretch' called after scope built")
+        self._stretches_local.pop(stretch.name)
+
     def get_var(self, name: str):
+        if name in self._stretches_local:
+            return None
         if (out := self._vars_local.get(name)) is not None:
             return out
         return self._parent.get_var(name)
 
+    def get_stretch(self, name: str):
+        if name in self._vars_local:
+            return None
+        if (out := self._stretches_local.get(name)) is not None:
+            return out
+        return self._parent.get_stretch(name)
+
     def use_var(self, var: expr.Var):
+        if (local := self._stretches_local.get(var.name)) is not None:
+            raise CircuitError(f"cannot use '{var}' which is shadowed by the local '{local}'")
         if (local := self._vars_local.get(var.name)) is not None:
             if local == var:
                 return
@@ -497,14 +567,39 @@ class ControlFlowBuilderBlock(CircuitScopeInterface):
         self._parent.use_var(var)
         self._vars_capture[var.name] = var
 
+    def use_stretch(self, stretch: expr.Stretch):
+        if (local := self._vars_local.get(stretch.name)) is not None:
+            raise CircuitError(f"cannot use '{stretch}' which is shadowed by the local '{local}'")
+        if (local := self._stretches_local.get(stretch.name)) is not None:
+            if local == stretch:
+                return
+            raise CircuitError(f"cannot use '{stretch}' which is shadowed by the local '{local}'")
+        if self._stretches_capture.get(stretch.name) == stretch:
+            return
+        if self._parent.get_stretch(stretch.name) != stretch:
+            raise CircuitError(f"cannot close over '{stretch}', which is not in scope")
+        self._parent.use_stretch(stretch)
+        self._stretches_capture[stretch.name] = stretch
+
+    def use_qubit(self, qubit: Qubit):
+        self._instructions.add_qubit(qubit, strict=False)
+
     def iter_local_vars(self):
         """Iterator over the variables currently declared in this scope."""
         return self._vars_local.values()
 
+    def iter_local_stretches(self):
+        """Iterator over the stretches currently declared in this scope."""
+        return self._stretches_local.values()
+
     def iter_captured_vars(self):
         """Iterator over the variables currently captured in this scope."""
         return self._vars_capture.values()
 
+    def iter_captured_stretches(self):
+        """Iterator over the stretches currently captured in this scope."""
+        return self._stretches_capture.values()
+
     def peek(self) -> CircuitInstruction:
         """Get the value of the most recent instruction tuple in this scope."""
         if not self._instructions:
@@ -605,13 +700,16 @@ class ControlFlowBuilderBlock(CircuitScopeInterface):
             self._instructions.clbits,
             *self.registers,
             global_phase=self.global_phase,
-            captures=self._vars_capture.values(),
+            captures=itertools.chain(self._vars_capture.values(), self._stretches_capture.values()),
         )
         for var in self._vars_local.values():
             # The requisite `Store` instruction to initialise the variable will have been appended
             # into the instructions.
             out.add_uninitialized_var(var)
 
+        for var in self._stretches_local.values():
+            out.add_stretch(var)
+
         # Maps placeholder index to the newly concrete instruction.
         placeholder_to_concrete = {}
 
@@ -685,6 +783,8 @@ class ControlFlowBuilderBlock(CircuitScopeInterface):
         out.global_phase = self.global_phase
         out._vars_local = self._vars_local.copy()
         out._vars_capture = self._vars_capture.copy()
+        out._stretches_local = self._stretches_local.copy()
+        out._stretches_capture = self._stretches_capture.copy()
         out._parent = self._parent
         out._allow_jumps = self._allow_jumps
         out._forbidden_message = self._forbidden_message

qiskit/circuit/controlflow/continue_loop.py

@@ -48,9 +48,7 @@ class ContinueLoopPlaceholder(InstructionPlaceholder):
 
     def concrete_instruction(self, qubits, clbits):
         return (
-            self._copy_mutable_properties(
-                ContinueLoopOp(len(qubits), len(clbits), label=self.label)
-            ),
+            ContinueLoopOp(len(qubits), len(clbits), label=self.label),
             InstructionResources(qubits=tuple(qubits), clbits=tuple(clbits)),
         )
 

qiskit/circuit/controlflow/control_flow.py

@@ -82,3 +82,13 @@ class ControlFlowOp(Instruction, ABC):
                 if var not in seen:
                     seen.add(var)
                     yield var
+
+    def iter_captured_stretches(self) -> typing.Iterable[expr.Stretch]:
+        """Get an iterator over the unique captured stretch variables in all blocks of this
+        construct."""
+        seen = set()
+        for block in self.blocks:
+            for stretch in block.iter_captured_stretches():
+                if stretch not in seen:
+                    seen.add(stretch)
+                    yield stretch

qiskit/circuit/controlflow/for_loop.py

@@ -138,7 +138,8 @@ class ForLoopContext:
             qc.rx(i * math.pi/4, 0)
             qc.cx(0, 1)
             qc.measure(0, 0)
-            qc.break_loop().c_if(0, True)
+            with qc.if_test((0, True)):
+                qc.break_loop()
 
     This context should almost invariably be created by a :meth:`.QuantumCircuit.for_loop` call, and
     the resulting instance is a "friend" of the calling circuit.  The context will manipulate the

qiskit/circuit/controlflow/if_else.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 from typing import Optional, Union, Iterable, TYPE_CHECKING
 import itertools
 
-from qiskit.circuit.classicalregister import ClassicalRegister, Clbit
+from qiskit.circuit import ClassicalRegister, Clbit  # pylint: disable=cyclic-import
 from qiskit.circuit.classical import expr
 from qiskit.circuit.instructionset import InstructionSet
 from qiskit.circuit.exceptions import CircuitError
@@ -95,6 +95,7 @@ class IfElseOp(ControlFlowOp):
 
     @property
     def condition(self):
+        """The condition for the if else operation."""
         return self._condition
 
     @condition.setter
@@ -162,12 +163,6 @@ class IfElseOp(ControlFlowOp):
         )
         return IfElseOp(self._condition, true_body, false_body=false_body, label=self.label)
 
-    def c_if(self, classical, val):
-        raise NotImplementedError(
-            "IfElseOp cannot be classically controlled through Instruction.c_if. "
-            "Please nest it in an IfElseOp instead."
-        )
-
 
 class IfElsePlaceholder(InstructionPlaceholder):
     """A placeholder instruction to use in control-flow context managers, when calculating the
@@ -295,9 +290,7 @@ class IfElsePlaceholder(InstructionPlaceholder):
                 (true_body, self.__false_block.build(qubits, clbits))
             )
         return (
-            self._copy_mutable_properties(
-                IfElseOp(self._condition, true_body, false_body, label=self.label)
-            ),
+            IfElseOp(self._condition, true_body, false_body, label=self.label),
             InstructionResources(
                 qubits=tuple(true_body.qubits),
                 clbits=tuple(true_body.clbits),
@@ -306,12 +299,6 @@ class IfElsePlaceholder(InstructionPlaceholder):
             ),
         )
 
-    def c_if(self, classical, val):
-        raise NotImplementedError(
-            "IfElseOp cannot be classically controlled through Instruction.c_if. "
-            "Please nest it in another IfElseOp instead."
-        )
-
 
 class IfContext:
     """A context manager for building up ``if`` statements onto circuits in a natural order, without

qiskit/circuit/controlflow/switch_case.py

@@ -19,7 +19,7 @@ __all__ = ("SwitchCaseOp", "CASE_DEFAULT")
 import contextlib
 from typing import Union, Iterable, Any, Tuple, Optional, List, Literal, TYPE_CHECKING
 
-from qiskit.circuit.classicalregister import ClassicalRegister, Clbit
+from qiskit.circuit import ClassicalRegister, Clbit  # pylint: disable=cyclic-import
 from qiskit.circuit.classical import expr, types
 from qiskit.circuit.exceptions import CircuitError
 
@@ -182,12 +182,6 @@ class SwitchCaseOp(ControlFlowOp):
             raise CircuitError(f"needed {len(self._case_map)} blocks but received {len(blocks)}")
         return SwitchCaseOp(self.target, zip(self._label_spec, blocks))
 
-    def c_if(self, classical, val):
-        raise NotImplementedError(
-            "SwitchCaseOp cannot be classically controlled through Instruction.c_if. "
-            "Please nest it in an IfElseOp instead."
-        )
-
 
 class SwitchCasePlaceholder(InstructionPlaceholder):
     """A placeholder instruction to use in control-flow context managers, when calculating the
@@ -269,7 +263,7 @@ class SwitchCasePlaceholder(InstructionPlaceholder):
         else:
             resources = self.__resources
         return (
-            self._copy_mutable_properties(SwitchCaseOp(self.__target, cases, label=self.label)),
+            SwitchCaseOp(self.__target, cases, label=self.label),
             resources,
         )
 

qiskit/circuit/controlflow/while_loop.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from qiskit.circuit.classicalregister import Clbit, ClassicalRegister
+from qiskit.circuit import ClassicalRegister, Clbit  # pylint: disable=cyclic-import
 from qiskit.circuit.classical import expr
 from qiskit.circuit.exceptions import CircuitError
 from ._builder_utils import validate_condition, condition_resources
@@ -61,6 +61,7 @@ class WhileLoopOp(ControlFlowOp):
 
     @property
     def condition(self):
+        """The condition for the while loop."""
         return self._condition
 
     @condition.setter
@@ -98,12 +99,6 @@ class WhileLoopOp(ControlFlowOp):
         (body,) = blocks
         return WhileLoopOp(self._condition, body, label=self.label)
 
-    def c_if(self, classical, val):
-        raise NotImplementedError(
-            "WhileLoopOp cannot be classically controlled through Instruction.c_if. "
-            "Please use an IfElseOp instead."
-        )
-
 
 class WhileLoopContext:
     """A context manager for building up while loops onto circuits in a natural order, without

qiskit/circuit/controlledgate.py

@@ -19,9 +19,9 @@ from typing import Optional, Union
 from qiskit.circuit.exceptions import CircuitError
 
 # pylint: disable=cyclic-import
+from . import QuantumRegister
 from .quantumcircuit import QuantumCircuit
 from .gate import Gate
-from .quantumregister import QuantumRegister
 from ._utils import _ctrl_state_to_int
 
 
@@ -38,8 +38,6 @@ class ControlledGate(Gate):
         definition: Optional["QuantumCircuit"] = None,
         ctrl_state: Optional[Union[int, str]] = None,
         base_gate: Optional[Gate] = None,
-        duration=None,
-        unit=None,
         *,
         _base_label=None,
     ):
@@ -101,7 +99,7 @@ class ControlledGate(Gate):
            qc2.draw('mpl')
         """
         self.base_gate = None if base_gate is None else base_gate.copy()
-        super().__init__(name, num_qubits, params, label=label, duration=duration, unit=unit)
+        super().__init__(name, num_qubits, params, label=label)
         self._num_ctrl_qubits = 1
         self.num_ctrl_qubits = num_ctrl_qubits
         self.definition = copy.deepcopy(definition)

qiskit/circuit/delay.py

@@ -14,25 +14,51 @@
 Delay instruction (for circuit module).
 """
 import numpy as np
+
+from qiskit.circuit.classical import expr, types
 from qiskit.circuit.exceptions import CircuitError
 from qiskit.circuit.instruction import Instruction
 from qiskit.circuit.gate import Gate
 from qiskit.circuit import _utils
 from qiskit.circuit.parameterexpression import ParameterExpression
-from qiskit.utils import deprecate_func
+from qiskit._accelerate.circuit import StandardInstructionType
 
 
 @_utils.with_gate_array(np.eye(2, dtype=complex))
 class Delay(Instruction):
     """Do nothing and just delay/wait/idle for a specified duration."""
 
-    def __init__(self, duration, unit="dt"):
+    _standard_instruction_type = StandardInstructionType.Delay
+
+    def __init__(self, duration, unit=None):
         """
         Args:
-            duration: the length of time of the duration.  Given in units of ``unit``.
-            unit: the unit of the duration.  Must be ``"dt"`` or an SI-prefixed seconds unit.
+            duration: the length of time of the duration. If this is an
+                :class:`~.expr.Expr`, it must be a constant expression of type
+                :class:`~.types.Duration` and the ``unit`` parameter should be
+                omitted (or MUST be "expr" if it is specified).
+            unit: the unit of the duration, if ``duration`` is a numeric
+                value. Must be ``"dt"``, an SI-prefixed seconds unit, or "expr".
+
+        Raises:
+            CircuitError: A ``duration`` expression was specified with a resolved
+                type that is not timing-based, or the ``unit`` was improperly specified.
         """
-        if unit not in {"s", "ms", "us", "ns", "ps", "dt"}:
+        if isinstance(duration, expr.Expr):
+            if unit is not None and unit != "expr":
+                raise CircuitError(
+                    "Argument 'unit' must not be specified for a duration expression."
+                )
+            if duration.type.kind is not types.Duration:
+                raise CircuitError(
+                    f"Expression of type '{duration.type}' is not valid for 'duration'."
+                )
+            if not duration.const:
+                raise CircuitError("Duration expressions must be constant.")
+            unit = "expr"
+        elif unit is None:
+            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
@@ -47,13 +73,9 @@ class Delay(Instruction):
         """Special case. Return self."""
         return self
 
-    @deprecate_func(since="1.3.0", removal_timeline="in 2.0.0")
-    def c_if(self, classical, val):
-        raise CircuitError("Conditional Delay is not yet implemented.")
-
     @property
     def unit(self):
-
+        """The unit for the duration of the delay in :attr`.params`"""
         return self.__unit
 
     @unit.setter
@@ -90,8 +112,9 @@ class Delay(Instruction):
         """Return the official string representing the delay."""
         return f"{self.__class__.__name__}(duration={self.params[0]}[unit={self.unit}])"
 
+    # pylint: disable=too-many-return-statements
     def validate_parameter(self, parameter):
-        """Delay parameter (i.e. duration) must be int, float or ParameterExpression."""
+        """Delay parameter (i.e. duration) must be Expr, int, float or ParameterExpression."""
         if isinstance(parameter, int):
             if parameter < 0:
                 raise CircuitError(
@@ -109,6 +132,12 @@ class Delay(Instruction):
                     raise CircuitError("Integer duration is expected for 'dt' unit.")
                 return parameter_int
             return parameter
+        elif isinstance(parameter, expr.Expr):
+            if parameter.type.kind is not types.Duration:
+                raise CircuitError(f"Expression duration of type '{parameter.type}' is not valid.")
+            if not parameter.const:
+                raise CircuitError("Duration expressions must be constant.")
+            return parameter
         elif isinstance(parameter, ParameterExpression):
             if len(parameter.parameters) > 0:
                 return parameter  # expression has free parameters, we cannot validate it

qiskit/circuit/duration.py

@@ -63,21 +63,6 @@ def convert_durations_to_dt(qc: QuantumCircuit, dt_in_sec: float, inplace=True):
     else:
         circ = qc.copy()
 
-    for instruction in circ.data:
-        operation = instruction.operation
-        if operation.unit == "dt" or operation.duration is None:
-            continue
-
-        if not operation.unit.endswith("s"):
-            raise CircuitError(f"Invalid time unit: '{operation.unit}'")
-
-        duration = operation.duration
-        if operation.unit != "s":
-            duration = apply_prefix(duration, operation.unit)
-
-        operation.duration = duration_in_dt(duration, dt_in_sec)
-        operation.unit = "dt"
-
     if circ.duration is not None and circ.unit != "dt":
         if not circ.unit.endswith("s"):
             raise CircuitError(f"Invalid time unit: '{circ.unit}'")

qiskit/circuit/gate.py

@@ -31,8 +31,6 @@ class Gate(Instruction):
         num_qubits: int,
         params: list,
         label: str | None = None,
-        duration=None,
-        unit="dt",
     ) -> None:
         """Create a new gate.
 
@@ -43,7 +41,7 @@ class Gate(Instruction):
             label: An optional label for the gate.
         """
         self.definition = None
-        super().__init__(name, num_qubits, 0, params, label=label, duration=duration, unit=unit)
+        super().__init__(name, num_qubits, 0, params, label=label)
 
     # Set higher priority than Numpy array and matrix classes
     __array_priority__ = 20
@@ -137,7 +135,7 @@ class Gate(Instruction):
         """
         if not annotated:  # captures both None and False
             # pylint: disable=cyclic-import
-            from .add_control import add_control
+            from ._add_control import add_control
 
             return add_control(self, num_ctrl_qubits, label, ctrl_state)