classiq 0.102.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -1,7 +1,15 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, NoReturn, cast
 
-from classiq.interface.exceptions import ClassiqExpansionError
+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,
+    Integer,
+)
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.block import Block
@@ -20,9 +28,11 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 )
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_type import (
+    QuantumBit,
     QuantumBitvector,
     QuantumNumeric,
     QuantumScalar,
+    QuantumType,
 )
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.variable_declaration_statement import (
@@ -31,6 +41,18 @@ from classiq.interface.model.variable_declaration_statement import (
 from classiq.interface.model.within_apply_operation import WithinApply
 
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    QmodType,
+    array_len,
+    element_types,
+    is_numeric_type,
+)
+from classiq.evaluators.qmod_type_inference.classical_type_inference import (
+    infer_classical_type,
+)
+from classiq.evaluators.qmod_type_inference.quantum_type_comparison import (
+    compare_quantum_types,
+)
 from classiq.evaluators.qmod_type_inference.quantum_type_inference import (
     inject_quantum_type_attributes_inplace,
 )
@@ -43,13 +65,22 @@ from classiq.model_expansions.quantum_operations.arithmetic.explicit_boolean_exp
     validate_assignment_bool_expression,
 )
 from classiq.model_expansions.quantum_operations.emitter import Emitter
-from classiq.model_expansions.scope import ClassicalSymbol
+from classiq.model_expansions.scope import ClassicalSymbol, QuantumSymbol
 from classiq.qmod.builtins.functions.standard_gates import CX
 
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 
 
+def _get_expr_type(op: QuantumAssignmentOperation) -> QmodType:
+    expr_val = op.expression.value.value
+    if isinstance(expr_val, QmodAnnotatedExpression):
+        return expr_val.get_type(expr_val.root)
+    else:
+        expr_type = infer_classical_type(expr_val)
+    return expr_type
+
+
 class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
     def __init__(
         self, interpreter: "BaseInterpreter", replace_assignment_if_needed: bool = False
@@ -60,14 +91,26 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
     def emit(self, op: QuantumAssignmentOperation, /) -> bool:
         result_symbol = self._interpreter.evaluate(op.result_var).value
         if isinstance(result_symbol, ClassicalSymbol):
-            return False
+            return self._emit_classical_assignment(op)
+        if isinstance(result_symbol.quantum_type, QuantumScalar):
+            return self._emit_scalar_assignment(op)
+        expr_val = op.expression.value.value
+        if isinstance(expr_val, QmodAnnotatedExpression) and isinstance(
+            expr_val.get_type(expr_val.root), QuantumType
+        ):
+            return self._emit_quantum_var_quantum_expr_assignment(op)
+        return self._emit_quantum_var_classical_expr_assignment(op)
+
+    def _emit_classical_assignment(self, _: QuantumAssignmentOperation, /) -> bool:
+        return False
+
+    def _emit_scalar_assignment(self, op: QuantumAssignmentOperation, /) -> bool:
+        result_symbol = self._interpreter.evaluate(op.result_var).value
         result_type = result_symbol.quantum_type
-        if not isinstance(result_type, QuantumScalar):
-            raise ClassiqExpansionError(
-                f"Cannot assign into a non-scalar quantum variable "
-                f"{str(result_symbol.handle)!r} of type "
-                f"{result_type.raw_qmod_type_name}"
-            )
+
+        expr_type = _get_expr_type(op)
+        if not is_numeric_type(expr_type) and not isinstance(expr_type, Bool):
+            self._raise_type_error(result_symbol, expr_type)
 
         if not (
             isinstance(op, ArithmeticOperation)
@@ -82,36 +125,73 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         )
         convert_assignment_bool_expression(op)
 
-        expression_type = self._infer_expression_type(op)
-        if expression_type is None:
+        quantum_expr_type = self._infer_scalar_expression_type(op)
+        if quantum_expr_type is None:
             return False
 
         if not result_type.is_instantiated:
-            if not inject_quantum_type_attributes_inplace(expression_type, result_type):
-                raise ClassiqExpansionError(
-                    f"Cannot assign expression of type "
-                    f"{expression_type.qmod_type_name} to variable "
-                    f"{str(result_symbol)!r} of type "
-                    f"{result_symbol.quantum_type.qmod_type_name}"
-                )
+            if not inject_quantum_type_attributes_inplace(
+                quantum_expr_type, result_type
+            ):
+                self._raise_type_error(result_symbol, expr_type)
             return False
 
-        if isinstance(result_type, QuantumNumeric) and isinstance(
-            expression_type, QuantumNumeric
+        if not isinstance(result_type, QuantumScalar) or not isinstance(
+            quantum_expr_type, QuantumScalar
         ):
-            result_type.set_bounds(expression_type.get_bounds())
-        if self._same_numeric_attributes(result_type, expression_type):
+            return False
+        if isinstance(result_type, QuantumNumeric):
+            result_type.set_bounds(quantum_expr_type.get_bounds())
+        if self._same_numeric_attributes(result_type, quantum_expr_type):
             return False
         self._validate_declared_attributes(
-            result_type, expression_type, str(op.result_var)
+            result_type, quantum_expr_type, str(op.result_var)
         )
         if not self._replace_assignment_if_needed:
             return False
 
-        self._assign_to_inferred_var_and_bind(op, result_type, expression_type)
+        self._assign_to_inferred_var_and_bind(op, result_type, quantum_expr_type)
         return True
 
-    def _infer_expression_type(self, op: ArithmeticOperation) -> QuantumScalar | None:
+    def _emit_quantum_var_quantum_expr_assignment(
+        self, op: QuantumAssignmentOperation, /
+    ) -> bool:
+        result_symbol = self._interpreter.evaluate(op.result_var).value
+        result_type = result_symbol.quantum_type
+        expr_type = cast(QuantumType, _get_expr_type(op))
+        if not inject_quantum_type_attributes_inplace(
+            expr_type, result_type
+        ) or not compare_quantum_types(result_type, expr_type):
+            self._raise_type_error(result_symbol, expr_type)
+        return False
+
+    def _emit_quantum_var_classical_expr_assignment(
+        self, op: QuantumAssignmentOperation, /
+    ) -> bool:
+        result_symbol = self._interpreter.evaluate(op.result_var).value
+        result_type = result_symbol.quantum_type
+
+        quantum_expr_type = self._infer_classical_array_expression_type(op)
+        if quantum_expr_type is None or not inject_quantum_type_attributes_inplace(
+            quantum_expr_type, result_type
+        ):
+            self._raise_type_error(result_symbol, _get_expr_type(op))
+
+        return False
+
+    def _raise_type_error(
+        self, result_symbol: QuantumSymbol, expr_type: QmodType
+    ) -> NoReturn:
+        raise ClassiqExpansionError(
+            f"Cannot assign expression of type "
+            f"{expr_type.qmod_type_name} to variable "
+            f"{str(result_symbol)!r} of type "
+            f"{result_symbol.quantum_type.qmod_type_name}"
+        )
+
+    def _infer_scalar_expression_type(
+        self, op: QuantumAssignmentOperation
+    ) -> QuantumType | None:
         expr = self._evaluate_expression(op.expression)
         expr_val = expr.value.value
         if isinstance(expr_val, QmodAnnotatedExpression):
@@ -129,9 +209,33 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
             ).to_quantum_numeric()
         return None
 
+    def _infer_classical_array_expression_type(
+        self, op: QuantumAssignmentOperation
+    ) -> QuantumType | None:
+        expr = self._evaluate_expression(op.expression)
+        expr_val = expr.value.value
+        if isinstance(expr_val, QmodAnnotatedExpression):
+            root_type = expr_val.get_type(expr_val.root)
+            if isinstance(root_type, (ClassicalArray, ClassicalTuple)) and all(
+                isinstance(element_type, Integer)
+                for element_type in element_types(root_type)
+            ):
+                list_len = array_len(root_type)
+                len_expr = (
+                    Expression(expr=str(list_len)) if list_len is not None else None
+                )
+                return QuantumBitvector(element_type=QuantumBit(), length=len_expr)
+            return None
+        if isinstance(expr_val, list) and all(
+            element in (0, 1) for element in expr_val
+        ):
+            length_expr = Expression(expr=str(len(expr_val)))
+            return QuantumBitvector(element_type=QuantumBit(), length=length_expr)
+        return None
+
     @staticmethod
     def _same_numeric_attributes(
-        result_type: QuantumNumeric, expression_type: QuantumScalar
+        result_type: QuantumScalar, expression_type: QuantumScalar
     ) -> bool:
         return (
             result_type.size_in_bits == expression_type.size_in_bits
@@ -142,7 +246,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
 
     @classmethod
     def _validate_declared_attributes(
-        cls, result_type: QuantumNumeric, expression_type: QuantumScalar, var: str
+        cls, result_type: QuantumScalar, expression_type: QuantumScalar, var: str
     ) -> None:
         result_size, result_sign, result_fractions = (
             result_type.size_in_bits,

classiq/model_expansions/quantum_operations/bind.py

@@ -97,6 +97,8 @@ class BindEmitter(Emitter[BindOperation]):
             state = self._builder.current_block.captured_vars.get_state(
                 var_name, inp.defining_function
             )
+            if state is None:
+                continue
             if not state:
                 raise ClassiqExpansionError(
                     f"Cannot use uninitialized quantum variable "
@@ -112,6 +114,8 @@ class BindEmitter(Emitter[BindOperation]):
             state = self._builder.current_block.captured_vars.get_state(
                 var_name, out.defining_function
             )
+            if state is None:
+                continue
             if state:
                 raise ClassiqExpansionError(
                     f"Cannot use initialized quantum variable "

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -12,9 +12,6 @@ from classiq.interface.debug_info.debug_info import (
     new_function_debug_info_by_node,
 )
 from classiq.interface.exceptions import ClassiqExpansionError
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.helpers.text_utils import are, readable_list, s
 from classiq.interface.model.block import Block
@@ -45,8 +42,6 @@ from classiq.evaluators.parameter_types import (
 )
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.model_expansions.capturing.captured_vars import (
-    INITIALIZED_VAR_MESSAGE,
-    UNINITIALIZED_VAR_MESSAGE,
     validate_args_are_not_propagated,
 )
 from classiq.model_expansions.closure import Closure, FunctionClosure
@@ -109,12 +104,14 @@ def _validate_gen_args(
         if (
             isinstance(param, ClassicalParameterDeclaration)
             and not param.classical_type.is_purely_declarative
-            and isinstance(arg.value, QmodAnnotatedExpression)
+            and isinstance(arg_val := arg.value, QmodAnnotatedExpression)
         ):
             readable_expr = transform_expression(str(arg.value), {}, {}, one_line=True)
+            expr_type = arg_val.get_type(arg_val.root)
             raise ClassiqExpansionError(
-                f"Cannot pass symbolic expression {readable_expr!r} as Python-type "
-                f"parameter {param.name!r}"
+                f"Cannot pass {readable_expr!r} of type {expr_type.qmod_type_name} as "
+                f"parameter {param.name!r} of Python-type "
+                f"{param.classical_type.python_type_name}"
             )
 
 
@@ -195,7 +192,6 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
     ) -> QuantumFunctionCall:
         function = function.clone()
         function = function.set_depth(self._builder.current_function.depth + 1)
-        self._validate_call_args(function.positional_arg_declarations, args)
         evaluated_args = [self._interpreter.evaluate(arg) for arg in args]
         _validate_cloning(evaluated_args)
         _validate_runtime_args(evaluated_args, self._current_scope)
@@ -391,32 +387,6 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
             permutation=function.permutation,
         )
 
-    def _validate_call_args(
-        self, params: Sequence[PositionalArg], args: list[ArgValue]
-    ) -> None:
-        for param, arg in zip(params, args):
-            if not isinstance(param, PortDeclaration) or not isinstance(
-                arg, HandleBinding
-            ):
-                continue
-            var_name = arg.name
-            symbol = self._interpreter.evaluate(var_name)
-            if (
-                not isinstance(symbol.value, QuantumSymbol)
-                or symbol.defining_function is None
-            ):
-                continue
-            var_state = self._builder.current_block.captured_vars.get_state(
-                var_name, symbol.defining_function
-            )
-            if not var_state and param.direction in (
-                PortDeclarationDirection.Inout,
-                PortDeclarationDirection.Input,
-            ):
-                raise ClassiqExpansionError(UNINITIALIZED_VAR_MESSAGE.format(var_name))
-            if var_state and param.direction == PortDeclarationDirection.Output:
-                raise ClassiqExpansionError(INITIALIZED_VAR_MESSAGE.format(var_name))
-
     def _validate_type_modifiers(
         self, func_context: FunctionContext, func_def: NativeFunctionDefinition
     ) -> None:

classiq/model_expansions/quantum_operations/emitter.py

@@ -144,11 +144,8 @@ class Emitter(Generic[QuantumStatementT], ABC):
         expression: Expression,
         *,
         simplify: bool = False,
-        treat_qnum_as_float: bool = False,
     ) -> Expression:
-        expr_val = self._interpreter.evaluate(
-            expression, simplify=simplify, treat_qnum_as_float=treat_qnum_as_float
-        ).value
+        expr_val = self._interpreter.evaluate(expression, simplify=simplify).value
         new_expr = Expression(expr=str(expr_val))
         new_expr._evaluated_expr = EvaluatedExpression(value=expr_val)
         return new_expr

classiq/model_expansions/quantum_operations/expression_evaluator.py

@@ -26,14 +26,12 @@ class ExpressionEvaluator(Emitter[QuantumOperation]):
         *,
         readable_expression_name: str | None = None,
         simplify: bool = False,
-        treat_qnum_as_float: bool = False,
         allow_link_time_vars: bool = True,
         allow_runtime_vars: bool = True,
     ) -> None:
         super().__init__(interpreter)
         self._expression_name = expression_name
         self._simplify = simplify
-        self._treat_qnum_as_float = treat_qnum_as_float
         self._allow_link_time_vars = allow_link_time_vars
         self._allow_runtime_vars = allow_runtime_vars
         if (
@@ -49,7 +47,6 @@ class ExpressionEvaluator(Emitter[QuantumOperation]):
         evaluated_expression = self._evaluate_expression(
             expression,
             simplify=self._simplify,
-            treat_qnum_as_float=self._treat_qnum_as_float,
         )
         for symbol in self._get_symbols_in_expression(evaluated_expression):
             self._capture_handle(symbol.handle, PortDeclarationDirection.Inout)

classiq/model_expansions/visitors/uncomputation_signature_inference.py

@@ -21,9 +21,6 @@ from classiq.interface.model.invert import Invert
 from classiq.interface.model.model_visitor import ModelStatementsVisitor
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.power import Power
-from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
-    AmplitudeLoadingOperation,
-)
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
 )
@@ -147,12 +144,6 @@ class UncomputationSignatureInference(ModelStatementsVisitor):
         else:
             self._mark_as_non_const(arith.result_var.name, True)
 
-    def visit_AmplitudeLoadingOperation(
-        self, amp_load: AmplitudeLoadingOperation
-    ) -> None:
-        self._mark_as_non_permutation()
-        self._mark_as_non_const(amp_load.result_var.name, False)
-
     def visit_Control(self, control: Control) -> None:
         self.visit(control.body)
         if control.else_block is not None:

classiq/qmod/builtins/functions/__init__.py

@@ -2,7 +2,8 @@ from .allocation import *
 from .arithmetic import *
 from .benchmarking import *
 from .exponentiation import *
-from .mcx_func import mcx
+from .gray_code import *
+from .mcx_func import *
 from .mid_circuit_measurement import *
 from .operators import *
 from .standard_gates import *
@@ -38,29 +39,32 @@ CORE_LIB_DECLS = [
         SWAP,
         IDENTITY,
         prepare_state,
-        prepare_state_approx,
         prepare_amplitudes,
-        prepare_amplitudes_approx,
         unitary,
         add,
         add_inplace_right,
+        canonical_add,
+        canonical_add_constant,
         modular_add,
         integer_xor,
         modular_add_constant,
         real_xor_constant,
+        multiply,
+        multiply_constant,
+        canonical_multiply,
+        canonical_multiply_constant,
         U,
         CCX,
         free,
         drop,
         randomized_benchmarking,
         inplace_prepare_state,
-        inplace_prepare_state_approx,
         inplace_prepare_amplitudes,
-        inplace_prepare_amplitudes_approx,
         single_pauli_exponent,
         commuting_paulis_exponent,
         suzuki_trotter,
         unscheduled_suzuki_trotter,
+        sequential_suzuki_trotter,
         exponentiate,
         multi_suzuki_trotter,
         parametric_suzuki_trotter,
@@ -69,7 +73,10 @@ CORE_LIB_DECLS = [
         exponentiation_with_depth_constraint,
         RESET,
         mcx,
+        mcx_gray_code,
+        mcx_hybrid_rec,
         SX,
+        select_rotation,
     )
 ]
 
@@ -89,6 +96,8 @@ __all__ = [  # noqa: RUF022
     "I",
     "IDENTITY",
     "mcx",
+    "mcx_gray_code",
+    "mcx_hybrid_rec",
     "PHASE",
     "R",
     "RX",
@@ -109,14 +118,18 @@ __all__ = [  # noqa: RUF022
     "SX",
     "add",
     "add_inplace_right",
+    "canonical_add",
+    "canonical_add_constant",
     "apply",
     "exponentiation_with_depth_constraint",
+    "multiply",
+    "multiply_constant",
+    "canonical_multiply",
+    "canonical_multiply_constant",
     "free",
     "drop",
     "inplace_prepare_amplitudes",
-    "inplace_prepare_amplitudes_approx",
     "inplace_prepare_state",
-    "inplace_prepare_state_approx",
     "integer_xor",
     "modular_add",
     "modular_add_constant",
@@ -124,9 +137,7 @@ __all__ = [  # noqa: RUF022
     "parametric_suzuki_trotter",
     "permute",
     "prepare_amplitudes",
-    "prepare_amplitudes_approx",
     "prepare_state",
-    "prepare_state_approx",
     "qdrift",
     "randomized_benchmarking",
     "real_xor_constant",
@@ -135,6 +146,7 @@ __all__ = [  # noqa: RUF022
     "suzuki_trotter",
     "unitary",
     "RESET",
+    "select_rotation",
 ]
 BUILTIN_FUNCTION_DECLARATIONS = {
     func_decl.name: func_decl for func_decl in STD_QMOD_OPERATORS + CORE_LIB_DECLS

classiq/qmod/builtins/functions/allocation.py

@@ -144,39 +144,3 @@ def inplace_prepare_amplitudes(
 
     """
     pass
-
-
-@qfunc(external=True)
-def inplace_prepare_amplitudes_approx(
-    amplitudes: CArray[CReal],
-    bound: CReal,
-    target: QArray[QBit, Literal["log(amplitudes.len, 2)"]],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def prepare_amplitudes_approx(
-    amplitudes: CArray[CReal],
-    bound: CReal,
-    out: Output[QArray[QBit, Literal["log(amplitudes.len, 2)"]]],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def inplace_prepare_state_approx(
-    probabilities: CArray[CReal],
-    bound: CReal,
-    target: QArray[QBit, Literal["log(probabilities.len, 2)"]],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def prepare_state_approx(
-    probabilities: CArray[CReal],
-    bound: CReal,
-    out: Output[QArray[QBit, Literal["log(probabilities.len, 2)"]]],
-) -> None:
-    pass