classiq 0.86.1__py3-none-any.whl → 0.88.0__py3-none-any.whl

classiq/evaluators/qmod_node_evaluators/classical_function_evaluation.py

@@ -28,10 +28,14 @@ from classiq.evaluators.qmod_node_evaluators.utils import (
     QmodType,
     array_len,
     element_types,
-    get_qmod_type_name,
+    is_classical_integer,
+)
+from classiq.evaluators.qmod_type_inference.classical_type_inference import (
+    infer_classical_type,
 )
 
-MIN_MAX_FUNCTION_NAMES = {"min", "Min", "max", "Max"}
+# These sympy functions are not declared as int funcs for some reason...
+INTEGER_FUNCTION_OVERRIDE = {"floor", "ceiling"}
 
 
 def _check_classical_array_arg_type(
@@ -91,8 +95,8 @@ def _check_classical_arg(
     ):
         raise ClassiqExpansionError(
             f"Parameter {param_name!r} of function {func_name!r} expects a "
-            f"{get_qmod_type_name(param_type)} argument, but got a "
-            f"{get_qmod_type_name(arg_type)}"
+            f"{param_type.qmod_type_name} argument, but got a "
+            f"{arg_type.qmod_type_name}"
         )
 
 
@@ -168,7 +172,9 @@ def eval_function(
         cast(str, kwarg_name): expr_val.get_value(kwarg_value)
         for kwarg_name, kwarg_value in kwargs.items()
     }
-    expr_val.set_value(node, func(*arg_values, **kwarg_values))
+    ret_val = func(*arg_values, **kwarg_values)
+    expr_val.set_type(node, infer_classical_type(ret_val))
+    expr_val.set_value(node, ret_val)
 
 
 def try_eval_sympy_function(
@@ -191,7 +197,9 @@ def try_eval_sympy_function(
         ret_type = Bool()
         if args is not None:
             ret_val = bool(sympy_ret_val)
-    elif hasattr(sympy_func, "is_Integer") and sympy_func.is_Integer:
+    elif (
+        hasattr(sympy_func, "is_Integer") and sympy_func.is_Integer
+    ) or func_name in INTEGER_FUNCTION_OVERRIDE:
         ret_type = Integer()
         if args is not None:
             ret_val = int(sympy_ret_val)
@@ -241,15 +249,6 @@ def try_eval_builtin_function(
     )
     args_have_values = all(expr_val.has_value(arg) for arg in node.args)
 
-    if func_name in MIN_MAX_FUNCTION_NAMES:
-        if not try_eval_sympy_function(expr_val, node, func_name.capitalize()):
-            return False
-        if args_are_int:
-            expr_val.set_type(node, Integer())
-            if expr_val.has_value(node):
-                expr_val.set_value(node, int(expr_val.get_value(node)))
-        return True
-
     if func_name == "mod_inverse":
         _validate_no_kwargs(node)
         ret_type: QmodType
@@ -267,10 +266,10 @@ def try_eval_builtin_function(
                 *[expr_val.get_value(arg) for arg in node.args]
             )
             ret_val: Any
-            if args_are_int:
-                ret_val = int(sympy_val)
-            elif isinstance(sympy_val, sympy.Expr) and sympy_val.is_imaginary:
+            if isinstance(sympy_val, sympy.Expr) and sympy_val.is_imaginary:
                 ret_val = complex(sympy_val)
+            elif args_are_int:
+                ret_val = int(sympy_val)
             else:
                 ret_val = float(sympy_val)
             expr_val.set_value(node, ret_val)
@@ -292,9 +291,27 @@ def try_eval_builtin_function(
     if func_name == "sqrt":
         _validate_no_kwargs(node)
         expr_val.set_type(node, Real())
+        if args_have_values:
+            sympy_val = sympy.sqrt(*[expr_val.get_value(arg) for arg in node.args])
+            if isinstance(sympy_val, sympy.Expr) and sympy_val.is_imaginary:
+                ret_val = complex(sympy_val)
+            elif float(sympy_val) == int(sympy_val):
+                ret_val = int(sympy_val)
+            else:
+                ret_val = float(sympy_val)
+            expr_val.set_value(node, ret_val)
+        return True
+
+    if func_name == "abs":
+        _validate_no_kwargs(node)
+        if len(node.args) > 0 and is_classical_integer(expr_val.get_type(node.args[0])):
+            ret_type = Integer()
+        else:
+            ret_type = Real()
+        expr_val.set_type(node, ret_type)
         if args_have_values:
             expr_val.set_value(
-                node, sympy.sqrt(*[expr_val.get_value(arg) for arg in node.args])
+                node, abs(*[expr_val.get_value(arg) for arg in node.args])
             )
         return True
 

classiq/evaluators/qmod_node_evaluators/compare_evaluation.py

@@ -14,6 +14,7 @@ from classiq.interface.generator.functions.classical_type import (
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.model.quantum_type import (
     QuantumBit,
+    QuantumBitvector,
     QuantumNumeric,
     QuantumScalar,
 )
@@ -23,7 +24,6 @@ from classiq.evaluators.qmod_node_evaluators.list_evaluation import list_allowed
 from classiq.evaluators.qmod_node_evaluators.utils import (
     QmodType,
     element_types,
-    get_qmod_type_name,
     is_classical_integer,
     is_classical_type,
     qnum_is_qbit,
@@ -34,11 +34,13 @@ def comparison_allowed(
     left: QmodType, right: QmodType, inequality: bool = False
 ) -> bool:
     if isinstance(left, Bool):
-        return isinstance(right, (Bool, QuantumBit)) or (
+        return isinstance(right, (Bool, Integer, QuantumBit)) or (
             isinstance(right, QuantumNumeric) and qnum_is_qbit(right)
         )
     if isinstance(left, Real) or is_classical_integer(left):
-        return isinstance(right, (Real, QuantumScalar)) or is_classical_integer(right)
+        return isinstance(right, (Real, Bool, QuantumScalar)) or is_classical_integer(
+            right
+        )
     if isinstance(left, (ClassicalArray, ClassicalTuple)):
         if inequality:
             return False
@@ -62,6 +64,8 @@ def comparison_allowed(
         return isinstance(right, (Bool, Real, QuantumScalar)) or is_classical_integer(
             right
         )
+    if isinstance(left, QuantumBitvector):
+        return False
     raise ClassiqInternalExpansionError
 
 
@@ -76,8 +80,8 @@ def eval_compare(expr_val: QmodAnnotatedExpression, node: ast.Compare) -> None:
     right_type = expr_val.get_type(right)
     if not comparison_allowed(left_type, right_type, not isinstance(op, ast.Eq)):
         raise ClassiqExpansionError(
-            f"Cannot compare {get_qmod_type_name(left_type)} {ast.unparse(left)!r} "
-            f"and {get_qmod_type_name(right_type)} {ast.unparse(right)!r}"
+            f"Cannot compare {left_type.qmod_type_name} {ast.unparse(left)!r} "
+            f"and {right_type.qmod_type_name} {ast.unparse(right)!r}"
         )
     qmod_type: QmodType
     if not is_classical_type(left_type) or not is_classical_type(right_type):
@@ -96,12 +100,20 @@ def eval_compare(expr_val: QmodAnnotatedExpression, node: ast.Compare) -> None:
     elif isinstance(op, ast.NotEq):
         expr_val.set_value(node, left_value != right_value)
     elif isinstance(op, ast.Lt):
+        if isinstance(left_value, complex) or isinstance(right_value, complex):
+            raise ClassiqExpansionError("Inequality with a complex number")
         expr_val.set_value(node, left_value < right_value)
     elif isinstance(op, ast.Gt):
+        if isinstance(left_value, complex) or isinstance(right_value, complex):
+            raise ClassiqExpansionError("Inequality with a complex number")
         expr_val.set_value(node, left_value > right_value)
     elif isinstance(op, ast.LtE):
+        if isinstance(left_value, complex) or isinstance(right_value, complex):
+            raise ClassiqExpansionError("Inequality with a complex number")
         expr_val.set_value(node, left_value <= right_value)
     elif isinstance(op, ast.GtE):
+        if isinstance(left_value, complex) or isinstance(right_value, complex):
+            raise ClassiqExpansionError("Inequality with a complex number")
         expr_val.set_value(node, left_value >= right_value)
     else:
         raise ClassiqExpansionError(f"Unsupported comparison {type(op).__name__!r}")

classiq/evaluators/qmod_node_evaluators/constant_evaluation.py

@@ -7,12 +7,22 @@ import sympy
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
 )
-from classiq.interface.generator.functions.classical_type import Bool, Integer, Real
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+    ClassicalType,
+    Integer,
+    Real,
+)
 from classiq.interface.generator.functions.type_name import Enum
 
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.evaluators.qmod_node_evaluators.utils import SYMPY_SYMBOLS, QmodType
 
+QMOD_LITERALS: dict[str, tuple[ClassicalType, Any]] = {
+    "false": (Bool(), False),
+    "true": (Bool(), True),
+}
+
 
 def eval_enum_member(
     expr_val: QmodAnnotatedExpression, node: ast.Attribute, enum: type[IntEnum]
@@ -23,7 +33,10 @@ def eval_enum_member(
     }
     attr = node.attr
     if attr not in enum_members:
-        raise ClassiqExpansionError(f"Enum {enum_name} has no member named {attr!r}")
+        raise ClassiqExpansionError(
+            f"Enum {enum_name} has no member {attr!r}. Available members: "
+            f"{', '.join(enum_members.keys())}"
+        )
 
     expr_val.set_type(node, Enum(name=enum_name))
     expr_val.set_value(node, enum_members[attr])
@@ -44,6 +57,15 @@ def eval_constant(expr_val: QmodAnnotatedExpression, node: ast.Constant) -> None
     expr_val.set_type(node, constant_type)
 
 
+def try_eval_qmod_literal(expr_val: QmodAnnotatedExpression, node: ast.Name) -> bool:
+    if node.id not in QMOD_LITERALS:
+        return False
+    lit_type, lit_val = QMOD_LITERALS[node.id]
+    expr_val.set_type(node, lit_type)
+    expr_val.set_value(node, lit_val)
+    return True
+
+
 def try_eval_sympy_constant(expr_val: QmodAnnotatedExpression, node: ast.Name) -> bool:
     sympy_val = SYMPY_SYMBOLS.get(node.id)
     if not isinstance(sympy_val, sympy.Expr) or not sympy_val.is_constant():

classiq/evaluators/qmod_node_evaluators/min_max_evaluation.py

@@ -0,0 +1,97 @@
+import ast
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.functions.classical_type import Integer, Real
+from classiq.interface.model.quantum_type import QuantumNumeric
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.numeric_attrs_utils import (
+    get_numeric_attrs,
+)
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    QmodType,
+    is_classical_integer,
+    is_classical_type,
+    is_numeric_type,
+)
+from classiq.model_expansions.arithmetic import NumericAttributes
+from classiq.model_expansions.arithmetic_compute_result_attrs import (
+    compute_result_attrs_max,
+    compute_result_attrs_min,
+)
+
+
+def _infer_min_max_op_type(
+    expr_val: QmodAnnotatedExpression,
+    node: ast.Call,
+    func_name: str,
+    args_types: list[QmodType],
+    treat_qnum_as_float: bool,
+    machine_precision: int,
+) -> QmodType:
+    if all(is_classical_type(arg_type) for arg_type in args_types):
+        if all(is_classical_integer(arg_type) for arg_type in args_types):
+            return Integer()
+        return Real()
+
+    args_attrs: list[NumericAttributes] = []
+    for arg, arg_type in zip(node.args, args_types):
+        attrs = get_numeric_attrs(
+            expr_val, arg, arg_type, machine_precision, treat_qnum_as_float
+        )
+        if attrs is None:
+            return QuantumNumeric()
+        args_attrs.append(attrs)
+
+    if func_name == "min":
+        result_attrs = compute_result_attrs_min(args_attrs, machine_precision)
+    elif func_name == "max":
+        result_attrs = compute_result_attrs_max(args_attrs, machine_precision)
+    else:
+        raise ClassiqInternalExpansionError
+
+    return result_attrs.to_quantum_numeric()
+
+
+def eval_min_max_op(
+    expr_val: QmodAnnotatedExpression,
+    node: ast.Call,
+    func_name: str,
+    treat_qnum_as_float: bool,
+    machine_precision: int,
+) -> None:
+    if len(node.args) < 1:
+        raise ClassiqExpansionError(f"{func_name!r} expects at least one argument")
+
+    args_types = [expr_val.get_type(arg) for arg in node.args]
+    if not all(is_numeric_type(arg_type) for arg_type in args_types):
+        raise ClassiqExpansionError(
+            f"All arguments of {func_name!r} must be scalar values"
+        )
+
+    inferred_type = _infer_min_max_op_type(
+        expr_val,
+        node,
+        func_name,
+        args_types,
+        treat_qnum_as_float,
+        machine_precision,
+    )
+    expr_val.set_type(node, inferred_type)
+
+    if all(expr_val.has_value(arg) for arg in node.args):
+        values = [expr_val.get_value(arg) for arg in node.args]
+        if not all(isinstance(value, (int, float)) for value in values):
+            raise ClassiqExpansionError(f"Invalid argument for function {func_name!r}")
+
+        if func_name == "min":
+            result_value = min(*values)
+        elif func_name == "max":
+            result_value = max(*values)
+        else:
+            raise ClassiqInternalExpansionError
+
+        expr_val.set_value(node, result_value)

classiq/evaluators/qmod_node_evaluators/name_evaluation.py

@@ -1,6 +1,8 @@
 import ast
 from typing import Any
 
+import sympy
+
 from classiq.interface.exceptions import (
     ClassiqInternalExpansionError,
 )
@@ -8,42 +10,25 @@ from classiq.interface.generator.expressions.proxies.classical.qmod_struct_insta
     QmodStructInstance,
 )
 from classiq.interface.generator.functions.classical_type import (
-    Bool,
-    ClassicalTuple,
     ClassicalType,
-    Integer,
-    Real,
 )
-from classiq.interface.generator.functions.type_name import Struct
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.quantum_type import QuantumType
 
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
-
-
-def _infer_classical_type(value: Any) -> ClassicalType:
-    if isinstance(value, bool):
-        return Bool()
-    if isinstance(value, int):
-        return Integer()
-    if isinstance(value, (float, complex)):
-        return Real()
-    if isinstance(value, list):
-        return ClassicalTuple(
-            element_types=[_infer_classical_type(item) for item in value]
-        )
-    if isinstance(value, QmodStructInstance):
-        classical_type = Struct(name=value.struct_declaration.name)
-        classical_type.set_classical_struct_decl(value.struct_declaration)
-        return classical_type
-    raise ClassiqInternalExpansionError
+from classiq.evaluators.qmod_type_inference.classical_type_inference import (
+    infer_classical_type,
+)
 
 
 def eval_name(expr_val: QmodAnnotatedExpression, node: ast.Name, value: Any) -> None:
-    if isinstance(value, (bool, int, float, complex, list, QmodStructInstance)):
-        expr_val.set_type(node, _infer_classical_type(value))
+    # FIXME: Remove sympy compatibility (CLS-3214)
+    if isinstance(
+        value, (bool, int, float, complex, list, QmodStructInstance, sympy.Basic)
+    ):
+        expr_val.set_type(node, infer_classical_type(value))
         expr_val.set_value(node, value)
-    elif isinstance(value, (ClassicalType, QuantumType)):
+    elif isinstance(value, (ClassicalType, QuantumType)):  # type:ignore[unreachable]
         expr_val.set_type(node, value)
         expr_val.set_var(node, HandleBinding(name=node.id))
     else:

classiq/evaluators/qmod_node_evaluators/numeric_attrs_utils.py

@@ -0,0 +1,56 @@
+import ast
+from typing import TYPE_CHECKING, Optional
+
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.functions.classical_type import Bool
+from classiq.interface.model.quantum_type import QuantumScalar
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import QmodType, is_classical_type
+from classiq.model_expansions.arithmetic import NumericAttributes
+
+
+def get_numeric_attrs(
+    expr_val: QmodAnnotatedExpression,
+    node: ast.AST,
+    qmod_type: QmodType,
+    machine_precision: int,
+    treat_qnum_as_float: bool,
+) -> Optional[NumericAttributes]:
+    if isinstance(qmod_type, Bool):
+        return NumericAttributes.from_bounds(0, 1, 0, machine_precision)
+    if is_classical_type(qmod_type):
+        value = get_classical_value_for_arithmetic(
+            expr_val, node, qmod_type, treat_qnum_as_float
+        )
+        if value is None:
+            return None
+        return NumericAttributes.from_constant(value, machine_precision)
+
+    if TYPE_CHECKING:
+        assert isinstance(qmod_type, QuantumScalar)
+    if not qmod_type.is_constant:
+        return None
+    return NumericAttributes.from_quantum_scalar(qmod_type, machine_precision)
+
+
+def get_classical_value_for_arithmetic(
+    expr_val: QmodAnnotatedExpression,
+    node: ast.AST,
+    qmod_type: QmodType,
+    treat_qnum_as_float: bool,
+) -> Optional[float]:
+    if not is_classical_type(qmod_type):
+        return None
+    if not expr_val.has_value(node):
+        return None
+
+    value = expr_val.get_value(node)
+    if not isinstance(value, (int, float)):
+        if treat_qnum_as_float and isinstance(value, complex):
+            return None
+        raise ClassiqExpansionError(
+            "Arithmetic of quantum variables and non-real values is not supported"
+        )
+
+    return float(value)

classiq/evaluators/qmod_node_evaluators/piecewise_evaluation.py

@@ -0,0 +1,40 @@
+import ast
+from collections.abc import Sequence
+
+import sympy
+
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.functions.classical_type import Bool, Integer, Real
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+
+
+def eval_piecewise(
+    expr_val: QmodAnnotatedExpression,
+    node: ast.Call,
+    args: Sequence[tuple[ast.AST, ast.AST]],
+) -> None:
+    cond_types = [expr_val.get_type(cond) for _, cond in args]
+    if not all(isinstance(cond_type, Bool) for cond_type in cond_types):
+        raise ClassiqExpansionError(
+            "Piecewise conditions must be classical Boolean values"
+        )
+
+    value_types = [expr_val.get_type(value) for value, _ in args]
+    if not all(isinstance(value_type, (Integer, Real)) for value_type in value_types):
+        raise ClassiqExpansionError("Piecewise values must be classical numeric values")
+
+    if all(isinstance(value_type, Integer) for value_type in value_types):
+        expr_val.set_type(node, Integer())
+    else:
+        expr_val.set_type(node, Real())
+
+    if not all(
+        expr_val.has_value(value) and expr_val.has_value(cond) for value, cond in args
+    ):
+        return
+
+    values = [
+        (expr_val.get_value(value), expr_val.get_value(cond)) for value, cond in args
+    ]
+    expr_val.set_value(node, sympy.Piecewise(*values))

classiq/evaluators/qmod_node_evaluators/struct_instantiation_evaluation.py

@@ -15,13 +15,12 @@ from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.evaluators.qmod_node_evaluators.compare_evaluation import (
     comparison_allowed,
 )
-from classiq.evaluators.qmod_node_evaluators.utils import get_qmod_type_name
 
 
 def eval_struct_instantiation(
     expr_val: QmodAnnotatedExpression, node: ast.Call, decl: StructDeclaration
 ) -> None:
-    if len(node.args) > 0 or any(kwarg.arg is None for kwarg in node.keywords):
+    if len(node.args) != 1 or any(kwarg.arg is None for kwarg in node.keywords):
         raise ClassiqExpansionError(
             "Classical structs must be instantiated using keyword arguments"
         )
@@ -42,8 +41,8 @@ def eval_struct_instantiation(
         expected_type = decl.variables[field_name]
         if not comparison_allowed(assignment_type, expected_type):
             raise ClassiqExpansionError(
-                f"Cannot assign value of type {get_qmod_type_name(assignment_type)} "
-                f"to field {field_name!r} of type {get_qmod_type_name(expected_type)}"
+                f"Cannot assign value of type {assignment_type.qmod_type_name} "
+                f"to field {field_name!r} of type {expected_type.qmod_type_name}"
             )
 
     classical_type = Struct(name=decl.name)

classiq/evaluators/qmod_node_evaluators/subscript_evaluation.py

@@ -4,10 +4,7 @@ from typing import Optional, cast
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
-)
-from classiq.interface.generator.arith.arithmetic import (
-    aggregate_numeric_types,
-    compute_arithmetic_result_type,
+    ClassiqValueError,
 )
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
@@ -16,6 +13,7 @@ from classiq.interface.generator.functions.classical_type import (
     Integer,
     Real,
 )
+from classiq.interface.helpers.text_utils import s
 from classiq.interface.model.handle_binding import (
     SlicedHandleBinding,
     SubscriptHandleBinding,
@@ -23,16 +21,19 @@ from classiq.interface.model.handle_binding import (
 from classiq.interface.model.quantum_type import (
     QuantumBitvector,
     QuantumNumeric,
+    QuantumScalar,
     QuantumType,
-    register_info_to_quantum_type,
 )
 
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.evaluators.qmod_node_evaluators.utils import (
     QmodType,
+    array_len,
     element_types,
-    get_qmod_type_name,
-    qnum_is_qint,
+    get_numeric_properties,
+)
+from classiq.model_expansions.arithmetic_compute_result_attrs import (
+    compute_result_attrs_quantum_subscript,
 )
 
 
@@ -49,7 +50,7 @@ def _eval_slice(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> None:
     for index_type in (start_type, stop_type):
         if not isinstance(index_type, Integer):
             raise ClassiqExpansionError(
-                f"Slice indices must be integers, not {get_qmod_type_name(index_type)!r}"
+                f"Slice indices must be integers, not {index_type.raw_qmod_type_name}"
             )
 
     start_val: Optional[int] = None
@@ -68,7 +69,7 @@ def _eval_slice(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> None:
     subject_type = expr_val.get_type(subject)
     slice_type: QmodType
     if isinstance(subject_type, ClassicalArray):
-        if subject_type.has_length and (
+        if subject_type.has_constant_length and (
             (start_val is not None and start_val >= subject_type.length_value)
             or (stop_val is not None and stop_val > subject_type.length_value)
         ):
@@ -92,7 +93,7 @@ def _eval_slice(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> None:
             slice_type = subject_type.get_raw_type()
     elif isinstance(subject_type, QuantumBitvector):
         if start_val is not None and stop_val is not None:
-            if subject_type.has_length and (
+            if subject_type.has_constant_length and (
                 start_val >= subject_type.length_value
                 or stop_val > subject_type.length_value
             ):
@@ -105,7 +106,7 @@ def _eval_slice(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> None:
         )
     else:
         raise ClassiqExpansionError(
-            f"{get_qmod_type_name(subject_type)} is not subscriptable"
+            f"{subject_type.raw_qmod_type_name} is not subscriptable"
         )
     expr_val.set_type(node, slice_type)
 
@@ -134,7 +135,8 @@ def _eval_subscript(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> N
     index_type = expr_val.get_type(subscript)
     if not isinstance(index_type, Integer):
         raise ClassiqExpansionError(
-            f"Array indices must be integers or slices, not {get_qmod_type_name(index_type)}"
+            f"Array indices must be integers or slices, not "
+            f"{index_type.raw_qmod_type_name}"
         )
 
     sub_val: Optional[int] = None
@@ -148,7 +150,7 @@ def _eval_subscript(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> N
     if isinstance(subject_type, (ClassicalArray, QuantumBitvector)):
         if (
             sub_val is not None
-            and subject_type.has_length
+            and subject_type.has_constant_length
             and sub_val >= subject_type.length_value
         ):
             raise ClassiqExpansionError("Array index out of range")
@@ -165,7 +167,7 @@ def _eval_subscript(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> N
             sub_type = raw_subject_type.element_type
     else:
         raise ClassiqExpansionError(
-            f"{get_qmod_type_name(subject_type)} is not subscriptable"
+            f"{subject_type.raw_qmod_type_name} is not subscriptable"
         )
     expr_val.set_type(node, sub_type)
 
@@ -192,15 +194,38 @@ def eval_subscript(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> No
         _eval_subscript(expr_val, node)
 
 
+def validate_quantum_subscript_index_properties(
+    index_size: Optional[int],
+    index_sign: Optional[bool],
+    index_fraction_digits: Optional[int],
+    array_len: Optional[int],
+) -> None:
+    if index_sign or (index_fraction_digits is not None and index_fraction_digits > 0):
+        raise ClassiqValueError("Quantum index must be an unsigned integer")
+    if array_len == 0:
+        raise ClassiqValueError(
+            "Classical arrays indexed by a quantum variable must not be empty"
+        )
+    if array_len is None or index_size is None:
+        return
+    if 2**index_size > array_len:
+        adjective = "short"
+    elif 2**index_size < array_len:
+        adjective = "long"
+    else:
+        return
+    raise ClassiqValueError(
+        f"Array is too {adjective}. It has {array_len} item{s(array_len)}, but its "
+        f"quantum index has {index_size} bit{s(index_size)}"
+    )
+
+
 def eval_quantum_subscript(
     expr_val: QmodAnnotatedExpression, node: ast.Subscript, machine_precision: int
 ) -> None:
     subject = node.value
     subscript = node.slice
 
-    index_type = cast(QuantumType, expr_val.get_type(subscript))
-    if not qnum_is_qint(index_type):
-        raise ClassiqExpansionError("Quantum indices must be unsigned quantum numerics")
     subject_type = expr_val.get_type(subject)
     if not isinstance(subject_type, (ClassicalArray, ClassicalTuple)) or not all(
         isinstance(element_type, (Integer, Real))
@@ -210,16 +235,18 @@ def eval_quantum_subscript(
             "Only classical numeric arrays may have quantum subscripts"
         )
 
+    index_type = cast(QuantumType, expr_val.get_type(subscript))
+    if not isinstance(index_type, QuantumScalar):
+        raise ClassiqExpansionError("Quantum index must be an unsigned integer")
+    validate_quantum_subscript_index_properties(
+        *get_numeric_properties(index_type), array_len(subject_type)
+    )
+
     expr_val.set_quantum_subscript(node, subject, subscript)
     if not expr_val.has_value(subject):
         expr_val.set_type(node, QuantumNumeric())
         return
 
     items = expr_val.get_value(subject)
-    numeric_types = [
-        compute_arithmetic_result_type(str(num), {}, machine_precision) for num in items
-    ]
-    unified_numeric_type = register_info_to_quantum_type(
-        aggregate_numeric_types(numeric_types)
-    )
-    expr_val.set_type(node, unified_numeric_type)
+    result_attrs = compute_result_attrs_quantum_subscript(items, machine_precision)
+    expr_val.set_type(node, result_attrs.to_quantum_numeric())