classiq 0.54.0__py3-none-any.whl → 0.56.0__py3-none-any.whl

classiq/model_expansions/function_builder.py

@@ -19,7 +19,6 @@ from classiq.interface.generator.functions.port_declaration import (
 )
 from classiq.interface.model.model import MAIN_FUNCTION_NAME
 from classiq.interface.model.native_function_definition import (
-    FunctionSynthesisData,
     NativeFunctionDefinition,
 )
 from classiq.interface.model.port_declaration import PortDeclaration
@@ -31,6 +30,7 @@ from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.model_expansions.capturing.captured_var_manager import update_captured_vars
 from classiq.model_expansions.capturing.mangling_utils import demangle_name
 from classiq.model_expansions.closure import Closure, FunctionClosure
+from classiq.model_expansions.scope import Scope
 
 ClosureType = TypeVar("ClosureType", bound=Closure)
 
@@ -76,16 +76,12 @@ class FunctionContext(OperationContext[FunctionClosure]):
     def is_lambda(self) -> bool:
         return self.closure.is_lambda
 
-    @property
-    def synthesis_data(self) -> FunctionSynthesisData:
-        return self.closure.synthesis_data
-
 
 class OperationBuilder:
-    def __init__(self) -> None:
+    def __init__(self, functions_scope: Scope) -> None:
         self._operations: list[OperationContext] = []
         self._blocks: list[str] = []
-        self._counter = 0
+        self._functions_scope = functions_scope
 
     @property
     def current_operation(self) -> Closure:
@@ -163,8 +159,12 @@ class OperationBuilder:
     ) -> NativeFunctionDefinition:
         name = function_context.name
         if name != MAIN_FUNCTION_NAME:
-            name = f"{name}_{LAMBDA_KEYWORD + '_0_0_' if function_context.is_lambda else ''}{EXPANDED_KEYWORD}_{self._counter}"
-            self._counter += 1
+            idx = 0
+            new_name = name
+            while idx == 0 or new_name in self._functions_scope:
+                new_name = f"{name}_{LAMBDA_KEYWORD + '_0_0_' if function_context.is_lambda else ''}{EXPANDED_KEYWORD}_{idx}"
+                idx += 1
+            name = new_name
 
         new_parameters: list[PortDeclaration] = [
             param
@@ -176,7 +176,6 @@ class OperationBuilder:
             name=name,
             body=function_context.body,
             positional_arg_declarations=new_parameters,
-            synthesis_data=function_context.synthesis_data,
         )
 
 

classiq/model_expansions/generative_functions.py

