classiq 0.54.0__py3-none-any.whl → 0.55.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/emitter.py

@@ -70,7 +70,12 @@ class Emitter(Generic[QuantumStatementT]):
 
         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._generative_contexts: dict[str, OperationContext] = {}
 
     @abstractmethod
@@ -100,7 +105,7 @@ class Emitter(Generic[QuantumStatementT]):
         return self._interpreter._current_scope
 
     @property
-    def _expanded_functions(self) -> list[NativeFunctionDefinition]:
+    def _expanded_functions(self) -> dict[str, NativeFunctionDefinition]:
         return self._interpreter._expanded_functions
 
     @property
@@ -137,23 +142,34 @@ class Emitter(Generic[QuantumStatementT]):
         )
         new_positional_arg_decls = new_declaration.positional_arg_declarations
         is_atomic = function.is_atomic
-        if not is_atomic:  # perform monomorphization
+        new_function_name = function.name
+        if not is_atomic:  # perform monomorphization per interpreted parameters set
             self._add_params_to_scope(
                 new_positional_arg_decls, evaluated_args, function
             )
             context = self._expand_operation(
                 function.with_new_declaration(new_declaration)
             )
-            self._expanded_functions.append(
-                self._builder.create_definition(cast(FunctionContext, context))
+            function_context = cast(FunctionContext, context)
+            closure_id = function_context.closure.closure_id
+            function_def = self._expanded_functions.get(closure_id)
+            if function_def is None:
+                function_def = self._builder.create_definition(function_context)
+                self._expanded_functions[closure_id] = function_def
+            new_function_name = function_def.name
+            compilation_metadata = self._functions_compilation_metadata.get(
+                function.name
             )
+            if compilation_metadata is not None:
+                self._expanded_functions_compilation_metadata[new_function_name] = (
+                    compilation_metadata
+                )
+
         new_positional_args = self._get_new_positional_args(
             evaluated_args, is_atomic, new_positional_arg_decls
         )
         new_call = QuantumFunctionCall(
-            function=(
-                new_declaration.name if is_atomic else self._expanded_functions[-1].name
-            ),
+            function=new_function_name,
             positional_args=new_positional_args,
         )
         is_allocate_or_free = (

classiq/model_expansions/quantum_operations/expression_operation.py

@@ -1,7 +1,7 @@
 import ast
 from abc import abstractmethod
 from itertools import chain
-from typing import TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING, TypeVar, Union
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -13,6 +13,7 @@ from classiq.interface.generator.expressions.evaluated_expression import (
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.control import Control
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     HandleBinding,
@@ -20,6 +21,7 @@ from classiq.interface.model.handle_binding import (
     SubscriptHandleBinding,
 )
 from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumAssignmentOperation,
     QuantumExpressionOperation,
 )
 from classiq.interface.model.quantum_type import (
@@ -214,3 +216,25 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
             self._machine_precision,
         )
         return op_with_evaluated_types
+
+    @staticmethod
+    def _all_vars_boolean(op: QuantumExpressionOperation) -> bool:
+        if not all(
+            var_type.has_size_in_bits and var_type.size_in_bits == 1
+            for var_type in op.var_types.values()
+        ):
+            return False
+        return not any(
+            isinstance(var_type, QuantumNumeric)
+            and (var_type.sign_value or var_type.fraction_digits_value > 0)
+            for var_type in op.var_types.values()
+        )
+
+    @staticmethod
+    def _is_res_boolean(op: Union[QuantumAssignmentOperation, Control]) -> bool:
+        if not (op.result_type.has_size_in_bits and op.result_type.size_in_bits == 1):
+            return False
+        return not (
+            isinstance(op.result_type, QuantumNumeric)
+            and (op.result_type.sign_value or op.result_type.fraction_digits_value > 0)
+        )

classiq/model_expansions/quantum_operations/quantum_assignment_operation.py

@@ -101,7 +101,7 @@ class QuantumAssignmentOperationEmitter(
         if (
             op.operation_kind != ArithmeticOperationKind.InplaceXor
             or op.result_type.size_in_bits > 1
-            or not _is_res_boolean(op)
+            or not self._is_res_boolean(op)
             or target.quantum_type.size_in_bits > 1
             or _is_constant(expression.expr)
         ):
@@ -141,7 +141,8 @@ class QuantumAssignmentOperationEmitter(
                 ArithmeticOperationKind.Assignment,
                 ArithmeticOperationKind.InplaceXor,
             )
-            or not _all_vars_boolean(op)
+            or not self._all_vars_boolean(op)
+            or not self._is_res_boolean(op)
         ):
             return op, expression, False
         optimizer = BooleanExpressionOptimizer()
@@ -250,27 +251,3 @@ def _validate_naive_inplace_handles(qe: ArithmeticOperation) -> None:
         raise ClassiqExpansionError(
             HANDLE_ERROR_MESSAGE.format(handle_str=str(qe.result_var))
         )
-
-
-def _all_vars_boolean(op: ArithmeticOperation) -> bool:
-    if not all(
-        var_type.has_size_in_bits and var_type.size_in_bits == 1
-        for var_type in op.var_types.values()
-    ):
-        return False
-    if any(
-        isinstance(var_type, QuantumNumeric)
-        and (var_type.sign_value or var_type.fraction_digits_value > 0)
-        for var_type in op.var_types.values()
-    ):
-        return False
-    return _is_res_boolean(op)
-
-
-def _is_res_boolean(op: ArithmeticOperation) -> bool:
-    if not (op.result_type.has_size_in_bits and op.result_type.size_in_bits == 1):
-        return False
-    return not (
-        isinstance(op.result_type, QuantumNumeric)
-        and (op.result_type.sign_value or op.result_type.fraction_digits_value > 0)
-    )

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -2,10 +2,6 @@ from typing import TYPE_CHECKING
 
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 
-from classiq.model_expansions.call_to_model_converter import (
-    BlockFunctionInfo,
-    CallToModelConverter,
-)
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.qmod.semantics.error_manager import ErrorManager
@@ -18,37 +14,11 @@ class QuantumFunctionCallEmitter(Emitter[QuantumFunctionCall]):
     def __init__(self, interpreter: "Interpreter") -> None:
         super().__init__(interpreter)
         self._model = self._interpreter._model
-        self._synthesized_separately_blocks = (
-            self._interpreter._synthesized_separately_blocks
-        )
 
     def emit(self, call: QuantumFunctionCall, /) -> None:
-        function: FunctionClosure = self._interpreter.evaluate(call.function).as_type(
-            FunctionClosure
-        )
+        function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
         args = call.positional_args
         with ErrorManager().call(
             function.name
         ), function.scope.freeze(), self._propagated_var_stack.capture_variables(call):
-            new_call = self._emit_quantum_function_call(function, args)
-            if function.synthesis_data.should_synthesize_separately:
-                interpreted_call_converter = CallToModelConverter(
-                    call,
-                    function.positional_arg_declarations,
-                    function.scope.data,
-                    self._model,
-                )
-                self._update_synthesized_separately_models(
-                    interpreted_call_converter, new_call.func_name
-                )
-
-    def _update_synthesized_separately_models(
-        self, call_converter: CallToModelConverter, call_name: str
-    ) -> None:
-        synthesized_separately_blocks = self._synthesized_separately_blocks
-        block_id = call_converter.block_id
-        block_function = synthesized_separately_blocks.get(block_id)
-        if block_function is None:
-            block_function = BlockFunctionInfo.from_call_converter(call_converter)
-            synthesized_separately_blocks[block_id] = block_function
-        block_function.calls.add(call_name)
+            self._emit_quantum_function_call(function, args)

classiq/model_expansions/quantum_operations/within_apply.py

@@ -1,5 +1,4 @@
 from classiq.interface.generator.functions.builtins.internal_operators import (
-    COMPUTE_OPERATOR_NAME,
     WITHIN_APPLY_NAME,
 )
 from classiq.interface.model.within_apply_operation import WithinApply
@@ -26,10 +25,6 @@ class WithinApplyEmitter(Emitter[WithinApply]):
                 }
             )
 
