classiq 0.45.1__py3-none-any.whl → 0.46.1__py3-none-any.whl

classiq/model_expansions/function_builder.py

@@ -0,0 +1,192 @@
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from typing import Dict, Generic, Iterable, Iterator, List, Optional, Sequence, TypeVar
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.compiler_keywords import (
+    EXPANDED_KEYWORD,
+    LAMBDA_KEYWORD,
+)
+from classiq.interface.generator.functions.builtins.internal_operators import (
+    WITHIN_APPLY_NAME,
+)
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.model import MAIN_FUNCTION_NAME
+from classiq.interface.model.native_function_definition import (
+    NativeFunctionDefinition,
+)
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_declaration import (
+    PositionalArg,
+)
+from classiq.interface.model.quantum_statement import QuantumStatement
+
+from classiq.model_expansions.capturing.captured_var_manager import update_captured_vars
+from classiq.model_expansions.capturing.mangling_utils import demangle_name
+from classiq.model_expansions.closure import Closure, FunctionClosure
+
+ClosureType = TypeVar("ClosureType", bound=Closure)
+
+
+@dataclass
+class Block:
+    statements: List[QuantumStatement] = field(default_factory=list)
+    captured_vars: List[PortDeclaration] = field(default_factory=list)
+
+
+@dataclass
+class OperationContext(Generic[ClosureType]):
+    closure: ClosureType
+    blocks: Dict[str, Block] = field(default_factory=dict)
+
+    @property
+    def name(self) -> str:
+        return self.closure.name
+
+    @property
+    def positional_arg_declarations(self) -> Sequence[PositionalArg]:
+        return self.closure.positional_arg_declarations
+
+    def statements(self, block_name: str) -> List[QuantumStatement]:
+        return self.blocks[block_name].statements
+
+
+@dataclass
+class FunctionContext(OperationContext[FunctionClosure]):
+    @classmethod
+    def create(cls, original_function: FunctionClosure) -> "FunctionContext":
+        return cls(original_function, {"body": Block()})
+
+    @property
+    def body(self) -> List[QuantumStatement]:
+        return self.statements("body")
+
+    @property
+    def captured_vars(self) -> List[PortDeclaration]:
+        return self.blocks["body"].captured_vars
+
+    @property
+    def is_lambda(self) -> bool:
+        return self.closure.is_lambda
+
+
+class OperationBuilder:
+    def __init__(self) -> None:
+        self._operations: List[OperationContext] = []
+        self._blocks: List[str] = []
+        self._counter = 0
+
+    @property
+    def current_operation(self) -> Closure:
+        return self._operations[-1].closure
+
+    @property
+    def current_function(self) -> FunctionClosure:
+        for operation in reversed(self._operations):
+            if isinstance(operation.closure, FunctionClosure):
+                return operation.closure
+        raise ClassiqInternalExpansionError("No function found")
+
+    @property
+    def _current_statements(self) -> List[QuantumStatement]:
+        return self._operations[-1].blocks[self._blocks[-1]].statements
+
+    def emit_statement(self, statement: QuantumStatement) -> None:
+        self._current_statements.append(statement)
+
+    @property
+    def current_statement(self) -> QuantumStatement:
+        return self._current_statements[-1]
+
+    def add_captured_vars(self, captured_vars: Iterable[PortDeclaration]) -> None:
+        self._operations[-1].blocks[self._blocks[-1]].captured_vars.extend(
+            captured_vars
+        )
+
+    @contextmanager
+    def block_context(self, block_name: str) -> Iterator[None]:
+        self._blocks.append(block_name)
+        self._operations[-1].blocks[block_name] = Block()
+        yield
+        self._blocks.pop()
+
+    @contextmanager
+    def operation_context(
+        self, original_operation: Closure
+    ) -> Iterator[OperationContext]:
+        context: OperationContext
+        if isinstance(original_operation, FunctionClosure):
+            context = FunctionContext.create(original_operation)
+        else:
+            context = OperationContext(closure=original_operation)
+        self._operations.append(context)
+        yield context
+        self._update_captured_vars()
+        self._operations.pop()
+
+    def _update_captured_vars(self) -> None:
+        for block in self._operations[-1].blocks.values():
+            block.captured_vars = update_captured_vars(block.captured_vars)
+            if not self._is_within_apply_context():
+                validate_captured_vars(block.captured_vars)
+
+    def is_compute_context(self) -> bool:
+        return self._is_within_apply_context("within")
+
+    def _is_within_apply_context(self, block_name: Optional[str] = None) -> bool:
+        return self._is_op_within_apply_context(block_name, -1) or (
+            len(self._operations) > 1
+            and isinstance(self._operations[-1], FunctionContext)
+            and self._is_op_within_apply_context(block_name, -2)
+        )
+
+    def _is_op_within_apply_context(
+        self, block_name: Optional[str], index: int
+    ) -> bool:
+        return self._operations[index].name == WITHIN_APPLY_NAME and (
+            block_name is None or self._blocks[index] == block_name
+        )
+
+    def create_definition(
+        self, function_context: FunctionContext
+    ) -> NativeFunctionDefinition:
+        name = function_context.name
+        if name != MAIN_FUNCTION_NAME:
+            name = f"{name}_{LAMBDA_KEYWORD + '_0_0_' if function_context.is_lambda else ''}{EXPANDED_KEYWORD}_{self._counter}"
+            self._counter += 1
+
+        new_parameters: List[PortDeclaration] = [
+            param
+            for param in function_context.positional_arg_declarations
+            if isinstance(param, PortDeclaration)
+        ] + function_context.captured_vars
+
+        return NativeFunctionDefinition(
+            name=name,
+            body=function_context.body,
+            positional_arg_declarations=new_parameters,
+        )
+
+
+def validate_captured_vars(captured_vars: List[PortDeclaration]) -> None:
+    if input_captured := [
+        demangle_name(var.name)
+        for var in captured_vars
+        if var.direction is PortDeclarationDirection.Input
+    ]:
+        raise ClassiqExpansionError(
+            f"Captured quantum variables {input_captured!r} cannot be used as inputs"
+        )
+    if output_captured := [
+        demangle_name(var.name)
+        for var in captured_vars
+        if var.direction is PortDeclarationDirection.Output
+    ]:
+        raise ClassiqExpansionError(
+            f"Captured quantum variables {output_captured!r} cannot be used as outputs"
+        )

classiq/model_expansions/generative_functions.py

@@ -0,0 +1,101 @@
+from typing import TYPE_CHECKING, Any, List
+
+from classiq.interface.generator.expressions.qmod_struct_instance import (
+    QmodStructInstance,
+)
+from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_declaration import (
+    PositionalArg,
+    QuantumFunctionDeclaration,
+    QuantumOperandDeclaration,
+)
+from classiq.interface.model.quantum_statement import QuantumStatement
+
+from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+from classiq.qmod.generative import generative_mode_context, set_frontend_interpreter
+from classiq.qmod.model_state_container import QMODULE
+from classiq.qmod.qmod_parameter import CParamStruct
+from classiq.qmod.qmod_variable import get_qvar
+from classiq.qmod.quantum_callable import QCallable
+from classiq.qmod.quantum_expandable import QExpandable, QTerminalCallable
+from classiq.qmod.quantum_function import QFunc
+from classiq.qmod.semantics.static_semantics_visitor import resolve_function_calls
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreter import Interpreter
+
+
+def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated) -> Any:
+    if isinstance(param, PortDeclaration):
+        quantum_symbol = evaluated.as_type(QuantumSymbol)
+        return get_qvar(quantum_symbol.quantum_type, quantum_symbol.handle)
+    if isinstance(param, QuantumOperandDeclaration):
+        if param.is_list:
+            func_list: List[FunctionClosure] = evaluated.as_type(list)
+            return [
+                QTerminalCallable(
+                    QuantumFunctionDeclaration(
+                        name=param.name,
+                        positional_arg_declarations=param.positional_arg_declarations,
+                    ),
+                    index_=idx,
+                )
+                for idx, func in enumerate(func_list)
+            ]
+        else:
+            func = evaluated.as_type(FunctionClosure)
+            return QTerminalCallable(
+                QuantumFunctionDeclaration(
+                    name=param.name if func.is_lambda else func.name,
+                    positional_arg_declarations=func.positional_arg_declarations,
+                ),
+            )
+    classical_value = evaluated.value
+    if isinstance(classical_value, QmodStructInstance):
+        return CParamStruct(
+            expr=param.name,
+            struct_type=Struct(name=classical_value.struct_declaration.name),
+            qmodule=QMODULE,
+        )
+    return classical_value
+
+
+class _InterpreterExpandable(QFunc):
+    def __init__(self, interpreter: "Interpreter"):
+        super().__init__(lambda: None)
+        self._interpreter = interpreter
+
+    def append_statement_to_body(self, stmt: QuantumStatement) -> None:
+        current_function = self._interpreter._builder.current_function
+        dummy_function = NativeFunctionDefinition(
+            name=current_function.name,
+            positional_arg_declarations=current_function.positional_arg_declarations,
+            body=self._interpreter._builder._current_statements + [stmt],
+        )
+        resolve_function_calls(
+            dummy_function,
+            nameables_to_dict(self._interpreter._get_function_declarations()),
+        )
+        stmt = dummy_function.body[-1]
+        self._interpreter.emit_statement(stmt)
+
+
+def emit_generative_statements(
+    interpreter: "Interpreter",
+    operation: GenerativeFunctionClosure,
+    args: List[Evaluated],
+) -> None:
+    python_qmod_args = [
+        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)
+    with interpreter._builder.block_context("body"), generative_mode_context(True):
+        operation.generative_function._py_callable(*python_qmod_args)