@@ -186,7 +186,7 @@ def _expand_operand_as_declarative(
 
 
 def _register_declarative_function(interpreter: "Interpreter", func_name: str) -> None:
-    if func_name in nameables_to_dict(interpreter._expanded_functions):
+    if func_name in nameables_to_dict(list(interpreter._expanded_functions.values())):
         return
 
     for user_gen_func in interpreter._generative_functions:
@@ -199,7 +199,7 @@ def _register_declarative_function(interpreter: "Interpreter", func_name: str) -
         dec_func = QFunc(user_gen_func._py_callable)
         dec_func.expand()
         dec_func_def = QMODULE.native_defs[func_name]
-        interpreter._expanded_functions.append(dec_func_def)
+        interpreter._expanded_functions[func_name] = dec_func_def
         _DecFuncVisitor(interpreter).visit(dec_func_def)
 
 

classiq/model_expansions/interpreter.py

@@ -11,7 +11,9 @@ from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
+from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.control import Control
@@ -46,7 +48,6 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq.model_expansions.call_to_model_converter import BlockFunctionInfo
 from classiq.model_expansions.capturing.propagated_var_stack import PropagatedVarStack
 from classiq.model_expansions.closure import (
     Closure,
@@ -81,6 +82,7 @@ from classiq.model_expansions.quantum_operations import (
 from classiq.model_expansions.quantum_operations.phase import PhaseEmitter
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.model_expansions.scope_initialization import (
+    add_constants_to_scope,
     add_entry_point_params_to_scope,
     get_main_renamer,
     init_top_level_scope,
@@ -107,8 +109,9 @@ class Interpreter:
         self._is_frontend = is_frontend
         self._model = model
         self._current_scope = Scope()
-        self._builder = OperationBuilder()
-        self._expanded_functions: list[NativeFunctionDefinition] = []
+        self._top_level_scope = self._current_scope
+        self._builder = OperationBuilder(self._top_level_scope)
+        self._expanded_functions: dict[str, NativeFunctionDefinition] = {}
         self._propagated_var_stack = PropagatedVarStack(
             self._current_scope, self._builder
         )
@@ -119,10 +122,11 @@ class Interpreter:
             generative_functions = []
         self._generative_functions = generative_functions
         init_top_level_scope(model, generative_functions, self._current_scope)
-
+        self._expanded_functions_compilation_metadata: dict[
+            str, CompilationMetadata
+        ] = dict()
         self._counted_name_allocator = CountedNameAllocator()
         self._error_manager: ErrorManager = ErrorManager()
-        self._synthesized_separately_blocks: dict[str, BlockFunctionInfo] = {}
 
     @contextmanager
     def _scope_guard(self, scope: Scope) -> Iterator[None]:
@@ -153,14 +157,13 @@ class Interpreter:
             main_closure.positional_arg_declarations, main_closure
         )
         context = self._expand_operation(main_closure)
-        self._expanded_functions.append(
+        self._expanded_functions[main_closure.closure_id] = (
             self._builder.create_definition(cast(FunctionContext, context))
         )
 
-    def expand(self) -> tuple[Model, dict[str, BlockFunctionInfo]]:
+    def expand(self) -> Model:
         try:
             with self._error_manager.call("main"):
-                self._synthesized_separately_blocks = {}
                 self._expand_main_func()
         except Exception as e:
             if isinstance(e, ClassiqInternalExpansionError) or debug_mode.get():
@@ -172,20 +175,18 @@ class Interpreter:
         finally:
             self._error_manager.report_errors(ClassiqExpansionError)
 
-        return (
-            Model(
-                constraints=self._model.constraints,
-                preferences=self._model.preferences,
-                classical_execution_code=self._model.classical_execution_code,
-                execution_preferences=self._model.execution_preferences,
-                functions=self._expanded_functions,
-                constants=self._model.constants,
-                enums=self._model.enums,
-                types=self._model.types,
-                qstructs=self._model.qstructs,
-                debug_info=self._model.debug_info,
-            ),
-            self._synthesized_separately_blocks,
+        return Model(
+            constraints=self._model.constraints,
+            preferences=self._model.preferences,
+            classical_execution_code=self._model.classical_execution_code,
+            execution_preferences=self._model.execution_preferences,
+            functions=list(self._expanded_functions.values()),
+            constants=self._model.constants,
+            enums=self._model.enums,
+            types=self._model.types,
+            qstructs=self._model.qstructs,
+            debug_info=self._model.debug_info,
+            functions_compilation_metadata=self._expanded_functions_compilation_metadata,
         )
 
     @singledispatchmethod
@@ -346,9 +347,8 @@ class Interpreter:
 
     def _expand_operation(self, operation: Closure) -> OperationContext:
         with self._builder.operation_context(operation) as context:
-            if (
-                isinstance(operation, FunctionClosure)
-                and operation.synthesis_data.should_synthesize_separately
+            if isinstance(operation, FunctionClosure) and (
+                self._expanded_functions.get(operation.closure_id) is not None
             ):
                 pass
             elif isinstance(operation, FunctionClosure) and operation.name == "permute":
@@ -385,5 +385,8 @@ class Interpreter:
         return (
             self._model.functions
             + [gen_func.func_decl for gen_func in self._generative_functions]
-            + self._expanded_functions  # type:ignore[operator]
+            + list(self._expanded_functions.values())
         )
+
+    def add_constant(self, constant: Constant) -> None:
+        add_constants_to_scope([constant], self._top_level_scope)

classiq/model_expansions/quantum_operations/control.py

@@ -9,6 +9,7 @@ from classiq.interface.exceptions import (
 from classiq.interface.generator.compiler_keywords import INPLACE_ARITH_AUX_VAR_PREFIX
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.expression_types import ExpressionValue
+from classiq.interface.generator.expressions.qmod_qarray_proxy import QmodQArrayProxy
 from classiq.interface.generator.expressions.qmod_qscalar_proxy import QmodQNumProxy
 from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
 from classiq.interface.generator.functions.builtins.internal_operators import (
@@ -16,18 +17,24 @@ from classiq.interface.generator.functions.builtins.internal_operators import (
 )
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.control import Control
-from classiq.interface.model.handle_binding import HANDLE_ID_SEPARATOR, HandleBinding
+from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
     ArithmeticOperationKind,
 )
-from classiq.interface.model.quantum_type import QuantumBit, QuantumBitvector
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumBitvector,
+    QuantumType,
+)
 from classiq.interface.model.statement_block import ConcreteQuantumStatement
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
+from classiq.model_expansions.capturing.mangling_utils import ARRAY_CAST_SUFFIX
 from classiq.model_expansions.capturing.propagated_var_stack import (
     validate_args_are_not_propagated,
 )
@@ -40,39 +47,71 @@ from classiq.model_expansions.quantum_operations.expression_operation import (
     ExpressionOperationEmitter,
 )
 from classiq.model_expansions.scope import Scope
-
-ARRAY_CAST_SUFFIX = HANDLE_ID_SEPARATOR + "array_cast"
+from classiq.qmod.builtins.functions.standard_gates import X
 
 
 class ControlEmitter(ExpressionOperationEmitter[Control]):
     def emit(self, control: Control, /) -> None:
         condition = self._evaluate_op_expression(control)
-        control = control.model_copy(update=dict(expression=condition))
 
         arrays_with_subscript = self._get_symbols_to_split(condition)
         if len(arrays_with_subscript) > 0:
+            if control.is_generative():
+                with self._propagated_var_stack.capture_variables(control):
+                    control = self._expand_generative_control(control)
             self._emit_with_split(control, condition, arrays_with_subscript)
             return
 
+        control = self._evaluate_types_in_expression(control, condition)
         condition_val = condition.value.value
         if isinstance(condition_val, QmodSizedProxy):
-            self._validate_canonical_condition(condition_val)
-            self._emit_canonical_control(control)
-            return
+            if control.else_block is None:
+                self._validate_canonical_condition(condition_val)
+                self._emit_canonical_control(control)
+                return
+            else:
+                self._interpreter.emit_statement(
+                    control.model_copy(
+                        update=dict(
+                            expression=self._uncanonize_condition(condition_val)
+                        )
+                    )
+                )
+                return
 
-        self._validate_condition(condition_val)
+        self._validate_condition(control)
         self._emit_with_boolean(control)
 
+    def _uncanonize_condition(self, condition_val: QmodSizedProxy) -> Expression:
+        lhs = (
+            " & ".join(
+                f"{condition_val.handle}[{idx}]" for idx in range(condition_val.size)
+            )
+            if isinstance(condition_val, QmodQArrayProxy)
+            else condition_val.handle
+        )
+        return Expression(expr=f"{lhs} == 1")
+
+    def _expand_generative_control(self, control: Control) -> Control:
+        block_names = ["body"]
+        if control.has_generative_block("else_block"):
+            block_names += ["else_block"]
+        context = self._register_generative_context(
+            control, CONTROL_OPERATOR_NAME, block_names
+        )
+        new_blocks = {"body": context.statements("body")}
+        if "else_block" in block_names:
+            new_blocks["else_block"] = context.statements("else_block")
+        return control.model_copy(update=new_blocks)
+
     def _emit_canonical_control(self, control: Control) -> None:
         # canonical means control(q, body) where q is a single quantum variable
-        control = self._evaluate_types_in_expression(control, control.expression)
         with self._propagated_var_stack.capture_variables(control):
             self._emit_propagated(control)
 
     def _emit_propagated(self, control: Control) -> None:
         if control.is_generative():
-            context = self._register_generative_context(control, CONTROL_OPERATOR_NAME)
-            control = control.model_copy(update={"body": context.statements("body")})
+            control = self._expand_generative_control(control)
 
         if self._should_wrap_control(control):
             self._emit_wrapped(control)
@@ -98,7 +137,7 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         context = self._expand_operation(control_operation)
         validate_args_are_not_propagated(
             control.var_handles,
-            self._propagated_var_stack.get_propagated_variables(),
+            self._propagated_var_stack.get_propagated_variables(flatten=False),
         )
         self._update_control_state(control)
         self._builder.emit_statement(
@@ -111,7 +150,7 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         )
         validate_args_are_not_propagated(
             control.var_handles,
-            self._propagated_var_stack.get_propagated_variables(),
+            self._propagated_var_stack.get_propagated_variables(flatten=False),
         )
         self._update_control_state(control)
         self._builder.emit_statement(
@@ -129,9 +168,10 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         condition_val = control.expression.value.value
         if self._is_simple_equality(condition_val):
             ctrl, ctrl_state = resolve_num_condition(condition_val)
-            self._emit_with_x_gates(control, ctrl, ctrl_state)
-        else:
-            self._emit_with_arithmetic(control)
+            if control.else_block is None or ctrl.size == 1:
+                self._emit_with_x_gates(control, ctrl, ctrl_state)
+                return
+        self._emit_with_arithmetic(control)
 
     @staticmethod
     def _is_simple_equality(condition_val: ExpressionValue) -> TypeGuard[Equality]:
@@ -151,13 +191,38 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
 
     def _create_canonical_control_op(
         self, control: Control, handle_name: str
-    ) -> Control:
+    ) -> list[ConcreteQuantumStatement]:
         handle_expr = self._interpreter.evaluate(Expression(expr=handle_name)).emit()
-        return control.model_copy(update=dict(expression=handle_expr))
+        control_then = control.model_copy(
+            update=dict(expression=handle_expr, else_block=None)
+        )
+        if control.else_block is None:
+            return [control_then]
+        else_compute_call = QuantumFunctionCall(
+            function="X", positional_args=[HandleBinding(name=handle_name)]
+        )
+        else_compute_call.set_func_decl(X.func_decl)
+        control_else_inner = control.model_copy(
+            update=dict(
+                expression=handle_expr, body=control.else_block, else_block=None
+            ),
+            deep=True,
+        )
+        control_else = WithinApply(
+            compute=[else_compute_call],
+            action=[control_else_inner],
+        )
+        if control_else_inner.is_generative():
+            control_then.remove_generative_block("else_block")
+            control_else_inner.set_generative_block(
+                "body", control_else_inner.get_generative_block("else_block")
+            )
+            control_else_inner.remove_generative_block("else_block")
+        return [control_then, control_else]
 
-    def _emit_with_x_gates(
+    def _control_with_x_gates(
         self, control: Control, ctrl: QmodSizedProxy, ctrl_state: str
-    ) -> None:
+    ) -> ConcreteQuantumStatement:
         compute_op: list[ConcreteQuantumStatement] = []
 
         x_gate_value = self._get_x_gate_value(ctrl_state)
@@ -175,12 +240,19 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
             cast_decl, bind_op = self._get_array_cast_ops(ctrl)
             self._interpreter.emit_statement(cast_decl)
             compute_op.append(bind_op)
-            control_op = self._create_canonical_control_op(control, str(cast_decl.name))
+            control_ops = self._create_canonical_control_op(
+                control, str(cast_decl.name)
+            )
         else:
-            control_op = self._create_canonical_control_op(control, str(ctrl.handle))
+            control_ops = self._create_canonical_control_op(control, str(ctrl.handle))
+
+        return WithinApply(compute=compute_op, action=control_ops)
 
+    def _emit_with_x_gates(
+        self, control: Control, ctrl: QmodSizedProxy, ctrl_state: str
+    ) -> None:
         self._interpreter.emit_statement(
-            WithinApply(compute=compute_op, action=[control_op])
+            self._control_with_x_gates(control, ctrl, ctrl_state)
         )
 
     @staticmethod
@@ -217,20 +289,33 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         self._interpreter.emit_statement(
             WithinApply(
                 compute=[arith_expression],
-                action=[self._create_canonical_control_op(control, aux_var)],
+                action=self._create_canonical_control_op(control, aux_var),
             )
         )
 
-    @staticmethod
-    def _validate_condition(condition_val: ExpressionValue) -> None:
-        if not isinstance(condition_val, Boolean):
-            raise ClassiqExpansionError(_condition_err_msg(condition_val))
+    def _validate_condition(self, control: Control) -> None:
+        condition_value = control.expression.value.value
+        if not (
+            isinstance(condition_value, Boolean)
+            or self._all_vars_boolean(control)
+            and self._is_res_boolean(control)
+        ):
+            raise ClassiqExpansionError(_condition_err_msg(condition_value))
 
     @staticmethod
     def _validate_canonical_condition(condition_val: ExpressionValue) -> None:
         if isinstance(condition_val, QmodQNumProxy):
             raise ClassiqExpansionError(_condition_err_msg(condition_val))
 
+    def _get_updated_op_split_symbols(
+        self, op: Control, symbol_mapping: dict[HandleBinding, tuple[str, QuantumType]]
+    ) -> Control:
+        new_body = self._rewrite(op.body, symbol_mapping)
+        new_else = None
+        if op.else_block is not None:
+            new_else = self._rewrite(op.else_block, symbol_mapping)
+        return op.model_copy(update=dict(body=new_body, else_block=new_else))
+
 
 def _condition_err_msg(condition_val: ExpressionValue) -> str:
     return (

classiq/model_expansions/quantum_operations/emitter.py

@@ -70,7 +70,12 @@ class Emitter(Generic[QuantumStatementT]):
 
         self._scope_guard = self._interpreter._scope_guard
         self._machine_precision = self._interpreter._model.preferences.machine_precision
-
+        self._expanded_functions_compilation_metadata = (
+            self._interpreter._expanded_functions_compilation_metadata
+        )
+        self._functions_compilation_metadata = (
+            self._interpreter._model.functions_compilation_metadata
+        )
         self._generative_contexts: dict[str, OperationContext] = {}
 
     @abstractmethod
@@ -100,7 +105,11 @@ class Emitter(Generic[QuantumStatementT]):
         return self._interpreter._current_scope
 
     @property
-    def _expanded_functions(self) -> list[NativeFunctionDefinition]:
+    def _top_level_scope(self) -> Scope:
+        return self._interpreter._top_level_scope
+
+    @property
+    def _expanded_functions(self) -> dict[str, NativeFunctionDefinition]:
         return self._interpreter._expanded_functions
 
     @property
@@ -137,23 +146,38 @@ class Emitter(Generic[QuantumStatementT]):
         )
         new_positional_arg_decls = new_declaration.positional_arg_declarations
         is_atomic = function.is_atomic
-        if not is_atomic:  # perform monomorphization
+        new_function_name = function.name
+        if not is_atomic:  # perform monomorphization per interpreted parameters set
             self._add_params_to_scope(
                 new_positional_arg_decls, evaluated_args, function
             )
             context = self._expand_operation(
                 function.with_new_declaration(new_declaration)
             )
-            self._expanded_functions.append(
-                self._builder.create_definition(cast(FunctionContext, context))
+            function_context = cast(FunctionContext, context)
+            closure_id = function_context.closure.closure_id
+            function_def = self._expanded_functions.get(closure_id)
+            if function_def is None:
+                function_def = self._builder.create_definition(function_context)
+                self._expanded_functions[closure_id] = function_def
+                self._top_level_scope[function_def.name] = Evaluated(
+                    value=function_context.closure.with_new_declaration(function_def)
+                )
+            new_declaration = function_def
+            new_function_name = function_def.name
+            compilation_metadata = self._functions_compilation_metadata.get(
+                function.name
             )
+            if compilation_metadata is not None:
+                self._expanded_functions_compilation_metadata[new_function_name] = (
+                    compilation_metadata
+                )
+
         new_positional_args = self._get_new_positional_args(
             evaluated_args, is_atomic, new_positional_arg_decls
         )
         new_call = QuantumFunctionCall(
-            function=(
-                new_declaration.name if is_atomic else self._expanded_functions[-1].name
-            ),
+            function=new_function_name,
             positional_args=new_positional_args,
         )
         is_allocate_or_free = (
@@ -178,8 +202,7 @@ class Emitter(Generic[QuantumStatementT]):
             is_allocate_or_free=is_allocate_or_free,
             port_to_passed_variable_map=port_to_passed_variable_map,
         )
-        if is_atomic:
-            new_call.set_func_decl(new_declaration)
+        new_call.set_func_decl(new_declaration)
         return new_call
 
     @staticmethod
@@ -220,7 +243,9 @@ class Emitter(Generic[QuantumStatementT]):
             arg.emit() for arg in evaluated_args if isinstance(arg.value, QuantumSymbol)
         ]
 
-        propagated_variables = self._propagated_var_stack.get_propagated_variables()
+        propagated_variables = self._propagated_var_stack.get_propagated_variables(
+            flatten=True
+        )
         validate_args_are_not_propagated(positional_args, propagated_variables)
         positional_args.extend(propagated_variables)
 
@@ -279,6 +304,7 @@ class Emitter(Generic[QuantumStatementT]):
         )
         context = self._interpreter._expand_operation(gen_closure)
         self._generative_contexts[context_name] = context
+        op.clear_generative_blocks()
         return context
 
     def _evaluate_expression(self, expression: Expression) -> Expression: