classiq 0.65.4__py3-none-any.whl → 0.66.1__py3-none-any.whl

classiq/model_expansions/scope_initialization.py

@@ -1,22 +1,19 @@
 from collections.abc import Sequence
-from typing import TYPE_CHECKING
+from typing import Any
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression_constants import (
     CPARAM_EXECUTION_SUFFIX,
+    RESERVED_EXPRESSIONS,
 )
-from classiq.interface.model.classical_parameter_declaration import (
-    ClassicalParameterDeclaration,
-)
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 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 (
-    NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
-    QuantumFunctionDeclaration,
 )
 
 from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
@@ -26,7 +23,6 @@ from classiq.model_expansions.evaluators.classical_expression import (
 from classiq.model_expansions.evaluators.parameter_types import (
     evaluate_type_in_quantum_symbol,
 )
-from classiq.model_expansions.expression_renamer import ExpressionRenamer
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.qmod.builtins import BUILTIN_CONSTANTS
 from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
@@ -39,19 +35,6 @@ from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.quantum_function import GenerativeQFunc
 
 
-def get_main_renamer(
-    func_decls: Sequence[QuantumFunctionDeclaration],
-) -> ExpressionRenamer:
-    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_decl.positional_arg_declarations, CPARAM_EXECUTION_SUFFIX
-            )
-    return ExpressionRenamer(var_mapping={})
-
-
 def add_constants_to_scope(constants: list[Constant], scope: Scope) -> None:
     for constant in constants:
         scope[constant.name] = Evaluated(
@@ -122,21 +105,17 @@ def add_entry_point_params_to_scope(
     parameters: Sequence[PositionalArg], main_closure: FunctionClosure
 ) -> None:
     for parameter in parameters:
-        if isinstance(parameter, PortDeclaration):
-            main_closure.scope[parameter.name] = Evaluated(
-                value=QuantumSymbol(
-                    handle=HandleBinding(name=parameter.name),
-                    quantum_type=evaluate_type_in_quantum_symbol(
-                        parameter.quantum_type, main_closure.scope, parameter.name
-                    ),
+        if not isinstance(parameter, PortDeclaration):
+            continue
+        main_closure.scope[parameter.name] = Evaluated(
+            value=QuantumSymbol(
+                handle=HandleBinding(name=parameter.name),
+                quantum_type=evaluate_type_in_quantum_symbol(
+                    parameter.quantum_type, main_closure.scope, parameter.name
                 ),
-                defining_function=main_closure,
-            )
-        elif isinstance(parameter, ClassicalParameterDeclaration):
-            main_closure.scope[parameter.name] = Evaluated(
-                value=parameter.classical_type.as_symbolic(parameter.name),
-                defining_function=main_closure,
-            )
+            ),
+            defining_function=main_closure,
+        )
 
 
 def init_top_level_scope(model: Model, scope: Scope) -> None:
@@ -148,3 +127,39 @@ def init_top_level_scope(model: Model, scope: Scope) -> None:
 def init_builtin_types() -> None:
     QMODULE.enum_decls |= BUILTIN_ENUM_DECLARATIONS
     QMODULE.type_decls |= BUILTIN_STRUCT_DECLARATIONS
+
+
+def _rename_exec_param(param_name: str) -> str:
+    if param_name in RESERVED_EXPRESSIONS:
+        return param_name
+    return param_name + CPARAM_EXECUTION_SUFFIX
+
+
+def _add_exec_param_parts_to_scope(param_val: Any, scope: Scope) -> None:
+    if not isinstance(param_val, list):
+        scope[str(param_val)] = Evaluated(value=param_val)
+        return
+    for param_part in param_val:
+        _add_exec_param_parts_to_scope(param_part, scope)
+
+
+def init_exec_params(model: Model, scope: Scope) -> dict[str, ConcreteClassicalType]:
+    if model.execution_parameters is not None:
+        exec_params = {
+            param_name: (param_name, param_type)
+            for param_name, param_type in model.execution_parameters.items()
+        }
+    else:
+        exec_params = {
+            param.name: (_rename_exec_param(param.name), param.classical_type)
+            for param in model.function_dict.get(
+                "_dec_main", model.main_func
+            ).param_decls
+        }
+    for param_name, (param_rename, param_type) in exec_params.items():
+        param_val = param_type.as_symbolic(param_rename)
+        scope[param_name] = Evaluated(value=param_val)
+        scope[param_rename] = Evaluated(value=param_val)
+        if isinstance(param_val, list):
+            _add_exec_param_parts_to_scope(param_val, scope)
+    return dict(exec_params.values())

classiq/model_expansions/transformers/model_renamer.py

@@ -0,0 +1,98 @@
+import ast
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from typing import TypeVar, cast
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.visitor import NodeType
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.model_visitor import ModelTransformer
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
+)
+
+from classiq.model_expansions.visitors.variable_references import VarRefCollector
+
+AST_NODE = TypeVar("AST_NODE", bound=NodeType)
+
+
+@dataclass(frozen=True)
+class HandleRenaming:
+    source_handle: HandleBinding
+    target_var_name: str
+
+    @property
+    def target_var_handle(self) -> HandleBinding:
+        return HandleBinding(name=self.target_var_name)
+
+
+SymbolRenaming = Mapping[HandleBinding, Sequence[HandleRenaming]]
+
+
+class ModelRenamer:
+    def rewrite(self, subject: AST_NODE, symbol_mapping: SymbolRenaming) -> AST_NODE:
+        if len(symbol_mapping) == 0:
+            return subject
+        handle_replacements = {
+            part.source_handle: part.target_var_handle
+            for parts in symbol_mapping.values()
+            for part in parts
+        }
+
+        class ReplaceSplitVars(ModelTransformer):
+            @staticmethod
+            def visit_HandleBinding(handle: HandleBinding) -> HandleBinding:
+                handle = handle.collapse()
+                for handle_to_replace, replacement in handle_replacements.items():
+                    handle = handle.replace_prefix(handle_to_replace, replacement)
+                return handle
+
+            @staticmethod
+            def visit_Expression(expr: Expression) -> Expression:
+                return self._rewrite_expression(symbol_mapping, expr)
+
+            def visit_QuantumExpressionOperation(
+                self, op: QuantumExpressionOperation
+            ) -> QuantumExpressionOperation:
+                op = cast(QuantumExpressionOperation, self.generic_visit(op))
+                previous_var_handles = list(op._var_handles)
+                op._var_handles = self.visit(op._var_handles)
+                op._var_types = {
+                    new_handle.name: op._var_types.get(
+                        new_handle.name, op._var_types[previous_handle.name]
+                    )
+                    for previous_handle, new_handle in zip(
+                        previous_var_handles, op._var_handles
+                    )
+                }
+                return op
+
+        return ReplaceSplitVars().visit(subject)
+
+    def _rewrite_expression(
+        self,
+        symbol_mapping: SymbolRenaming,
+        expression: Expression,
+    ) -> Expression:
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(expression.expr))
+
+        handle_names = {
+            part.source_handle: part.target_var_handle
+            for parts in symbol_mapping.values()
+            for part in parts
+        }
+        new_expr_str = expression.expr
+        for handle in vrc.var_handles:
+            new_handle = handle.collapse()
+            for handle_to_replace, replacement in handle_names.items():
+                new_handle = new_handle.replace_prefix(handle_to_replace, replacement)
+            new_expr_str = new_expr_str.replace(str(handle), str(new_handle))
+            if handle.qmod_expr != str(handle):
+                new_expr_str = new_expr_str.replace(
+                    handle.qmod_expr, new_handle.qmod_expr
+                )
+
+        new_expr = Expression(expr=new_expr_str)
+        new_expr._evaluated_expr = expression._evaluated_expr
+        return new_expr

