classiq 0.61.0__py3-none-any.whl → 0.63.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -8,6 +8,9 @@ from typing import (
 )
 
 from classiq.interface.debug_info.debug_info import FunctionDebugInfo
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
 from classiq.interface.generator.generated_circuit_data import OperationLevel
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
@@ -20,6 +23,10 @@ from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
 )
+from classiq.interface.model.quantum_lambda_function import (
+    OperandIdentifier,
+    QuantumLambdaFunction,
+)
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
@@ -28,7 +35,7 @@ from classiq.interface.model.variable_declaration_statement import (
 from classiq.model_expansions.capturing.captured_vars import (
     validate_args_are_not_propagated,
 )
-from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.closure import FunctionClosure, GenerativeClosure
 from classiq.model_expansions.evaluators.argument_types import (
     add_information_from_output_arguments,
 )
@@ -45,6 +52,7 @@ from classiq.model_expansions.quantum_operations.emitter import (
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.model_expansions.transformers.var_splitter import VarSplitter
 from classiq.qmod.builtins.functions import allocate, free
+from classiq.qmod.model_state_container import QMODULE
 
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreter import Interpreter
@@ -53,7 +61,7 @@ if TYPE_CHECKING:
 class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSplitter):
     def __init__(self, interpreter: "Interpreter") -> None:
         Emitter.__init__(self, interpreter)
-        VarSplitter.__init__(self, interpreter._current_scope)
+        VarSplitter.__init__(self, interpreter._builder.current_scope)
 
     @staticmethod
     def _should_wrap(body: Sequence[QuantumStatement]) -> bool:
@@ -65,7 +73,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         self, name: str, body: Sequence[QuantumStatement]
     ) -> QuantumFunctionCall:
         wrapping_function = FunctionClosure.create(
-            name=name,
+            name=self._counted_name_allocator.allocate(name),
             body=body,
             scope=Scope(parent=self._current_scope),
             is_lambda=True,
@@ -90,14 +98,21 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         args: list[ArgValue],
         propagated_debug_info: Optional[FunctionDebugInfo] = None,
     ) -> QuantumFunctionCall:
+        function = function.clone()
         function = function.set_depth(self._builder.current_function.depth + 1)
-        function = function.copy_scope()
         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
+        if (
+            self._interpreter._is_shallow
+            and self._is_function_purely_declarative(function)
+            and self._are_args_purely_declarative(args)
+        ):
+            is_atomic = True
+            self._interpreter.add_purely_declarative_function(function)
         new_function_name = function.name
         if not is_atomic:  # perform monomorphization per interpreted parameters set
             self._add_params_to_scope(
@@ -115,15 +130,20 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
                 self._top_level_scope[function_def.name] = Evaluated(
                     value=function_context.closure.with_new_declaration(function_def)
                 )
+                compilation_metadata = self._functions_compilation_metadata.get(
+                    function.name
+                )
+                if compilation_metadata is not None:
+                    self._expanded_functions_compilation_metadata[function_def.name] = (
+                        compilation_metadata
+                    )
+            else:
+                self._expanded_functions_compilation_metadata[
+                    function_def.name
+                ].occurrences_number += 1
+
             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
@@ -239,13 +259,56 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         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,
-                ),
+        # 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 _is_function_purely_declarative(self, function: FunctionClosure) -> bool:
+        if function.name not in QMODULE.native_defs:
+            return False
+
+        if isinstance(function, GenerativeClosure):
+            return False
+
+        if any(
+            not param.quantum_type.is_instantiated
+            for param in function.positional_arg_declarations
+            if isinstance(param, PortDeclaration)
+            and param.direction == PortDeclarationDirection.Output
+        ):
+            return False
+
+        dependencies = QMODULE.function_dependencies[function.name]
+        return self._are_identifiers_purely_declarative(dependencies)
+
+    def _are_args_purely_declarative(self, args: list[ArgValue]) -> bool:
+        if any(
+            isinstance(arg, (OperandIdentifier, QuantumLambdaFunction))
+            or (
+                isinstance(arg, list)
+                and any(
+                    isinstance(item, (OperandIdentifier, QuantumLambdaFunction))
+                    for item in arg
+                )
             )
+            for arg in args
+        ):
+            return False
+
+        dependencies = [arg for arg in args if isinstance(arg, str)]
+        dependencies += [
+            cast(str, item) for arg in args if isinstance(arg, list) for item in arg
+        ]
+        return self._are_identifiers_purely_declarative(dependencies)
+
+    def _are_identifiers_purely_declarative(self, dependencies: list[str]) -> bool:
+        return not any(
+            isinstance(self._current_scope[dep].value, GenerativeClosure)
+            for dep in dependencies
+        )