-        if self._should_wrap(within_apply.compute):
-            self._emit_wrapped(within_apply)
-            return
-
         self._emit_as_operation(within_apply)
 
     def _emit_as_operation(self, within_apply: WithinApply) -> None:
@@ -46,14 +41,3 @@ class WithinApplyEmitter(Emitter[WithinApply]):
                 source_ref=within_apply.source_ref,
             )
         )
-
-    def _emit_wrapped(self, within_apply: WithinApply) -> None:
-        wrapped_compute = self._create_expanded_wrapping_function(
-            COMPUTE_OPERATOR_NAME, within_apply.compute
-        )
-        wrapped_within_apply = WithinApply(
-            compute=[wrapped_compute],
-            action=within_apply.action,
-            source_ref=within_apply.source_ref,
-        )
-        self._builder.emit_statement(wrapped_within_apply)

classiq/model_expansions/scope_initialization.py

@@ -60,7 +60,6 @@ def _add_functions_to_scope(
                 positional_arg_declarations=function.positional_arg_declarations,
                 body=function.body,
                 scope=Scope(parent=scope),
-                synthesis_data=function.synthesis_data,
             )
         )
 

classiq/qmod/builtins/operations.py

@@ -1,12 +1,16 @@
 import inspect
 import sys
+import warnings
 from collections.abc import Mapping
 from types import FrameType
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     Final,
+    Optional,
     Union,
