[Stretch] Support const classical expressions.

qiskit/circuit/classical/expr/expr.py

@@ -151,8 +151,8 @@ def new(cls, name: str, type: types.Type) -> typing.Self:
 
     @property
     def standalone(self) -> bool:
-        """Whether this :class:`Var` is a standalone variable that owns its storage location.  If
-        false, this is a wrapper :class:`Var` around a pre-existing circuit object."""
+        """Whether this :class:`Var` is a standalone variable that owns its storage location, if applicable.
+        If false, this is a wrapper :class:`Var` around a pre-existing circuit object."""
         return isinstance(self.var, uuid.UUID)
 
     def accept(self, visitor, /):

qiskit/circuit/classical/expr/visitors.py

@@ -276,13 +276,15 @@ def is_lvalue(node: expr.Expr, /) -> bool:
             >>> expr.is_lvalue(expr.lift(2))
             False
 
-        :class:`~.expr.Var` nodes are always l-values, because they always have some associated
-        memory location::
+        :class:`~.expr.Var` nodes are l-values (unless their resolution type is `const`!), because
+        they have some associated memory location::
 
             >>> from qiskit.circuit.classical import types
             >>> from qiskit.circuit import Clbit
             >>> expr.is_lvalue(expr.Var.new("a", types.Bool()))
             True
+            >>> expr.is_lvalue(expr.Var.new("a", types.Bool(const=False)))
+            False
             >>> expr.is_lvalue(expr.lift(Clbit()))
             True
 
@@ -297,4 +299,8 @@ def is_lvalue(node: expr.Expr, /) -> bool:
             >>> expr.is_lvalue(expr.bit_and(a, b))
             False
     """
+    if node.type.const:
+        # If the expression's resolution type is const, then this can never be
+        # an l-value (even if the expression is a Var).
+        return False
     return node.accept(_IS_LVALUE)

qiskit/circuit/classical/types/ordering.py

@@ -83,14 +83,39 @@ def order(left: Type, right: Type, /) -> Ordering:
             >>> types.order(types.Uint(8), types.Uint(16))
             Ordering.LESS
 
+        Compare two :class:`Bool` types of differing const-ness::
+
+            >>> from qiskit.circuit.classical import types
+            >>> types.order(types.Bool(), types.Bool(const=True))
+            Ordering.GREATER
+
         Compare two types that have no ordering between them::
 
             >>> types.order(types.Uint(8), types.Bool())
             Ordering.NONE
+            >>> types.order(types.Uint(8), types.Uint(16, const=True))
+            Ordering.NONE
     """
     if (orderer := _ORDERERS.get((left.kind, right.kind))) is None:
         return Ordering.NONE
-    return orderer(left, right)
+    order_ = orderer(left, right)
+
+    # If the natural type ordering is equal (either one can represent both)
+    # but the types differ in const-ness, the non-const variant is greater.
+    # If one type is greater (and thus is the only type that can represent
+    # both) an ordering is only defined if that type is non-const or both
+    # types are const.
+    if left.const is True and right.const is False:
+        if order_ is Ordering.EQUAL:
+            return Ordering.LESS
+        if order_ is Ordering.GREATER:
+            return Ordering.NONE
+    if right.const is True and left.const is False:
+        if order_ is Ordering.EQUAL:
+            return Ordering.GREATER
+        if order_ is Ordering.LESS:
+            return Ordering.NONE
+    return order_
 
 
 def is_subtype(left: Type, right: Type, /, strict: bool = False) -> bool:
@@ -111,6 +136,8 @@ def is_subtype(left: Type, right: Type, /, strict: bool = False) -> bool:
             True
             >>> types.is_subtype(types.Bool(), types.Bool(), strict=True)
             False
+            >>> types.is_subtype(types.Bool(const=True), types.Bool(), strict=True)
+            True
     """
     order_ = order(left, right)
     return order_ is Ordering.LESS or (not strict and order_ is Ordering.EQUAL)
@@ -134,6 +161,8 @@ def is_supertype(left: Type, right: Type, /, strict: bool = False) -> bool:
             True
             >>> types.is_supertype(types.Bool(), types.Bool(), strict=True)
             False
+            >>> types.is_supertype(types.Bool(), types.Bool(const=True), strict=True)
+            True
     """
     order_ = order(left, right)
     return order_ is Ordering.GREATER or (not strict and order_ is Ordering.EQUAL)
@@ -215,11 +244,20 @@ def cast_kind(from_: Type, to_: Type, /) -> CastKind:
             <CastKind.EQUAL: 1>
             >>> types.cast_kind(types.Uint(8), types.Bool())
             <CastKind.IMPLICIT: 2>
+            >>> types.cast_kind(types.Uint(8, const=True), types.Uint(8))
+            <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 to_.const is True and from_.const is False:
+        # We can't cast to a const type.
+        return CastKind.NONE
     if (coercer := _ALLOWED_CASTS.get((from_.kind, to_.kind))) is None:
         return CastKind.NONE
-    return coercer(from_, to_)
+    cast_kind_ = coercer(from_, to_)
+    if cast_kind_ is CastKind.EQUAL and to_.const != from_.const:
+        # We need an implicit cast to drop const.
+        return CastKind.IMPLICIT
+    return cast_kind_

qiskit/circuit/classical/types/types.py

@@ -19,33 +19,11 @@
 
 from __future__ import annotations
 
-__all__ = [
-    "Type",
-    "Bool",
-    "Uint",
-]
+__all__ = ["Type", "Bool", "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.
@@ -62,6 +40,11 @@ def kind(self):
         this a hashable enum-like discriminator you can rely on."""
         return self.__class__
 
+    @property
+    def const(self):
+        """Get the const-ness of this type."""
+        raise NotImplementedError("types must implement the 'const' attribute")
+
     # Enforcement of immutability.  The constructor methods need to manually skip this.
 
     def __setattr__(self, _key, _value):
@@ -81,37 +64,44 @@ def __setstate__(self, state):
 
 
 @typing.final
-class Bool(Type, metaclass=_Singleton):
+class Bool(Type):
     """The Boolean type.  This has exactly two values: ``True`` and ``False``."""
 
-    __slots__ = ()
+    __slots__ = ("const",)
+
+    def __init__(self, *, const: bool = False):
+        super(Type, self).__setattr__("const", const)
 
     def __repr__(self):
-        return "Bool()"
+        return f"Bool(const={self.const})"
 
     def __hash__(self):
-        return hash(self.__class__)
+        return hash((self.__class__, self.const))
 
     def __eq__(self, other):
-        return isinstance(other, Bool)
+        return isinstance(other, Bool) and self.const == other.const
 
 
 @typing.final
 class Uint(Type):
     """An unsigned integer of fixed bit width."""
 
-    __slots__ = ("width",)
+    __slots__ = (
+        "const",
+        "width",
+    )
 
-    def __init__(self, width: int):
+    def __init__(self, width: int, *, const: bool = False):
         if isinstance(width, int) and width <= 0:
             raise ValueError("uint width must be greater than zero")
+        super(Type, self).__setattr__("const", const)
         super(Type, self).__setattr__("width", width)
 
     def __repr__(self):
-        return f"Uint({self.width})"
+        return f"Uint({self.width}, const={self.const})"
 
     def __hash__(self):
-        return hash((self.__class__, self.width))
+        return hash((self.__class__, self.const, self.width))
 
     def __eq__(self, other):
-        return isinstance(other, Uint) and self.width == other.width
+        return isinstance(other, Uint) and self.const == other.const and self.width == other.width

qiskit/qpy/binary_io/value.py

@@ -367,9 +367,10 @@ def _write_expr(
 
 
 def _write_expr_type(file_obj, type_: types.Type):
-    if type_.kind is types.Bool:
+    # Currently, QPY doesn't support const types
+    if type_.kind is types.Bool and not type_.const:
         file_obj.write(type_keys.ExprType.BOOL)
-    elif type_.kind is types.Uint:
+    elif type_.kind is types.Uint and not type_.const:
         file_obj.write(type_keys.ExprType.UINT)
         file_obj.write(
             struct.pack(formats.EXPR_TYPE_UINT_PACK, *formats.EXPR_TYPE_UINT(type_.width))

releasenotes/notes/const-expr-397ff09042942b81.yaml

@@ -0,0 +1,21 @@
+---
+features_circuits:
+  - |
+    The classical realtime-expressions module :mod:`qiskit.circuit.classical` can now represent
+    constant types and operations on them. All :class:`~.types.Type` classes now have a bool
+    :attr:`~.types.Type.const` property which is used to mark const-ness and enforce const
+    invariants across the types system.
+
+    To create a const value expression use :func:`~.expr.lift`, setting ``try_const=True``::
+
+      from qiskit.circuit.classical import expr
+
+      expr.lift(5, try_const=True)
+      # >>> Value(5, Uint(3, const=True))
+
+    The result type of an operation applied to const types is also const::
+
+      from qiskit.circuit.classical import expr
+
+      expr.bit_and(expr.lift(5, try_const=True), expr.lift(6, try_const=True)).type.const
+      # >>> True