classiq 0.56.1__py3-none-any.whl → 0.58.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -0,0 +1,207 @@
+from collections.abc import Sequence
+from typing import (
+    Generic,
+    cast,
+)
+
+from classiq.interface.debug_info.debug_info import FunctionDebugInfo
+from classiq.interface.generator.generated_circuit_data import OperationLevel
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_call import ArgValue, QuantumFunctionCall
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+    PositionalArg,
+)
+from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+
+from classiq.model_expansions.capturing.propagated_var_stack import (
+    validate_args_are_not_propagated,
+)
+from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.evaluators.argument_types import (
+    add_information_from_output_arguments,
+)
+from classiq.model_expansions.evaluators.parameter_types import (
+    evaluate_parameter_types_from_args,
+)
+from classiq.model_expansions.function_builder import (
+    FunctionContext,
+)
+from classiq.model_expansions.generative_functions import emit_operands_as_declarative
+from classiq.model_expansions.quantum_operations.emitter import (
+    Emitter,
+    QuantumStatementT,
+)
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.qmod.builtins.functions import allocate, free
+
+
+class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT]):
+    @staticmethod
+    def _should_wrap(body: Sequence[QuantumStatement]) -> bool:
+        # This protects shadowing of captured variables (i.e, bad user code) by wrapping the body in a function
+        # I'm sure there are better ways to handle it, but this is the simplest way to do it for now
+        return any(isinstance(stmt, VariableDeclarationStatement) for stmt in body)
+
+    def _create_expanded_wrapping_function(
+        self, name: str, body: Sequence[QuantumStatement]
+    ) -> QuantumFunctionCall:
+        wrapping_function = FunctionClosure.create(
+            name=name, body=body, scope=Scope(parent=self._current_scope)
+        )
+        return self._create_quantum_function_call(wrapping_function, list())
+
+    def _emit_quantum_function_call(
+        self, function: FunctionClosure, args: list[ArgValue]
+    ) -> QuantumFunctionCall:
+        call = self._create_quantum_function_call(function, args)
+        self._builder.emit_statement(call)
+        return call
+
+    def _create_quantum_function_call(
+        self, function: FunctionClosure, args: list[ArgValue]
+    ) -> QuantumFunctionCall:
+        evaluated_args = [self._interpreter.evaluate(arg) for arg in args]
+        new_declaration = self._prepare_fully_typed_declaration(
+            function, evaluated_args
+        )
+        new_positional_arg_decls = new_declaration.positional_arg_declarations
+        is_atomic = function.is_atomic
+        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)
+            )
+            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_function_name,
+            positional_args=new_positional_args,
+        )
+        is_allocate_or_free = (
+            new_call.func_name == allocate.func_decl.name
+            or new_call.func_name == free.func_decl.name
+        )
+        parameters = {
+            arg_decl.name: FunctionDebugInfo.param_controller(value=evaluated_arg.value)
+            for arg_decl, evaluated_arg in zip(new_positional_arg_decls, evaluated_args)
+            if isinstance(arg_decl, ClassicalParameterDeclaration)
+        }
+
+        port_to_passed_variable_map = {
+            arg_decl.name: str(evaluated_arg.value.handle)
+            for arg_decl, evaluated_arg in zip(new_positional_arg_decls, evaluated_args)
+            if isinstance(arg_decl, PortDeclaration)
+        }
+        self._interpreter._model.debug_info[new_call.uuid] = FunctionDebugInfo(
+            name=new_call.func_name,
+            level=OperationLevel.QMOD_FUNCTION_CALL,
+            parameters=parameters,
+            is_allocate_or_free=is_allocate_or_free,
+            port_to_passed_variable_map=port_to_passed_variable_map,
+        )
+        new_call.set_func_decl(new_declaration)
+        return new_call
+
+    @staticmethod
+    def _add_params_to_scope(
+        parameters: Sequence[PositionalArg],
+        arguments: Sequence[Evaluated],
+        closure: FunctionClosure,
+    ) -> None:
+        for parameter, argument in zip(parameters, arguments):
+            if isinstance(argument.value, QuantumSymbol):
+                assert isinstance(parameter, PortDeclaration)
+                closure.scope[parameter.name] = Evaluated(
+                    QuantumSymbol(
+                        handle=HandleBinding(name=parameter.name),
+                        quantum_type=parameter.quantum_type,
+                    ),
+                    defining_function=closure,
+                )
+            else:
+                closure.scope[parameter.name] = argument
+
+    def _get_new_positional_args(
+        self,
+        evaluated_args: list[Evaluated],
+        is_atomic: bool,
+        new_positional_arg_decls: Sequence[PositionalArg],
+    ) -> list[ArgValue]:
+        evaluated_args = add_information_from_output_arguments(
+            new_positional_arg_decls, evaluated_args
+        )
+        if is_atomic:
+            return [
+                emit_operands_as_declarative(self._interpreter, param, arg)
+                for param, arg in zip(new_positional_arg_decls, evaluated_args)
+            ]
+
+        positional_args = [
+            arg.emit() for arg in evaluated_args if isinstance(arg.value, QuantumSymbol)
+        ]
+
+        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)
+
+        return positional_args
+
+    def _prepare_fully_typed_declaration(
+        self, function: FunctionClosure, evaluated_args: list[Evaluated]
+    ) -> NamedParamsQuantumFunctionDeclaration:
+        """
+        Given, for example,
+        def my_func(x: int, q: QArray["x"], p: QArray[]) -> None:
+        ...
+        def main(...):
+            ...
+            allocate(5, s)
+            my_func(3, r, s)
+        The code below will evaluate x to be 3, q to be of size 3 and p to be of size 5.
+        Note that it requires a scope for the parameter declaration space, which is
+        different from the call scope. For example, the former uses r,s and the latter
+        uses p, q.
+        """
+        with self._scope_guard(Scope(parent=self._current_scope)):
+            # The signature scope is passed as a separate argument to avoid contaminating the statement execution scope
+            return NamedParamsQuantumFunctionDeclaration(
+                name=function.name,
+                positional_arg_declarations=evaluate_parameter_types_from_args(
+                    function,
+                    function.signature_scope,
+                    evaluated_args,
+                ),
+            )

classiq/model_expansions/quantum_operations/classicalif.py

@@ -5,7 +5,7 @@ from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_statement import QuantumStatement
 
 from classiq.model_expansions.closure import FunctionClosure
-from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
 from classiq.model_expansions.scope import Scope
 
 
@@ -16,7 +16,7 @@ def _is_all_identity_calls(body: Sequence[QuantumStatement]) -> bool:
     )
 
 
-class ClassicalIfEmitter(Emitter[ClassicalIf]):
+class ClassicalIfEmitter(CallEmitter[ClassicalIf]):
     def emit(self, classical_if: ClassicalIf, /) -> None:
         with self._propagated_var_stack.capture_variables(classical_if):
             self._emit_propagated(classical_if)

classiq/model_expansions/quantum_operations/control.py

@@ -26,7 +26,6 @@ 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 (
@@ -47,6 +46,7 @@ from classiq.model_expansions.quantum_operations.expression_operation import (
     ExpressionOperationEmitter,
 )
 from classiq.model_expansions.scope import Scope
+from classiq.model_expansions.transformers.var_splitter import SymbolParts
 from classiq.qmod.builtins.functions.standard_gates import X
 
 
@@ -54,7 +54,9 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
     def emit(self, control: Control, /) -> None:
         condition = self._evaluate_op_expression(control)
 
-        arrays_with_subscript = self._get_symbols_to_split(condition)
+        arrays_with_subscript = self.split_symbols(
+            condition, self._counted_name_allocator.allocate
+        )
         if len(arrays_with_subscript) > 0:
             if control.is_generative():
                 with self._propagated_var_stack.capture_variables(control):
@@ -308,12 +310,12 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
             raise ClassiqExpansionError(_condition_err_msg(condition_val))
 
     def _get_updated_op_split_symbols(
-        self, op: Control, symbol_mapping: dict[HandleBinding, tuple[str, QuantumType]]
+        self, op: Control, symbol_parts: SymbolParts
     ) -> Control:
-        new_body = self._rewrite(op.body, symbol_mapping)
+        new_body = self.rewrite(op.body, symbol_parts)
         new_else = None
         if op.else_block is not None:
-            new_else = self._rewrite(op.else_block, symbol_mapping)
+            new_else = self.rewrite(op.else_block, symbol_parts)
         return op.model_copy(update=dict(body=new_body, else_block=new_else))
 
 

classiq/model_expansions/quantum_operations/emitter.py

@@ -1,61 +1,38 @@
 from abc import abstractmethod
-from collections.abc import Sequence
 from typing import (
     TYPE_CHECKING,
     Generic,
     Optional,
     TypeVar,
     Union,
-    cast,
 )
 
 import sympy
 
-from classiq.interface.debug_info.debug_info import FunctionDebugInfo
 from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.generated_circuit_data import OperationLevel
-from classiq.interface.model.classical_parameter_declaration import (
-    ClassicalParameterDeclaration,
-)
-from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
-from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_function_call import ArgValue, QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
-    PositionalArg,
 )
 from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
-from classiq.interface.model.variable_declaration_statement import (
-    VariableDeclarationStatement,
-)
 
 from classiq.model_expansions.capturing.propagated_var_stack import (
     PropagatedVarStack,
-    validate_args_are_not_propagated,
 )
 from classiq.model_expansions.closure import Closure, FunctionClosure, GenerativeClosure
-from classiq.model_expansions.evaluators.argument_types import (
-    add_information_from_output_arguments,
-)
-from classiq.model_expansions.evaluators.parameter_types import (
-    evaluate_parameter_types_from_args,
-)
 from classiq.model_expansions.function_builder import (
     FunctionContext,
     OperationBuilder,
     OperationContext,
 )
-from classiq.model_expansions.generative_functions import emit_operands_as_declarative
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.model_expansions.scope import Scope
 from classiq.model_expansions.sympy_conversion.sympy_to_python import (
     translate_sympy_quantum_expression,
 )
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
-from classiq.qmod.builtins.functions import allocate, free
 from classiq.qmod.quantum_function import GenerativeQFunc
 
 if TYPE_CHECKING:
@@ -116,168 +93,6 @@ class Emitter(Generic[QuantumStatementT]):
     def _counted_name_allocator(self) -> CountedNameAllocator:
         return self._interpreter._counted_name_allocator
 
-    @staticmethod
-    def _should_wrap(body: Sequence[QuantumStatement]) -> bool:
-        # This protects shadowing of captured variables (i.e, bad user code) by wrapping the body in a function
-        # I'm sure there are better ways to handle it, but this is the simplest way to do it for now
-        return any(isinstance(stmt, VariableDeclarationStatement) for stmt in body)
-
-    def _create_expanded_wrapping_function(
-        self, name: str, body: Sequence[QuantumStatement]
-    ) -> QuantumFunctionCall:
-        wrapping_function = FunctionClosure.create(
-            name=name, body=body, scope=Scope(parent=self._current_scope)
-        )
-        return self._create_quantum_function_call(wrapping_function, list())
-
-    def _emit_quantum_function_call(
-        self, function: FunctionClosure, args: list[ArgValue]
-    ) -> QuantumFunctionCall:
-        call = self._create_quantum_function_call(function, args)
-        self._builder.emit_statement(call)
-        return call
-
-    def _create_quantum_function_call(
-        self, function: FunctionClosure, args: list[ArgValue]
-    ) -> QuantumFunctionCall:
-        evaluated_args = [self._interpreter.evaluate(arg) for arg in args]
-        new_declaration = self._prepare_fully_typed_declaration(
-            function, evaluated_args
-        )
-        new_positional_arg_decls = new_declaration.positional_arg_declarations
-        is_atomic = function.is_atomic
-        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)
-            )
-            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_function_name,
-            positional_args=new_positional_args,
-        )
-        is_allocate_or_free = (
-            new_call.func_name == allocate.func_decl.name
-            or new_call.func_name == free.func_decl.name
-        )
-        parameters = {
-            arg_decl.name: FunctionDebugInfo.param_controller(value=evaluated_arg.value)
-            for arg_decl, evaluated_arg in zip(new_positional_arg_decls, evaluated_args)
-            if isinstance(arg_decl, ClassicalParameterDeclaration)
-        }
-
-        port_to_passed_variable_map = {
-            arg_decl.name: str(evaluated_arg.value.handle)
-            for arg_decl, evaluated_arg in zip(new_positional_arg_decls, evaluated_args)
-            if isinstance(arg_decl, PortDeclaration)
-        }
-        self._interpreter._model.debug_info[new_call.uuid] = FunctionDebugInfo(
-            name=new_call.func_name,
-            level=OperationLevel.QMOD_FUNCTION_CALL,
-            parameters=parameters,
-            is_allocate_or_free=is_allocate_or_free,
-            port_to_passed_variable_map=port_to_passed_variable_map,
-        )
-        new_call.set_func_decl(new_declaration)
-        return new_call
-
-    @staticmethod
-    def _add_params_to_scope(
-        parameters: Sequence[PositionalArg],
-        arguments: Sequence[Evaluated],
-        closure: FunctionClosure,
-    ) -> None:
-        for parameter, argument in zip(parameters, arguments):
-            if isinstance(argument.value, QuantumSymbol):
-                assert isinstance(parameter, PortDeclaration)
-                closure.scope[parameter.name] = Evaluated(
-                    QuantumSymbol(
-                        handle=HandleBinding(name=parameter.name),
-                        quantum_type=parameter.quantum_type,
-                    ),
-                    defining_function=closure,
-                )
-            else:
-                closure.scope[parameter.name] = argument
-
-    def _get_new_positional_args(
-        self,
-        evaluated_args: list[Evaluated],
-        is_atomic: bool,
-        new_positional_arg_decls: Sequence[PositionalArg],
-    ) -> list[ArgValue]:
-        evaluated_args = add_information_from_output_arguments(
-            new_positional_arg_decls, evaluated_args
-        )
-        if is_atomic:
-            return [
-                emit_operands_as_declarative(self._interpreter, param, arg)
-                for param, arg in zip(new_positional_arg_decls, evaluated_args)
-            ]
-
-        positional_args = [
-            arg.emit() for arg in evaluated_args if isinstance(arg.value, QuantumSymbol)
-        ]
-
-        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)
-
-        return positional_args
-
-    def _prepare_fully_typed_declaration(
-        self, function: FunctionClosure, evaluated_args: list[Evaluated]
-    ) -> NamedParamsQuantumFunctionDeclaration:
-        """
-        Given, for example,
-        def my_func(x: int, q: QArray["x"], p: QArray[]) -> None:
-        ...
-        def main(...):
-            ...
-            allocate(5, s)
-            my_func(3, r, s)
-        The code below will evaluate x to be 3, q to be of size 3 and p to be of size 5.
-        Note that it requires a scope for the parameter declaration space, which is
-        different from the call scope. For example, the former uses r,s and the latter
-        uses p, q.
-        """
-        with self._scope_guard(Scope(parent=self._current_scope)):
-            # The signature scope is passed as a separate argument to avoid contaminating the statement execution scope
-            return NamedParamsQuantumFunctionDeclaration(
-                name=function.name,
-                positional_arg_declarations=evaluate_parameter_types_from_args(
-                    function,
-                    function.signature_scope,
-                    evaluated_args,
-                ),
-            )
-
     def _register_generative_context(
         self,
         op: QuantumOperation,