[Stretch] Support Float type in classical expressions.

qiskit/circuit/classical/expr/__init__.py

@@ -39,14 +39,18 @@
 
 These objects are mutable and should not be reused in a different location without a copy.
 
+All :class`Expr` instances define a boolean :attr:`~Expr.const` attribute, which indicates
+whether the expression can be evaluated at compile-time. Most expression classes infer this
+during construction based on the const-ness of their operands.
+
 The base for dynamic variables is the :class:`Var`, which can be either an arbitrarily typed
 real-time variable, or a wrapper around a :class:`.Clbit` or :class:`.ClassicalRegister`.
 
 .. autoclass:: Var
     :members: var, name, new
 
 Similarly, literals used in expressions (such as integers) should be lifted to :class:`Value` nodes
-with associated types.
+with associated types. A :class:`Value` is always considered a constant expression.
 
 .. autoclass:: Value
 

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",
 ]
 
@@ -121,6 +125,9 @@ 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
     else:
         raise TypeError(f"failed to infer a type for '{value}'")
     if type is None:
@@ -181,11 +188,16 @@ 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)
+    try:
+        operand = _coerce_lossless(operand, types.Bool())
+        return Unary(Unary.Op.LOGIC_NOT, operand, operand.type)
+    except TypeError as ex:
+        raise TypeError(f"cannot apply '{Unary.Op.BIT_NOT}' to type '{operand.type}'") from ex
 
 
 def _lift_binary_operands(left: typing.Any, right: typing.Any) -> tuple[Expr, Expr]:
@@ -300,9 +312,14 @@ 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)
+    try:
+        left = _coerce_lossless(left, bool_)
+        right = _coerce_lossless(right, bool_)
+        return Binary(op, left, right, bool_)
+    except TypeError as ex:
+        raise TypeError(f"invalid types for '{op}': '{left.type}' and '{right.type}'") from ex
 
 
 def logic_and(left: typing.Any, right: typing.Any, /) -> Expr:

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)
 
@@ -151,8 +155,9 @@ 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, /):
@@ -185,6 +190,7 @@ def __getstate__(self):
     def __setstate__(self, state):
         var, type, name = state
         super().__setattr__("type", type)
+        super().__setattr__("const", False)
         super().__setattr__("var", var)
         super().__setattr__("name", name)
 
@@ -206,6 +212,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)
@@ -257,6 +264,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)
@@ -265,6 +273,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
         )
@@ -348,6 +357,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)
@@ -356,6 +366,7 @@ def __eq__(self, other):
         return (
             isinstance(other, Binary)
             and self.type == other.type
+            and self.const == other.const
             and self.op is other.op
             and self.left == other.left
             and self.right == other.right
@@ -381,6 +392,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)
@@ -389,6 +401,7 @@ def __eq__(self, other):
         return (
             isinstance(other, Index)
             and self.type == other.type
+            and self.const == other.const
             and self.target == other.target
             and self.index == other.index
         )

qiskit/circuit/classical/types/__init__.py

@@ -95,6 +95,7 @@
 __all__ = [
     "Type",
     "Bool",
+    "Float",
     "Uint",
     "Ordering",
     "order",
@@ -105,5 +106,5 @@
     "cast_kind",
 ]
 
-from .types import Type, Bool, Uint
+from .types import Type, Bool, Float, 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, Float, 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,9 @@ 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,
 }
 
 
@@ -195,8 +192,13 @@ 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,
 }
 
 

qiskit/circuit/classical/types/types.py

@@ -19,11 +19,7 @@
 
 from __future__ import annotations
 
-__all__ = [
-    "Type",
-    "Bool",
-    "Uint",
-]
+__all__ = ["Type", "Bool", "Float", "Uint"]
 
 import typing
 
@@ -115,3 +111,21 @@ def __hash__(self):
 
     def __eq__(self, other):
         return isinstance(other, Uint) and self.width == other.width
+
+
+@typing.final
+class Float(Type, metaclass=_Singleton):
+    """A floating point number of unspecified width.
+    In the future, this may also be used to represent a fixed-width float.
+    """
+
+    __slots__ = ()
+
+    def __repr__(self):
+        return "Float()"
+
+    def __hash__(self):
+        return hash(self.__class__)
+
+    def __eq__(self, other):
+        return isinstance(other, Float)

qiskit/qasm3/ast.py

@@ -136,6 +136,7 @@ class ClassicalType(ASTNode):
 class FloatType(ClassicalType, enum.Enum):
     """Allowed values for the width of floating-point types."""
 
+    UNSPECIFIED = 0
     HALF = 16
     SINGLE = 32
     DOUBLE = 64
@@ -242,6 +243,13 @@ def __init__(self, value):
         self.value = value
 
 
+class FloatLiteral(Expression):
+    __slots__ = ("value",)
+
+    def __init__(self, value):
+        self.value = value
+
+
 class BooleanLiteral(Expression):
     __slots__ = ("value",)
 

qiskit/qasm3/exporter.py

@@ -1253,6 +1253,8 @@ def _build_ast_type(type_: types.Type) -> ast.ClassicalType:
         return ast.BoolType()
     if type_.kind is types.Uint:
         return ast.UintType(type_.width)
+    if type_.kind is types.Float:
+        return ast.FloatType.UNSPECIFIED
     raise RuntimeError(f"unhandled expr type '{type_}'")
 
 
@@ -1274,6 +1276,8 @@ def visit_value(self, node, /):
             return ast.BooleanLiteral(node.value)
         if node.type.kind is types.Uint:
             return ast.IntegerLiteral(node.value)
+        if node.type.kind is types.Float:
+            return ast.FloatLiteral(node.value)
         raise RuntimeError(f"unhandled Value type '{node}'")
 
     def visit_cast(self, node, /):

qiskit/qasm3/printer.py

@@ -78,7 +78,9 @@ class BasicPrinter:
         ast.QuantumGateModifierName.POW: "pow",
     }
 
-    _FLOAT_WIDTH_LOOKUP = {type: str(type.value) for type in ast.FloatType}
+    _FLOAT_TYPE_LOOKUP = {ast.FloatType.UNSPECIFIED: "float"} | {
+        type: f"float[{type.value}]" for type in ast.FloatType if type.value > 0
+    }
 
     # The visitor names include the class names, so they mix snake_case with PascalCase.
     # pylint: disable=invalid-name
@@ -205,7 +207,7 @@ def _visit_CalibrationGrammarDeclaration(self, node: ast.CalibrationGrammarDecla
         self._write_statement(f'defcalgrammar "{node.name}"')
 
     def _visit_FloatType(self, node: ast.FloatType) -> None:
-        self.stream.write(f"float[{self._FLOAT_WIDTH_LOOKUP[node]}]")
+        self.stream.write(self._FLOAT_TYPE_LOOKUP[node])
 
     def _visit_BoolType(self, _node: ast.BoolType) -> None:
         self.stream.write("bool")
@@ -282,6 +284,9 @@ def _visit_QuantumDelay(self, node: ast.QuantumDelay) -> None:
     def _visit_IntegerLiteral(self, node: ast.IntegerLiteral) -> None:
         self.stream.write(str(node.value))
 
+    def _visit_FloatLiteral(self, node: ast.FloatLiteral) -> None:
+        self.stream.write(str(node.value))
+
     def _visit_BooleanLiteral(self, node: ast.BooleanLiteral):
         self.stream.write("true" if node.value else "false")