Move const-ness from Type to Expr.

Author: kevinhartman

qiskit/circuit/classical/expr/constructors.py

@@ -77,7 +77,7 @@ def lift_legacy_condition(
     return Binary(Binary.Op.EQUAL, left, right, types.Bool())
 
 
-def lift(value: typing.Any, /, type: types.Type | None = None, *, try_const: bool = False) -> Expr:
+def lift(value: typing.Any, /, type: types.Type | None = None) -> Expr:
     """Lift the given Python ``value`` to a :class:`~.expr.Value` or :class:`~.expr.Var`.
 
     By default, lifted scalars are not const.  To lift supported scalars to const-typed
@@ -106,31 +106,16 @@ def lift(value: typing.Any, /, type: types.Type | None = None, *, try_const: boo
             Var(ClassicalRegister(3, "c"), Uint(5, const=False))
             >>> expr.lift(5, types.Uint(4))
             Value(5, Uint(4))
-
-        Lifting non-classical resource scalars to const values::
-
-            >>> from qiskit.circuit.classical import expr, types
-            >>> expr.lift(7)
-            Value(7, Uint(3, const=False))
-            >>> expr.lift(7, try_const=True)
-            Value(7, Uint(3, const=True))
-            >>> expr.lift(7, types.Uint(8, const=True))
-            Value(7, Uint(8, const=True))
-
     """
     if isinstance(value, 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
 
-    if type is not None:
-        # If a type was specified, the inferred type must be the same
-        # const-ness.
-        try_const = type.const
     inferred: types.Type
     if value is True or value is False:
-        inferred = types.Bool(const=try_const)
+        inferred = types.Bool()
         constructor = Value
     elif isinstance(value, Clbit):
         inferred = types.Bool()
@@ -141,7 +126,7 @@ def lift(value: typing.Any, /, type: types.Type | None = None, *, try_const: boo
     elif isinstance(value, int):
         if value < 0:
             raise ValueError("cannot represent a negative value")
-        inferred = types.Uint(width=value.bit_length() or 1, const=try_const)
+        inferred = types.Uint(width=value.bit_length() or 1)
         constructor = Value
     else:
         raise TypeError(f"failed to infer a type for '{value}'")
@@ -218,7 +203,7 @@ def logic_not(operand: typing.Any, /) -> Expr:
 Bool(const=False))
     """
     operand = lift(operand)
-    operand = _coerce_lossless(operand, types.Bool(const=operand.type.const))
+    operand = _coerce_lossless(operand, types.Bool())
     return Unary(Unary.Op.LOGIC_NOT, operand, operand.type)
 
 
@@ -233,24 +218,13 @@ def _lift_binary_operands(left: typing.Any, right: typing.Any) -> tuple[Expr, Ex
         to be interoperable.
       * If both operands are expressions, they are returned as-is, and may require a cast node.
     """
-    left_bool = isinstance(left, bool)
     left_int = isinstance(left, int) and not isinstance(left, bool)
-    right_bool = isinstance(right, bool)
-    right_int = isinstance(right, int) and not right_bool
+    right_int = isinstance(right, int) and not isinstance(right, bool)
     if not (left_int or right_int):
-        if left_bool == right_bool:
-            # They're either both bool, or neither are, so we lift them
-            # independently.
-            left = lift(left)
-            right = lift(right)
-        elif not right_bool:
-            # Left is a bool, which should only be const if right is const.
-            right = lift(right)
-            left = lift(left, try_const=right.type.const)
-        elif not left_bool:
-            # Right is a bool, which should only be const if left is const.
-            left = lift(left)
-            right = lift(right, try_const=left.type.const)
+        # They're either both bool, or neither are, so we lift them
+        # independently.
+        left = lift(left)
+        right = lift(right)
     elif not right_int:
         # Left is an int.
         right = lift(right)
@@ -262,7 +236,7 @@ def _lift_binary_operands(left: typing.Any, right: typing.Any) -> tuple[Expr, Ex
             # Left will share const-ness of right.
             left = Value(left, right.type)
         else:
-            left = lift(left, try_const=right.type.const)
+            left = lift(left)
     elif not left_int:
         # Right is an int.
         left = lift(left)
@@ -274,7 +248,7 @@ def _lift_binary_operands(left: typing.Any, right: typing.Any) -> tuple[Expr, Ex
             # Right will share const-ness of left.
             right = Value(right, left.type)
         else:
-            right = lift(right, try_const=left.type.const)
+            right = lift(right)
     else:
         # Both are `int`, so we take our best case to make things work.
         # If the caller needs a const type, they should lift one side to
@@ -289,14 +263,14 @@ def _binary_bitwise(op: Binary.Op, left: typing.Any, right: typing.Any) -> Expr:
     left, right = _lift_binary_operands(left, right)
     type: types.Type
     if left.type.kind is right.type.kind is types.Bool:
-        type = types.Bool(const=(left.type.const and right.type.const))
+        type = types.Bool()
     elif left.type.kind is types.Uint and right.type.kind is types.Uint:
         if left.type.width != right.type.width:
             raise TypeError(
                 "binary bitwise operations are defined between unsigned integers of the same width,"
                 f" but got {left.type.width} and {right.type.width}."
             )
-        type = types.Uint(width=left.type.width, const=(left.type.const and right.type.const))
+        type = types.Uint(width=left.type.width)
     else:
         raise TypeError(f"invalid types for '{op}': '{left.type}' and '{right.type}'")
     return Binary(op, _coerce_lossless(left, type), _coerce_lossless(right, type), type)
@@ -362,7 +336,7 @@ def bit_xor(left: typing.Any, right: typing.Any, /) -> Expr:
 def _binary_logical(op: Binary.Op, left: typing.Any, right: typing.Any) -> Expr:
     left = lift(left)
     right = lift(right)
-    type = types.Bool(const=(left.type.const and right.type.const))
+    type = types.Bool()
     left = _coerce_lossless(left, type)
     right = _coerce_lossless(right, type)
     return Binary(op, left, right, type)
@@ -416,7 +390,7 @@ def _equal_like(op: Binary.Op, left: typing.Any, right: typing.Any) -> Expr:
         op,
         _coerce_lossless(left, type),
         _coerce_lossless(right, type),
-        types.Bool(const=type.const),
+        types.Bool(),
     )
 
 
@@ -469,7 +443,7 @@ def _binary_relation(op: Binary.Op, left: typing.Any, right: typing.Any) -> Expr
         op,
         _coerce_lossless(left, type),
         _coerce_lossless(right, type),
-        types.Bool(const=type.const),
+        types.Bool(),
     )
 
 
@@ -554,14 +528,14 @@ def _shift_like(
         left = _coerce_lossless(left, type) if type is not None else left
     else:
         left = lift(left, type)
-    right = lift(right, try_const=left.type.const)
+    right = lift(right)
     if left.type.kind != types.Uint or right.type.kind != types.Uint:
         raise TypeError(f"invalid types for '{op}': '{left.type}' and '{right.type}'")
     return Binary(
         op,
         left,
         right,
-        types.Uint(width=left.type.width, const=(left.type.const and right.type.const)),
+        types.Uint(width=left.type.width),
     )
 
 
@@ -631,7 +605,7 @@ def index(target: typing.Any, index: typing.Any, /) -> Expr:
 Bool(const=False))
     """
     target = lift(target)
-    index = lift(index, try_const=target.type.const)
+    index = lift(index)
     if target.type.kind is not types.Uint or index.type.kind is not types.Uint:
         raise TypeError(f"invalid types for indexing: '{target.type}' and '{index.type}'")
-    return Index(target, index, types.Bool(const=target.type.const and index.type.const))
+    return Index(target, index, types.Bool())

qiskit/circuit/classical/expr/expr.py

@@ -55,9 +55,10 @@ class Expr(abc.ABC):
     All subclasses are responsible for setting their ``type`` attribute in their ``__init__``, and
     should not call the parent initializer."""
 
-    __slots__ = ("type",)
+    __slots__ = ("type", "const")
 
     type: types.Type
+    const: bool
 
     # Sentinel to prevent instantiation of the base class.
     @abc.abstractmethod
@@ -89,6 +90,7 @@ class Cast(Expr):
 
     def __init__(self, operand: Expr, type: types.Type, implicit: bool = False):
         self.type = type
+        self.const = operand.const
         self.operand = operand
         self.implicit = implicit
 
@@ -99,6 +101,7 @@ def __eq__(self, other):
         return (
             isinstance(other, Cast)
             and self.type == other.type
+            and self.const == other.const
             and self.operand == other.operand
             and self.implicit == other.implicit
         )
@@ -141,6 +144,7 @@ def __init__(
         name: str | None = None,
     ):
         super().__setattr__("type", type)
+        super().__setattr__("const", False)
         super().__setattr__("var", var)
         super().__setattr__("name", name)
 
@@ -207,6 +211,7 @@ class Value(Expr):
     def __init__(self, value: typing.Any, type: types.Type):
         self.type = type
         self.value = value
+        self.const = True
 
     def accept(self, visitor, /):
         return visitor.visit_value(self)
@@ -258,6 +263,7 @@ def __init__(self, op: Unary.Op, operand: Expr, type: types.Type):
         self.op = op
         self.operand = operand
         self.type = type
+        self.const = operand.const
 
     def accept(self, visitor, /):
         return visitor.visit_unary(self)
@@ -266,6 +272,7 @@ def __eq__(self, other):
         return (
             isinstance(other, Unary)
             and self.type == other.type
+            and self.const == other.const
             and self.op is other.op
             and self.operand == other.operand
         )
@@ -349,6 +356,7 @@ def __init__(self, op: Binary.Op, left: Expr, right: Expr, type: types.Type):
         self.left = left
         self.right = right
         self.type = type
+        self.const = left.const and right.const
 
     def accept(self, visitor, /):
         return visitor.visit_binary(self)
@@ -382,6 +390,7 @@ def __init__(self, target: Expr, index: Expr, type: types.Type):
         self.target = target
         self.index = index
         self.type = type
+        self.const = target.const and index.const
 
     def accept(self, visitor, /):
         return visitor.visit_index(self)

qiskit/circuit/classical/types/ordering.py

@@ -98,24 +98,7 @@ def order(left: Type, right: Type, /) -> Ordering:
     """
     if (orderer := _ORDERERS.get((left.kind, right.kind))) is None:
         return Ordering.NONE
-    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 and not right.const:
-        if order_ is Ordering.EQUAL:
-            return Ordering.LESS
-        if order_ is Ordering.GREATER:
-            return Ordering.NONE
-    if right.const and not left.const:
-        if order_ is Ordering.EQUAL:
-            return Ordering.GREATER
-        if order_ is Ordering.LESS:
-            return Ordering.NONE
-    return order_
+    return orderer(left, right)
 
 
 def is_subtype(left: Type, right: Type, /, strict: bool = False) -> bool:
@@ -251,13 +234,7 @@ def cast_kind(from_: Type, to_: Type, /) -> CastKind:
             >>> types.cast_kind(types.Uint(16), types.Uint(8))
             <CastKind.DANGEROUS: 4>
     """
-    if to_.const and not from_.const:
-        # 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
     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

@@ -30,13 +30,10 @@ class Type:
 
     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.
-
-    All subclasses are responsible for setting the ``const`` attribute in their ``__init__``.
     """
 
-    __slots__ = ("const",)
+    __slots__ = ()
 
-    const: bool
 
     @property
     def kind(self):
@@ -69,17 +66,14 @@ class Bool(Type):
 
     __slots__ = ()
 
-    def __init__(self, *, const: bool = False):
-        super(Type, self).__setattr__("const", const)
-
     def __repr__(self):
-        return f"Bool(const={self.const})"
+        return f"Bool()"
 
     def __hash__(self):
-        return hash((self.__class__, self.const))
+        return hash(self.__class__)
 
     def __eq__(self, other):
-        return isinstance(other, Bool) and self.const == other.const
+        return isinstance(other, Bool)
 
 
 @typing.final
@@ -88,17 +82,16 @@ class Uint(Type):
 
     __slots__ = ("width",)
 
-    def __init__(self, width: int, *, const: bool = False):
+    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__("const", const)
         super(Type, self).__setattr__("width", width)
 
     def __repr__(self):
-        return f"Uint({self.width}, const={self.const})"
+        return f"Uint({self.width})"
 
     def __hash__(self):
-        return hash((self.__class__, self.const, self.width))
+        return hash(self.__class__)
 
     def __eq__(self, other):
-        return isinstance(other, Uint) and self.const == other.const and self.width == other.width
+        return isinstance(other, Uint) and self.width == other.width

qiskit/circuit/quantumcircuit.py

@@ -2812,8 +2812,6 @@ def add_var(self, name_or_var: str | expr.Var, /, initial: typing.Any) -> expr.V
         circuit_scope = self._current_scope()
         coerce_type = None
         if isinstance(name_or_var, expr.Var):
-            if name_or_var.type.const:
-                raise CircuitError("const variables are not supported.")
             if (
                 name_or_var.type.kind is types.Uint
                 and isinstance(initial, int)
@@ -2872,8 +2870,6 @@ def add_uninitialized_var(self, var: expr.Var, /):
             raise CircuitError("cannot add an uninitialized variable in a control-flow scope")
         if not var.standalone:
             raise CircuitError("cannot add a variable wrapping a bit or register to a circuit")
-        if var.type.const:
-            raise CircuitError("const variables are not supported.")
         self._builder_api.add_uninitialized_var(var)
 
     def add_capture(self, var: expr.Var):
@@ -2939,10 +2935,6 @@ def add_input(  # pylint: disable=missing-raises-doc
         if isinstance(name_or_var, expr.Var):
             if type_ is not None:
                 raise ValueError("cannot give an explicit type with an existing Var")
-            if name_or_var.type.const:
-                raise CircuitError("const variables cannot be input variables")
-        elif type_ is not None and type_.const:
-            raise CircuitError("const variables cannot be input variables")
 
         var = self._prepare_new_var(name_or_var, type_)
         self._vars_input[var.name] = var