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

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_evaluated:
+        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,7 +15,6 @@ 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(
@@ -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
@@ -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
@@ -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())

classiq/evaluators/qmod_node_evaluators/unary_op_evaluation.py

@@ -1,5 +1,5 @@
 import ast
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -7,10 +7,23 @@ from classiq.interface.exceptions import (
 )
 from classiq.interface.generator.functions.classical_type import Integer, Real
 from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.model.quantum_type import (
+    QuantumNumeric,
+    QuantumScalar,
+)
 
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.evaluators.qmod_node_evaluators.bool_op_evaluation import is_bool_type
-from classiq.evaluators.qmod_node_evaluators.utils import QmodType, is_numeric_type
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    QmodType,
+    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_bitwise_invert,
+    compute_result_attrs_negate,
+)
 
 
 def unary_op_allowed(op: ast.AST, operand_type: QmodType) -> bool:
@@ -19,7 +32,42 @@ def unary_op_allowed(op: ast.AST, operand_type: QmodType) -> bool:
     return is_numeric_type(operand_type)
 
 
-def eval_unary_op(expr_val: QmodAnnotatedExpression, node: ast.UnaryOp) -> None:
+def _infer_unary_op_type(
+    op: ast.AST, operand_type: QmodType, machine_precision: int
+) -> QmodType:
+    if is_classical_type(operand_type):
+        if isinstance(operand_type, TypeName):
+            # The operand is enum, return as integer
+            return Integer()
+        return operand_type
+
+    if TYPE_CHECKING:
+        assert isinstance(operand_type, QuantumScalar)
+
+    if isinstance(op, (ast.Not, ast.UAdd)):
+        return operand_type
+
+    if not operand_type.is_evaluated:
+        return QuantumNumeric()
+
+    operand_attrs = NumericAttributes.from_quantum_scalar(
+        operand_type, machine_precision
+    )
+    if isinstance(op, ast.Invert):
+        result_attrs = compute_result_attrs_bitwise_invert(
+            operand_attrs, machine_precision
+        )
+    elif isinstance(op, ast.USub):
+        result_attrs = compute_result_attrs_negate(operand_attrs, machine_precision)
+    else:
+        raise ClassiqInternalExpansionError
+
+    return result_attrs.to_quantum_numeric()
+
+
+def eval_unary_op(
+    expr_val: QmodAnnotatedExpression, node: ast.UnaryOp, machine_precision: int
+) -> None:
     operand = node.operand
     op = node.op
 
@@ -34,12 +82,8 @@ def eval_unary_op(expr_val: QmodAnnotatedExpression, node: ast.UnaryOp) -> None:
         raise ClassiqExpansionError(
             f"Operation {type(op).__name__!r} on a real value is not supported"
         )
-    op_type: QmodType
-    if isinstance(operand_type, TypeName):
-        op_type = Integer()
-    else:
-        op_type = operand_type
-    expr_val.set_type(node, op_type)
+
+    expr_val.set_type(node, _infer_unary_op_type(op, operand_type, machine_precision))
 
     if not expr_val.has_value(operand):
         return

classiq/evaluators/qmod_node_evaluators/utils.py

@@ -1,7 +1,8 @@
-from typing import Any, Optional, Union, cast
+from typing import Optional, Union, cast
 
 import sympy
 
+from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
     ClassicalTuple,
@@ -24,10 +25,6 @@ NumberValueType = Union[IntegerValueType, RealValueType]
 SYMPY_SYMBOLS = {sym: getattr(sympy, sym) for sym in sympy.__all__}
 
 
-def get_qmod_type_name(type_: Any) -> str:
-    return getattr(type_, "type_name", type(type_).__name__)
-
-
 def is_classical_type(qmod_type: QmodType) -> bool:
     if isinstance(qmod_type, TypeName):
         return qmod_type.has_classical_struct_decl or qmod_type.is_enum
@@ -42,6 +39,31 @@ def qnum_is_qbit(qmod_type: QuantumNumeric) -> bool:
     )
 
 
+def get_numeric_properties(
+    qmod_type: QuantumScalar,
+) -> tuple[Optional[int], Optional[bool], Optional[int]]:
+    if isinstance(qmod_type, QuantumBit):
+        return 1, False, 0
+    if not isinstance(qmod_type, QuantumNumeric):
+        raise ClassiqInternalExpansionError
+    size = qmod_type.size_in_bits if qmod_type.has_size_in_bits else None
+    is_signed_expr = qmod_type.is_signed
+    if is_signed_expr is None:
+        is_signed = False
+    elif is_signed_expr.is_evaluated() and is_signed_expr.is_constant():
+        is_signed = is_signed_expr.to_bool_value()
+    else:
+        is_signed = None
+    fraction_digits_expr = qmod_type.fraction_digits
+    if fraction_digits_expr is None:
+        fraction_digits = 0
+    elif fraction_digits_expr.is_evaluated() and fraction_digits_expr.is_constant():
+        fraction_digits = fraction_digits_expr.to_int_value()
+    else:
+        fraction_digits = None
+    return size, is_signed, fraction_digits
+
+
 def qnum_is_qint(qmod_type: QuantumType) -> bool:
     return isinstance(qmod_type, QuantumBit) or (
         isinstance(qmod_type, QuantumNumeric)