classiq 0.37.1__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -0,0 +1,249 @@
+from functools import singledispatchmethod
+from typing import Any
+
+import numpy as np
+from numpy.random import permutation
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.builtins.internal_operators import (
+    CONTROL_OPERATOR_NAME,
+    INVERT_OPERATOR_NAME,
+    WITHIN_APPLY_NAME,
+)
+from classiq.interface.model.allocate import Allocate
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.classical_if import ClassicalIf
+from classiq.interface.model.control import Control
+from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
+from classiq.interface.model.invert import Invert
+from classiq.interface.model.model import Model
+from classiq.interface.model.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_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+)
+from classiq.interface.model.quantum_lambda_function import (
+    OperandIdentifier,
+    QuantumLambdaFunction,
+)
+from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.interface.model.repeat import Repeat
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+from classiq.interface.model.within_apply_operation import WithinApply
+
+from classiq.model_expansions.closure import (
+    Closure,
+    FunctionClosure,
+    GenerativeClosure,
+    GenerativeFunctionClosure,
+)
+from classiq.model_expansions.generative_functions import emit_generative_statements
+from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+from classiq.model_expansions.quantum_operations import (
+    BindEmitter,
+    ClassicalIfEmitter,
+    QuantumFunctionCallEmitter,
+    RepeatEmitter,
+    VariableDeclarationStatementEmitter,
+)
+from classiq.model_expansions.quantum_operations.shallow_emitter import ShallowEmitter
+from classiq.model_expansions.scope import Evaluated, Scope
+from classiq.model_expansions.scope_initialization import (
+    add_functions_to_scope,
+    add_generative_functions_to_scope,
+)
+from classiq.qmod.builtins.functions import permute
+from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
+from classiq.qmod.quantum_function import GenerativeQFunc
+
+
+class GenerativeInterpreter(BaseInterpreter):
+    def __init__(
+        self,
+        model: Model,
+        generative_functions: list[GenerativeQFunc],
+    ) -> None:
+        super().__init__(model)
+        add_generative_functions_to_scope(generative_functions, self._top_level_scope)
+
+    def evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
+        renamed_params = [
+            param.rename(function.pos_rename_params[idx])
+            for idx, param in enumerate(function.func_decl.positional_arg_declarations)
+        ]
+        func_decl = NamedParamsQuantumFunctionDeclaration(
+            name=self._counted_name_allocator.allocate(
+                function.func_decl.name or "<lambda>"
+            ),
+            positional_arg_declarations=renamed_params,
+        )
+
+        closure_class: type[FunctionClosure]
+        extra_args: dict[str, Any]
+        if function.is_generative():
+            closure_class = GenerativeFunctionClosure
+            extra_args = {
+                "generative_blocks": {
+                    "body": GenerativeQFunc(function.py_callable, func_decl),
+                }
+            }
+        else:
+            closure_class = FunctionClosure
+            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,
+            ),
+            defining_function=self._builder.current_function,
+        )
+
+    @singledispatchmethod
+    def emit(self, statement: QuantumStatement) -> None:  # type:ignore[override]
+        raise NotImplementedError(f"Cannot emit {statement!r}")
+
+    @emit.register
+    def _emit_quantum_function_call(self, call: QuantumFunctionCall) -> None:
+        self.emit_quantum_function_call(call)
+
+    def emit_quantum_function_call(self, call: QuantumFunctionCall) -> None:
+        QuantumFunctionCallEmitter(self).emit(call)
+
+    @emit.register
+    def emit_allocate(self, allocate: Allocate) -> None:
+        ShallowEmitter(self, "allocate", components=["size", "target"]).emit(allocate)
+
+    @emit.register
+    def emit_bind(self, bind: BindOperation) -> None:
+        BindEmitter(self).emit(bind)
+
+    @emit.register
+    def emit_quantum_assignment_operation(self, op: QuantumAssignmentOperation) -> None:
+        ShallowEmitter(
+            self, "assignment_operation", components=["expression", "result_var"]
+        ).emit(op)
+
+    @emit.register
+    def emit_inplace_binary_operation(self, op: InplaceBinaryOperation) -> None:
+        ShallowEmitter(
+            self, "inplace_binary_operation", components=["target", "value"]
+        ).emit(op)
+
+    @emit.register
+    def emit_variable_declaration(
+        self, variable_declaration: VariableDeclarationStatement
+    ) -> None:
+        VariableDeclarationStatementEmitter(self).emit(variable_declaration)
+
+    @emit.register
+    def emit_classical_if(self, classical_if: ClassicalIf) -> None:
+        ClassicalIfEmitter(self).emit(classical_if)
+
+    @emit.register
+    def emit_within_apply(self, within_apply: WithinApply) -> None:
+        ShallowEmitter(
+            self,
+            WITHIN_APPLY_NAME,
+            components=["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)
+
+    @emit.register
+    def emit_repeat(self, repeat: Repeat) -> None:
+        RepeatEmitter(self).emit(repeat)
+
+    @emit.register
+    def emit_control(self, control: Control) -> None:
+        ShallowEmitter(
+            self,
+            CONTROL_OPERATOR_NAME,
+            components=["expression", "body", "else_block"],
+        ).emit(control)
+
+    @emit.register
+    def emit_power(self, power: Power) -> None:
+        ShallowEmitter(self, CONTROL_OPERATOR_NAME, components=["power", "body"]).emit(
+            power
+        )
+
+    @emit.register
+    def emit_phase(self, phase: PhaseOperation) -> None:
+        ShallowEmitter(self, "phase", components=["expression", "theta"]).emit(phase)
+
+    def _expand_body(self, operation: Closure) -> None:
+        if isinstance(operation, FunctionClosure) and operation.name == "permute":
+            # special expansion since permute is generative
+            self._expand_permute()
+        elif isinstance(operation, GenerativeClosure):
+            args = [
+                self.evaluate(param.name)
+                for param in operation.positional_arg_declarations
+            ]
+            emit_generative_statements(self, operation, args)
+        else:
+            super()._expand_body(operation)
+
+    def _expand_permute(self) -> None:
+        functions = self.evaluate("functions").as_type(list)
+        functions_permutation = permutation(np.array(range(len(functions))))
+        calls: list[QuantumFunctionCall] = []
+        for function_index in functions_permutation:
+            permute_call = QuantumFunctionCall(
+                function=OperandIdentifier(
+                    name="functions", index=Expression(expr=f"{function_index}")
+                )
+            )
+            permute_call.set_func_decl(permute.func_decl)
+            calls.append(permute_call)
+        self._expand_block(calls, "body")
+
+    def update_generative_functions(
+        self, generative_functions: dict[str, GenerativeQFunc]
+    ) -> None:
+        add_generative_functions_to_scope(
+            list(generative_functions.values()), self._top_level_scope
+        )
+        for name, gen_func in generative_functions.items():
+            if gen_func.compilation_metadata is not None:
+                self._functions_compilation_metadata[name] = (
+                    gen_func.compilation_metadata
+                )
+
+    def update_declarative_functions(
+        self,
+        functions: dict[str, NativeFunctionDefinition],
+        qmodule: ModelStateContainer,
+    ) -> None:
+        add_functions_to_scope(list(functions.values()), self._top_level_scope)
+        for dec_func_name in functions:
+            if dec_func_name in qmodule.functions_compilation_metadata:
+                self._functions_compilation_metadata[dec_func_name] = (
+                    qmodule.functions_compilation_metadata[dec_func_name]
+                )
+
+    def add_purely_declarative_function(self, function: FunctionClosure) -> None:
+        functions_to_add = [function.name] + QMODULE.function_dependencies[
+            function.name
+        ]
+        for func in functions_to_add:
+            if func not in self._expanded_functions and func in QMODULE.native_defs:
+                self._expanded_functions[func] = QMODULE.native_defs[func]
+                if func in QMODULE.functions_compilation_metadata:
+                    self._expanded_functions_compilation_metadata[func] = (
+                        QMODULE.functions_compilation_metadata[func]
+                    )

classiq/model_expansions/model_tables.py

@@ -0,0 +1,18 @@
+from typing import Optional
+
+from classiq.interface.generator.expressions.handle_identifier import HandleIdentifier
+from classiq.interface.generator.functions.classical_type import QmodPyObject
+
+
+class HandleTable:
+    _handle_map: dict[HandleIdentifier, QmodPyObject] = {}
+
+    @classmethod
+    def get_handle_object(cls, hid: HandleIdentifier) -> Optional[QmodPyObject]:
+        return cls._handle_map.get(hid)
+
+    @classmethod
+    def set_handle_object(cls, qmod_object: QmodPyObject) -> HandleIdentifier:
+        hid = HandleIdentifier(id(qmod_object))
+        cls._handle_map[hid] = qmod_object
+        return hid

classiq/model_expansions/quantum_operations/__init__.py

@@ -0,0 +1,9 @@
+from classiq.model_expansions.quantum_operations.bind import BindEmitter
+from classiq.model_expansions.quantum_operations.classicalif import ClassicalIfEmitter
+from classiq.model_expansions.quantum_operations.quantum_function_call import (
+    QuantumFunctionCallEmitter,
+)
+from classiq.model_expansions.quantum_operations.repeat import RepeatEmitter
+from classiq.model_expansions.quantum_operations.variable_decleration import (
+    VariableDeclarationStatementEmitter,
+)

classiq/model_expansions/quantum_operations/bind.py

@@ -0,0 +1,60 @@
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.model.bind_operation import BindOperation
+
+from classiq.model_expansions.evaluators.parameter_types import (
+    evaluate_types_in_quantum_symbols,
+)
+from classiq.model_expansions.evaluators.quantum_type_utils import (
+    set_size,
+    validate_bind_targets,
+)
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import 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)
+        validate_bind_targets(bind, self._current_scope)
+        unsized_outputs = [
+            output for output in outputs if not output.quantum_type.has_size_in_bits
+        ]
+
+        if len(unsized_outputs) > 1:
+            raise ClassiqExpansionError(
+                f"Cannot perform the split operation {bind.in_handles[0].name} -> {{{', '.join(out_handle.name for out_handle in bind.out_handles)}}}:\n"
+                f"Quantum variables {', '.join(str(out_handle.handle) for out_handle in unsized_outputs)} are used as bind outputs, but their size cannot be inferred."
+            )
+
+        input_size = sum(input.quantum_type.size_in_bits for input in inputs)
+        output_size = sum(
+            output.quantum_type.size_in_bits
+            for output in outputs
+            if output.quantum_type.has_size_in_bits
+        )
+
+        if len(unsized_outputs) == 1:
+            set_size(
+                unsized_outputs[0].quantum_type,
+                input_size - output_size,
+                str(unsized_outputs[0].handle),
+            )
+
+        else:
+            if input_size != output_size:
+                raise ClassiqExpansionError(
+                    f"The total size for the input and output of the bind operation must be the same. The in size is {input_size} and the out size is {output_size}"
+                )
+
+        self.emit_statement(
+            BindOperation(in_handles=bind.in_handles, out_handles=bind.out_handles)
+        )

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -0,0 +1,266 @@
+from collections.abc import Sequence
+from itertools import chain
+from typing import (
+    TYPE_CHECKING,
+    Generic,
+    Optional,
+    cast,
+)
+
+from classiq.interface.debug_info.debug_info import FunctionDebugInfo
+from classiq.interface.generator.generated_circuit_data import OperationLevel
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_call import ArgValue, QuantumFunctionCall
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+    PositionalArg,
+)
+from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+
+from classiq.model_expansions.capturing.captured_vars import (
+    validate_args_are_not_propagated,
+)
+from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.evaluators.argument_types import (
+    add_information_from_output_arguments,
+)
+from classiq.model_expansions.evaluators.parameter_types import (
+    evaluate_parameter_types_from_args,
+)
+from classiq.model_expansions.function_builder import (
+    FunctionContext,
+)
+from classiq.model_expansions.quantum_operations.emitter import (
+    Emitter,
+    QuantumStatementT,
+)
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.model_expansions.transformers.var_splitter import VarSplitter
+from classiq.qmod.builtins.functions import allocate, free
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
+
+class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSplitter):
+    def __init__(self, interpreter: "BaseInterpreter") -> None:
+        Emitter.__init__(self, interpreter)
+        VarSplitter.__init__(self, interpreter._builder.current_scope)
+
+    @staticmethod
+    def _should_wrap(body: Sequence[QuantumStatement]) -> bool:
+        # This protects shadowing of captured variables (i.e, bad user code) by wrapping the body in a function
+        # I'm sure there are better ways to handle it, but this is the simplest way to do it for now
+        return any(isinstance(stmt, VariableDeclarationStatement) for stmt in body)
+
+    def _create_expanded_wrapping_function(
+        self, name: str, body: Sequence[QuantumStatement]
+    ) -> QuantumFunctionCall:
+        wrapping_function = FunctionClosure.create(
+            name=self._counted_name_allocator.allocate(name),
+            body=body,
+            scope=Scope(parent=self._current_scope),
+            is_lambda=True,
+        )
+        return self._create_quantum_function_call(wrapping_function, list())
+
+    def _emit_quantum_function_call(
+        self,
+        function: FunctionClosure,
+        args: list[ArgValue],
+        propagated_debug_info: Optional[FunctionDebugInfo] = None,
+    ) -> QuantumFunctionCall:
+        call = self._create_quantum_function_call(
+            function, args, propagated_debug_info=propagated_debug_info
+        )
+        self.emit_statement(call)
+        return call
+
+    def _create_quantum_function_call(
+        self,
+        function: FunctionClosure,
+        args: list[ArgValue],
+        propagated_debug_info: Optional[FunctionDebugInfo] = None,
+    ) -> QuantumFunctionCall:
+        function = function.clone()
+        function = function.set_depth(self._builder.current_function.depth + 1)
+        evaluated_args = [self._interpreter.evaluate(arg) for arg in args]
+        new_declaration = self._prepare_fully_typed_declaration(
+            function, evaluated_args
+        )
+        new_positional_arg_decls = new_declaration.positional_arg_declarations
+        if not self.should_expand_function(function, evaluated_args):
+            is_atomic = True
+            new_declaration = self._expanded_functions_by_name.get(
+                function.name, new_declaration
+            )
+        else:
+            is_atomic = False
+            new_declaration = self._expand_function(
+                evaluated_args, new_declaration, function
+            )
+
+        new_positional_args = self._get_new_positional_args(
+            evaluated_args, is_atomic, new_positional_arg_decls
+        )
+        captured_args = function.captured_vars.get_captured_args(
+            self._builder.current_function
+        )
+        validate_args_are_not_propagated(new_positional_args, captured_args)
+        new_positional_args.extend(captured_args)
+        new_call = QuantumFunctionCall(
+            function=new_declaration.name, positional_args=new_positional_args
+        )
+        is_allocate_or_free = (
+            new_call.func_name == allocate.func_decl.name
+            or new_call.func_name == free.func_decl.name
+        )
+        parameters = {
+            arg_decl.name: FunctionDebugInfo.param_controller(value=evaluated_arg.value)
+            for arg_decl, evaluated_arg in zip(new_positional_arg_decls, evaluated_args)
+            if isinstance(arg_decl, ClassicalParameterDeclaration)
+        }
+
+        port_to_passed_variable_map = {
+            arg_decl.name: str(evaluated_arg.value.handle)
+            for arg_decl, evaluated_arg in zip(new_positional_arg_decls, evaluated_args)
+            if isinstance(arg_decl, PortDeclaration)
+        }
+        self._debug_info[new_call.uuid] = FunctionDebugInfo(
+            name=new_call.func_name,
+            level=OperationLevel.QMOD_FUNCTION_CALL,
+            parameters=(
+                parameters
+                if propagated_debug_info is None
+                else propagated_debug_info.parameters
+            ),
+            is_allocate_or_free=is_allocate_or_free,
+            port_to_passed_variable_map=port_to_passed_variable_map,
+        )
+        new_call.set_func_decl(new_declaration)
+        return new_call
+
+    def should_expand_function(
+        self, function: FunctionClosure, args: list[Evaluated]
+    ) -> bool:
+        return not function.is_atomic
+
+    def _expand_function(
+        self,
+        args: list[Evaluated],
+        decl: NamedParamsQuantumFunctionDeclaration,
+        function: FunctionClosure,
+    ) -> NamedParamsQuantumFunctionDeclaration:
+        self._add_params_to_scope(decl.positional_arg_declarations, args, function)
+        context = self._expand_operation(function.with_new_declaration(decl))
+        function_context = cast(FunctionContext, context)
+        closure_id = function_context.closure.closure_id
+        if closure_id in self._expanded_functions:
+            function_def = self._expanded_functions[closure_id]
+            self._expanded_functions_compilation_metadata[
+                function_def.name
+            ].occurrences_number += 1
+            return function_def
+
+        function_def = self._create_function_definition(function_context)
+        self._expanded_functions[closure_id] = function_def
+        self._top_level_scope[function_def.name] = Evaluated(
+            value=function_context.closure.with_new_declaration(function_def)
+        )
+        compilation_metadata = self._functions_compilation_metadata.get(function.name)
+        if compilation_metadata is not None:
+            self._expanded_functions_compilation_metadata[function_def.name] = (
+                compilation_metadata
+            )
+        return function_def
+
+    def _create_function_definition(
+        self, function_context: FunctionContext
+    ) -> NativeFunctionDefinition:
+        func_def = self._builder.create_definition(function_context)
+
+        captured_ports = function_context.closure.captured_vars.get_captured_ports()
+        if len(captured_ports) == 0:
+            return func_def
+        func_def.positional_arg_declarations = list(
+            chain.from_iterable((func_def.positional_arg_declarations, captured_ports))
+        )
+
+        if not function_context.is_lambda:
+            return func_def
+        func_def.body = self.rewrite(
+            func_def.body, function_context.closure.captured_vars.get_captured_mapping()
+        )
+
+        return func_def
+
+    @staticmethod
+    def _add_params_to_scope(
+        parameters: Sequence[PositionalArg],
+        arguments: Sequence[Evaluated],
+        closure: FunctionClosure,
+    ) -> None:
+        for parameter, argument in zip(parameters, arguments):
+            if isinstance(argument.value, QuantumSymbol):
+                assert isinstance(parameter, PortDeclaration)
+                closure.scope[parameter.name] = Evaluated(
+                    QuantumSymbol(
+                        handle=HandleBinding(name=parameter.name),
+                        quantum_type=parameter.quantum_type,
+                    ),
+                    defining_function=closure,
+                )
+            else:
+                closure.scope[parameter.name] = argument
+
+    def _get_new_positional_args(
+        self,
+        evaluated_args: list[Evaluated],
+        is_atomic: bool,
+        new_positional_arg_decls: Sequence[PositionalArg],
+    ) -> list[ArgValue]:
+        evaluated_args = add_information_from_output_arguments(
+            new_positional_arg_decls, evaluated_args
+        )
+        if is_atomic:
+            return [arg.emit() for arg in evaluated_args]
+
+        positional_args = [
+            arg.emit() for arg in evaluated_args if isinstance(arg.value, QuantumSymbol)
+        ]
+
+        return positional_args
+
+    def _prepare_fully_typed_declaration(
+        self, function: FunctionClosure, evaluated_args: list[Evaluated]
+    ) -> NamedParamsQuantumFunctionDeclaration:
+        """
+        Given, for example,
+        def my_func(x: int, q: QArray["x"], p: QArray[]) -> None:
+        ...
+        def main(...):
+            ...
+            allocate(5, s)
+            my_func(3, r, s)
+        The code below will evaluate x to be 3, q to be of size 3 and p to be of size 5.
+        Note that it requires a scope for the parameter declaration space, which is
+        different from the call scope. For example, the former uses r,s and the latter
+        uses p, q.
+        """
+        # The signature scope is passed as a separate argument to avoid contaminating the statement execution scope
+        return NamedParamsQuantumFunctionDeclaration(
+            name=function.name,
+            positional_arg_declarations=evaluate_parameter_types_from_args(
+                function,
+                function.signature_scope,
+                evaluated_args,
+            ),
+        )

classiq/model_expansions/quantum_operations/classicalif.py

@@ -0,0 +1,53 @@
+from collections.abc import Sequence
+
+from classiq.interface.model.classical_if import ClassicalIf
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_statement import QuantumStatement
+
+from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
+from classiq.model_expansions.scope import Scope
+
+
+def _is_all_identity_calls(body: Sequence[QuantumStatement]) -> bool:
+    return all(
+        isinstance(stmt, QuantumFunctionCall) and stmt.func_name.lower() == "identity"
+        for stmt in body
+    )
+
+
+class ClassicalIfEmitter(CallEmitter[ClassicalIf]):
+    def emit(self, classical_if: ClassicalIf, /) -> None:
+        condition = self._interpreter.evaluate(classical_if.condition).as_type(bool)
+        op_name = "then" if condition else "else"
+        is_generative = classical_if.is_generative()
+
+        body: Sequence[QuantumStatement]
+        if is_generative:
+            if not classical_if.has_generative_block(op_name):
+                return
+            context = self._expand_generative_context(classical_if, op_name, op_name)
+            context.blocks["body"] = context.blocks[op_name]
+            context.blocks.pop(op_name)
+            body = context.statements("body")
+        else:
+            body = classical_if.then if condition else classical_if.else_
+
+        if _is_all_identity_calls(body):
+            return
+
+        if is_generative or not self._should_wrap(body):
+            for stmt in body:
+                if is_generative:
+                    self._interpreter._builder.emit_statement(stmt)
+                else:
+                    self._interpreter.emit_statement(stmt)
+            return
+
+        then_else_func = FunctionClosure.create(
+            name=self._counted_name_allocator.allocate("then" if condition else "else"),
+            body=body,
+            scope=Scope(parent=self._current_scope),
+            is_lambda=True,
+        )
+        self._emit_quantum_function_call(then_else_func, list())