classiq 0.60.1__py3-none-any.whl → 0.62.0__py3-none-any.whl

classiq/model_expansions/interpreter.py

@@ -1,6 +1,6 @@
-import copy
-from collections.abc import Iterator, Sequence
-from contextlib import contextmanager, nullcontext
+from collections import defaultdict
+from collections.abc import Sequence
+from contextlib import nullcontext
 from functools import singledispatchmethod
 from typing import Any, Optional, cast
 
@@ -15,6 +15,11 @@ from classiq.interface.exceptions import (
 )
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.builtins.internal_operators import (
+    CONTROL_OPERATOR_NAME,
+    INVERT_OPERATOR_NAME,
+    WITHIN_APPLY_NAME,
+)
 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
@@ -35,14 +40,16 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumAssignmentOperation,
 )
 from classiq.interface.model.quantum_function_call import (
-    OperandIdentifier,
     QuantumFunctionCall,
 )
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
     QuantumFunctionDeclaration,
 )
-from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
+from classiq.interface.model.quantum_lambda_function import (
+    OperandIdentifier,
+    QuantumLambdaFunction,
+)
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.variable_declaration_statement import (
@@ -81,6 +88,7 @@ from classiq.model_expansions.quantum_operations import (
     WithinApplyEmitter,
 )
 from classiq.model_expansions.quantum_operations.phase import PhaseEmitter
+from classiq.model_expansions.quantum_operations.shallow_emitter import ShallowEmitter
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.model_expansions.scope_initialization import (
     add_constants_to_scope,
@@ -103,43 +111,30 @@ class Interpreter:
     ) -> None:
         self._is_frontend = is_frontend
         self._model = model
-        self._current_scope = Scope()
-        self._top_level_scope = self._current_scope
+        self._top_level_scope = Scope()
         self._builder = OperationBuilder(self._top_level_scope)
         self._expanded_functions: dict[str, NativeFunctionDefinition] = {}
 
-        self._main_renamer: ExpressionRenamer = get_main_renamer(self._model.functions)
+        self._main_renamer: Optional[ExpressionRenamer] = (
+            get_main_renamer(self._model.functions) if self._is_frontend else None
+        )
 
         if generative_functions is None:
             generative_functions = []
         self._generative_functions = generative_functions
-        init_top_level_scope(model, generative_functions, self._current_scope)
+        init_top_level_scope(model, generative_functions, self._top_level_scope)
         self._expanded_functions_compilation_metadata: dict[
             str, CompilationMetadata
-        ] = dict()
+        ] = defaultdict(CompilationMetadata)
         self._counted_name_allocator = CountedNameAllocator()
         self._error_manager: ErrorManager = ErrorManager()
 
-    @contextmanager
-    def _scope_guard(self, scope: Scope) -> Iterator[None]:
-        """This manager restores both `scope` and `self._current_scope` to their previous values."""
-        scope_data = copy.copy(scope.data)
-        prev_context_scope_data = copy.copy(self._current_scope.data)
-
-        prev_context_scope = self._current_scope
-        self._current_scope = scope
-        yield
-        prev_context_scope.data = prev_context_scope_data
-        self._current_scope = prev_context_scope
-
-        scope.data = scope_data
-
     def _expand_main_func(self) -> None:
         main_closure = FunctionClosure.create(
             name=self._model.main_func.name,
             positional_arg_declarations=self._model.main_func.positional_arg_declarations,
             body=self._model.main_func.body,
-            scope=Scope(parent=self._current_scope),
+            scope=Scope(parent=self._top_level_scope),
             expr_renamer=self._main_renamer,
             _depth=0,
         )
@@ -188,11 +183,11 @@ class Interpreter:
 
     @evaluate.register
     def evaluate_classical_expression(self, expression: Expression) -> Evaluated:
-        return evaluate_classical_expression(expression, self._current_scope)
+        return evaluate_classical_expression(expression, self._builder.current_scope)
 
     @evaluate.register
     def evaluate_identifier(self, identifier: str) -> Evaluated:
-        return self._current_scope[identifier]
+        return self._builder.current_scope[identifier]
 
     @evaluate.register
     def evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
