[Stretch] Support Float type in classical expressions.

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(
@@ -121,6 +123,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 +186,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 +309,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:

qiskit/circuit/classical/types/__init__.py

@@ -33,12 +33,13 @@
 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.
@@ -89,12 +90,16 @@
 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",
+    "Float",
     "Uint",
     "Ordering",
     "order",
@@ -105,5 +110,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

@@ -22,6 +22,7 @@
 __all__ = [
     "Type",
     "Bool",
+    "Float",
     "Uint",
 ]
 
@@ -115,3 +116,21 @@ 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)

qiskit/qasm3/ast.py

@@ -242,6 +242,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.DOUBLE
     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,7 @@ class BasicPrinter:
         ast.QuantumGateModifierName.POW: "pow",
     }
 
-    _FLOAT_WIDTH_LOOKUP = {type: str(type.value) for type in ast.FloatType}
+    _FLOAT_TYPE_LOOKUP = {type: f"float[{type.value}]" for type in ast.FloatType}
 
     # The visitor names include the class names, so they mix snake_case with PascalCase.
     # pylint: disable=invalid-name
@@ -205,7 +205,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 +282,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")
 

qiskit/qpy/__init__.py

@@ -377,6 +377,37 @@ def open(*args):
 by ``num_circuits`` in the file header). There is no padding between the
 circuits in the data.
 
+.. _qpy_version_14:
+
+Version 14
+----------
+
+Version 14 adds support for additional :class:`~.types.Type` classes.
+
+Changes to EXPR_TYPE
+~~~~~~~~~~~~~~~~~~~~
+
+The following table shows the new type classes added in the version:
+
+======================  =========  =================================================================
+Qiskit class            Type code  Payload
+======================  =========  =================================================================
+:class:`~.types.Float`  ``f``      None.
+======================  =========  =================================================================
+
+Changes to EXPR_VALUE
+~~~~~~~~~~~~~~~~~~~~~
+
+The classical expression's type system now supports new encoding types for value literals, in
+addition to the existing encodings for int and bool. The new value type encodings are below:
+
+===========  =========  ============================================================================
+Python type  Type code  Payload
+===========  =========  ============================================================================
+``float``    ``f``      One ``double value``.
+
+===========  =========  ============================================================================
+
 .. _qpy_version_13:
 
 Version 13

qiskit/qpy/binary_io/circuits.py

@@ -1236,7 +1236,7 @@ def write_circuit(
         file_obj.write(metadata_raw)
         # Write header payload
         file_obj.write(registers_raw)
-        standalone_var_indices = value.write_standalone_vars(file_obj, circuit)
+        standalone_var_indices = value.write_standalone_vars(file_obj, circuit, version)
     else:
         if circuit.num_vars:
             raise exceptions.UnsupportedFeatureForVersion(