classiq 0.47.0__py3-none-any.whl → 0.48.1__py3-none-any.whl

classiq/model_expansions/quantum_operations/inplace_binary_operation.py

@@ -1,6 +1,5 @@
-from typing import TYPE_CHECKING, List, Optional, Sequence, Tuple
+from typing import TYPE_CHECKING, List, Tuple
 
-from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -25,6 +24,7 @@ from classiq.interface.model.quantum_type import (
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
+from classiq.interface.model.within_apply_operation import WithinApply
 
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.evaluators.parameter_types import (
@@ -35,7 +35,7 @@ from classiq.model_expansions.evaluators.quantum_type_utils import (
 )
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import QuantumSymbol, Scope
-from classiq.qmod.builtins.functions import integer_xor, modular_add
+from classiq.qmod.builtins.functions import CX, allocate, integer_xor, modular_add
 
 
 def _binary_function_declaration(
@@ -59,16 +59,13 @@ class InplaceBinaryOperationEmitter(Emitter[InplaceBinaryOperation]):
             assert isinstance(value_var.quantum_type, QuantumNumeric)
             assert isinstance(target_var.quantum_type, QuantumNumeric)
 
-        sign_diff = int(value_var.quantum_type.sign_value) - int(
-            target_var.quantum_type.sign_value
-        )
         frac_digits_diff = (
             value_var.quantum_type.fraction_digits_value
             - target_var.quantum_type.fraction_digits_value
         )
         if (
-            sign_diff + frac_digits_diff == value_var.quantum_type.size_in_bits
-            or -sign_diff - frac_digits_diff == target_var.quantum_type.size_in_bits
+            frac_digits_diff == value_var.quantum_type.size_in_bits
+            or -frac_digits_diff == target_var.quantum_type.size_in_bits
         ):
             with self._propagated_var_stack.capture_variables(op):
                 return
@@ -97,7 +94,6 @@ class InplaceBinaryOperationEmitter(Emitter[InplaceBinaryOperation]):
             body=_build_inplace_binary_operation(
                 value_var=value_var,
                 target_var=target_var,
-                frac_digits_diff=frac_digits_diff,
                 internal_function_declaration=_binary_function_declaration(
                     op.operation
                 ),
@@ -113,53 +109,56 @@ class InplaceBinaryOperationEmitter(Emitter[InplaceBinaryOperation]):
 def _build_inplace_binary_operation(
     value_var: QuantumSymbol,
     target_var: QuantumSymbol,
-    frac_digits_diff: int,
     internal_function_declaration: NamedParamsQuantumFunctionDeclaration,
 ) -> List[QuantumStatement]:
     if TYPE_CHECKING:
         assert isinstance(value_var.quantum_type, QuantumNumeric)
         assert isinstance(target_var.quantum_type, QuantumNumeric)
 
-    value_overlap_var, value_sign_var, value_bind_targets = _get_inplace_bind_targets(
-        "value", value_var, frac_digits_diff
+    frac_digits_diff = (
+        value_var.quantum_type.fraction_digits_value
+        - target_var.quantum_type.fraction_digits_value
     )
-    target_overlap_var, target_sign_var, target_bind_targets = (
-        _get_inplace_bind_targets("target", target_var, -frac_digits_diff)
+    size_diff = (
+        value_var.quantum_type.size_in_bits - target_var.quantum_type.size_in_bits
     )
 
-    value_pre_ops, value_post_ops = _get_inplace_pre_post_ops(
-        value_var, value_bind_targets
+    target_overlap_var, target_var_decls, target_bind_ops = (
+        _trim_superfluous_fraction_digits("target", target_var, -frac_digits_diff)
     )
-    target_pre_ops, target_post_ops = _get_inplace_pre_post_ops(
-        target_var, target_bind_targets
+    value_overlap_var, value_trim_var_decls, value_bind_ops = (
+        _trim_superfluous_fraction_digits("value", value_var, frac_digits_diff)
     )
+    (
+        value_padded_var,
+        value_pad_var_decls,
+        value_pad_pre_bind_ops,
+        value_pad_init_ops,
+        value_post_bind_ops,
+    ) = _pad_with_sign_bit("value", value_overlap_var, size_diff)
 
-    binary_ops = []
-    if value_overlap_var is not None and target_overlap_var is not None:
-        binary_ops.append(
-            _internal_inplace_binary_operation_function_call(
-                internal_function_declaration,
-                value_overlap_var.handle,
-                target_overlap_var.handle,
-            )
-        )
-    if value_sign_var is not None and target_sign_var is not None:
-        binary_ops.append(
-            _internal_inplace_binary_operation_function_call(
-                internal_function_declaration,
-                value_sign_var.handle,
-                target_sign_var.handle,
-            )
-        )
-    if len(binary_ops) == 0:
-        raise ClassiqInternalExpansionError("Bug in unrolling inplace operation")
+    op_call = _internal_inplace_binary_operation_function_call(
+        internal_function_declaration,
+        value_padded_var.handle,
+        target_overlap_var.handle,
+    )
 
     return [
-        *value_pre_ops,
-        *target_pre_ops,
-        *binary_ops,
-        *target_post_ops,
-        *value_post_ops,
+        *target_var_decls,
+        *value_trim_var_decls,
+        *value_pad_var_decls,
+        WithinApply(
+            compute=[
+                *target_bind_ops,
+                *value_bind_ops,
+                *value_pad_pre_bind_ops,
+                *value_pad_init_ops,
+                *value_post_bind_ops,
+            ],
+            action=[
+                op_call,
+            ],
+        ),
     ]
 
 
@@ -176,75 +175,144 @@ def _internal_inplace_binary_operation_function_call(
     return internal_function_call
 
 
-def _get_inplace_bind_targets(
+def _trim_superfluous_fraction_digits(
     kind: str, var: QuantumSymbol, frac_digits_diff: int
-) -> Tuple[Optional[QuantumSymbol], Optional[QuantumSymbol], List[QuantumSymbol]]:
+) -> Tuple[QuantumSymbol, List[VariableDeclarationStatement], List[BindOperation]]:
+    if frac_digits_diff <= 0:
+        return var, [], []
+
     quantum_type = var.quantum_type
     if TYPE_CHECKING:
         assert isinstance(quantum_type, QuantumNumeric)
 
-    if not quantum_type.sign_value and frac_digits_diff <= 0:
-        return var, None, []
-
-    significand_overlap = (
-        quantum_type.size_in_bits
-        - quantum_type.fraction_digits_value
-        - int(quantum_type.sign_value)
+    trimmed_fraction_digits_var = QuantumSymbol(
+        handle=HandleBinding(name=f"trimmed_{kind}_fraction_digits"),
+        quantum_type=QuantumBitvector(
+            length=Expression(expr=str(frac_digits_diff)),
+        ),
     )
-    fraction_overlap = quantum_type.fraction_digits_value - max(0, frac_digits_diff)
-    if significand_overlap + fraction_overlap == 0 and quantum_type.size_in_bits == 1:
-        assert quantum_type.sign_value
-        return None, var, []
-
-    bind_targets = []
+    overlap_var = QuantumSymbol(
+        handle=HandleBinding(name=f"{kind}_overlap"),
+        quantum_type=QuantumNumeric(
+            size=Expression(expr=str(quantum_type.size_in_bits - frac_digits_diff)),
+            is_signed=quantum_type.is_signed,
+            fraction_digits=Expression(expr="0"),
+        ),
+    )
+    bind_targets = trimmed_fraction_digits_var, overlap_var
 
-    if frac_digits_diff > 0:
-        bind_targets.append(
-            QuantumSymbol(
-                handle=HandleBinding(name=f"trimmed_{kind}_fraction_digits"),
-                quantum_type=QuantumBitvector(
-                    length=Expression(expr=str(frac_digits_diff)),
-                ),
-            )
+    split_var_declarations = [
+        VariableDeclarationStatement(
+            name=var.handle.name,
+            quantum_type=var.quantum_type,
         )
+        for var in bind_targets
+    ]
+    bind_op = BindOperation(
+        in_handles=[var.handle],
+        out_handles=[var.handle for var in bind_targets],
+    )
 
-    overlap_var = None
-    if significand_overlap + fraction_overlap > 0:
-        overlap_var = QuantumSymbol(
-            handle=HandleBinding(name=f"{kind}_overlap"),
-            quantum_type=QuantumNumeric(
-                size=Expression(expr=str(significand_overlap + fraction_overlap)),
-                is_signed=Expression(expr="False"),
-                fraction_digits=Expression(expr=str(fraction_overlap)),
-            ),
-        )
-        bind_targets.append(overlap_var)
+    return overlap_var, split_var_declarations, [bind_op]
 
-    sign_var = None
-    if quantum_type.sign_value:
-        sign_var = QuantumSymbol(
-            handle=HandleBinding(name=f"trimmed_{kind}_sign"),
-            quantum_type=QuantumBit(),
-        )
-        bind_targets.append(sign_var)
 
-    return overlap_var, sign_var, bind_targets
+def _pad_with_sign_bit(kind: str, var: QuantumSymbol, size_diff: int) -> Tuple[
+    QuantumSymbol,
+    List[VariableDeclarationStatement],
+    List[QuantumStatement],
+    List[QuantumFunctionCall],
+    List[BindOperation],
+]:
+    quantum_type = var.quantum_type
+    if TYPE_CHECKING:
+        assert isinstance(quantum_type, QuantumNumeric)
 
+    if not quantum_type.sign_value or size_diff >= 0:
+        return var, [], [], [], []
 
-def _get_inplace_pre_post_ops(
-    var: QuantumSymbol, bind_targets: List[QuantumSymbol]
-) -> Tuple[Sequence[QuantumStatement], Sequence[QuantumStatement]]:
-    if len(bind_targets) == 0:
-        return [], []
+    significand_var, sign_var, sign_split_bind = _split_sign(kind, var)
+    padding_var, padding_allocation = _allocate_padding(kind, size_diff)
+    padding_init_ops = _init_padding(sign_var, padding_var, size_diff)
 
-    value_bind_op = BindOperation(
-        in_handles=[var.handle],
-        out_handles=[var.handle for var in bind_targets],
+    padded_var = QuantumSymbol(
+        handle=HandleBinding(name=f"padded_{kind}"),
+        quantum_type=QuantumNumeric(
+            size=Expression(expr=str(quantum_type.size_in_bits - size_diff)),
+            is_signed=Expression(expr="False"),
+            fraction_digits=Expression(expr="0"),
+        ),
     )
-    return [
+    padding_rebind = BindOperation(
+        in_handles=[significand_var.handle, sign_var.handle, padding_var.handle],
+        out_handles=[padded_var.handle],
+    )
+
+    var_decls = [
         VariableDeclarationStatement(
             name=var.handle.name,
             quantum_type=var.quantum_type,
         )
-        for var in bind_targets
-    ] + [value_bind_op], [value_bind_op.reversed()]
+        for var in (significand_var, sign_var, padding_var, padded_var)
+    ]
+
+    return (
+        padded_var,
+        var_decls,
+        [sign_split_bind, padding_allocation],
+        padding_init_ops,
+        [padding_rebind],
+    )
+
+
+def _init_padding(
+    sign_var: QuantumSymbol, padding_var: QuantumSymbol, size_diff: int
+) -> List[QuantumFunctionCall]:
+    padding_init_ops = [
+        QuantumFunctionCall(
+            function=CX.func_decl.name,
+            positional_args=[sign_var.handle, padding_var[idx].handle],
+        )
+        for idx in range(-size_diff)
+    ]
+    for cx_call in padding_init_ops:
+        cx_call.set_func_decl(CX.func_decl)
+    return padding_init_ops
+
+
+def _allocate_padding(
+    kind: str, size_diff: int
+) -> Tuple[QuantumSymbol, QuantumFunctionCall]:
+    padding_var = QuantumSymbol(
+        handle=HandleBinding(name=f"{kind}_sign_padding"),
+        quantum_type=QuantumBitvector(
+            length=Expression(expr=str(-size_diff)),
+        ),
+    )
+    padding_allocation = QuantumFunctionCall(
+        function=allocate.func_decl.name,
+        positional_args=[Expression(expr=str(-size_diff)), padding_var.handle],
+    )
+    padding_allocation.set_func_decl(allocate.func_decl)
+    return padding_var, padding_allocation
+
+
+def _split_sign(
+    kind: str, var: QuantumSymbol
+) -> Tuple[QuantumSymbol, QuantumSymbol, BindOperation]:
+    significand_var = QuantumSymbol(
+        handle=HandleBinding(name=f"{kind}_significand"),
+        quantum_type=QuantumNumeric(
+            size=Expression(expr=str(var.quantum_type.size_in_bits - 1)),
+            is_signed=Expression(expr="False"),
+            fraction_digits=Expression(expr="0"),
+        ),
+    )
+    sign_var = QuantumSymbol(
+        handle=HandleBinding(name=f"{kind}_sign_bit"),
+        quantum_type=QuantumBit(),
+    )
+    sign_split_bind = BindOperation(
+        in_handles=[var.handle],
+        out_handles=[significand_var.handle, sign_var.handle],
+    )
+    return significand_var, sign_var, sign_split_bind

classiq/model_expansions/quantum_operations/invert.py

@@ -10,6 +10,14 @@ from classiq.model_expansions.scope import Scope
 
 class InvertEmitter(Emitter[Invert]):
     def emit(self, invert: Invert, /) -> None:
+        with self._propagated_var_stack.capture_variables(invert):
+            self._emit_propagated(invert)
+
+    def _emit_propagated(self, invert: Invert, /) -> None:
+        if invert.is_generative():
+            context = self._register_generative_context(invert, INVERT_OPERATOR_NAME)
+            invert = invert.copy(update={"body": context.statements("body")})
+
         if self._should_wrap(invert.body):
             self._emit_wrapped(invert)
             return
@@ -22,17 +30,15 @@ class InvertEmitter(Emitter[Invert]):
             blocks={"body": invert.body},
             scope=Scope(parent=self._current_scope),
         )
-        with self._propagated_var_stack.capture_variables(invert):
-            context = self._expand_operation(invert_operation)
+        context = self._expand_operation(invert_operation)
         self._builder.emit_statement(
             Invert(body=context.statements("body"), source_ref=invert.source_ref)
         )
 
     def _emit_wrapped(self, invert: Invert) -> None:
-        with self._propagated_var_stack.capture_variables(invert):
-            wrapping_function = self._create_expanded_wrapping_function(
-                INVERT_OPERATOR_NAME, invert.body
-            )
+        wrapping_function = self._create_expanded_wrapping_function(
+            INVERT_OPERATOR_NAME, invert.body
+        )
         self._builder.emit_statement(
             Invert(body=[wrapping_function], source_ref=invert.source_ref)
         )

classiq/model_expansions/quantum_operations/phase.py

@@ -21,7 +21,6 @@ from classiq.interface.model.within_apply_operation import WithinApply
 
 from classiq.applications.combinatorial_helpers.transformations.ising_converter import (
     _find_sub_list_items,
-    _get_coeff_from_expr,
     _get_vars,
     _refine_ising_expr,
     _to_ising_symbolic_objective_function,
@@ -34,6 +33,12 @@ from classiq.qmod.semantics.error_manager import ErrorManager
 
 
 class PhaseEmitter(ExpressionOperationEmitter[PhaseOperation]):
+    def _negate_expression(self, expression: Expression, /) -> Expression:
+        return self._evaluate_expression(
+            # TODO: change to model_copy for pydantic V2
+            expression.copy(update=dict(expr=f"-({expression.expr})"))
+        )
+
     def emit(self, phase_op: PhaseOperation, /) -> None:
         phase_expression = self._evaluate_op_expression(phase_op)
         phase_op = phase_op.copy(update=dict(expression=phase_expression))
@@ -41,7 +46,10 @@ class PhaseEmitter(ExpressionOperationEmitter[PhaseOperation]):
         if len(arrays_with_subscript) > 0:
             self._emit_with_split(phase_op, phase_op.expression, arrays_with_subscript)
             return
-
+        # TODO: change to model_copy for pydantic V2
+        phase_op = phase_op.copy(
+            update=dict(expression=self._negate_expression(phase_op.expression))
+        )
         phase_op = self._evaluate_types_in_expression(phase_op, phase_op.expression)
         if len(phase_op.var_handles) == 0:
             ErrorManager().add_error(
@@ -135,6 +143,7 @@ def _convert_ising_sympy_to_pauli_terms(
     ising_expr: sympy.Expr, ordered_sympy_vars: List[sympy.Symbol]
 ) -> str:
     pauli_terms: List[str] = []
+    coefficients = ising_expr.as_coefficients_dict(*ordered_sympy_vars)
     for expr_term in ising_expr.args:
         expr_vars = _get_vars(expr_term)
         z_vec = _find_sub_list_items(ordered_sympy_vars, expr_vars)
@@ -144,7 +153,10 @@ def _convert_ising_sympy_to_pauli_terms(
                 pauli_elements[len(z_vec) - index - 1] = (
                     "Z"  # reminder: Pauli reverses the order!
                 )
-        coeff = _get_coeff_from_expr(expr_term)
+        term_var = sympy.Mul(
+            *(var for i, var in enumerate(ordered_sympy_vars) if z_vec[i])
+        )
+        coeff = float(coefficients[term_var])
         paulis = [f"Pauli.{pauli}" for pauli in pauli_elements]
         pauli_terms.append(
             # fmt: off

classiq/model_expansions/quantum_operations/power.py

@@ -2,7 +2,6 @@ from typing import Union
 
 import sympy
 
-from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
@@ -22,6 +21,14 @@ class PowerEmitter(Emitter[Power]):
     _power_expr: Expression
 
     def emit(self, power: Power, /) -> None:
+        with self._propagated_var_stack.capture_variables(power):
+            self._emit_propagated(power)
+
+    def _emit_propagated(self, power: Power) -> None:
+        if power.is_generative():
+            context = self._register_generative_context(power, POWER_OPERATOR_NAME)
+            power = power.copy(update={"body": context.statements("body")})
+
         self._power = power
         self._power_value = self._get_power_value()
         self._power_expr = Expression(
@@ -41,8 +48,7 @@ class PowerEmitter(Emitter[Power]):
             blocks=dict(body=self._power.body),
             scope=Scope(parent=self._current_scope),
         )
-        with self._propagated_var_stack.capture_variables(self._power):
-            context = self._expand_operation(power_operation)
+        context = self._expand_operation(power_operation)
         self._builder.emit_statement(
             Power(
                 body=context.statements("body"),
@@ -66,9 +72,4 @@ class PowerEmitter(Emitter[Power]):
 
     def _get_power_value(self) -> Union[int, sympy.Basic]:
         power_value = self._interpreter.evaluate(self._power.power).value
-        if not (isinstance(power_value, int) or power_value.is_symbol):
-            raise ClassiqExpansionError(
-                f"`power`'s argument should be an integer or identifier. Complex "
-                f"expressions are not supported. Got {str(power_value)!r}"
-            )
         return power_value

classiq/model_expansions/quantum_operations/quantum_assignment_operation.py

@@ -11,6 +11,7 @@ from classiq.interface.model.inplace_binary_operation import (
 )
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
+    ArithmeticOperationKind,
 )
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumAssignmentOperation,
@@ -62,7 +63,7 @@ class QuantumAssignmentOperationEmitter(
         self, op: ArithmeticOperation, expression: Expression
     ) -> None:
         op, expression, is_bool_opt = self._optimize_boolean_expression(op, expression)
-        if op.inplace_result:
+        if op.is_inplace:
             self._emit_inplace_arithmetic_op(op, expression, is_bool_opt)
         else:
             self._emit_general_assignment_operation(op)
@@ -70,7 +71,9 @@ class QuantumAssignmentOperationEmitter(
     def _emit_inplace_arithmetic_op(
         self, op: ArithmeticOperation, expression: Expression, is_bool_opt: bool
     ) -> None:
-        if op.result_type.size_in_bits > 1 or not _is_res_boolean(op):
+        if op.operation_kind != ArithmeticOperationKind.InplaceXor or (
+            op.result_type.size_in_bits > 1 or not _is_res_boolean(op)
+        ):
             _validate_naive_inplace_handles(op)
             self._build_naive_inplace(op, expression)
             return
@@ -100,7 +103,15 @@ class QuantumAssignmentOperationEmitter(
     def _optimize_boolean_expression(
         self, op: ArithmeticOperation, expression: Expression
     ) -> Tuple[ArithmeticOperation, Expression, bool]:
-        if not _all_vars_boolean(op):
+        if (
+            self._interpreter._is_frontend
+            or op.operation_kind
+            not in (
+                ArithmeticOperationKind.Assignment,
+                ArithmeticOperationKind.InplaceXor,
+            )
+            or not _all_vars_boolean(op)
+        ):
             return op, expression, False
         optimizer = BooleanExpressionOptimizer()
         optimized_expression = Expression(
@@ -130,10 +141,14 @@ class QuantumAssignmentOperationEmitter(
         arith_expression = ArithmeticOperation(
             result_var=HandleBinding(name=aux_var),
             expression=new_expression,
-            inplace_result=False,
+            operation_kind=ArithmeticOperationKind.Assignment,
         )
+        if qe.operation_kind == ArithmeticOperationKind.InplaceXor:
+            op = BinaryOperation.Xor
+        else:
+            op = BinaryOperation.Addition
         inplace_store = InplaceBinaryOperation(
-            operation=BinaryOperation.Xor,
+            operation=op,
             target=qe.result_var,
             value=HandleBinding(name=aux_var),
         )

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -11,5 +11,5 @@ class QuantumFunctionCallEmitter(Emitter[QuantumFunctionCall]):
         args = call.positional_args
         with ErrorManager().call(
             function.name
-        ), self._propagated_var_stack.capture_variables(call):
+        ), function.scope.freeze(), self._propagated_var_stack.capture_variables(call):
             self._emit_quantum_function_call(function, args)

classiq/model_expansions/quantum_operations/repeat.py

@@ -1,3 +1,5 @@
+from typing import Type
+
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
     REPEAT_OPERATOR_NAME,
@@ -8,9 +10,10 @@ from classiq.interface.model.classical_parameter_declaration import (
 )
 from classiq.interface.model.repeat import Repeat
 
-from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import Scope
+from classiq.qmod.quantum_function import GenerativeQFunc
 
 
 class RepeatEmitter(Emitter[Repeat]):
@@ -18,16 +21,32 @@ class RepeatEmitter(Emitter[Repeat]):
         count = self._interpreter.evaluate(repeat.count).as_type(int)
         for i in range(count):
             with self._propagated_var_stack.capture_variables(repeat):
-                iteration_function = FunctionClosure.create(
-                    name=REPEAT_OPERATOR_NAME,
-                    positional_arg_declarations=[
-                        ClassicalParameterDeclaration(
-                            name=repeat.iter_var, classical_type=Integer()
-                        )
-                    ],
-                    body=repeat.body,
-                    scope=Scope(parent=self._current_scope),
-                )
-                self._emit_quantum_function_call(
-                    iteration_function, [Expression(expr=str(i))]
+                self._emit_propagated(repeat, i)
+
+    def _emit_propagated(self, repeat: Repeat, i: int) -> None:
+        closure_constructor: Type[FunctionClosure]
+        extra_args: dict
+        if repeat.is_generative():
+            closure_constructor = GenerativeFunctionClosure
+            extra_args = {
+                "generative_blocks": {
+                    "body": GenerativeQFunc(
+                        repeat.get_generative_block("body"),
+                    ),
+                }
+            }
+        else:
+            closure_constructor = FunctionClosure
+            extra_args = {}
+        iteration_function = closure_constructor.create(
+            name=REPEAT_OPERATOR_NAME,
+            positional_arg_declarations=[
+                ClassicalParameterDeclaration(
+                    name=repeat.iter_var, classical_type=Integer()
                 )
+            ],
+            body=repeat.body,
+            scope=Scope(parent=self._current_scope),
+            **extra_args,
+        )
+        self._emit_quantum_function_call(iteration_function, [Expression(expr=str(i))])

classiq/model_expansions/quantum_operations/within_apply.py

@@ -11,6 +11,21 @@ from classiq.model_expansions.scope import Scope
 
 class WithinApplyEmitter(Emitter[WithinApply]):
     def emit(self, within_apply: WithinApply, /) -> None:
+        with self._propagated_var_stack.capture_variables(within_apply):
+            self._emit_propagated(within_apply)
+
+    def _emit_propagated(self, within_apply: WithinApply) -> None:
+        if within_apply.is_generative():
+            within_apply_context = self._register_generative_context(
+                within_apply, WITHIN_APPLY_NAME, ["within", "apply"]
+            )
+            within_apply = within_apply.copy(
+                update={
+                    "compute": within_apply_context.statements("within"),
+                    "action": within_apply_context.statements("apply"),
+                }
+            )
+
         if self._should_wrap(within_apply.compute):
             self._emit_wrapped(within_apply)
             return
@@ -23,8 +38,7 @@ class WithinApplyEmitter(Emitter[WithinApply]):
             blocks=dict(within=within_apply.compute, apply=within_apply.action),
             scope=Scope(parent=self._current_scope),
         )
-        with self._propagated_var_stack.capture_variables(within_apply):
-            context = self._expand_operation(within_apply_operation)
+        context = self._expand_operation(within_apply_operation)
         self._builder.emit_statement(
             WithinApply(
                 compute=context.statements("within"),
@@ -34,10 +48,9 @@ class WithinApplyEmitter(Emitter[WithinApply]):
         )
 
     def _emit_wrapped(self, within_apply: WithinApply) -> None:
-        with self._propagated_var_stack.capture_variables(within_apply):
-            wrapped_compute = self._create_expanded_wrapping_function(
-                COMPUTE_OPERATOR_NAME, within_apply.compute
-            )
+        wrapped_compute = self._create_expanded_wrapping_function(
+            COMPUTE_OPERATOR_NAME, within_apply.compute
+        )
         wrapped_within_apply = WithinApply(
             compute=[wrapped_compute],
             action=within_apply.action,