classiq/model_expansions/interpreter.py

@@ -0,0 +1,365 @@
+import copy
+from contextlib import contextmanager, nullcontext
+from functools import singledispatchmethod
+from typing import Any, Iterator, List, Optional, Sequence, Tuple, Type, cast
+
+import numpy as np
+from numpy.random import permutation
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.expression import Expression
+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.handle_binding import (
+    FieldHandleBinding,
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
+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.power import Power
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumAssignmentOperation,
+)
+from classiq.interface.model.quantum_function_call import (
+    OperandIdentifier,
+    QuantumFunctionCall,
+)
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+    QuantumFunctionDeclaration,
+)
+from classiq.interface.model.quantum_lambda_function import 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.capturing.propagated_var_stack import PropagatedVarStack
+from classiq.model_expansions.closure import (
+    Closure,
+    FunctionClosure,
+    GenerativeFunctionClosure,
+)
+from classiq.model_expansions.debug_flag import debug_mode
+from classiq.model_expansions.evaluators.classical_expression import (
+    evaluate_classical_expression,
+)
+from classiq.model_expansions.expression_renamer import ExpressionRenamer
+from classiq.model_expansions.function_builder import (
+    FunctionContext,
+    OperationBuilder,
+    OperationContext,
+)
+from classiq.model_expansions.generative_functions import emit_generative_statements
+from classiq.model_expansions.quantum_operations import (
+    BindEmitter,
+    ClassicalIfEmitter,
+    ControlEmitter,
+    InplaceBinaryOperationEmitter,
+    InvertEmitter,
+    PowerEmitter,
+    QuantumAssignmentOperationEmitter,
+    QuantumFunctionCallEmitter,
+    RepeatEmitter,
+    VariableDeclarationStatementEmitter,
+    WithinApplyEmitter,
+)
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.model_expansions.scope_initialization import (
+    add_entry_point_params_to_scope,
+    get_main_renamer,
+    init_top_level_scope,
+)
+from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
+from classiq.qmod.builtins.functions import permute
+from classiq.qmod.generative import is_generative_mode
+from classiq.qmod.quantum_function import GenerativeQFunc
+from classiq.qmod.semantics.error_manager import ErrorManager
+
+STATEMENT_TYPES_FOR_SOURCE_REFERENCE_PROPAGATION: Tuple[Type[QuantumStatement], ...] = (
+    QuantumFunctionCall,
+    VariableDeclarationStatement,
+    QuantumAssignmentOperation,
+)
+
+
+class Interpreter:
+    def __init__(
+        self, model: Model, generative_functions: Optional[List[GenerativeQFunc]] = None
+    ) -> None:
+        self._model = model
+        self._current_scope = Scope()
+        self._builder = OperationBuilder()
+        self._expanded_functions: List[NativeFunctionDefinition] = []
+        self._propagated_var_stack = PropagatedVarStack(
+            self._current_scope, self._builder
+        )
+
+        self._main_renamer: ExpressionRenamer = get_main_renamer(self._model.functions)
+
+        if generative_functions is None:
+            generative_functions = []
+        self._generative_functions = generative_functions
+        init_top_level_scope(model, generative_functions, self._current_scope)
+
+        self._counted_name_allocator = CountedNameAllocator()
+        self._error_manager: ErrorManager = ErrorManager()
+
+    @contextmanager
+    def _scope_guard(self, scope: Scope) -> Iterator[None]:
+        """This manager restores both `scope` and `self._current_scope` to their previous values."""
+        scope_data = copy.copy(scope.data)
+        prev_context_scope_data = copy.copy(self._current_scope.data)
+
+        prev_context_scope = self._current_scope
+        self._current_scope = scope
+        self._propagated_var_stack.set_scope(scope)
+        yield
+        prev_context_scope.data = prev_context_scope_data
+        self._current_scope = prev_context_scope
+        self._propagated_var_stack.set_scope(prev_context_scope)
+
+        scope.data = scope_data
+
+    def _expand_main_func(self) -> None:
+        main_closure = FunctionClosure.create(
+            name=self._model.main_func.name,
+            positional_arg_declarations=self._model.main_func.positional_arg_declarations,
+            body=self._model.main_func.body,
+            scope=Scope(parent=self._current_scope),
+            expr_renamer=self._main_renamer,
+        )
+
+        add_entry_point_params_to_scope(
+            main_closure.positional_arg_declarations, main_closure
+        )
+        context = self._expand_operation(main_closure)
+        self._expanded_functions.append(
+            self._builder.create_definition(cast(FunctionContext, context))
+        )
+
+    def expand(self) -> Model:
+        try:
+            with self._error_manager.call("main"):
+                self._expand_main_func()
+        except Exception as e:
+            if isinstance(e, ClassiqInternalExpansionError) or debug_mode.get():
+                raise e
+            prefix = ""
+            if not isinstance(e, ClassiqExpansionError):
+                prefix = f"{type(e).__name__}: "
+            self._error_manager.add_error(f"{prefix}{e}")
+        finally:
+            self._error_manager.report_errors(ClassiqExpansionError)
+
+        return Model(
+            constraints=self._model.constraints,
+            preferences=self._model.preferences,
+            classical_execution_code=self._model.classical_execution_code,
+            execution_preferences=self._model.execution_preferences,
+            functions=self._expanded_functions,
+            constants=self._model.constants,
+            enums=self._model.enums,
+            types=self._model.types,
+            qstructs=self._model.qstructs,
+            debug_info=self._model.debug_info,
+        )
+
+    @singledispatchmethod
+    def evaluate(self, expression: Any) -> Evaluated:
+        raise NotImplementedError(f"Cannot evaluate {expression!r}")
+
+    @evaluate.register
+    def evaluate_classical_expression(self, expression: Expression) -> Evaluated:
+        return evaluate_classical_expression(expression, self._current_scope)
+
+    @evaluate.register
+    def evaluate_identifier(self, identifier: str) -> Evaluated:
+        return self._current_scope[identifier]
+
+    @evaluate.register
+    def evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
+        renamed_params = [
+            param.rename(function.get_rename_params()[idx])
+            for idx, param in enumerate(function.func_decl.positional_arg_declarations)
+        ]
+        func_decl = NamedParamsQuantumFunctionDeclaration(
+            name=function.func_decl.name or "<lambda>",
+            positional_arg_declarations=renamed_params,
+        )
+
+        closure_class: Type[FunctionClosure]
+        extra_args: dict[str, Any]
+        if is_generative_mode():
+            closure_class = GenerativeFunctionClosure
+            extra_args = {
+                "generative_function": 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._current_scope),
+                is_lambda=True,
+                **extra_args,
+            ),
+            defining_function=self._builder.current_function,
+        )
+
+    @evaluate.register
+    def evaluate_handle_binding(self, handle_binding: HandleBinding) -> Evaluated:
+        return self.evaluate(handle_binding.name)
+
+    @evaluate.register
+    def evaluate_sliced_handle_binding(
+        self, sliced_handle_binding: SlicedHandleBinding
+    ) -> Evaluated:
+        quantum_variable = self.evaluate(sliced_handle_binding.base_handle).as_type(
+            QuantumSymbol
+        )
+        start = self.evaluate(sliced_handle_binding.start).as_type(int)
+        end = self.evaluate(sliced_handle_binding.end).as_type(int)
+        return Evaluated(value=quantum_variable[start:end])
+
+    @evaluate.register
+    def evaluate_list(self, value: list) -> Evaluated:
+        return Evaluated(value=[self.evaluate(arg).value for arg in value])
+
+    @evaluate.register
+    def evaluate_subscript_handle(self, subscript: SubscriptHandleBinding) -> Evaluated:
+        base_value = self.evaluate(subscript.base_handle)
+        index_value = self.evaluate(subscript.index).as_type(int)
+        return Evaluated(value=base_value.value[index_value])
+
+    @evaluate.register
+    def evaluate_subscript_operand(self, subscript: OperandIdentifier) -> Evaluated:
+        base_value = self.evaluate(subscript.name)
+        index_value = self.evaluate(subscript.index).as_type(int)
+        return Evaluated(value=base_value.value[index_value])
+
+    @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])
+
+    @singledispatchmethod
+    def emit(self, statement: QuantumStatement) -> None:
+        raise NotImplementedError(f"Cannot emit {statement!r}")
+
+    @emit.register
+    def emit_quantum_function_call(self, call: QuantumFunctionCall) -> None:
+        QuantumFunctionCallEmitter(self).emit(call)
+
+    @emit.register
+    def emit_bind(self, bind: BindOperation) -> None:
+        BindEmitter(self).emit(bind)
+
+    @emit.register
+    def emit_quantum_assignment_operation(self, op: QuantumAssignmentOperation) -> None:
+        QuantumAssignmentOperationEmitter(self).emit(op)
+
+    @emit.register
+    def emit_inplace_binary_operation(self, operation: InplaceBinaryOperation) -> None:
+        InplaceBinaryOperationEmitter(self).emit(operation)
+
+    @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:
+        WithinApplyEmitter(self).emit(within_apply)
+
+    @emit.register
+    def emit_invert(self, invert: Invert) -> None:
+        InvertEmitter(self).emit(invert)
+
+    @emit.register
+    def emit_repeat(self, repeat: Repeat) -> None:
+        RepeatEmitter(self).emit(repeat)
+
+    @emit.register
+    def emit_control(self, control: Control) -> None:
+        ControlEmitter(self).emit(control)
+
+    @emit.register
+    def emit_power(self, power: Power) -> None:
+        PowerEmitter(self).emit(power)
+
+    def _expand_block(self, block: Sequence[QuantumStatement], block_name: str) -> None:
+        with self._builder.block_context(block_name):
+            for statement in block:
+                self.emit_statement(statement)
+
+    def emit_statement(self, statement: QuantumStatement) -> None:
+        with (
+            self._error_manager.node_context(statement)
+            if statement.source_ref is not None
+            else nullcontext()
+        ):
+            self.emit(statement)
+        if isinstance(
+            statement,
+            STATEMENT_TYPES_FOR_SOURCE_REFERENCE_PROPAGATION,
+        ):
+            self._builder.current_statement.source_ref = statement.source_ref
+
+    def _expand_operation(self, operation: Closure) -> OperationContext:
+        with self._builder.operation_context(operation) as context:
+            if isinstance(operation, FunctionClosure) and operation.name == "permute":
+                # special expansion since permute is generative
+                with self._scope_guard(operation.scope):
+                    self._expand_permute()
+            elif isinstance(operation, GenerativeFunctionClosure):
+                with self._scope_guard(operation.scope):
+                    args = [
+                        self.evaluate(param.name)
+                        for param in operation.positional_arg_declarations
+                    ]
+                    emit_generative_statements(self, operation, args)
+            else:
+                for block, block_body in operation.blocks.items():
+                    with self._scope_guard(operation.scope):
+                        self._expand_block(block_body, block)
+
+        return context
+
+    def _expand_permute(self) -> None:
+        functions = self.evaluate("functions").as_type(list)
+        functions_permutation = permutation(np.array(range(len(functions))))
+        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)
+            self.emit(permute_call)
+
+    def _get_function_declarations(self) -> Sequence[QuantumFunctionDeclaration]:
+        return (
+            self._model.functions
+            + [gen_func.func_decl for gen_func in self._generative_functions]
+            + self._expanded_functions  # type:ignore[operator]
+        )