[Stretch] Support Duration type in classical expressions.

crates/circuit/src/duration.rs

@@ -0,0 +1,36 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2025
+//
+// 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.
+
+use pyo3::prelude::*;
+
+#[pyclass(eq, module = "qiskit._accelerate.circuit")]
+#[derive(PartialEq, Clone, Copy, Debug)]
+#[allow(non_camel_case_types)]
+pub enum Duration {
+    dt(u64),
+    ns(f64),
+    us(f64),
+    ms(f64),
+    s(f64),
+}
+
+impl Duration {
+    fn __repr__(&self) -> String {
+        match self {
+            Duration::ns(t) => format!("Duration.ns({})", t),
+            Duration::us(t) => format!("Duration.us({})", t),
+            Duration::ms(t) => format!("Duration.ms({})", t),
+            Duration::s(t) => format!("Duration.s({})", t),
+            Duration::dt(t) => format!("Duration.dt({})", t),
+        }
+    }
+}

crates/circuit/src/lib.rs

@@ -17,6 +17,7 @@ pub mod converters;
 pub mod dag_circuit;
 pub mod dag_node;
 mod dot_utils;
+pub mod duration;
 pub mod error;
 pub mod gate_matrix;
 pub mod imports;
@@ -157,6 +158,7 @@ macro_rules! impl_intopyobject_for_copy_pyclass {
 }
 
 pub fn circuit(m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_class::<duration::Duration>()?;
     m.add_class::<circuit_data::CircuitData>()?;
     m.add_class::<circuit_instruction::CircuitInstruction>()?;
     m.add_class::<dag_circuit::DAGCircuit>()?;

qiskit/circuit/__init__.py

@@ -1282,6 +1282,8 @@ def __array__(self, dtype=None, copy=None):
         \end{pmatrix}
 """
 
+from qiskit._accelerate.circuit import Duration  # pylint: disable=unused-import
+
 from .exceptions import CircuitError
 from . import _utils
 from .quantumcircuit import QuantumCircuit

qiskit/circuit/classical/expr/constructors.py

@@ -19,6 +19,7 @@
 
 __all__ = [
     "lift",
+    "cast",
     "bit_not",
     "logic_not",
     "bit_and",
@@ -32,6 +33,9 @@
     "less_equal",
     "greater",
     "greater_equal",
+    "shift_left",
+    "shift_right",
+    "index",
     "lift_legacy_condition",
 ]
 
@@ -45,19 +49,17 @@
     import qiskit
 
 
-def _coerce_lossless(expr: Expr, type: types.Type) -> Expr:
+def _coerce_lossless(expr: Expr, type: types.Type) -> Expr | None:
     """Coerce ``expr`` to ``type`` by inserting a suitable :class:`Cast` node, if the cast is
-    lossless.  Otherwise, raise a ``TypeError``."""
+    lossless.  Otherwise, return ``None``."""
     kind = cast_kind(expr.type, type)
     if kind is CastKind.EQUAL:
         return expr
     if kind is CastKind.IMPLICIT:
         return Cast(expr, type, implicit=True)
     if kind is CastKind.LOSSLESS:
         return Cast(expr, type, implicit=False)
-    if kind is CastKind.DANGEROUS:
-        raise TypeError(f"cannot cast '{expr}' to '{type}' without loss of precision")
-    raise TypeError(f"no cast is defined to take '{expr}' to '{type}'")
+    return None
 
 
 def lift_legacy_condition(
@@ -107,7 +109,7 @@ def lift(value: typing.Any, /, type: types.Type | None = None) -> Expr:
         if type is not None:
             raise ValueError("use 'cast' to cast existing expressions, not 'lift'")
         return value
-    from qiskit.circuit import Clbit, ClassicalRegister  # pylint: disable=cyclic-import
+    from qiskit.circuit import Clbit, ClassicalRegister, Duration  # pylint: disable=cyclic-import
 
     inferred: types.Type
     if value is True or value is False or isinstance(value, Clbit):
@@ -121,6 +123,12 @@ def lift(value: typing.Any, /, type: types.Type | None = None) -> Expr:
             raise ValueError("cannot represent a negative value")
         inferred = types.Uint(width=value.bit_length() or 1)
         constructor = Value
+    elif isinstance(value, float):
+        inferred = types.Float()
+        constructor = Value
+    elif isinstance(value, Duration):
+        inferred = types.Duration()
+        constructor = Value
     else:
         raise TypeError(f"failed to infer a type for '{value}'")
     if type is None:
@@ -181,11 +189,15 @@ def logic_not(operand: typing.Any, /) -> Expr:
             >>> expr.logic_not(ClassicalRegister(3, "c"))
             Unary(\
 Unary.Op.LOGIC_NOT, \
-Cast(Var(ClassicalRegister(3, 'c'), Uint(3)), Bool(), implicit=True), \
+Cast(Var(ClassicalRegister(3, 'c'), Uint(3)), \
+Bool(), implicit=True), \
 Bool())
     """
-    operand = _coerce_lossless(lift(operand), types.Bool())
-    return Unary(Unary.Op.LOGIC_NOT, operand, operand.type)
+    operand = lift(operand)
+    coerced_operand = _coerce_lossless(operand, types.Bool())
+    if coerced_operand is None:
+        raise TypeError(f"cannot apply '{Unary.Op.LOGIC_NOT}' to type '{operand.type}'")
+    return Unary(Unary.Op.LOGIC_NOT, coerced_operand, coerced_operand.type)
 
 
 def _lift_binary_operands(left: typing.Any, right: typing.Any) -> tuple[Expr, Expr]:
@@ -300,9 +312,13 @@ def bit_xor(left: typing.Any, right: typing.Any, /) -> Expr:
 
 def _binary_logical(op: Binary.Op, left: typing.Any, right: typing.Any) -> Expr:
     bool_ = types.Bool()
-    left = _coerce_lossless(lift(left), bool_)
-    right = _coerce_lossless(lift(right), bool_)
-    return Binary(op, left, right, bool_)
+    left = lift(left)
+    right = lift(right)
+    coerced_left = _coerce_lossless(left, bool_)
+    coerced_right = _coerce_lossless(right, bool_)
+    if coerced_left is None or coerced_right is None:
+        raise TypeError(f"invalid types for '{op}': '{left.type}' and '{right.type}'")
+    return Binary(op, coerced_left, coerced_right, bool_)
 
 
 def logic_and(left: typing.Any, right: typing.Any, /) -> Expr:
@@ -337,7 +353,7 @@ def logic_or(left: typing.Any, right: typing.Any, /) -> Expr:
 
 def _equal_like(op: Binary.Op, left: typing.Any, right: typing.Any) -> Expr:
     left, right = _lift_binary_operands(left, right)
-    if left.type.kind is not right.type.kind:
+    if left.type.kind is not right.type.kind or left.type.kind is types.Stretch:
         raise TypeError(f"invalid types for '{op}': '{left.type}' and '{right.type}'")
     type = types.greater(left.type, right.type)
     return Binary(op, _coerce_lossless(left, type), _coerce_lossless(right, type), types.Bool())
@@ -381,7 +397,7 @@ def not_equal(left: typing.Any, right: typing.Any, /) -> Expr:
 
 def _binary_relation(op: Binary.Op, left: typing.Any, right: typing.Any) -> Expr:
     left, right = _lift_binary_operands(left, right)
-    if left.type.kind is not right.type.kind or left.type.kind is types.Bool:
+    if left.type.kind is not right.type.kind or left.type.kind in {types.Bool, types.Stretch}:
         raise TypeError(f"invalid types for '{op}': '{left.type}' and '{right.type}'")
     type = types.greater(left.type, right.type)
     return Binary(op, _coerce_lossless(left, type), _coerce_lossless(right, type), types.Bool())

qiskit/circuit/classical/expr/expr.py

@@ -144,7 +144,14 @@ def __init__(
         name: str | None = None,
     ):
         super().__setattr__("type", type)
-        super().__setattr__("const", False)
+        # For now, Stretch is the only kind of const variable we allow.
+        # In the future, we may want to add a 'const' constructor arg here
+        # to let users create other kinds of constants, or perhaps introduce
+        # a separate expr.Const that requires a const expr initializer for this
+        # purpose. `QuantumCircuit.add_stretch` is the official way to create
+        # stretches, and makes no promise that we will track stretches using
+        # `Var` (it accepts just a name and returns just _some_ `Expr`).
+        super().__setattr__("const", type.kind is types.Stretch)
         super().__setattr__("var", var)
         super().__setattr__("name", name)
 
@@ -175,6 +182,7 @@ def __eq__(self, other):
         return (
             isinstance(other, Var)
             and self.type == other.type
+            and self.const == other.const
             and self.var == other.var
             and self.name == other.name
         )
@@ -190,7 +198,7 @@ def __getstate__(self):
     def __setstate__(self, state):
         var, type, name = state
         super().__setattr__("type", type)
-        super().__setattr__("const", False)
+        super().__setattr__("const", type.kind is types.Stretch)
         super().__setattr__("var", var)
         super().__setattr__("name", name)
 

qiskit/circuit/classical/expr/visitors.py

@@ -268,6 +268,8 @@ def is_lvalue(node: expr.Expr, /) -> bool:
     the scope that attempts to write to it.  This would be an access property of the containing
     program, however, and not an inherent property of the expression system.
 
+    A constant expression is never an lvalue.
+
     Examples:
         Literal values are never l-values; there's no memory location associated with (for example)
         the constant ``1``::
@@ -297,4 +299,7 @@ def is_lvalue(node: expr.Expr, /) -> bool:
             >>> expr.is_lvalue(expr.bit_and(a, b))
             False
     """
+    if node.const:
+        # A constant expression is _never_ an lvalue.
+        return False
     return node.accept(_IS_LVALUE)

qiskit/circuit/classical/types/__init__.py

@@ -33,16 +33,21 @@
 heap-allocating a new version of the same thing.  Where possible, the class constructors will return
 singleton instances to facilitate this.
 
-The two different types available are for Booleans (corresponding to :class:`.Clbit` and the
-literals ``True`` and ``False``), and unsigned integers (corresponding to
-:class:`.ClassicalRegister` and Python integers).
+The :class:`Bool` type represents :class:`.Clbit` and the literals ``True`` and ``False``, the
+:class:`Uint` type represents :class:`.ClassicalRegister` and Python integers, and the
+:class:`Float` type represents Python floats.
 
 .. autoclass:: Bool
 .. autoclass:: Uint
+.. autoclass:: Float
 
 Note that :class:`Uint` defines a family of types parametrized by their width; it is not one single
 type, which may be slightly different to the 'classical' programming languages you are used to.
 
+There are also two duration-like types for use in circuit timing expressions.
+
+.. autoclass:: Duration
+.. autoclass:: Stretch
 
 Working with types
 ==================
@@ -89,12 +94,18 @@
 The return values from this function are an enumeration explaining the types of cast that are
 allowed from the left type to the right type.
 
+Note that casts between :class:`Float` and :class:`Uint` are considered dangerous in either
+direction, and must be done explicitly.
+
 .. autoclass:: CastKind
 """
 
 __all__ = [
     "Type",
     "Bool",
+    "Duration",
+    "Float",
+    "Stretch",
     "Uint",
     "Ordering",
     "order",
@@ -105,5 +116,5 @@
     "cast_kind",
 ]
 
-from .types import Type, Bool, Uint
+from .types import Type, Bool, Duration, Float, Stretch, Uint
 from .ordering import Ordering, order, is_subtype, is_supertype, greater, CastKind, cast_kind

qiskit/circuit/classical/types/ordering.py

@@ -26,7 +26,7 @@
 
 import enum
 
-from .types import Type, Bool, Uint
+from .types import Type, Bool, Duration, Float, Stretch, Uint
 
 
 # While the type system is simple, it's overkill to represent the complete partial ordering graph of
@@ -55,10 +55,6 @@ def __repr__(self):
         return str(self)
 
 
-def _order_bool_bool(_a: Bool, _b: Bool, /) -> Ordering:
-    return Ordering.EQUAL
-
-
 def _order_uint_uint(left: Uint, right: Uint, /) -> Ordering:
     if left.width < right.width:
         return Ordering.LESS
@@ -68,8 +64,13 @@ def _order_uint_uint(left: Uint, right: Uint, /) -> Ordering:
 
 
 _ORDERERS = {
-    (Bool, Bool): _order_bool_bool,
+    (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,
+    (Duration, Stretch): lambda _a, _b, /: Ordering.LESS,
+    (Stretch, Stretch): lambda _a, _b, /: Ordering.EQUAL,
+    (Stretch, Duration): lambda _a, _b, /: Ordering.GREATER,
 }
 
 
@@ -195,8 +196,16 @@ def _uint_cast(from_: Uint, to_: Uint, /) -> CastKind:
 _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,
+    (Duration, Stretch): lambda _a, _b, /: CastKind.IMPLICIT,
+    (Stretch, Stretch): lambda _a, _b, /: CastKind.EQUAL,
 }
 
 

qiskit/circuit/classical/types/types.py

@@ -22,6 +22,9 @@
 __all__ = [
     "Type",
     "Bool",
+    "Duration",
+    "Float",
+    "Stretch",
     "Uint",
 ]
 
@@ -115,3 +118,53 @@ def __hash__(self):
 
     def __eq__(self, other):
         return isinstance(other, Uint) and self.width == other.width
+
+
+@typing.final
+class Float(Type, metaclass=_Singleton):
+    """An IEE-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)
+
+
+@typing.final
+class Stretch(Type, metaclass=_Singleton):
+    """A special type that denotes some not-yet-known non-negative duration."""
+
+    __slots__ = ()
+
+    def __repr__(self):
+        return "Stretch()"
+
+    def __hash__(self):
+        return hash(self.__class__)
+
+    def __eq__(self, other):
+        return isinstance(other, Stretch)