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

classiq/model_expansions/evaluators/control.py

@@ -4,6 +4,10 @@ from sympy import Equality
 from sympy.core.numbers import Number
 
 from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.arith.argument_utils import (
+    unsigned_integer_interpretation,
+)
+from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.expressions.qmod_qscalar_proxy import (
     QmodQNumProxy,
     QmodQScalarProxy,
@@ -31,14 +35,15 @@ def resolve_num_condition(condition: Equality) -> tuple[QmodSizedProxy, str]:
 def _calculate_ctrl_state(ctrl: QmodSizedProxy, ctrl_val: float) -> str:
     is_signed, fraction_places = _get_numeric_attributes(ctrl)
 
-    integer_ctrl_val = _get_integer_ctrl_val(ctrl, ctrl_val, fraction_places)
-
-    _validate_control_value_sign(ctrl, integer_ctrl_val, is_signed)
-    _validate_control_var_qubits(
-        ctrl, integer_ctrl_val, is_signed, fraction_places, ctrl_val
+    reg = RegisterArithmeticInfo(
+        size=ctrl.size, is_signed=is_signed, fraction_places=fraction_places
     )
+    uint_ctrl_val = unsigned_integer_interpretation(ctrl_val, reg)
 
-    return _to_twos_complement(integer_ctrl_val, ctrl.size)
+    _validate_control_value_sign(ctrl, ctrl_val, is_signed)
+    _validate_control_var_qubits(ctrl, uint_ctrl_val, fraction_places, ctrl_val)
+
+    return _to_twos_complement(uint_ctrl_val, ctrl.size)
 
 
 def _get_numeric_attributes(ctrl: QmodSizedProxy) -> tuple[bool, int]:
@@ -49,20 +54,8 @@ def _get_numeric_attributes(ctrl: QmodSizedProxy) -> tuple[bool, int]:
     )
 
 
-def _get_integer_ctrl_val(
-    ctrl: QmodSizedProxy, ctrl_val: float, fraction_places: int
-) -> int:
-    unfractioned_ctrl_val = ctrl_val * 2**fraction_places
-    if unfractioned_ctrl_val != int(unfractioned_ctrl_val):
-        raise ClassiqExpansionError(
-            f"Variable {str(ctrl)!r} doesne't have enough fraction digits to "
-            f"represent control value {ctrl_val}"
-        )
-    return int(unfractioned_ctrl_val)
-
-
 def _validate_control_value_sign(
-    ctrl: QmodSizedProxy, ctrl_val: int, is_signed: bool
+    ctrl: QmodSizedProxy, ctrl_val: float, is_signed: bool
 ) -> None:
     if not is_signed and ctrl_val < 0:
         raise ClassiqExpansionError(
@@ -74,18 +67,17 @@ def _validate_control_value_sign(
 def _validate_control_var_qubits(
     ctrl: QmodSizedProxy,
     ctrl_val: int,
-    is_signed: bool,
     fraction_places: int,
     orig_ctrl_val: float,
 ) -> None:
-    required_qubits = _min_bit_length(ctrl_val, is_signed)
+    required_qubits = _min_unsigned_bit_length(ctrl_val)
     fraction_places_message = (
         f" with {fraction_places} fraction digits" if fraction_places else ""
     )
     if ctrl.size < required_qubits:
         raise ClassiqExpansionError(
             f"Variable {str(ctrl)!r} has {ctrl.size} qubits{fraction_places_message} but control value "
-            f"{str(orig_ctrl_val if fraction_places else ctrl_val)!r} requires at least {required_qubits} qubits{fraction_places_message}"
+            f"{str(orig_ctrl_val if fraction_places else int(orig_ctrl_val))!r} requires at least {required_qubits} qubits{fraction_places_message}"
         )
 
 
@@ -116,22 +108,6 @@ def _min_unsigned_bit_length(number: int) -> int:
         raise e
 
 
-def _min_signed_bit_length(number: int) -> int:
-    pos_val = abs(number)
-    is_whole = pos_val & (pos_val - 1) == 0
-    if number <= 0 and is_whole:
-        return _min_unsigned_bit_length(pos_val)
-    return _min_unsigned_bit_length(pos_val) + 1
-
-
-def _min_bit_length(number: int, is_signed: bool) -> int:
-    return (
-        _min_signed_bit_length(number)
-        if is_signed
-        else _min_unsigned_bit_length(number)
-    )
-
-
 def _to_twos_complement(value: int, bits: int) -> str:
     if value >= 0:
         return bin(value)[2:].zfill(bits)[::-1]

classiq/model_expansions/function_builder.py

@@ -28,6 +28,7 @@ from classiq.interface.source_reference import SourceReference
 from classiq.model_expansions.capturing.captured_vars import (
     CapturedVars,
     validate_captured_directions,
+    validate_end_state,
 )
 from classiq.model_expansions.closure import (
     Closure,
@@ -142,7 +143,9 @@ class OperationBuilder:
     @contextmanager
     def block_context(self, block_name: str) -> Iterator[None]:
         self._blocks.append(block_name)
-        self._operations[-1].blocks[block_name] = Block()
+        block = Block()
+        block.captured_vars.set_parent(self.current_operation.captured_vars)
+        self._operations[-1].blocks[block_name] = block
         yield
         captured_vars = self.current_block.captured_vars
         if (
@@ -150,14 +153,12 @@ class OperationBuilder:
             and self.current_operation.name != WITHIN_APPLY_NAME
         ):
             validate_captured_directions(
-                captured_vars.filter_vars(
-                    self.current_function, self.current_block.variable_declarations
+                captured_vars.filter_var_decls(
+                    self.current_block.variable_declarations
                 ),
                 report_outin=False,
             )
-        self.current_operation.captured_vars.update(
-            captured_vars.filter_vars(self.current_function)
-        )
+        self.current_operation.captured_vars.update(captured_vars)
         self._blocks.pop()
 
     @contextmanager
@@ -167,11 +168,17 @@ class OperationBuilder:
         context: OperationContext
         if isinstance(original_operation, FunctionClosure):
             context = FunctionContext.create(original_operation)
+            context.closure.captured_vars.init_params(original_operation)
         else:
             context = OperationContext(closure=original_operation)
+            context.closure.captured_vars.set_parent(self.current_block.captured_vars)
         self._operations.append(context)
         yield context
         self._finalize_within_apply()
+        if isinstance(self.current_operation, FunctionClosure):
+            validate_end_state(
+                self.current_operation, self.current_operation.captured_vars
+            )
         self._propagate_captured_vars()
         self._operations.pop()
 
@@ -179,21 +186,19 @@ class OperationBuilder:
         if self.current_operation.name != WITHIN_APPLY_NAME:
             return
         within_captured_vars = self._operations[-1].blocks["within"].captured_vars
-        self.current_operation.captured_vars.update(
-            within_captured_vars.filter_vars(self.current_function).negate()
-        )
+        self.current_operation.captured_vars.update(within_captured_vars.negate())
 
     def _propagate_captured_vars(self) -> None:
         captured_vars = self.current_operation.captured_vars
         if isinstance(self.current_operation, FunctionClosure):
-            captured_vars = captured_vars.set_propagated()
-        validate_captured_directions(captured_vars)
+            captured_vars = captured_vars.filter_vars(
+                self.current_function
+            ).set_propagated()
+            validate_captured_directions(captured_vars)
         if len(self._operations) < 2:
             return
         parent_block = self._operations[-2].blocks[self._blocks[-1]]
-        parent_block.captured_vars.update(
-            captured_vars.filter_vars(self.parent_function)
-        )
+        parent_block.captured_vars.update(captured_vars)
 
     @contextmanager
     def source_ref_context(

classiq/model_expansions/generative_functions.py

@@ -24,9 +24,7 @@ from classiq.qmod.generative import generative_mode_context, set_frontend_interp
 from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.qmod_parameter import CParamStruct
 from classiq.qmod.qmod_variable import QNum, _create_qvar_for_qtype
-from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_expandable import (
-    QExpandable,
     QTerminalCallable,
 )
 from classiq.qmod.quantum_function import QFunc
@@ -147,12 +145,10 @@ def emit_generative_statements(
         translate_ast_arg_to_python_qmod(param, arg)
         for param, arg in zip(operation.positional_arg_declarations, args)
     ]
-    interpreter_expandable = _InterpreterExpandable(interpreter)
-    QExpandable.STACK.append(interpreter_expandable)
-    QCallable.CURRENT_EXPANDABLE = interpreter_expandable
-    set_frontend_interpreter(interpreter)
-    for block_name, generative_function in operation.generative_blocks.items():
-        with interpreter._builder.block_context(block_name), generative_mode_context(
-            True
-        ):
-            generative_function._py_callable(*python_qmod_args)
+    with _InterpreterExpandable(interpreter):
+        set_frontend_interpreter(interpreter)
+        for block_name, generative_function in operation.generative_blocks.items():
+            with interpreter._builder.block_context(
+                block_name
+            ), generative_mode_context(True):
+                generative_function._py_callable(*python_qmod_args)

classiq/model_expansions/interpreters/base_interpreter.py

@@ -144,7 +144,7 @@ class BaseInterpreter:
 
     def process_exception(self, e: Exception) -> None:
         if not isinstance(e, (ClassiqError, ValidationError)):
-            raise ClassiqInternalExpansionError(str(e)) from None
+            raise ClassiqInternalExpansionError(str(e)) from e
         prefix = ""
         if not isinstance(e, ClassiqExpansionError):
             prefix = f"{type(e).__name__}: "
@@ -212,8 +212,15 @@ class BaseInterpreter:
 
     @evaluate.register
     def evaluate_field_access(self, field_access: FieldHandleBinding) -> Evaluated:
-        base_value = self.evaluate(field_access.base_handle)
-        return Evaluated(value=base_value.value.fields[field_access.field])
+        base_value = self.evaluate(field_access.base_handle).as_type(QuantumSymbol)
+        fields = base_value.fields
+        field_name = field_access.field
+        if field_name not in fields:
+            raise ClassiqExpansionError(
+                f"Struct {base_value.quantum_type.type_name} has no field "
+                f"{field_name!r}. Available fields: {', '.join(fields.keys())}"
+            )
+        return Evaluated(value=fields[field_name])
 
     @abstractmethod
     def emit(self, statement: QuantumStatement) -> None:
@@ -251,8 +258,10 @@ class BaseInterpreter:
                 (func_def := self._expanded_functions.get(operation.closure_id))
                 is not None
             ):
-                captured_vars = self._top_level_scope[func_def.name].value.captured_vars
-                operation.captured_vars.update(captured_vars)
+                cached_closure = self._top_level_scope[func_def.name].value
+                operation.captured_vars.set(
+                    cached_closure.captured_vars, cached_closure, operation
+                )
             else:
                 self._expand_body(operation)
 

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,
@@ -101,15 +114,16 @@ class GenerativeInterpreter(BaseInterpreter):
             closure_class = FunctionClosure
             extra_args = {}
 
+        closure = closure_class.create(
+            name=func_decl.name,
+            positional_arg_declarations=func_decl.positional_arg_declarations,
+            body=function.body,
+            scope=Scope(parent=self._builder.current_scope),
+            lambda_external_vars=self._builder.current_block.captured_vars,
+            **extra_args,
+        )
         return Evaluated(
-            value=closure_class.create(
-                name=func_decl.name,
-                positional_arg_declarations=func_decl.positional_arg_declarations,
-                body=function.body,
-                scope=Scope(parent=self._builder.current_scope),
-                is_lambda=True,
-                **extra_args,
-            ),
+            value=closure,
             defining_function=self._builder.current_function,
         )
 
@@ -133,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
@@ -156,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,8 +12,7 @@ from classiq.model_expansions.scope import QuantumSymbol
 
 
 class AllocateEmitter(Emitter[Allocate]):
-    def emit(self, allocate: Allocate, /) -> None:
-        self._register_debug_info(allocate)
+    def emit(self, allocate: Allocate, /) -> bool:
         target: QuantumSymbol = self._interpreter.evaluate(allocate.target).as_type(
             QuantumSymbol
         )
@@ -25,9 +24,15 @@ class AllocateEmitter(Emitter[Allocate]):
 
         size = self._get_var_size(target, allocate.size)
         allocate = allocate.model_copy(
-            update=dict(size=Expression(expr=str(size)), target=target.handle)
+            update=dict(
+                size=Expression(expr=str(size)),
+                target=target.handle,
+                back_ref=allocate.uuid,
+            )
         )
+        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:
@@ -66,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

@@ -1,4 +1,7 @@
-from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
 from classiq.interface.model.bind_operation import BindOperation
 
 from classiq.model_expansions.evaluators.parameter_types import (
@@ -9,21 +12,12 @@ from classiq.model_expansions.evaluators.quantum_type_utils import (
     validate_bind_targets,
 )
 from classiq.model_expansions.quantum_operations.emitter import Emitter
-from classiq.model_expansions.scope import QuantumSymbol
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol
 
 
 class BindEmitter(Emitter[BindOperation]):
-    def emit(self, bind: BindOperation, /) -> None:
-        inputs: list[QuantumSymbol] = [
-            self._interpreter.evaluate(arg).as_type(QuantumSymbol)
-            for arg in bind.in_handles
-        ]
-        outputs: list[QuantumSymbol] = [
-            self._interpreter.evaluate(arg).as_type(QuantumSymbol)
-            for arg in bind.out_handles
-        ]
-        inputs = evaluate_types_in_quantum_symbols(inputs, self._current_scope)
-        outputs = evaluate_types_in_quantum_symbols(outputs, self._current_scope)
+    def emit(self, bind: BindOperation, /) -> bool:
+        inputs, outputs = self._get_inputs_outputs(bind)
         validate_bind_targets(bind, self._current_scope)
         unsized_outputs = [
             output for output in outputs if not output.quantum_type.has_size_in_bits
@@ -56,5 +50,64 @@ class BindEmitter(Emitter[BindOperation]):
                 )
 
         self.emit_statement(
-            BindOperation(in_handles=bind.in_handles, out_handles=bind.out_handles)
+            BindOperation(
+                in_handles=bind.in_handles,
+                out_handles=bind.out_handles,
+                back_ref=bind.uuid,
+            )
         )
+        return True
+
+    def _get_inputs_outputs(
+        self, bind: BindOperation
+    ) -> tuple[list[QuantumSymbol], list[QuantumSymbol]]:
+        evaluated_inputs: list[Evaluated] = [
+            self._interpreter.evaluate(arg) for arg in bind.in_handles
+        ]
+        evaluated_outputs: list[Evaluated] = [
+            self._interpreter.evaluate(arg) for arg in bind.out_handles
+        ]
+        self._validate_handle_states(evaluated_inputs, evaluated_outputs)
+        inputs: list[QuantumSymbol] = [
+            input.as_type(QuantumSymbol) for input in evaluated_inputs
+        ]
+        outputs: list[QuantumSymbol] = [
+            output.as_type(QuantumSymbol) for output in evaluated_outputs
+        ]
+        inputs = evaluate_types_in_quantum_symbols(inputs, self._current_scope)
+        outputs = evaluate_types_in_quantum_symbols(outputs, self._current_scope)
+        return inputs, outputs
+
+    def _validate_handle_states(
+        self, inputs: list[Evaluated], outputs: list[Evaluated]
+    ) -> None:
+        input_var_names: set[str] = set()
+        for inp in inputs:
+            if inp.defining_function is None:
+                raise ClassiqInternalExpansionError
+            var_name = inp.value.handle.name
+            input_var_names.add(var_name)
+            state = self._builder.current_block.captured_vars.get_state(
+                var_name, inp.defining_function
+            )
+            if not state:
+                raise ClassiqExpansionError(
+                    f"Cannot use uninitialized quantum variable "
+                    f"{inp.value.handle.name!r} on the left-hand side of a bind "
+                    f"statement"
+                )
+        for out in outputs:
+            if out.defining_function is None:
+                raise ClassiqInternalExpansionError
+            var_name = out.value.handle.name
+            if var_name in input_var_names:
+                continue
+            state = self._builder.current_block.captured_vars.get_state(
+                var_name, out.defining_function
+            )
+            if state:
+                raise ClassiqExpansionError(
+                    f"Cannot use initialized quantum variable "
+                    f"{out.value.handle.name!r} on the right-hand side of a bind "
+                    f"statement"
+                )