classiq 0.84.0__py3-none-any.whl → 0.86.0__py3-none-any.whl

classiq/evaluators/qmod_node_evaluators/list_evaluation.py

@@ -0,0 +1,107 @@
+import ast
+from typing import Optional, cast
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+    ClassicalArray,
+    ClassicalTuple,
+    ClassicalType,
+    Real,
+)
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.model.quantum_type import QuantumBitvector, QuantumType
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    element_types,
+    is_classical_integer,
+    is_classical_type,
+)
+
+
+def _list_allowed(left: ClassicalType, right: ClassicalType) -> bool:
+    for type_1, type_2 in ((left, right), (right, left)):
+        if isinstance(type_1, Real) or is_classical_integer(type_1):
+            return isinstance(type_2, Real) or is_classical_integer(type_2)
+
+    if isinstance(left, Bool):
+        return isinstance(right, Bool)
+
+    if isinstance(left, (ClassicalArray, ClassicalTuple)) and isinstance(
+        right, (ClassicalArray, ClassicalTuple)
+    ):
+        return list_allowed(element_types(left) + element_types(right))
+
+    if isinstance(left, TypeName) and left.has_classical_struct_decl:
+        return isinstance(right, TypeName) and left.name == right.name
+
+    return False
+
+
+def _has_empty_tuple(classical_type: ClassicalType) -> bool:
+    if isinstance(classical_type, ClassicalArray):
+        return _has_empty_tuple(classical_type.element_type)
+    if isinstance(classical_type, ClassicalTuple):
+        return len(classical_type.element_types) == 0 or any(
+            _has_empty_tuple(element_type)
+            for element_type in classical_type.element_types
+        )
+    return False
+
+
+def list_allowed(classical_types: list[ClassicalType]) -> bool:
+    if len(classical_types) < 2:
+        return True
+
+    element_without_empty_tuple: Optional[ClassicalType] = None
+    for classical_type in classical_types:
+        if not _has_empty_tuple(classical_type):
+            element_without_empty_tuple = classical_type
+            break
+
+    if element_without_empty_tuple is not None:
+        return all(
+            element_without_empty_tuple is other_type
+            or _list_allowed(element_without_empty_tuple, other_type)
+            for other_type in classical_types
+        )
+    # FIXME: optimize using ClassicalTuple.raw_type (CLS-3163)
+    return all(
+        element_type is other_type or _list_allowed(classical_types[0], other_type)
+        for i, element_type in enumerate(classical_types[:-1])
+        for other_type in classical_types[i + 1 :]
+    )
+
+
+def eval_list(expr_val: QmodAnnotatedExpression, node: ast.List) -> None:
+    item_types = [expr_val.get_type(item) for item in node.elts]
+    are_classical = [is_classical_type(item_type) for item_type in item_types]
+    all_classical = all(are_classical)
+    all_quantum = not any(are_classical)
+    if not all_classical and not all_quantum:
+        raise ClassiqExpansionError(
+            "Lists cannot contain both classical and quantum expressions"
+        )
+    if len(item_types) > 0 and all_quantum:
+        expr_val.set_concatenation(node, node.elts)
+        if all(
+            cast(QuantumType, item_type).has_size_in_bits for item_type in item_types
+        ):
+            total_size = sum(
+                [cast(QuantumType, item_type).size_in_bits for item_type in item_types]
+            )
+            concat_type = QuantumBitvector(length=Expression(expr=str(total_size)))
+        else:
+            concat_type = QuantumBitvector()
+        expr_val.set_type(node, concat_type)
+        return
+    if not list_allowed(cast(list[ClassicalType], item_types)):
+        raise ClassiqExpansionError("All list items must have the same type")
+
+    if all(expr_val.has_value(item) for item in node.elts):
+        expr_val.set_value(node, [expr_val.get_value(item) for item in node.elts])
+    expr_val.set_type(node, ClassicalTuple(element_types=item_types))

classiq/evaluators/qmod_node_evaluators/measurement_evaluation.py

@@ -0,0 +1,25 @@
+import ast
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+)
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+)
+from classiq.interface.model.quantum_type import QuantumBit
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    is_classical_type,
+)
+
+
+def eval_measurement(expr_val: QmodAnnotatedExpression, node: ast.Call) -> None:
+    if len(node.args) != 1 or len(node.keywords) != 0:
+        raise ClassiqExpansionError("'measure' expects one positional argument")
+    arg_type = expr_val.get_type(node.args[0])
+    if is_classical_type(arg_type):
+        raise ClassiqExpansionError("'measure' expects a quantum input")
+    if not isinstance(arg_type, QuantumBit):
+        raise ClassiqExpansionError("Currently, 'measure' only supports quantum bits")
+    expr_val.set_type(node, Bool())

classiq/evaluators/qmod_node_evaluators/name_evaluation.py

@@ -0,0 +1,50 @@
+import ast
+from typing import Any
+
+from classiq.interface.exceptions import (
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    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
+
+
+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))
+        expr_val.set_value(node, value)
+    elif isinstance(value, (ClassicalType, QuantumType)):
+        expr_val.set_type(node, value)
+        expr_val.set_var(node, HandleBinding(name=node.id))
+    else:
+        raise ClassiqInternalExpansionError

classiq/evaluators/qmod_node_evaluators/struct_instantiation_evaluation.py

@@ -0,0 +1,66 @@
+import ast
+from typing import cast
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+)
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
+)
+from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.helpers.text_utils import readable_list, s
+
+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):
+        raise ClassiqExpansionError(
+            "Classical structs must be instantiated using keyword arguments"
+        )
+
+    field_assignments = {cast(str, kwarg.arg): kwarg.value for kwarg in node.keywords}
+    assigned_fields = list(field_assignments)
+    expected_fields = list(decl.variables)
+    if set(assigned_fields) != set(expected_fields):
+        raise ClassiqExpansionError(
+            f"Struct {decl.name} has field{s(expected_fields)} "
+            f"{readable_list(expected_fields, quote=True)} but was instantiated "
+            f"using the field{s(assigned_fields)} "
+            f"{readable_list(assigned_fields, quote=True)}"
+        )
+
+    for field_name, field_value in field_assignments.items():
+        assignment_type = expr_val.get_type(field_value)
+        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)}"
+            )
+
+    classical_type = Struct(name=decl.name)
+    classical_type.set_classical_struct_decl(decl)
+    expr_val.set_type(node, classical_type)
+
+    if any(
+        not expr_val.has_value(field_value)
+        for field_value in field_assignments.values()
+    ):
+        return
+
+    struct_val = QmodStructInstance(
+        decl,
+        {
+            field_name: expr_val.get_value(field_value)
+            for field_name, field_value in field_assignments.items()
+        },
+    )
+    expr_val.set_value(node, struct_val)

classiq/evaluators/qmod_node_evaluators/subscript_evaluation.py

@@ -0,0 +1,225 @@
+import ast
+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,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ClassicalTuple,
+    Integer,
+    Real,
+)
+from classiq.interface.model.handle_binding import (
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
+from classiq.interface.model.quantum_type import (
+    QuantumBitvector,
+    QuantumNumeric,
+    QuantumType,
+    register_info_to_quantum_type,
+)
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    QmodType,
+    element_types,
+    get_qmod_type_name,
+    qnum_is_qint,
+)
+
+
+def _eval_slice(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> None:
+    subject = node.value
+    slice_ = cast(ast.Slice, node.slice)
+    start = cast(ast.AST, slice_.lower)
+    stop = cast(ast.AST, slice_.upper)
+    if slice_.step is not None:
+        raise ClassiqExpansionError("Slice step is not supported")
+
+    start_type = expr_val.get_type(start)
+    stop_type = expr_val.get_type(stop)
+    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}"
+            )
+
+    start_val: Optional[int] = None
+    if expr_val.has_value(start):
+        start_val = cast(int, expr_val.get_value(start))
+        if start_val < 0:
+            raise ClassiqExpansionError("Slice indices must be positive integers")
+    stop_val: Optional[int] = None
+    if expr_val.has_value(stop):
+        stop_val = cast(int, expr_val.get_value(stop))
+        if start_val is not None and stop_val < start_val:
+            raise ClassiqExpansionError(
+                "Slice upper bound must be greater or equal to the lower bound"
+            )
+
+    subject_type = expr_val.get_type(subject)
+    slice_type: QmodType
+    if isinstance(subject_type, ClassicalArray):
+        if subject_type.has_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)
+        ):
+            raise ClassiqExpansionError("Array index out of range")
+        length_expr: Optional[Expression] = None
+        if start_val is not None and stop_val is not None:
+            length_expr = Expression(expr=str(stop_val - start_val))
+        slice_type = ClassicalArray(
+            element_type=subject_type.element_type, length=length_expr
+        )
+    elif isinstance(subject_type, ClassicalTuple):
+        if start_val is not None and stop_val is not None:
+            if start_val >= len(subject_type.element_types) or stop_val > len(
+                subject_type.element_types
+            ):
+                raise ClassiqExpansionError("Array index out of range")
+            slice_type = ClassicalTuple(
+                element_types=subject_type.element_types[start_val:stop_val]
+            )
+        else:
+            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 (
+                start_val >= subject_type.length_value
+                or stop_val > subject_type.length_value
+            ):
+                raise ClassiqExpansionError("Array index out of range")
+            slice_length = Expression(expr=str(stop_val - start_val))
+        else:
+            slice_length = None
+        slice_type = QuantumBitvector(
+            element_type=subject_type.element_type, length=slice_length
+        )
+    else:
+        raise ClassiqExpansionError(
+            f"{get_qmod_type_name(subject_type)} is not subscriptable"
+        )
+    expr_val.set_type(node, slice_type)
+
+    if start_val is None or stop_val is None:
+        return
+    if expr_val.has_value(subject):
+        subject_val = expr_val.get_value(subject)
+        expr_val.set_value(node, subject_val[start_val:stop_val])
+    elif expr_val.has_var(subject):
+        subject_var = expr_val.get_var(subject)
+        expr_val.set_var(
+            node,
+            SlicedHandleBinding(
+                base_handle=subject_var,
+                start=Expression(expr=str(start_val)),
+                end=Expression(expr=str(stop_val)),
+            ),
+        )
+        expr_val.remove_var(subject)
+
+
+def _eval_subscript(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> None:
+    subject = node.value
+    subscript = node.slice
+
+    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)}"
+        )
+
+    sub_val: Optional[int] = None
+    if expr_val.has_value(subscript):
+        sub_val = cast(int, expr_val.get_value(subscript))
+        if sub_val < 0:
+            raise ClassiqExpansionError("Array indices must be positive integers")
+
+    subject_type = expr_val.get_type(subject)
+    sub_type: QmodType
+    if isinstance(subject_type, (ClassicalArray, QuantumBitvector)):
+        if (
+            sub_val is not None
+            and subject_type.has_length
+            and sub_val >= subject_type.length_value
+        ):
+            raise ClassiqExpansionError("Array index out of range")
+        sub_type = subject_type.element_type
+    elif isinstance(subject_type, ClassicalTuple):
+        if sub_val is not None:
+            if sub_val >= len(subject_type.element_types):
+                raise ClassiqExpansionError("Array index out of range")
+            sub_type = subject_type.element_types[sub_val]
+        else:
+            raw_subject_type = subject_type.get_raw_type()
+            if not isinstance(raw_subject_type, ClassicalArray):
+                raise ClassiqInternalExpansionError
+            sub_type = raw_subject_type.element_type
+    else:
+        raise ClassiqExpansionError(
+            f"{get_qmod_type_name(subject_type)} is not subscriptable"
+        )
+    expr_val.set_type(node, sub_type)
+
+    if sub_val is None:
+        return
+    if expr_val.has_value(subject):
+        subject_val = expr_val.get_value(subject)
+        expr_val.set_value(node, subject_val[sub_val])
+    elif expr_val.has_var(subject):
+        subject_var = expr_val.get_var(subject)
+        expr_val.set_var(
+            node,
+            SubscriptHandleBinding(
+                base_handle=subject_var, index=Expression(expr=str(sub_val))
+            ),
+        )
+        expr_val.remove_var(subject)
+
+
+def eval_subscript(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> None:
+    if isinstance(node.slice, ast.Slice):
+        _eval_slice(expr_val, node)
+    else:
+        _eval_subscript(expr_val, node)
+
+
+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))
+        for element_type in element_types(subject_type)
+    ):
+        raise ClassiqExpansionError(
+            "Only classical numeric arrays may have quantum subscripts"
+        )
+
+    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)

classiq/evaluators/qmod_node_evaluators/unary_op_evaluation.py

@@ -0,0 +1,58 @@
+import ast
+from typing import Any
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.functions.classical_type import Integer, Real
+from classiq.interface.generator.functions.type_name import TypeName
+
+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
+
+
+def unary_op_allowed(op: ast.AST, operand_type: QmodType) -> bool:
+    if isinstance(op, ast.Not):
+        return is_bool_type(operand_type)
+    return is_numeric_type(operand_type)
+
+
+def eval_unary_op(expr_val: QmodAnnotatedExpression, node: ast.UnaryOp) -> None:
+    operand = node.operand
+    op = node.op
+
+    operand_type = expr_val.get_type(operand)
+    if not unary_op_allowed(op, operand_type):
+        expected_val_type = "Boolean" if isinstance(op, ast.Not) else "scalar"
+        raise ClassiqExpansionError(
+            f"The operand of the unary operator {type(op).__name__!r} must be "
+            f"a {expected_val_type} value"
+        )
+    if isinstance(op, ast.Invert) and isinstance(operand_type, Real):
+        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)
+
+    if not expr_val.has_value(operand):
+        return
+    operand_value = expr_val.get_value(operand)
+    constant_value: Any
+    if isinstance(op, ast.Not):
+        constant_value = not operand_value
+    elif isinstance(op, ast.Invert):
+        constant_value = ~operand_value
+    elif isinstance(op, ast.UAdd):
+        constant_value = +operand_value
+    elif isinstance(op, ast.USub):
+        constant_value = -operand_value
+    else:
+        raise ClassiqInternalExpansionError
+    expr_val.set_value(node, constant_value)

classiq/evaluators/qmod_node_evaluators/utils.py

@@ -0,0 +1,80 @@
+from typing import Any, Optional, Union, cast
+
+import sympy
+
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ClassicalTuple,
+    ClassicalType,
+    Integer,
+    Real,
+)
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumNumeric,
+    QuantumScalar,
+    QuantumType,
+)
+
+QmodType = Union[ClassicalType, QuantumType]
+IntegerValueType = int
+RealValueType = Union[float, complex]
+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
+    return isinstance(qmod_type, ClassicalType)
+
+
+def qnum_is_qbit(qmod_type: QuantumNumeric) -> bool:
+    return (
+        (not qmod_type.has_size_in_bits or qmod_type.size_in_bits == 1)
+        and (not qmod_type.has_sign or not qmod_type.sign_value)
+        and (not qmod_type.has_fraction_digits or qmod_type.fraction_digits_value == 0)
+    )
+
+
+def qnum_is_qint(qmod_type: QuantumType) -> bool:
+    return isinstance(qmod_type, QuantumBit) or (
+        isinstance(qmod_type, QuantumNumeric)
+        and (not qmod_type.has_sign or not qmod_type.sign_value)
+        and (not qmod_type.has_fraction_digits or qmod_type.fraction_digits_value == 0)
+    )
+
+
+def element_types(
+    classical_type: Union[ClassicalArray, ClassicalTuple],
+) -> list[ClassicalType]:
+    if isinstance(classical_type, ClassicalArray):
+        return [classical_type.element_type]
+    return cast(list[ClassicalType], classical_type.element_types)
+
+
+def array_len(
+    classical_type: Union[ClassicalArray, ClassicalTuple],
+) -> Optional[int]:
+    if isinstance(classical_type, ClassicalTuple):
+        return len(classical_type.element_types)
+    if classical_type.has_length:
+        return classical_type.length_value
+    return None
+
+
+def is_numeric_type(qmod_type: QmodType) -> bool:
+    return isinstance(qmod_type, (Integer, Real, QuantumScalar)) or (
+        isinstance(qmod_type, TypeName) and qmod_type.is_enum
+    )
+
+
+def is_classical_integer(qmod_type: QmodType) -> bool:
+    return isinstance(qmod_type, Integer) or (
+        isinstance(qmod_type, TypeName) and qmod_type.is_enum
+    )