classiq/model_expansions/transformers/var_splitter.py

@@ -1,14 +1,13 @@
 import ast
 from dataclasses import dataclass
 from itertools import chain
-from typing import TYPE_CHECKING, Callable, Optional, TypeVar, cast
+from typing import TYPE_CHECKING, Callable, Optional
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.visitor import NodeType, Transformer
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.handle_binding import (
     HandleBinding,
@@ -16,9 +15,6 @@ from classiq.interface.model.handle_binding import (
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
-from classiq.interface.model.quantum_expressions.quantum_expression import (
-    QuantumExpressionOperation,
-)
 from classiq.interface.model.quantum_type import (
     QuantumBitvector,
     QuantumScalar,
@@ -29,27 +25,23 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 
 from classiq.model_expansions.scope import QuantumSymbol, Scope
+from classiq.model_expansions.transformers.model_renamer import (
+    HandleRenaming,
+    ModelRenamer,
+)
 from classiq.model_expansions.visitors.variable_references import VarRefCollector
 
-AST_NODE = TypeVar("AST_NODE", bound=NodeType)
-
 
 @dataclass(frozen=True)
-class SymbolPart:
-    source_handle: HandleBinding
-    target_var_name: str
+class SymbolPart(HandleRenaming):
     target_var_type: QuantumType
 
-    @property
-    def target_var_handle(self) -> HandleBinding:
-        return HandleBinding(name=self.target_var_name)
-
 
 SymbolParts = dict[HandleBinding, list[SymbolPart]]
 PartNamer = Callable[[str], str]
 
 
-class VarSplitter:
+class VarSplitter(ModelRenamer):
     def __init__(self, scope: Scope):
         self._scope = scope
 
@@ -230,70 +222,3 @@ class VarSplitter:
             )
             for part in chain.from_iterable(symbol_parts.values())
         ]
-
-    def rewrite(self, subject: AST_NODE, symbol_mapping: SymbolParts) -> AST_NODE:
-        if len(symbol_mapping) == 0:
-            return subject
-        handle_replacements = {
-            part.source_handle: part.target_var_handle
-            for parts in symbol_mapping.values()
-            for part in parts
-        }
-
-        class ReplaceSplitVars(Transformer):
-            @staticmethod
-            def visit_HandleBinding(handle: HandleBinding) -> HandleBinding:
-                handle = handle.collapse()
-                for handle_to_replace, replacement in handle_replacements.items():
-                    handle = handle.replace_prefix(handle_to_replace, replacement)
-                return handle
-
-            @staticmethod
-            def visit_Expression(expr: Expression) -> Expression:
-                return self._rewrite_expression(symbol_mapping, expr)
-
-            def visit_QuantumExpressionOperation(
-                self, op: QuantumExpressionOperation
-            ) -> QuantumExpressionOperation:
-                op = cast(QuantumExpressionOperation, self.generic_visit(op))
-                previous_var_handles = list(op._var_handles)
-                op._var_handles = self.visit(op._var_handles)
-                op._var_types = {
-                    new_handle.name: op._var_types.get(
-                        new_handle.name, op._var_types[previous_handle.name]
-                    )
-                    for previous_handle, new_handle in zip(
-                        previous_var_handles, op._var_handles
-                    )
-                }
-                return op
-
-        return ReplaceSplitVars().visit(subject)
-
-    def _rewrite_expression(
-        self,
-        symbol_mapping: SymbolParts,
-        expression: Expression,
-    ) -> Expression:
-        vrc = VarRefCollector(ignore_duplicated_handles=True)
-        vrc.visit(ast.parse(expression.expr))
-
-        handle_names = {
-            part.source_handle: part.target_var_handle
-            for parts in symbol_mapping.values()
-            for part in parts
-        }
-        new_expr_str = expression.expr
-        for handle in vrc.var_handles:
-            new_handle = handle.collapse()
-            for handle_to_replace, replacement in handle_names.items():
-                new_handle = new_handle.replace_prefix(handle_to_replace, replacement)
-            new_expr_str = new_expr_str.replace(str(handle), str(new_handle))
-            if handle.qmod_expr != str(handle):
-                new_expr_str = new_expr_str.replace(
-                    handle.qmod_expr, new_handle.qmod_expr
-                )
-
-        new_expr = Expression(expr=new_expr_str)
-        new_expr._evaluated_expr = expression._evaluated_expr
-        return new_expr

classiq/open_library/functions/__init__.py

@@ -1,3 +1,7 @@
+from .amplitude_amplification import (
+    amplitude_amplification,
+    exact_amplitude_amplification,
+)
 from .amplitude_estimation import *
 from .discrete_sine_cosine_transform import *
 from .discrete_sine_cosine_transform import _qct_d_operator, _qct_pi_operator
@@ -23,6 +27,8 @@ OPEN_LIBRARY_FUNCTIONS = [
     _single_pauli,
     linear_pauli_rotations,
     amplitude_estimation,
+    amplitude_amplification,
+    exact_amplitude_amplification,
     phase_oracle,
     reflect_about_zero,
     grover_diffuser,
@@ -78,12 +84,14 @@ OPEN_LIBRARY_FUNCTIONS = [
 __all__ = [
     "_single_pauli",
     "allocate_num",
+    "amplitude_amplification",
     "amplitude_estimation",
     "apply_to_all",
     "c_modular_multiply",
     "cc_modular_add",
     "encode_in_angle",
     "encode_on_bloch",
+    "exact_amplitude_amplification",
     "full_hea",
     "grover_diffuser",
     "grover_operator",

classiq/open_library/functions/amplitude_amplification.py

@@ -0,0 +1,92 @@
+from classiq.open_library.functions.grover import grover_operator
+from classiq.qmod.builtins.functions.standard_gates import RY
+from classiq.qmod.builtins.operations import (
+    allocate,
+    bind,
+    control,
+    repeat,
+    within_apply,
+)
+from classiq.qmod.cparam import CInt, CReal
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_variable import QArray, QBit
+from classiq.qmod.quantum_callable import QCallable
+from classiq.qmod.symbolic import acos, asin, ceiling, pi, sin
+
+
+@qfunc
+def amplitude_amplification(
+    reps: CInt,
+    oracle: QCallable[QArray[QBit]],
+    space_transform: QCallable[QArray[QBit]],
+    packed_qvars: QArray[QBit],
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies the Amplitude Amplification algorithm (QAE); Prepares a state using the given `space_transform` function, and applies `reps` repetititions
+    of the grover operator, using the given `oracle` functions which marks the "good" states.
+
+    Args:
+        reps: Number of repetitions to apply the grover operator on the initial state. Should be determined by the user, according to the calculated amplification.
+        oracle: The oracle operator that marks the "good" states. This operator should flip the sign of the amplitude of the "good" state.
+        space_transform: The space transform operator (which is known also the state preparation operator). First applied to prepare the state before the amplification, then used inside the Grover operator.
+        packed_vars: The variable that holds the state to be amplified. Assumed to be in the zero state at the beginning of the algorithm.
+    """
+    space_transform(packed_qvars)
+    repeat(reps, lambda index: grover_operator(oracle, space_transform, packed_qvars))
+
+
+@qfunc
+def exact_amplitude_amplification(
+    amplitude: CReal,
+    oracle: QCallable[QArray[QBit]],
+    space_transform: QCallable[QArray[QBit]],
+    packed_qvars: QArray[QBit],
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies an exact version of the Amplitude Amplification algorithm (QAE), assuming knowledge of the amplitude of the marked state.
+    The function should be applied on the zero state, and it takes care for preparing the initial state before amplification using the `space_transform`.
+
+    Based on the algorithm in [Quantum state preparation without coherent arithmetic](https://arxiv.org/abs/2210.14892).
+
+    Assuming the `space_transform` creates a state $|\\psi\rangle = a|\\psi_good\rangle + \\sqrt(1-a)|\\psi_bad\rangle$, given `a` as the `amplitude`
+    argument, the function will load exactly the state $|\\psi_good\rangle$.
+
+    Note: if the `amplitude` argument is not exact, the resulting state will not be exactly $|\\psi_good\rangle$, and there will be additional internal auxilliary of the function that is not released correctly.
+
+    Args:
+        amplitude: The amplitude of the state $|\\psi_good\rangle$ with regards to the initial state prepared by.
+        oracle: The oracle operator that marks the "good" states. This operator should flip the sign of the amplitude of the "good" state.
+        space_transform: The space transform operator (which is known also the state preparation operator). First applied to prepare the state before the amplification, then used inside the Grover operator.
+        packed_vars: The variable that holds the state to be amplified. Assumed to be in the zero state at the beginning of the algorithm.
+    """
+    aux = QBit()
+    k = ceiling((pi / (4 * asin(amplitude))) - 0.5)
+    theta = pi / (4 * k + 2)
+    rot_phase = 2 * acos(sin(theta) / amplitude)
+
+    extended_qvars: QArray = QArray("extended_qvars")
+    within_apply(
+        lambda: [  # type:ignore[arg-type]
+            allocate(aux),
+            bind(
+                [aux, packed_qvars], extended_qvars
+            ),  # type:ignore[func-returns-value]
+        ],
+        lambda: amplitude_amplification(
+            k,
+            lambda qvars_: control(
+                qvars_[0] == 0, lambda: oracle(qvars_[1 : qvars_.size])
+            ),
+            lambda qvars_: [
+                space_transform(  # type:ignore[func-returns-value]
+                    qvars_[1 : qvars_.size]
+                ),
+                RY(rot_phase, qvars_[0]),
+            ],
+            extended_qvars,
+        ),
+    )

classiq/open_library/functions/grover.py

@@ -25,14 +25,14 @@ def phase_oracle(
     Creates a phase oracle operator based on a predicate function.
 
     Applies a predicate function and marks "good" and "bad" states with a phase flip.
-    If the predicate is marked as $\\chi$, and the oracle is marked as $S_\\chi$, then:
+    If the predicate is marked as $\\chi$, and the oracle is marked as $S_{\\chi}$, then:
 
 
     $$
-    S_\\chi\\lvert x \rangle =
-    \begin{cases}
-    -\\lvert x \rangle & \text{if } \\chi(x) = 1 \\
-     \\phantom{-} \\lvert x \rangle & \text{if } \\chi(x) = 0
+    S_{\\chi}\\lvert x \\rangle =
+    \\begin{cases}
+    -\\lvert x \\rangle & \\text{if } \\chi(x) = 1 \\\\
+    \\phantom{-} \\lvert x \\rangle & \\text{if } \\chi(x) = 0
     \\end{cases}
     $$
 

classiq/qmod/builtins/__init__.py

@@ -12,7 +12,7 @@ from .enums import *  # noqa: F403
 from .enums import __all__ as _builtin_enums
 from .functions import *  # noqa: F403
 from .functions import __all__ as _builtin_functions
-from .operations import *  # type:ignore[assignment] # noqa: F403
+from .operations import *  # noqa: F403
 from .operations import __all__ as _builtin_operations
 from .structs import *  # noqa: F403
 from .structs import __all__ as _builtin_structs

classiq/qmod/builtins/functions/__init__.py

@@ -58,7 +58,6 @@ CORE_LIB_DECLS = [
         real_xor_constant,
         U,
         CCX,
-        allocate,
         free,
         randomized_benchmarking,
         inplace_prepare_state,
@@ -103,7 +102,6 @@ __all__ = [  # noqa: RUF022
     "Y",
     "Z",
     "add",
-    "allocate",
     "apply",
     "bloch_sphere_feature_map",
     "exponentiation_with_depth_constraint",

classiq/qmod/builtins/functions/allocation.py

@@ -1,35 +1,10 @@
 from typing import Literal
 
 from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_parameter import CArray, CInt, CReal
+from classiq.qmod.qmod_parameter import CArray, CReal
 from classiq.qmod.qmod_variable import Input, Output, QArray, QBit
 
 
-@qfunc(external=True)
-def allocate(
-    num_qubits: CInt, out: Output[QArray[QBit, Literal["num_qubits"]]]
-) -> None:
-    """
-    [Qmod core-library function]
-
-    Allocates the specified number of qubits to a given quantum variable and initializes
-    them in the zero state:
-
-    $$
-        \\left|\\text{out}\\right\\rangle = \\left|0\\right\\rangle^{\\otimes \\text{num_qubits}}
-    $$
-
-    Args:
-        num_qubits: The number of qubits to allocate. Must be a positive integer.
-        out: The quantum variable that will receive the allocated qubits. Must be uninitialized before allocation.
-
-    Notes:
-        1. If the output variable has been declared with a specific number of qubits, the number of qubits allocated must match the declared number.
-        2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
-    """
-    pass
-
-
 @qfunc(external=True)
 def free(in_: Input[QArray[QBit]]) -> None:
     """

classiq/qmod/builtins/operations.py

@@ -65,15 +65,21 @@ def allocate(out: Output[QVar]) -> None:
 
 def allocate(*args: Any, **kwargs: Any) -> None:
     """
-    Initialize a quantum variable.
+    Initialize a quantum variable to a new quantum object in the zero state:
 
-    If 'num_qubits' is specified, 'num_qubits' qubits will be allocated for variable
-    'out'. Otherwise, the number of qubits will be inferred according to the type of
-    'out'.
+    $$
+        \\left|\\text{out}\\right\\rangle = \\left|0\\right\\rangle^{\\otimes \\text{num_qubits}}
+    $$
+
+    If 'num_qubits' is not specified, it will be inferred according to the type of 'out'.
 
     Args:
-        size: The number of qubits to be allocated (optional)
-        out: The target variable
+        num_qubits: The number of qubits to allocate (positive integer, optional).
+        out: The quantum variable that will receive the allocated qubits. Must be uninitialized before allocation.
+
+    Notes:
+        1. If the output variable has been declared with a specific number of qubits, the number of qubits allocated must match the declared number.
+        2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))

classiq/qmod/generative.py

@@ -6,10 +6,12 @@ from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.expressions.expression import Expression
 
 if TYPE_CHECKING:
-    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+    from classiq.model_expansions.interpreters.generative_interpreter import (
+        GenerativeInterpreter,
+    )
 
 _GENERATIVE_MODE: bool = False
-_FRONTEND_INTERPRETER: Optional["BaseInterpreter"] = None
+_FRONTEND_INTERPRETER: Optional["GenerativeInterpreter"] = None
 
 
 def is_generative_mode() -> bool:
@@ -27,12 +29,12 @@ def generative_mode_context(generative: bool) -> Iterator[None]:
         _GENERATIVE_MODE = previous
 
 
-def set_frontend_interpreter(interpreter: "BaseInterpreter") -> None:
+def set_frontend_interpreter(interpreter: "GenerativeInterpreter") -> None:
     global _FRONTEND_INTERPRETER
     _FRONTEND_INTERPRETER = interpreter
 
 
-def get_frontend_interpreter() -> "BaseInterpreter":
+def get_frontend_interpreter() -> "GenerativeInterpreter":
     if _FRONTEND_INTERPRETER is None:
         raise ClassiqError("Interpreter was not set")
     return _FRONTEND_INTERPRETER

classiq/qmod/native/pretty_printer.py

@@ -21,7 +21,7 @@ from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
-from classiq.interface.generator.visitor import NodeType, Visitor
+from classiq.interface.generator.visitor import NodeType
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
@@ -38,6 +38,7 @@ from classiq.interface.model.handle_binding import (
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
 from classiq.interface.model.invert import Invert
 from classiq.interface.model.model import Model
+from classiq.interface.model.model_visitor import ModelVisitor
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.port_declaration import (
@@ -85,7 +86,7 @@ from classiq.qmod.semantics.annotation.call_annotation import resolve_function_c
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 
-class DSLPrettyPrinter(Visitor):
+class DSLPrettyPrinter(ModelVisitor):
     def __init__(
         self,
         decimal_precision: Optional[int] = DEFAULT_DECIMAL_PRECISION,

classiq/qmod/pretty_print/pretty_printer.py

@@ -41,6 +41,7 @@ from classiq.interface.model.handle_binding import (
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
 from classiq.interface.model.invert import Invert
 from classiq.interface.model.model import Model
+from classiq.interface.model.model_visitor import ModelVisitor
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.port_declaration import AnonPortDeclaration
@@ -120,7 +121,7 @@ class VariableDeclarationAssignment(Visitor):
         return qtype.name, []
 
 
-class PythonPrettyPrinter(Visitor):
+class PythonPrettyPrinter(ModelVisitor):
     def __init__(self, decimal_precision: int = DEFAULT_DECIMAL_PRECISION) -> None:
         self._level = 0
         self._decimal_precision = decimal_precision
@@ -407,6 +408,7 @@ class PythonPrettyPrinter(Visitor):
         return ", ".join(self.visit(arg) for arg in func_call.positional_args)
 
     def visit_Allocate(self, allocate: Allocate) -> str:
+        self._imports["allocate"] = 1
         if allocate.size is not None:
             size = f"{self.visit(allocate.size)}, "
         else: