classiq 0.67.0__py3-none-any.whl → 0.68.0__py3-none-any.whl

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -21,8 +21,11 @@ from classiq.interface.model.model import Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.power import Power
-from classiq.interface.model.quantum_expressions.quantum_expression import (
-    QuantumAssignmentOperation,
+from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
+    AmplitudeLoadingOperation,
+)
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
 )
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
@@ -55,7 +58,17 @@ from classiq.model_expansions.quantum_operations import (
     VariableDeclarationStatementEmitter,
 )
 from classiq.model_expansions.quantum_operations.allocate import AllocateEmitter
-from classiq.model_expansions.quantum_operations.shallow_emitter import ShallowEmitter
+from classiq.model_expansions.quantum_operations.assignment_result_processor import (
+    AssignmentResultProcessor,
+)
+from classiq.model_expansions.quantum_operations.block_evaluator import BlockEvaluator
+from classiq.model_expansions.quantum_operations.composite_emitter import (
+    CompositeEmitter,
+)
+from classiq.model_expansions.quantum_operations.expression_evaluator import (
+    ExpressionEvaluator,
+)
+from classiq.model_expansions.quantum_operations.handle_evaluator import HandleEvaluator
 from classiq.model_expansions.scope import Evaluated, Scope
 from classiq.model_expansions.scope_initialization import (
     add_constants_to_scope,
@@ -134,15 +147,39 @@ class GenerativeInterpreter(BaseInterpreter):
         BindEmitter(self).emit(bind)
 
     @emit.register
-    def emit_quantum_assignment_operation(self, op: QuantumAssignmentOperation) -> None:
-        ShallowEmitter(
-            self, "assignment_operation", components=["expression", "result_var"]
+    def emit_amplitude_loading_operation(self, op: AmplitudeLoadingOperation) -> None:
+        CompositeEmitter[AmplitudeLoadingOperation](
+            self,
+            [
+                HandleEvaluator(self, "result_var"),
+                ExpressionEvaluator(self, "expression"),
+                AssignmentResultProcessor(self),
+            ],
+        ).emit(op)
+
+    @emit.register
+    def _emit_arithmetic_operation(self, op: ArithmeticOperation) -> None:
+        self.emit_arithmetic_operation(op)
+
+    def emit_arithmetic_operation(self, op: ArithmeticOperation) -> None:
+        CompositeEmitter[ArithmeticOperation](
+            self,
+            [
+                HandleEvaluator(self, "result_var"),
+                ExpressionEvaluator(self, "expression"),
+                AssignmentResultProcessor(self),
+            ],
         ).emit(op)
 
     @emit.register
     def emit_inplace_binary_operation(self, op: InplaceBinaryOperation) -> None:
-        ShallowEmitter(
-            self, "inplace_binary_operation", components=["target", "value"]
+        CompositeEmitter[InplaceBinaryOperation](
+            self,
+            [
+                HandleEvaluator(self, "target"),
+                HandleEvaluator(self, "value"),
+                ExpressionEvaluator(self, "value"),
+            ],
         ).emit(op)
 
     @emit.register
@@ -157,37 +194,60 @@ class GenerativeInterpreter(BaseInterpreter):
 
     @emit.register
     def emit_within_apply(self, within_apply: WithinApply) -> None:
-        ShallowEmitter(
+        BlockEvaluator(
             self,
             WITHIN_APPLY_NAME,
-            components=["within", "apply", "compute", "action"],
+            "within",
+            "apply",
+            "compute",
+            "action",
         ).emit(within_apply)
 
     @emit.register
     def emit_invert(self, invert: Invert) -> None:
-        ShallowEmitter(self, INVERT_OPERATOR_NAME, components=["body"]).emit(invert)
+        BlockEvaluator(self, INVERT_OPERATOR_NAME, "body").emit(invert)
 
     @emit.register
     def emit_repeat(self, repeat: Repeat) -> None:
         RepeatEmitter(self).emit(repeat)
 
     @emit.register
+    def _emit_control(self, control: Control) -> None:
+        self.emit_control(control)
+
     def emit_control(self, control: Control) -> None:
-        ShallowEmitter(
+        CompositeEmitter[Control](
             self,
-            CONTROL_OPERATOR_NAME,
-            components=["expression", "body", "else_block"],
+            [
+                ExpressionEvaluator(self, "expression"),
+                BlockEvaluator(
+                    self,
+                    CONTROL_OPERATOR_NAME,
+                    "body",
+                    "else_block",
+                ),
+            ],
         ).emit(control)
 
     @emit.register
     def emit_power(self, power: Power) -> None:
-        ShallowEmitter(self, CONTROL_OPERATOR_NAME, components=["power", "body"]).emit(
-            power
-        )
+        CompositeEmitter[Power](
+            self,
+            [
+                ExpressionEvaluator(self, "power"),
+                BlockEvaluator(self, CONTROL_OPERATOR_NAME, "body"),
+            ],
+        ).emit(power)
 
     @emit.register
     def emit_phase(self, phase: PhaseOperation) -> None:
-        ShallowEmitter(self, "phase", components=["expression", "theta"]).emit(phase)
+        CompositeEmitter[PhaseOperation](
+            self,
+            [
+                ExpressionEvaluator(self, "expression"),
+                ExpressionEvaluator(self, "theta"),
+            ],
+        ).emit(phase)
 
     def _expand_body(self, operation: Closure) -> None:
         if isinstance(operation, FunctionClosure) and operation.name == "permute":

classiq/model_expansions/quantum_operations/allocate.py

@@ -12,7 +12,7 @@ from classiq.model_expansions.scope import QuantumSymbol
 
 
 class AllocateEmitter(Emitter[Allocate]):
-    def emit(self, allocate: Allocate, /) -> None:
+    def emit(self, allocate: Allocate, /) -> bool:
         target: QuantumSymbol = self._interpreter.evaluate(allocate.target).as_type(
             QuantumSymbol
         )
@@ -32,6 +32,7 @@ class AllocateEmitter(Emitter[Allocate]):
         )
         self._register_debug_info(allocate)
         self.emit_statement(allocate)
+        return True
 
     def _get_var_size(self, target: QuantumSymbol, size: Expression | None) -> int:
         if size is None:
@@ -70,4 +71,5 @@ class AllocateEmitter(Emitter[Allocate]):
             level=OperationLevel.QMOD_STATEMENT,
             is_allocate_or_free=True,
             port_to_passed_variable_map={"ARG": str(allocate.target)},
+            node=allocate._as_back_ref(),
         )

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -0,0 +1,52 @@
+from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+    ArithmeticOperationKind,
+)
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumAssignmentOperation,
+)
+
+from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import QuantumSymbol
+from classiq.model_expansions.transformers.ast_renamer import rename_variables
+
+
+class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
+    def emit(self, op: QuantumAssignmentOperation, /) -> bool:
+        if (
+            isinstance(op, ArithmeticOperation)
+            and op.operation_kind == ArithmeticOperationKind.Assignment
+        ):
+            direction = PortDeclarationDirection.Output
+            self._update_result_type(op)
+        else:
+            direction = PortDeclarationDirection.Inout
+        self._capture_handle(op.result_var, direction)
+        return False
+
+    def _update_result_type(self, op: ArithmeticOperation) -> None:
+        expr = self._evaluate_expression(op.expression)
+        symbols = self._get_symbols_in_expression(expr)
+        expr_str = rename_variables(
+            expr.expr,
+            {str(symbol.handle): symbol.handle.identifier for symbol in symbols}
+            | {symbol.handle.qmod_expr: symbol.handle.identifier for symbol in symbols},
+        )
+        for symbol in symbols:
+            expr_str = expr_str.replace(
+                symbol.handle.qmod_expr, symbol.handle.identifier
+            )
+        result_type = compute_arithmetic_result_type(
+            expr_str,
+            {symbol.handle.identifier: symbol.quantum_type for symbol in symbols},
+            self._machine_precision,
+        )
+        result_symbol = self._interpreter.evaluate(op.result_var).as_type(QuantumSymbol)
+        copy_type_information(
+            result_type, result_symbol.quantum_type, str(op.result_var)
+        )

classiq/model_expansions/quantum_operations/bind.py

@@ -16,7 +16,7 @@ from classiq.model_expansions.scope import Evaluated, QuantumSymbol
 
 
 class BindEmitter(Emitter[BindOperation]):
-    def emit(self, bind: BindOperation, /) -> None:
+    def emit(self, bind: BindOperation, /) -> bool:
         inputs, outputs = self._get_inputs_outputs(bind)
         validate_bind_targets(bind, self._current_scope)
         unsized_outputs = [
@@ -56,6 +56,7 @@ class BindEmitter(Emitter[BindOperation]):
                 back_ref=bind.uuid,
             )
         )
+        return True
 
     def _get_inputs_outputs(
         self, bind: BindOperation

classiq/model_expansions/quantum_operations/block_evaluator.py

@@ -0,0 +1,76 @@
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
+
+from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
+
+from classiq.model_expansions.closure import Closure
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import Scope
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
+
+_BLOCK_RENAMES = {
+    "compute": "within",
+    "action": "apply",
+}
+_REVERSE_BLOCK_RENAMES = {rename: name for name, rename in _BLOCK_RENAMES.items()}
+
+
+class BlockEvaluator(Emitter[QuantumOperation]):
+    def __init__(
+        self, interpreter: "BaseInterpreter", operation_name: str, *block_names: str
+    ) -> None:
+        super().__init__(interpreter)
+        self._operation_name = operation_name
+        self._block_names: Sequence[str] = block_names
+
+    def emit(self, op: QuantumOperation, /) -> bool:
+        expanded_blocks: dict[str, list[QuantumStatement]] = {}
+        blocks = [
+            block
+            for block in self._block_names
+            if hasattr(op, block) and getattr(op, block) is not None
+        ]
+
+        if len(blocks) > 0:
+            if op.is_generative():
+                expanded_blocks = self.expand_generative_blocks(op)
+            else:
+                expanded_blocks = self.expand_blocks(op, blocks)
+            expanded_blocks.update(expanded_blocks)
+
+        op = op.model_copy(update={**expanded_blocks, "back_ref": op.uuid})
+        self._builder.emit_statement(op)
+        return True
+
+    def expand_blocks(
+        self, op: QuantumOperation, block_names: list[str]
+    ) -> dict[str, list[QuantumStatement]]:
+        blocks = {
+            _BLOCK_RENAMES.get(block, block): getattr(op, block)
+            for block in block_names
+        }
+        block_closure = Closure(
+            name=self._operation_name,
+            scope=Scope(parent=self._current_scope),
+            blocks=blocks,
+        )
+        context = self._expand_operation(block_closure)
+        return {
+            block: context.statements(_BLOCK_RENAMES.get(block, block))
+            for block in block_names
+        }
+
+    def expand_generative_blocks(
+        self, op: QuantumOperation
+    ) -> dict[str, list[QuantumStatement]]:
+        blocks = [
+            block for block in self._block_names if op.has_generative_block(block)
+        ]
+        context = self._expand_generative_context(op, self._operation_name, blocks)
+        return {
+            _REVERSE_BLOCK_RENAMES.get(block, block): context.statements(block)
+            for block in blocks
+        }

classiq/model_expansions/quantum_operations/classicalif.py

@@ -18,7 +18,7 @@ def _is_all_identity_calls(body: Sequence[QuantumStatement]) -> bool:
 
 
 class ClassicalIfEmitter(CallEmitter[ClassicalIf]):
-    def emit(self, classical_if: ClassicalIf, /) -> None:
+    def emit(self, classical_if: ClassicalIf, /) -> bool:
         condition = self._interpreter.evaluate(classical_if.condition).as_type(bool)
         op_name = "then" if condition else "else"
         is_generative = classical_if.is_generative()
@@ -26,7 +26,7 @@ class ClassicalIfEmitter(CallEmitter[ClassicalIf]):
         body: Sequence[QuantumStatement]
         if is_generative:
             if not classical_if.has_generative_block(op_name):
-                return
+                return True
             context = self._expand_generative_context(classical_if, op_name, op_name)
             context.blocks["body"] = context.blocks[op_name]
             context.blocks.pop(op_name)
@@ -35,7 +35,7 @@ class ClassicalIfEmitter(CallEmitter[ClassicalIf]):
             body = classical_if.then if condition else classical_if.else_
 
         if _is_all_identity_calls(body):
-            return
+            return True
 
         if is_generative or not self._should_wrap(body):
             for stmt in body:
@@ -43,7 +43,7 @@ class ClassicalIfEmitter(CallEmitter[ClassicalIf]):
                     self._interpreter._builder.emit_statement(stmt)
                 else:
                     self._interpreter.emit_statement(stmt)
-            return
+            return True
 
         then_else_func = FunctionClosure.create(
             name=self._counted_name_allocator.allocate("then" if condition else "else"),
@@ -54,3 +54,4 @@ class ClassicalIfEmitter(CallEmitter[ClassicalIf]):
         self._emit_quantum_function_call(
             then_else_func, list(), new_function_debug_info_by_node(classical_if)
         )
+        return True

classiq/model_expansions/quantum_operations/composite_emitter.py

@@ -0,0 +1,27 @@
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Generic
+
+from classiq.model_expansions.quantum_operations.emitter import (
+    Emitter,
+    QuantumStatementT,
+)
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
+
+class CompositeEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT]):
+    def __init__(
+        self,
+        interpreter: "BaseInterpreter",
+        emitters: Sequence[Emitter[QuantumStatementT]],
+    ) -> None:
+        super().__init__(interpreter)
+        self._emitters = emitters
+
+    def emit(self, statement: QuantumStatementT, /) -> bool:
+        for emitter in self._emitters:
+            if emitter.emit(statement):
+                return True
+        self._builder.emit_statement(statement)
+        return True

classiq/model_expansions/quantum_operations/emitter.py

@@ -1,3 +1,4 @@
+import ast
 from abc import ABC, abstractmethod
 from typing import (
     TYPE_CHECKING,
@@ -39,12 +40,15 @@ 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:
     from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 
-QuantumStatementT = TypeVar("QuantumStatementT", bound=QuantumStatement)
+QuantumStatementT = TypeVar(
+    "QuantumStatementT", bound=QuantumStatement, contravariant=True
+)
 
 
 class Emitter(Generic[QuantumStatementT], ABC):
@@ -60,7 +64,7 @@ class Emitter(Generic[QuantumStatementT], ABC):
         )
 
     @abstractmethod
-    def emit(self, statement: QuantumStatementT, /) -> None:
+    def emit(self, statement: QuantumStatementT, /) -> bool:
         pass
 
     def _expand_operation(self, closure: Closure) -> OperationContext:
@@ -173,3 +177,13 @@ class Emitter(Generic[QuantumStatementT], ABC):
             defining_function=defining_function,
             direction=direction,
         )
+
+    def _get_symbols_in_expression(self, expr: Expression) -> list[QuantumSymbol]:
+        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)
+        )
+        return [self._interpreter.evaluate(handle).value for handle in handles]

classiq/model_expansions/quantum_operations/expression_evaluator.py

@@ -0,0 +1,33 @@
+from typing import TYPE_CHECKING
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
+
+class ExpressionEvaluator(Emitter[QuantumOperation]):
+    def __init__(self, interpreter: "BaseInterpreter", expression_name: str) -> None:
+        super().__init__(interpreter)
+        self._expression_name = expression_name
+
+    def emit(self, op: QuantumOperation, /) -> bool:
+        expression = getattr(op, self._expression_name)
+        if not isinstance(expression, Expression) or expression.is_evaluated():
+            return False
+        evaluated_expression = self._evaluate_expression(
+            expression, preserve_bool_ops=True
+        )
+        for symbol in self._get_symbols_in_expression(evaluated_expression):
+            self._capture_handle(symbol.handle, PortDeclarationDirection.Inout)
+        op = op.model_copy(
+            update={self._expression_name: evaluated_expression, "back_ref": op.uuid}
+        )
+        self._interpreter.emit(op)
+        return True

classiq/model_expansions/quantum_operations/handle_evaluator.py

@@ -0,0 +1,28 @@
+from typing import TYPE_CHECKING
+
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
+
+class HandleEvaluator(Emitter[QuantumOperation]):
+    def __init__(self, interpreter: "BaseInterpreter", handle_name: str) -> None:
+        super().__init__(interpreter)
+        self._handle_name = handle_name
+
+    def emit(self, op: QuantumOperation, /) -> bool:
+        handle = getattr(op, self._handle_name)
+        if not isinstance(handle, HandleBinding):
+            return False
+        evaluated_handle = self._interpreter.evaluate(handle).value.handle
+        if handle == evaluated_handle:
+            return False
+        op = op.model_copy(
+            update={self._handle_name: evaluated_handle, "back_ref": op.uuid}
+        )
+        self._interpreter.emit(op)
+        return True

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -28,16 +28,17 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
         super().__init__(interpreter)
         self._model = self._interpreter._model
 
-    def emit(self, call: QuantumFunctionCall, /) -> None:
+    def emit(self, call: QuantumFunctionCall, /) -> bool:
         if call.function == "allocate":  # FIXME: Remove compatibility (CAD-25935)
             self._allocate_compatibility(call)
-            return
+            return True
         function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
         args = call.positional_args
         with ErrorManager().call(function.name):
             self._emit_quantum_function_call(
                 function, args, self._debug_info.get(call.uuid)
             )
+        return True
 
     def _allocate_compatibility(self, call: QuantumFunctionCall) -> None:
         if len(call.positional_args) != 2:

classiq/model_expansions/quantum_operations/repeat.py

@@ -17,7 +17,7 @@ from classiq.qmod.quantum_function import GenerativeQFunc
 
 
 class RepeatEmitter(CallEmitter[Repeat]):
-    def emit(self, repeat: Repeat, /) -> None:
+    def emit(self, repeat: Repeat, /) -> bool:
         count = self._interpreter.evaluate(repeat.count).as_type(int)
         if count < 0:
             raise ClassiqExpansionError(
@@ -26,6 +26,7 @@ class RepeatEmitter(CallEmitter[Repeat]):
         op_name = self._counted_name_allocator.allocate(REPEAT_OPERATOR_NAME)
         for i in range(count):
             self._emit_iteration(repeat, i, op_name)
+        return True
 
     def _emit_iteration(self, repeat: Repeat, i: int, op_name: str) -> None:
         closure_constructor: type[FunctionClosure]

classiq/model_expansions/quantum_operations/variable_decleration.py

@@ -12,7 +12,7 @@ from classiq.model_expansions.scope import Evaluated, QuantumSymbol
 
 
 class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement]):
-    def emit(self, variable_declaration: VariableDeclarationStatement, /) -> None:
+    def emit(self, variable_declaration: VariableDeclarationStatement, /) -> bool:
         var_decl = variable_declaration.model_copy(
             update=dict(back_ref=variable_declaration.uuid)
         )
@@ -36,3 +36,4 @@ class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement])
             var_decl.name, self._builder.current_function
         )
         self.emit_statement(var_decl)
+        return True

classiq/model_expansions/sympy_conversion/expression_to_sympy.py

@@ -174,6 +174,6 @@ class ExpressionSympyTranslator(ast.NodeTransformer):
     def visit_Attribute(self, node: ast.Attribute) -> ast.Call:
         return ast.Call(
             func=ast.Name("get_field"),
-            args=[node.value, ast.Constant(value=node.attr)],
+            args=[self.visit(node.value), ast.Constant(value=node.attr)],
             keywords=[],
         )

classiq/open_library/functions/__init__.py

@@ -10,7 +10,7 @@ from .hea import *
 from .linear_pauli_rotation import *
 from .linear_pauli_rotation import _single_pauli
 from .modular_exponentiation import *
-from .modular_exponentiation import _check_msb, _ctrl_x
+from .modular_exponentiation import _check_msb
 from .qaoa_penalty import *
 from .qft_functions import *
 from .qpe import *
@@ -72,7 +72,6 @@ OPEN_LIBRARY_FUNCTIONS = [
     qst_type2,
     modular_increment,
     qft,
-    _ctrl_x,
     _prepare_uniform_trimmed_state_step,
     _qct_d_operator,
     _qct_pi_operator,

classiq/open_library/functions/amplitude_amplification.py

@@ -4,7 +4,7 @@ from classiq.qmod.builtins.operations import (
     allocate,
     bind,
     control,
-    repeat,
+    power,
     within_apply,
 )
 from classiq.qmod.cparam import CInt, CReal
@@ -24,7 +24,7 @@ def amplitude_amplification(
     """
     [Qmod Classiq-library function]
 
-    Applies the Amplitude Amplification algorithm (QAE); Prepares a state using the given `space_transform` function, and applies `reps` repetititions
+    Applies the Amplitude Amplification algorithm; 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:
@@ -34,7 +34,10 @@ def amplitude_amplification(
         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))
+    power(
+        reps,
+        lambda: grover_operator(oracle, space_transform, packed_qvars),
+    )
 
 
 @qfunc
@@ -47,7 +50,7 @@ def exact_amplitude_amplification(
     """
     [Qmod Classiq-library function]
 
-    Applies an exact version of the Amplitude Amplification algorithm (QAE), assuming knowledge of the amplitude of the marked state.
+    Applies an exact version of the Amplitude Amplification algorithm, 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).
@@ -68,7 +71,7 @@ def exact_amplitude_amplification(
     theta = pi / (4 * k + 2)
     rot_phase = 2 * acos(sin(theta) / amplitude)
 
-    extended_qvars: QArray = QArray("extended_qvars")
+    extended_qvars: QArray = QArray()
     within_apply(
         lambda: [  # type:ignore[arg-type]
             allocate(aux),