classiq/model_expansions/quantum_operations/classicalif.py

@@ -45,7 +45,7 @@ class ClassicalIfEmitter(CallEmitter[ClassicalIf]):
             return
 
         then_else_func = FunctionClosure.create(
-            name=op_name,
+            name=self._counted_name_allocator.allocate("then" if condition else "else"),
             body=body,
             scope=Scope(parent=self._current_scope),
             is_lambda=True,

classiq/model_expansions/quantum_operations/control.py

@@ -1,5 +1,3 @@
-from typing import cast
-
 from sympy import Equality
 from sympy.logic.boolalg import Boolean
 from typing_extensions import TypeGuard
@@ -55,6 +53,9 @@ from classiq.qmod.builtins.functions.standard_gates import X
 
 class ControlEmitter(ExpressionOperationEmitter[Control]):
     def emit(self, control: Control, /) -> None:
+        validate_args_are_not_propagated(
+            extract_handles(control.expression), extract_handles(control.body)
+        )
         condition = control.expression
         arrays_with_subscript = self.split_symbols(
             condition, self._counted_name_allocator.allocate
@@ -117,10 +118,6 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
             scope=Scope(parent=self._current_scope),
         )
         context = self._expand_operation(control_operation)
-        validate_args_are_not_propagated(
-            control.var_handles,
-            extract_handles([block.statements for block in context.blocks.values()]),
-        )
         self._update_control_state(control)
         self.emit_statement(
             control.model_copy(update=dict(body=context.statements("body")))
@@ -130,10 +127,6 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         wrapping_function = self._create_expanded_wrapping_function(
             CONTROL_OPERATOR_NAME, control.body
         )
-        validate_args_are_not_propagated(
-            control.var_handles,
-            cast(list[HandleBinding], wrapping_function.positional_args),
-        )
         self._update_control_state(control)
         self.emit_statement(control.model_copy(update=dict(body=[wrapping_function])))
 

classiq/model_expansions/quantum_operations/emitter.py

@@ -49,13 +49,12 @@ class Emitter(Generic[QuantumStatementT]):
     def __init__(self, interpreter: "Interpreter") -> None:
         self._interpreter = interpreter
 
-        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._interpreter._functions_compilation_metadata
         )
 
     @abstractmethod
@@ -71,7 +70,7 @@ class Emitter(Generic[QuantumStatementT]):
 
     @property
     def _current_scope(self) -> Scope:
-        return self._interpreter._current_scope
+        return self._builder.current_scope
 
     @property
     def _top_level_scope(self) -> Scope:
@@ -104,7 +103,7 @@ class Emitter(Generic[QuantumStatementT]):
         )
         gen_closure = GenerativeClosure(
             name=func_decl.name,
-            scope=Scope(parent=self._interpreter._current_scope),
+            scope=Scope(parent=self._interpreter._builder.current_scope),
             blocks={},
             generative_blocks={
                 block_name: GenerativeQFunc(

classiq/model_expansions/quantum_operations/quantum_assignment_operation.py

@@ -123,8 +123,7 @@ class QuantumAssignmentOperationEmitter(
         self, op: ArithmeticOperation
     ) -> tuple[ArithmeticOperation, Expression, bool]:
         if (
-            self._interpreter._is_frontend
-            or op.operation_kind
+            op.operation_kind
             not in (
                 ArithmeticOperationKind.Assignment,
                 ArithmeticOperationKind.InplaceXor,

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -18,7 +18,7 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
     def emit(self, call: QuantumFunctionCall, /) -> None:
         function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
         args = call.positional_args
-        with ErrorManager().call(function.name), function.freeze():
+        with ErrorManager().call(function.name):
             self._emit_quantum_function_call(
                 function, args, self._debug_info.get(call.uuid)
             )

classiq/model_expansions/quantum_operations/repeat.py

@@ -22,10 +22,11 @@ class RepeatEmitter(CallEmitter[Repeat]):
             raise ClassiqExpansionError(
                 f"repeat count must be non-negative, got {count}"
             )
+        op_name = self._counted_name_allocator.allocate(REPEAT_OPERATOR_NAME)
         for i in range(count):
-            self._emit_iteration(repeat, i)
+            self._emit_iteration(repeat, i, op_name)
 
-    def _emit_iteration(self, repeat: Repeat, i: int) -> None:
+    def _emit_iteration(self, repeat: Repeat, i: int, op_name: str) -> None:
         closure_constructor: type[FunctionClosure]
         extra_args: dict
         if repeat.is_generative():
@@ -41,7 +42,7 @@ class RepeatEmitter(CallEmitter[Repeat]):
             closure_constructor = FunctionClosure
             extra_args = {}
         iteration_function = closure_constructor.create(
-            name=REPEAT_OPERATOR_NAME,
+            name=op_name,
             positional_arg_declarations=[
                 ClassicalParameterDeclaration(
                     name=repeat.iter_var, classical_type=Integer()

classiq/model_expansions/quantum_operations/shallow_emitter.py

@@ -11,6 +11,9 @@ from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
     ArithmeticOperationKind,
 )
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumAssignmentOperation,
+)
 from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
 
 from classiq.model_expansions.closure import Closure
@@ -68,12 +71,15 @@ class ShallowEmitter(Emitter[QuantumOperation]):
             ).value.handle
 
         op = op.model_copy(update=expanded_components)
-        if isinstance(op, ArithmeticOperation):
+        if isinstance(op, QuantumAssignmentOperation):
             self._post_process_assignment(op)
         self._builder.emit_statement(op)
 
-    def _post_process_assignment(self, op: ArithmeticOperation) -> None:
-        if op.operation_kind == ArithmeticOperationKind.Assignment:
+    def _post_process_assignment(self, op: QuantumAssignmentOperation) -> None:
+        if (
+            isinstance(op, ArithmeticOperation)
+            and op.operation_kind == ArithmeticOperationKind.Assignment
+        ):
             direction = PortDeclarationDirection.Output
             self._update_result_type(op)
         else:

classiq/model_expansions/scope.py

@@ -2,7 +2,6 @@ import itertools
 import re
 from collections import UserDict
 from collections.abc import Iterator
-from contextlib import contextmanager
 from dataclasses import dataclass
 from functools import singledispatch
 from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
@@ -164,8 +163,14 @@ class Evaluated:  # FIXME: Merge with EvaluatedExpression if possible
         return int(self.value)
 
     def emit(self) -> ArgValue:
-        if isinstance(self.value, QuantumSymbol):
+        from classiq.model_expansions.closure import FunctionClosure
+
+        if isinstance(self.value, (QuantumSymbol, FunctionClosure)):
             return self.value.emit()
+        if isinstance(self.value, list) and all(
+            isinstance(item, FunctionClosure) for item in self.value
+        ):
+            return [item.emit() for item in self.value]
 
         ret = Expression(expr=evaluated_to_str(self.value))
         ret._evaluated_expr = EvaluatedExpression(value=self.value)
@@ -231,14 +236,5 @@ class Scope(EvaluatedUserDict):
             parent=parent,
         )
 
-    def _copy(self) -> "Scope":
-        return Scope(
-            self.data, parent=None if self._parent is None else self._parent.copy()
-        )
-
-    @contextmanager
-    def freeze(self) -> Iterator[None]:
-        previous = self._copy()
-        yield
-        self.data = previous.data
-        self._parent = previous._parent
+    def clone(self) -> "Scope":
+        return Scope(self.data, parent=self._parent)

classiq/model_expansions/scope_initialization.py

@@ -1,4 +1,5 @@
 from collections.abc import Sequence
+from typing import TYPE_CHECKING
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.constant import Constant
@@ -12,7 +13,11 @@ from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_function_declaration import PositionalArg
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+    PositionalArg,
+    QuantumFunctionDeclaration,
+)
 
 from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
 from classiq.model_expansions.evaluators.classical_expression import (
@@ -32,12 +37,14 @@ from classiq.qmod.quantum_function import GenerativeQFunc
 
 
 def get_main_renamer(
-    functions: Sequence[NativeFunctionDefinition],
+    func_decls: Sequence[QuantumFunctionDeclaration],
 ) -> ExpressionRenamer:
-    for func in functions:
-        if func.name == MAIN_FUNCTION_NAME:
+    for func_decl in func_decls:
+        if func_decl.name == MAIN_FUNCTION_NAME:
+            if TYPE_CHECKING:
+                assert isinstance(func_decl, NamedParamsQuantumFunctionDeclaration)
             return ExpressionRenamer.from_positional_arg_declarations(
-                func.positional_arg_declarations, CPARAM_EXECUTION_SUFFIX
+                func_decl.positional_arg_declarations, CPARAM_EXECUTION_SUFFIX
             )
     return ExpressionRenamer(var_mapping={})
 
@@ -49,32 +56,34 @@ def add_constants_to_scope(constants: list[Constant], scope: Scope) -> None:
         )
 
 
-def _add_functions_to_scope(
-    functions: list[NativeFunctionDefinition], scope: Scope
+def add_functions_to_scope(
+    functions: Sequence[NativeFunctionDefinition], scope: Scope
 ) -> None:
     for function in functions:
-        scope[function.name] = Evaluated(
-            value=FunctionClosure.create(
-                name=function.name,
-                positional_arg_declarations=function.positional_arg_declarations,
-                body=function.body,
-                scope=Scope(parent=scope),
+        if function.name not in scope:
+            scope[function.name] = Evaluated(
+                value=FunctionClosure.create(
+                    name=function.name,
+                    positional_arg_declarations=function.positional_arg_declarations,
+                    body=function.body,
+                    scope=Scope(parent=scope),
+                )
             )
-        )
 
 
-def _add_generative_functions_to_scope(
-    functions: list[GenerativeQFunc], scope: Scope
+def add_generative_functions_to_scope(
+    functions: Sequence[GenerativeQFunc], scope: Scope
 ) -> None:
     for function in functions:
-        scope[function.func_decl.name] = Evaluated(
-            value=GenerativeFunctionClosure.create(
-                name=function.func_decl.name,
-                positional_arg_declarations=function.func_decl.positional_arg_declarations,
-                scope=Scope(parent=scope),
-                generative_blocks={"body": function},
+        if function.func_decl.name not in scope:
+            scope[function.func_decl.name] = Evaluated(
+                value=GenerativeFunctionClosure.create(
+                    name=function.func_decl.name,
+                    positional_arg_declarations=function.func_decl.positional_arg_declarations,
+                    scope=Scope(parent=scope),
+                    generative_blocks={"body": function},
+                )
             )
-        )
 
 
 def _init_builtins_scope(scope: Scope) -> None:
@@ -129,7 +138,7 @@ def add_entry_point_params_to_scope(
 def init_top_level_scope(
     model: Model, generative_functions: list[GenerativeQFunc], scope: Scope
 ) -> None:
-    _add_functions_to_scope(model.functions, scope)
-    _add_generative_functions_to_scope(generative_functions, scope)
+    add_generative_functions_to_scope(generative_functions, scope)
+    add_functions_to_scope(model.functions, scope)
     add_constants_to_scope(model.constants, scope)
     _init_builtins_scope(scope)

classiq/model_expansions/transformers/var_splitter.py

@@ -1,7 +1,7 @@
 import ast
 from dataclasses import dataclass
 from itertools import chain
-from typing import TYPE_CHECKING, Callable, TypeVar, cast
+from typing import TYPE_CHECKING, Callable, Optional, TypeVar, cast
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -14,6 +14,7 @@ from classiq.interface.model.handle_binding import (
     HandleBinding,
     NestedHandleBinding,
     SlicedHandleBinding,
+    SubscriptHandleBinding,
 )
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumExpressionOperation,
@@ -125,12 +126,7 @@ class VarSplitter:
             raise ClassiqExpansionError(
                 f"Could not determine the length of quantum array " f"{symbol.handle}."
             )
-        target_slices = {
-            target_part.start.to_int_value(): target_part.end.to_int_value()
-            for target_part in target_parts
-            if isinstance(target_part, SlicedHandleBinding)
-            and symbol.handle == target_part.base_handle
-        }
+        target_slices = self._get_target_slices(symbol, target_parts)
 
         symbol_parts: list[QuantumSymbol] = []
         idx = 0
@@ -151,6 +147,60 @@ class VarSplitter:
 
         return symbol_parts
 
+    def _get_target_slices(
+        self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
+    ) -> dict[int, int]:
+        if TYPE_CHECKING:
+            assert isinstance(symbol.quantum_type, QuantumBitvector)
+        target_items = {
+            idx
+            for idx in range(symbol.quantum_type.length_value)
+            for target_part in target_parts
+            if target_part
+            in SubscriptHandleBinding(
+                base_handle=symbol.handle, index=Expression(expr=str(idx))
+            )
+        }
+        target_slices = {
+            target_part.start.to_int_value(): target_part.end.to_int_value()
+            for target_part in target_parts
+            if isinstance(target_part, SlicedHandleBinding)
+            and symbol.handle == target_part.base_handle
+        }
+        self._add_unused_indices_as_slices(symbol, target_items, target_slices)
+        return target_slices
+
+    @staticmethod
+    def _add_unused_indices_as_slices(
+        symbol: QuantumSymbol, target_items: set[int], target_slices: dict[int, int]
+    ) -> None:
+        if TYPE_CHECKING:
+            assert isinstance(symbol.quantum_type, QuantumBitvector)
+        last_unused_idx: Optional[int] = None
+        array_length = symbol.quantum_type.length_value
+        idx = 0
+
+        while idx < array_length:
+            if (
+                idx in target_items or idx in target_slices
+            ) and last_unused_idx is not None:
+                target_slices[last_unused_idx] = idx
+                last_unused_idx = None
+
+            if idx in target_slices:
+                if target_slices[idx] <= idx:
+                    raise ClassiqInternalExpansionError
+                idx = target_slices[idx]
+                continue
+
+            if idx not in target_items and last_unused_idx is None:
+                last_unused_idx = idx
+
+            idx += 1
+
+        if last_unused_idx is not None:
+            target_slices[last_unused_idx] = array_length
+
     def _get_struct_parts(
         self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
     ) -> list[QuantumSymbol]:

classiq/open_library/__init__.py

@@ -0,0 +1,4 @@
+from .functions import *  # noqa: F403
+from .functions import __all__ as _functions_all
+
+__all__ = _functions_all