@@ -223,7 +218,7 @@ class Interpreter:
                 name=func_decl.name,
                 positional_arg_declarations=func_decl.positional_arg_declarations,
                 body=function.body,
-                scope=Scope(parent=self._current_scope),
+                scope=Scope(parent=self._builder.current_scope),
                 is_lambda=True,
                 **extra_args,
             ),
@@ -280,11 +275,21 @@ class Interpreter:
 
     @emit.register
     def emit_quantum_assignment_operation(self, op: QuantumAssignmentOperation) -> None:
-        QuantumAssignmentOperationEmitter(self).emit(op)
+        if self._is_frontend:
+            ShallowEmitter(
+                self, "assignment_operation", components=["expression", "result_var"]
+            ).emit(op)
+        else:
+            QuantumAssignmentOperationEmitter(self).emit(op)
 
     @emit.register
-    def emit_inplace_binary_operation(self, operation: InplaceBinaryOperation) -> None:
-        InplaceBinaryOperationEmitter(self).emit(operation)
+    def emit_inplace_binary_operation(self, op: InplaceBinaryOperation) -> None:
+        if self._is_frontend:
+            ShallowEmitter(
+                self, "inplace_binary_operation", components=["target", "value"]
+            ).emit(op)
+        else:
+            InplaceBinaryOperationEmitter(self).emit(op)
 
     @emit.register
     def emit_variable_declaration(
@@ -298,11 +303,21 @@ class Interpreter:
 
     @emit.register
     def emit_within_apply(self, within_apply: WithinApply) -> None:
-        WithinApplyEmitter(self).emit(within_apply)
+        if self._is_frontend:
+            ShallowEmitter(
+                self,
+                WITHIN_APPLY_NAME,
+                components=["within", "apply", "compute", "action"],
+            ).emit(within_apply)
+        else:
+            WithinApplyEmitter(self).emit(within_apply)
 
     @emit.register
     def emit_invert(self, invert: Invert) -> None:
-        InvertEmitter(self).emit(invert)
+        if self._is_frontend:
+            ShallowEmitter(self, INVERT_OPERATOR_NAME, components=["body"]).emit(invert)
+        else:
+            InvertEmitter(self).emit(invert)
 
     @emit.register
     def emit_repeat(self, repeat: Repeat) -> None:
@@ -310,15 +325,32 @@ class Interpreter:
 
     @emit.register
     def emit_control(self, control: Control) -> None:
-        ControlEmitter(self).emit(control)
+        if self._is_frontend:
+            ShallowEmitter(
+                self,
+                CONTROL_OPERATOR_NAME,
+                components=["expression", "body", "else_block"],
+            ).emit(control)
+        else:
+            ControlEmitter(self).emit(control)
 
     @emit.register
     def emit_power(self, power: Power) -> None:
-        PowerEmitter(self).emit(power)
+        if self._is_frontend:
+            ShallowEmitter(
+                self, CONTROL_OPERATOR_NAME, components=["power", "body"]
+            ).emit(power)
+        else:
+            PowerEmitter(self).emit(power)
 
     @emit.register
     def emit_phase(self, phase: PhaseOperation) -> None:
-        PhaseEmitter(self).emit(phase)
+        if self._is_frontend:
+            ShallowEmitter(self, "phase", components=["expression", "theta"]).emit(
+                phase
+            )
+        else:
+            PhaseEmitter(self).emit(phase)
 
     def _expand_block(self, block: Sequence[QuantumStatement], block_name: str) -> None:
         with self._builder.block_context(block_name):
@@ -343,19 +375,16 @@ class Interpreter:
                 pass
             elif isinstance(operation, FunctionClosure) and operation.name == "permute":
                 # special expansion since permute is generative
-                with self._scope_guard(operation.scope):
-                    self._expand_permute()
+                self._expand_permute()
             elif isinstance(operation, GenerativeClosure):
-                with self._scope_guard(operation.scope):
-                    args = [
-                        self.evaluate(param.name)
-                        for param in operation.positional_arg_declarations
-                    ]
-                    emit_generative_statements(self, operation, args)
+                args = [
+                    self.evaluate(param.name)
+                    for param in operation.positional_arg_declarations
+                ]
+                emit_generative_statements(self, operation, args)
             else:
                 for block, block_body in operation.blocks.items():
-                    with self._scope_guard(operation.scope):
-                        self._expand_block(block_body, block)
+                    self._expand_block(block_body, block)
 
         return context
 

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -3,6 +3,7 @@ from itertools import chain
 from typing import (
     TYPE_CHECKING,
     Generic,
+    Optional,
     cast,
 )
 
@@ -37,7 +38,6 @@ from classiq.model_expansions.evaluators.parameter_types import (
 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,
@@ -53,7 +53,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:
@@ -73,17 +73,25 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         return self._create_quantum_function_call(wrapping_function, list())
 
     def _emit_quantum_function_call(
-        self, function: FunctionClosure, args: list[ArgValue]
+        self,
+        function: FunctionClosure,
+        args: list[ArgValue],
+        propagated_debug_info: Optional[FunctionDebugInfo] = None,
     ) -> QuantumFunctionCall:
-        call = self._create_quantum_function_call(function, args)
+        call = self._create_quantum_function_call(
+            function, args, propagated_debug_info=propagated_debug_info
+        )
         self.emit_statement(call)
         return call
 
     def _create_quantum_function_call(
-        self, function: FunctionClosure, args: list[ArgValue]
+        self,
+        function: FunctionClosure,
+        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
@@ -107,15 +115,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
@@ -144,10 +157,14 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             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(
+        self._debug_info[new_call.uuid] = FunctionDebugInfo(
             name=new_call.func_name,
             level=OperationLevel.QMOD_FUNCTION_CALL,
-            parameters=parameters,
+            parameters=(
+                parameters
+                if propagated_debug_info is None
+                else propagated_debug_info.parameters
+            ),
             is_allocate_or_free=is_allocate_or_free,
             port_to_passed_variable_map=port_to_passed_variable_map,
         )
@@ -203,10 +220,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             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)
-            ]
+            return [arg.emit() for arg in evaluated_args]
 
         positional_args = [
             arg.emit() for arg in evaluated_args if isinstance(arg.value, QuantumSymbol)
@@ -230,13 +244,12 @@ 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,
+            ),
+        )

classiq/model_expansions/quantum_operations/classicalif.py

@@ -26,7 +26,7 @@ class ClassicalIfEmitter(CallEmitter[ClassicalIf]):
         if is_generative:
             if not classical_if.has_generative_block(op_name):
                 return
-            context = self._register_generative_context(classical_if, op_name, op_name)
+            context = self._expand_generative_context(classical_if, op_name, op_name)
             context.blocks["body"] = context.blocks[op_name]
             context.blocks.pop(op_name)
             body = context.statements("body")

classiq/model_expansions/quantum_operations/control.py

@@ -55,19 +55,16 @@ 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)
-
+        condition = control.expression
         arrays_with_subscript = self.split_symbols(
             condition, self._counted_name_allocator.allocate
         )
         if len(arrays_with_subscript) > 0:
-            if control.is_generative():
-                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
+        control = self._evaluate_types_in_expression(control)
+        condition_val = control.expression.value.value
         if isinstance(condition_val, QmodSizedProxy):
             if control.else_block is None:
                 self._validate_canonical_condition(condition_val)
@@ -96,25 +93,9 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         )
         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
-        is_generative = control.is_generative()
-        if is_generative:
-            control = self._expand_generative_control(control)
-
-        if not is_generative and self._should_wrap_control(control):
+        if self._should_wrap_control(control):
             self._emit_wrapped(control)
             return
         self._emit_as_operation(control)
@@ -211,12 +192,6 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
             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 _control_with_x_gates(
@@ -296,8 +271,7 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         condition_value = control.expression.value.value
         if not (
             isinstance(condition_value, Boolean)
-            or self._all_vars_boolean(control)
-            and self._is_res_boolean(control)
+            or (self._all_vars_boolean(control) and self._is_res_boolean(control))
         ):
             raise ClassiqExpansionError(_condition_err_msg(condition_value))
 

classiq/model_expansions/quantum_operations/emitter.py

@@ -1,3 +1,4 @@
+import ast
 from abc import abstractmethod
 from typing import (
     TYPE_CHECKING,
@@ -9,6 +10,7 @@ from typing import (
 
 import sympy
 
+from classiq.interface.debug_info.debug_info import DebugInfoCollection
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
@@ -24,9 +26,8 @@ from classiq.interface.model.quantum_function_declaration import (
 )
 from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
 
-from classiq.model_expansions.closure import Closure, FunctionClosure, GenerativeClosure
+from classiq.model_expansions.closure import Closure, GenerativeClosure
 from classiq.model_expansions.function_builder import (
-    FunctionContext,
     OperationBuilder,
     OperationContext,
 )
@@ -35,6 +36,7 @@ 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.model_expansions.visitors.variable_references import VarRefCollector
 from classiq.qmod.quantum_function import GenerativeQFunc
 
 if TYPE_CHECKING:
@@ -47,7 +49,6 @@ 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
@@ -55,20 +56,12 @@ class Emitter(Generic[QuantumStatementT]):
         self._functions_compilation_metadata = (
             self._interpreter._model.functions_compilation_metadata
         )
-        self._generative_contexts: dict[str, OperationContext] = {}
 
     @abstractmethod
     def emit(self, statement: QuantumStatementT, /) -> None:
         pass
 
     def _expand_operation(self, closure: Closure) -> OperationContext:
-        if closure.name in self._generative_contexts:
-            if isinstance(closure, FunctionClosure):
-                return FunctionContext(
-                    closure=closure,
-                    blocks=self._generative_contexts[closure.name].blocks,
-                )
-            return self._generative_contexts[closure.name]
         return self._interpreter._expand_operation(closure)
 
     @property
@@ -77,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:
@@ -91,7 +84,11 @@ class Emitter(Generic[QuantumStatementT]):
     def _counted_name_allocator(self) -> CountedNameAllocator:
         return self._interpreter._counted_name_allocator
 
-    def _register_generative_context(
+    @property
+    def _debug_info(self) -> DebugInfoCollection:
+        return self._interpreter._model.debug_info
+
+    def _expand_generative_context(
         self,
         op: QuantumOperation,
         context_name: str,
@@ -106,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(
@@ -116,15 +113,19 @@ 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:
+    def _evaluate_expression(
+        self, expression: Expression, preserve_bool_ops: bool = False
+    ) -> Expression:
         evaluated_expression = self._interpreter.evaluate(expression)
         if isinstance(evaluated_expression.value, sympy.Basic):
             new_expression = Expression(
-                expr=translate_sympy_quantum_expression(evaluated_expression.value)
+                expr=translate_sympy_quantum_expression(
+                    evaluated_expression.value,
+                    preserve_bool_ops=preserve_bool_ops,
+                )
             )
         else:
             new_expression = Expression(expr=str(evaluated_expression.value))
@@ -162,3 +163,14 @@ class Emitter(Generic[QuantumStatementT]):
             defining_function=defining_function,
             direction=direction,
         )
+
+    def capture_handles_in_expression(self, expr: Expression) -> None:
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(expr.expr))
+        handles = dict.fromkeys(
+            handle
+            for handle in vrc.var_handles
+            if isinstance(self._current_scope[handle.name].value, QuantumSymbol)
+        )
+        for handle in handles:
+            self._capture_handle(handle, PortDeclarationDirection.Inout)

classiq/model_expansions/quantum_operations/expression_operation.py

@@ -60,13 +60,11 @@ class ExpressionOperationEmitter(
     ) -> ExpressionOperationT:
         return op
 
-    def _evaluate_op_expression(self, op: ExpressionOperationT) -> Expression:
-        return self._evaluate_expression(op.expression)
-
     def _evaluate_types_in_expression(
-        self, op: ExpressionOperationT, expression: Expression
+        self, op: ExpressionOperationT
     ) -> ExpressionOperationT:
-        op_with_evaluated_types = op.model_copy(update={"expression": expression})
+        new_expression = self._evaluate_expression(op.expression)
+        op_with_evaluated_types = op.model_copy(update={"expression": new_expression})
         vrc = VarRefCollector()
         vrc.visit(ast.parse(op_with_evaluated_types.expression.expr))
         handles = vrc.var_handles