+    overload,
 )
 
 from classiq.interface.exceptions import ClassiqValueError
@@ -21,13 +25,16 @@ from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
 from classiq.interface.model.control import Control
-from classiq.interface.model.inplace_binary_operation import (
-    BinaryOperation,
-    InplaceBinaryOperation,
-)
 from classiq.interface.model.invert import Invert
 from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.power import Power
+from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
+    AmplitudeLoadingOperation,
+)
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+    ArithmeticOperationKind,
+)
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     QuantumOperandDeclaration,
@@ -37,7 +44,7 @@ from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum, QVar
+from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum, QScalar, QVar
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_expandable import prepare_arg
 from classiq.qmod.symbolic_expr import SymbolicExpr
@@ -91,6 +98,7 @@ def if_(
 def control(
     ctrl: Union[SymbolicExpr, QBit, QArray[QBit]],
     stmt_block: Union[QCallable, Callable[[], None]],
+    else_block: Union[QCallable, Callable[[], None], None] = None,
 ) -> None:
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
@@ -98,39 +106,125 @@ def control(
     control_stmt = Control(
         expression=Expression(expr=str(ctrl)),
         body=_operand_to_body(stmt_block, "stmt_block"),
+        else_block=_operand_to_body(else_block, "else_block") if else_block else None,
         source_ref=source_ref,
     )
     control_stmt.set_generative_block("body", stmt_block)
+    if else_block is not None:
+        control_stmt.set_generative_block("else_block", else_block)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(control_stmt)
 
 
+def assign(expression: SymbolicExpr, target_var: QScalar) -> None:
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        ArithmeticOperation(
+            expression=Expression(expr=str(expression)),
+            result_var=target_var.get_handle_binding(),
+            operation_kind=ArithmeticOperationKind.Assignment,
+            source_ref=source_ref,
+        )
+    )
+
+
+def assign_amplitude(expression: SymbolicExpr, target_var: QScalar) -> None:
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        AmplitudeLoadingOperation(
+            expression=Expression(expr=str(expression)),
+            result_var=target_var.get_handle_binding(),
+            source_ref=source_ref,
+        )
+    )
+
+
+@overload
+def inplace_add(expression: SymbolicExpr, target_var: QScalar) -> None:
+    pass
+
+
+@overload
+def inplace_add(*, value: QNum, target: QNum) -> None:
+    pass
+
+
 def inplace_add(
-    value: QNum,
-    target: QNum,
+    expression: Optional[SymbolicExpr] = None,
+    target_var: Optional[QScalar] = None,
+    value: Optional[QNum] = None,
+    target: Optional[QNum] = None,
 ) -> None:
     assert QCallable.CURRENT_EXPANDABLE is not None
+    if value is not None or target is not None:
+        warnings.warn(
+            "Parameters 'value' and 'target of function 'inplace_add' have "
+            "been renamed to 'expression' and 'target_var' respectively. Parameters "
+            "'value' and 'target' will no longer be supported starting on 02/12/24 at "
+            "the earliest.\nHint: Change `inplace_add(value=..., target=...)` to "
+            "`inplace_add(expression=..., target_var=...)` or `inplace_add(..., ...)`.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+    if value is not None:
+        expression = value
+    if target is not None:
+        target_var = target
+    if TYPE_CHECKING:
+        assert expression is not None
+        assert target_var is not None
     source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        InplaceBinaryOperation(
-            target=target.get_handle_binding(),
-            value=value.get_handle_binding(),
-            operation=BinaryOperation.Addition,
+        ArithmeticOperation(
+            expression=Expression(expr=str(expression)),
+            result_var=target_var.get_handle_binding(),
+            operation_kind=ArithmeticOperationKind.InplaceAdd,
             source_ref=source_ref,
         )
     )
 
 
+@overload
+def inplace_xor(expression: SymbolicExpr, target_var: QScalar) -> None:
+    pass
+
+
+@overload
+def inplace_xor(*, value: QNum, target: QNum) -> None:
+    pass
+
+
 def inplace_xor(
-    value: QNum,
-    target: QNum,
+    expression: Optional[SymbolicExpr] = None,
+    target_var: Optional[QScalar] = None,
+    value: Optional[QNum] = None,
+    target: Optional[QNum] = None,
 ) -> None:
     assert QCallable.CURRENT_EXPANDABLE is not None
+    if value is not None or target is not None:
+        warnings.warn(
+            "Parameters 'value' and 'target of function 'inplace_xor' have "
+            "been renamed to 'expression' and 'target_var' respectively. Parameters "
+            "'value' and 'target' will no longer be supported starting on 02/12/24 at "
+            "the earliest.\nHint: Change `inplace_xor(value=..., target=...)` to "
+            "`inplace_xor(expression=..., target_var=...)` or `inplace_xor(..., ...)`.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+    if value is not None:
+        expression = value
+    if target is not None:
+        target_var = target
+    if TYPE_CHECKING:
+        assert expression is not None
+        assert target_var is not None
     source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        InplaceBinaryOperation(
-            target=target.get_handle_binding(),
-            value=value.get_handle_binding(),
-            operation=BinaryOperation.Xor,
+        ArithmeticOperation(
+            expression=Expression(expr=str(expression)),
+            result_var=target_var.get_handle_binding(),
+            operation_kind=ArithmeticOperationKind.InplaceXor,
             source_ref=source_ref,
         )
     )
@@ -297,6 +391,8 @@ def _operand_to_body(
 
 
 __all__ = [
+    "assign",
+    "assign_amplitude",
     "bind",
     "control",
     "invert",

classiq/qmod/create_model_function.py

@@ -60,6 +60,7 @@ def create_model(
     user_gen_functions = {
         gen_func._py_callable.__name__ for gen_func in GEN_QFUNCS
     } - set(BUILTIN_FUNCTION_DECLARATIONS.keys())
+
     if len(user_gen_functions) > 0 and is_generative_expansion_enabled():
         model = _expand_generative_model(
             (
@@ -100,11 +101,17 @@ def _expand_generative_model(
     def _dummy() -> None:
         pass
 
+    functions_compilation_metadata = {
+        dec_func._py_callable.__name__: dec_func.compilation_metadata
+        for dec_func in DEC_QFUNCS
+        if dec_func.compilation_metadata is not None
+    }
     model = _dummy.create_model(
         constraints,
         execution_preferences,
         preferences,
         classical_execution_function,
+        functions_compilation_metadata,
     )
     generative_functions = _get_generative_functions(gen_main, preferences)
     model.functions = generative_functions
@@ -157,7 +164,8 @@ def _get_wrapper_main(gen_main: QFunc, preferences: Optional[Preferences]) -> Mo
 def _get_all_model_functions_as_generative_functions() -> list[GenerativeQFunc]:
 
     gen_functions = list(GEN_QFUNCS) + [
-        _get_gen_from_dec(dec_func) for dec_func in DEC_QFUNCS
+        GenerativeQFunc(dec_func._py_callable, dec_func.func_decl)
+        for dec_func in DEC_QFUNCS
     ]
     return [
         (
@@ -173,16 +181,6 @@ def _get_all_model_functions_as_generative_functions() -> list[GenerativeQFunc]:
     ]
 
 
-def _get_gen_from_dec(dec_func: QFunc) -> GenerativeQFunc:
-    synthesis_data = dec_func.synthesis_data
-    if synthesis_data is not None and synthesis_data.should_synthesize_separately:
-        raise ClassiqError(
-            """The model contains generative functions,
-            which cannot coexist with functions marked for separate synthesis"""
-        )
-    return GenerativeQFunc(dec_func._py_callable, dec_func.func_decl)
-
-
 def _interpret_generative_model(
     gen_model: Model, gen_functions: list[GenerativeQFunc]
 ) -> dict[str, NativeFunctionDefinition]:
@@ -192,7 +190,7 @@ def _interpret_generative_model(
     )
     interpreter = Interpreter(gen_model, gen_functions, is_frontend=True)
     set_frontend_interpreter(interpreter)
-    expand_model, _ = interpreter.expand()
+    expand_model = interpreter.expand()
     functions_dict = nameables_to_dict(expand_model.functions)
 
     # Inline _gen_main call in main

classiq/qmod/model_state_container.py

@@ -1,8 +1,11 @@
 from classiq.interface.generator.constant import Constant
+from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 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.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.native_function_definition import (
+    NativeFunctionDefinition,
+)
 
 
 class ModelStateContainer:
@@ -11,6 +14,7 @@ class ModelStateContainer:
     qstruct_decls: dict[str, QStructDeclaration]
     native_defs: dict[str, NativeFunctionDefinition]
     constants: dict[str, Constant]
+    functions_compilation_metadata: dict[str, CompilationMetadata]
 
 
 QMODULE = ModelStateContainer()

classiq/qmod/native/pretty_printer.py

@@ -253,7 +253,12 @@ class DSLPrettyPrinter(Visitor):
     def visit_Control(self, op: Control) -> str:
         control = f"{self._indent}control ({self.visit(op.expression)}) {{\n"
         control += self._visit_body(op.body)
-        control += f"{self._indent}}}\n"
+        control += f"{self._indent}}}"
+        if op.else_block is not None:
+            control += " else {\n"
+            control += self._visit_body(op.else_block)
+            control += f"{self._indent}}}"
+        control += "\n"
         return control
 
     def visit_PhaseOperation(self, op: PhaseOperation) -> str:

classiq/qmod/pretty_print/pretty_printer.py

@@ -50,9 +50,6 @@ 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_function_call import (
     OperandIdentifier,
     QuantumFunctionCall,
@@ -391,7 +388,10 @@ class PythonPrettyPrinter(Visitor):
 
     def visit_Control(self, op: Control) -> str:
         self._imports["control"] = 1
-        return f"{self._indent}control({self.visit(op.expression)}, {self._visit_body(op.body)})\n"
+        control_else = (
+            f", {self._visit_body(op.else_block)}" if op.else_block is not None else ""
+        )
+        return f"{self._indent}control({self.visit(op.expression)}, {self._visit_body(op.body)}{control_else})\n"
 
     def visit_PhaseOperation(self, op: PhaseOperation) -> str:
         self._imports["phase"] = 1
@@ -429,13 +429,16 @@ class PythonPrettyPrinter(Visitor):
         code = f"lambda{argument_string}: {'[' if len(body) > 1 else ''}\n"
         self._level += 1
         for i, statement in enumerate(body):
-            if isinstance(
-                statement, (QuantumAssignmentOperation, VariableDeclarationStatement)
-            ):
+            if isinstance(statement, VariableDeclarationStatement):
                 raise AssertionError(
-                    "pretty printing quantum assignment operations or variable declaration statements in quantum lambda function is unsupported."
+                    "pretty printing variable declaration statements in quantum lambda function is unsupported."
                 )
-            code += self.visit(statement)
+            if isinstance(statement, AmplitudeLoadingOperation):
+                code += self.visit_AmplitudeLoadingOperation(statement, in_lambda=True)
+            elif isinstance(statement, ArithmeticOperation):
+                code += self.visit_ArithmeticOperation(statement, in_lambda=True)
+            else:
+                code += self.visit(statement)
             if i < len(body) - 1:
                 code += ","
         self._level -= 1
@@ -469,18 +472,29 @@ class PythonPrettyPrinter(Visitor):
     def visit_FieldHandleBinding(self, var_ref: FieldHandleBinding) -> str:
         return f"{self.visit(var_ref.base_handle)}.{self.visit(var_ref.field)}"
 
-    def visit_ArithmeticOperation(self, arith_op: ArithmeticOperation) -> str:
+    def visit_ArithmeticOperation(
+        self, arith_op: ArithmeticOperation, in_lambda: bool = False
+    ) -> str:
         if arith_op.operation_kind == ArithmeticOperationKind.Assignment:
             op = "|="
+            func = "assign"
         elif arith_op.operation_kind == ArithmeticOperationKind.InplaceXor:
             op = "^="
+            func = "inplace_xor"
         else:
             op = "+="
+            func = "inplace_add"
+        if in_lambda:
+            self._imports[func] = 1
+            return f"{func}({self.visit(arith_op.expression)}, {self._indent}{self.visit(arith_op.result_var)})\n"
         return f"{self._indent}{self.visit(arith_op.result_var)} {op} {self.visit(arith_op.expression)}\n"
 
     def visit_AmplitudeLoadingOperation(
-        self, amplitude_loading_op: AmplitudeLoadingOperation
+        self, amplitude_loading_op: AmplitudeLoadingOperation, in_lambda: bool = False
     ) -> str:
+        if in_lambda:
+            self._imports["assign_amplitude"] = 1
+            return f"assign_amplitude({self.visit(amplitude_loading_op.expression)}, {self._indent}{self.visit(amplitude_loading_op.result_var)})\n"
         return f"{self._indent}{self.visit(amplitude_loading_op.result_var)} *= {self.visit(amplitude_loading_op.expression)}\n"
 
     def _print_bind_handles(self, handles: list[HandleBinding]) -> str: