classiq 0.83.0__py3-none-any.whl → 0.85.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -1,10 +1,12 @@
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
 
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.block import Block
+from classiq.interface.model.bounds import SetBoundsStatement
 from classiq.interface.model.handle_binding import (
     ConcreteHandleBinding,
     HandleBinding,
@@ -19,25 +21,37 @@ 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 QuantumBitvector, QuantumNumeric
+from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
+from classiq.evaluators.quantum_type_utils import copy_type_information
 from classiq.model_expansions.quantum_operations.arithmetic.explicit_boolean_expressions import (
     convert_assignment_bool_expression,
     validate_assignment_bool_expression,
 )
 from classiq.model_expansions.quantum_operations.emitter import Emitter
-from classiq.model_expansions.scope import QuantumSymbol
+from classiq.model_expansions.scope import ClassicalSymbol
 from classiq.model_expansions.transformers.ast_renamer import rename_variables
 from classiq.qmod.builtins.functions.standard_gates import CX
 
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
 
 class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
+    def __init__(
+        self, interpreter: "BaseInterpreter", replace_assignment_if_needed: bool = False
+    ) -> None:
+        super().__init__(interpreter)
+        self._replace_assignment_if_needed = replace_assignment_if_needed
+
     def emit(self, op: QuantumAssignmentOperation, /) -> bool:
-        result_symbol = self._interpreter.evaluate(op.result_var).as_type(QuantumSymbol)
+        result_symbol = self._interpreter.evaluate(op.result_var).value
+        if isinstance(result_symbol, ClassicalSymbol):
+            return False
         result_type = result_symbol.quantum_type
 
         if not (
@@ -70,9 +84,11 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         self._validate_declared_attributes(
             result_type, inferred_result_type, str(op.result_var)
         )
-        self._assign_to_inferred_var_and_bind(op, result_type, inferred_result_type)
-        result_type.set_bounds(inferred_result_type.get_bounds())
-        return True
+        if self._replace_assignment_if_needed:
+            self._assign_to_inferred_var_and_bind(op, result_type, inferred_result_type)
+            return True
+        else:
+            return False
 
     def _infer_result_type(self, op: ArithmeticOperation) -> Optional[QuantumNumeric]:
         expr = self._evaluate_expression(op.expression)
@@ -182,6 +198,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         result_type: QuantumNumeric,
         inferred_result_type: QuantumNumeric,
     ) -> None:
+        stmts: StatementBlock = []
         handles: list[HandleBinding] = []
 
         extra_fraction_digits = (
@@ -190,20 +207,22 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         )
         if extra_fraction_digits > 0:
             handles.append(
-                self._declare_qarray("extra_fraction_digits", extra_fraction_digits)
+                self._declare_qarray(
+                    "extra_fraction_digits", extra_fraction_digits, stmts
+                )
             )
 
         inferred_result_name = self._counted_name_allocator.allocate("inferred_result")
         inferred_result_handle = HandleBinding(name=inferred_result_name)
-        self._interpreter.emit(
+        stmts.append(
             VariableDeclarationStatement(
-                name=inferred_result_name, quantum_type=inferred_result_type
+                name=inferred_result_name, qmod_type=inferred_result_type
             )
         )
         handles.append(inferred_result_handle)
         modified_op = op.model_copy(update={"result_var": inferred_result_handle})
         self._interpreter.add_to_debug_info(modified_op)
-        self._interpreter.emit(modified_op)
+        stmts.append(modified_op)
 
         result_integer_size = (
             result_type.size_in_bits - result_type.fraction_digits_value
@@ -214,11 +233,11 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         )
         extra_integers = result_integer_size - inferred_result_integer_size
         if extra_integers > 0:
-            handles.append(self._declare_qarray("extra_integers", extra_integers))
+            handles.append(
+                self._declare_qarray("extra_integers", extra_integers, stmts)
+            )
 
-        self._interpreter.emit(
-            BindOperation(in_handles=handles, out_handles=[op.result_var])
-        )
+        stmts.append(BindOperation(in_handles=handles, out_handles=[op.result_var]))
 
         if (
             result_type.sign_value
@@ -226,22 +245,44 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
             and extra_integers > 0
         ):
             sign_idx = result_type.size_in_bits - extra_integers - 1
-            self._sign_extension(op.result_var, sign_idx, result_type.size_in_bits)
+            self._sign_extension(
+                op.result_var, sign_idx, result_type.size_in_bits, stmts
+            )
+
+        if (inferred_bounds := inferred_result_type.get_bounds()) is not None:
+            lower_bound = Expression(expr=str(inferred_bounds[0]))
+            upper_bound = Expression(expr=str(inferred_bounds[1]))
+        else:
+            lower_bound, upper_bound = None, None
+        stmts.append(
+            SetBoundsStatement(
+                target=op.result_var,
+                lower_bound=lower_bound,
+                upper_bound=upper_bound,
+            )
+        )
+
+        self._interpreter.emit(
+            Block(
+                statements=stmts,
+                uuid=op.uuid,
+                back_ref=op.back_ref,
+            )
+        )
 
     def _declare_qarray(
         self,
         prefix: str,
         size: int,
+        stmts: StatementBlock,
         allocate: bool = True,
     ) -> HandleBinding:
         name = self._counted_name_allocator.allocate(prefix)
         handle = HandleBinding(name=name)
         quantum_type = QuantumBitvector(length=Expression(expr=str(size)))
-        self._interpreter.emit(
-            VariableDeclarationStatement(name=name, quantum_type=quantum_type)
-        )
+        stmts.append(VariableDeclarationStatement(name=name, qmod_type=quantum_type))
         if allocate:
-            self._interpreter.emit(Allocate(target=handle))
+            stmts.append(Allocate(target=handle))
         return handle
 
     def _sign_extension(
@@ -249,9 +290,10 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         result_var: ConcreteHandleBinding,
         sign_idx: int,
         size: int,
+        stmts: StatementBlock,
     ) -> None:
-        aux = self._declare_qarray("inferred_result_aux", size, allocate=False)
-        self._interpreter.emit(
+        aux = self._declare_qarray("inferred_result_aux", size, stmts, allocate=False)
+        stmts.append(
             WithinApply(
                 compute=[BindOperation(in_handles=[result_var], out_handles=[aux])],
                 action=[

classiq/model_expansions/quantum_operations/bind.py

@@ -8,10 +8,10 @@ from classiq.interface.exceptions import (
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.quantum_type import QuantumNumeric
 
-from classiq.model_expansions.evaluators.parameter_types import (
+from classiq.evaluators.parameter_types import (
     evaluate_types_in_quantum_symbols,
 )
-from classiq.model_expansions.evaluators.quantum_type_utils import (
+from classiq.evaluators.quantum_type_utils import (
     set_size,
     validate_bind_targets,
 )

classiq/model_expansions/quantum_operations/bounds.py

@@ -24,7 +24,13 @@ class SetBoundsEmitter(Emitter[SetBoundsStatement]):
             raise ClassiqExpansionError(
                 f"Cannot set bounds of a non-numeric variable {op.target.qmod_expr!r}"
             )
-        target.quantum_type.set_bounds(op.bounds)
+
+        if op.lower_bound is not None and op.upper_bound is not None:
+            target.quantum_type.set_bounds(
+                (op.lower_bound.to_float_value(), op.upper_bound.to_float_value())
+            )
+        else:
+            target.quantum_type.reset_bounds()
         if self._keep_statement:
             self.emit_statement(op)
         return True

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -50,19 +50,19 @@ from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 
+from classiq.evaluators.argument_types import (
+    add_information_from_output_arguments,
+    handle_args_numeric_bounds,
+)
+from classiq.evaluators.parameter_types import (
+    evaluate_parameter_types_from_args,
+)
 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
-from classiq.model_expansions.evaluators.argument_types import (
-    add_information_from_output_arguments,
-    handle_args_numeric_bounds,
-)
-from classiq.model_expansions.evaluators.parameter_types import (
-    evaluate_parameter_types_from_args,
-)
 from classiq.model_expansions.function_builder import (
     FunctionContext,
 )
@@ -135,13 +135,13 @@ def _validate_gen_args(
     ):
         if (
             isinstance(param, ClassicalParameterDeclaration)
-            and param.classical_type.is_purely_generative
+            and not param.classical_type.is_purely_declarative
             and _is_symbolic(arg.value)
         ):
+            readable_expr = transform_expression(str(arg.value), {}, {}, one_line=True)
             raise ClassiqExpansionError(
-                f"Parameter {param.name!r} is used in a compile-time expression "
-                f"context but is passed a runtime expression "
-                f"{transform_expression(str(arg.value), {}, {}, one_line=True)!r}"
+                f"Cannot pass symbolic expression {readable_expr!r} as Python-type "
+                f"parameter {param.name!r}"
             )
 
 
@@ -209,17 +209,21 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
                 function.name, new_declaration
             )
         else:
-            # FIXME: enable for BE (CLS-2390)
-            if type(self._interpreter).__name__ == "FrontendGenerativeInterpreter":
-                _validate_gen_args(function, evaluated_args)
+            _validate_gen_args(function, evaluated_args)
             new_declaration = self._expand_function(
                 evaluated_args, new_declaration, function
             )
             new_positional_arg_decls = new_declaration.positional_arg_declarations
             evaluated_args = [
                 arg
-                for arg in evaluated_args
-                if isinstance(arg.value, QuantumVariable) or _is_symbolic(arg.value)
+                for param, arg in zip_strict(
+                    function.positional_arg_declarations, evaluated_args, strict=True
+                )
+                if isinstance(arg.value, QuantumVariable)
+                or (
+                    isinstance(param, ClassicalParameterDeclaration)
+                    and param.classical_type.is_purely_declarative
+                )
             ]
 
         add_information_from_output_arguments(new_positional_arg_decls, evaluated_args)
@@ -312,7 +316,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             if isinstance(param, PortDeclaration)
             or (
                 isinstance(param, ClassicalParameterDeclaration)
-                and _is_symbolic(arg.value)
+                and param.classical_type.is_purely_declarative
             )
         ]
         func_def = self._builder.create_definition(function_context, params)
@@ -350,8 +354,10 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
                     ),
                     defining_function=closure,
                 )
-            elif _is_symbolic(argument.value):
-                assert isinstance(parameter, ClassicalParameterDeclaration)
+            elif (
+                isinstance(parameter, ClassicalParameterDeclaration)
+                and parameter.classical_type.is_purely_declarative
+            ):
                 inferred_arg = Evaluated(
                     value=parameter.classical_type.get_classical_proxy(param_handle),
                     defining_function=closure,
@@ -426,7 +432,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         ).unchecked
         TypeModifierValidation(
             skip_validation=self._interpreter.skip_type_modifier_validation
-        ).run(func_def.port_declarations, func_def.body, unchecked)
+        ).run(func_def, unchecked)
 
     @staticmethod
     def _should_override_type_modifiers(func_context: FunctionContext) -> bool:

classiq/model_expansions/quantum_operations/classical_var_emitter.py

@@ -0,0 +1,16 @@
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+)
+
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import ClassicalSymbol
+
+
+class ClassicalVarEmitter(Emitter[ArithmeticOperation]):
+    def emit(self, op: ArithmeticOperation, /) -> bool:
+        result_symbol = self._interpreter.evaluate(op.result_var).value
+        if not isinstance(result_symbol, ClassicalSymbol):
+            return False
+        op._classical_assignment = True
+        self.emit_statement(op)
+        return True

classiq/model_expansions/quantum_operations/variable_decleration.py

@@ -1,14 +1,19 @@
+from typing import TYPE_CHECKING, Union
+
 from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.functions.classical_type import ClassicalType
 from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.quantum_type import QuantumType
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 
-from classiq.model_expansions.evaluators.parameter_types import (
+from classiq.evaluators.parameter_types import (
+    evaluate_type_in_classical_symbol,
     evaluate_type_in_quantum_symbol,
 )
 from classiq.model_expansions.quantum_operations.emitter import Emitter
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+from classiq.model_expansions.scope import ClassicalSymbol, Evaluated, QuantumSymbol
 
 
 class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement]):
@@ -16,24 +21,39 @@ class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement])
         var_decl = variable_declaration.model_copy(
             update=dict(back_ref=variable_declaration.uuid)
         )
-        var_decl.quantum_type = variable_declaration.quantum_type.model_copy()
+        var_decl.qmod_type = variable_declaration.qmod_type.model_copy()
         if variable_declaration.name in self._current_scope:
             raise ClassiqExpansionError(
                 f"Variable {variable_declaration.name!r} is already defined"
             )
-        self._current_scope[variable_declaration.name] = Evaluated(
-            value=QuantumSymbol(
+        var_value: Union[QuantumSymbol, ClassicalSymbol]
+        if variable_declaration.is_quantum:
+            if TYPE_CHECKING:
+                assert isinstance(var_decl.qmod_type, QuantumType)
+            var_value = QuantumSymbol(
                 handle=HandleBinding(name=var_decl.name),
                 quantum_type=evaluate_type_in_quantum_symbol(
-                    var_decl.quantum_type,
+                    var_decl.qmod_type,
                     self._current_scope,
                     var_decl.name,
                 ),
-            ),
-            defining_function=self._builder.current_function,
-        )
-        self._builder.current_block.captured_vars.init_var(
-            var_decl.name, self._builder.current_function
+            )
+            self._builder.current_block.captured_vars.init_var(
+                var_decl.name, self._builder.current_function
+            )
+        else:
+            if TYPE_CHECKING:
+                assert isinstance(var_decl.qmod_type, ClassicalType)
+            var_value = ClassicalSymbol(
+                handle=HandleBinding(name=var_decl.name),
+                classical_type=evaluate_type_in_classical_symbol(
+                    var_decl.qmod_type,
+                    self._current_scope,
+                    var_decl.name,
+                ),
+            )
+        self._current_scope[variable_declaration.name] = Evaluated(
+            value=var_value, defining_function=self._builder.current_function
         )
         self.emit_statement(var_decl)
         return True

classiq/model_expansions/scope.py

@@ -21,6 +21,7 @@ from classiq.interface.generator.expressions.proxies.classical.classical_scalar_
 from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
+from classiq.interface.generator.functions.classical_type import ClassicalType
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.helpers.text_utils import readable_list, s
 from classiq.interface.model.handle_binding import (
@@ -202,6 +203,12 @@ class QuantumSymbolList(QuantumVariable):
         return str(self.handles)
 
 
+@dataclass(frozen=True)
+class ClassicalSymbol:
+    handle: HandleBinding
+    classical_type: ClassicalType
+
+
 @singledispatch
 def evaluated_to_str(value: Any) -> str:
     return str(value)

classiq/model_expansions/scope_initialization.py

@@ -11,13 +11,13 @@ from classiq.interface.model.native_function_definition import NativeFunctionDef
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import PositionalArg
 
-from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
-from classiq.model_expansions.evaluators.classical_expression import (
+from classiq.evaluators.classical_expression import (
     evaluate_classical_expression,
 )
-from classiq.model_expansions.evaluators.parameter_types import (
+from classiq.evaluators.parameter_types import (
     evaluate_type_in_quantum_symbol,
 )
+from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.qmod.builtins import BUILTIN_CONSTANTS
 from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS

classiq/model_expansions/transformers/model_renamer.py

@@ -77,7 +77,7 @@ class HandleRenaming:
 SymbolRenaming = Mapping[HandleBinding, Sequence[HandleRenaming]]
 
 
-def _rewrite_expression(
+def rewrite_expression(
     symbol_mapping: SymbolRenaming, expression: Expression
 ) -> Expression:
     normalized_expr = ExprNormalizer().visit(ast.parse(expression.expr))
@@ -88,7 +88,8 @@ def _rewrite_expression(
 
     handle_names = {
         part.source_handle: part.target_var_handle
-        for parts in symbol_mapping.values()
+        for source, parts in symbol_mapping.items()
+        if source.name in expression.expr
         for part in parts
     }
     new_expr_str = ast.unparse(normalized_expr)
@@ -101,7 +102,8 @@ def _rewrite_expression(
     for handle in sorted_handles:
         new_handle = handle.collapse()
         for handle_to_replace, replacement in handle_names.items():
-            new_handle = new_handle.replace_prefix(handle_to_replace, replacement)
+            if new_handle.name == handle_to_replace.name:
+                new_handle = new_handle.replace_prefix(handle_to_replace, replacement)
         new_expr_str = _replace_full_word(str(handle), str(new_handle), new_expr_str)
 
     new_expr = Expression(expr=new_expr_str)
@@ -132,7 +134,7 @@ class _ReplaceSplitVarsExpressions(ModelTransformer):
         self._symbol_mapping = symbol_mapping
 
     def visit_Expression(self, expr: Expression) -> Expression:
-        return _rewrite_expression(self._symbol_mapping, expr)
+        return rewrite_expression(self._symbol_mapping, expr)
 
     def visit_QuantumExpressionOperation(
         self, op: QuantumExpressionOperation