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

classiq/model_expansions/quantum_operations/declarative_call_emitter.py

@@ -0,0 +1,87 @@
+from itertools import chain
+from typing import TYPE_CHECKING, Generic
+
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.port_declaration import PortDeclaration
+
+from classiq.model_expansions.closure import FunctionClosure, GenerativeClosure
+from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
+from classiq.model_expansions.quantum_operations.emitter import QuantumStatementT
+from classiq.model_expansions.scope import Evaluated
+from classiq.qmod.model_state_container import QMODULE
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.generative_interpreter import (
+        GenerativeInterpreter,
+    )
+
+
+class DeclarativeCallEmitter(
+    Generic[QuantumStatementT], CallEmitter[QuantumStatementT]
+):
+    _interpreter: "GenerativeInterpreter"
+
+    def __init__(self, interpreter: "GenerativeInterpreter") -> None:
+        super().__init__(interpreter)
+
+    def should_expand_function(
+        self, function: FunctionClosure, args: list[Evaluated]
+    ) -> bool:
+        if not super().should_expand_function(function, args):
+            return False
+
+        if self._is_function_purely_declarative(
+            function
+        ) and self._are_args_purely_declarative(args):
+            self._interpreter.add_purely_declarative_function(function)
+            return False
+
+        return True
+
+    def _is_function_purely_declarative(self, function: FunctionClosure) -> bool:
+        if function.name not in QMODULE.native_defs:
+            return False
+
+        if isinstance(function, GenerativeClosure):
+            return False
+
+        if any(
+            not param.quantum_type.is_instantiated
+            for param in function.positional_arg_declarations
+            if isinstance(param, PortDeclaration)
+            and param.direction == PortDeclarationDirection.Output
+        ):
+            return False
+
+        dependencies = QMODULE.function_dependencies[function.name]
+        return self._are_identifiers_purely_declarative(dependencies)
+
+    def _are_args_purely_declarative(self, args: list[Evaluated]) -> bool:
+        values = [arg.value for arg in args]
+        function_inputs: list[FunctionClosure] = list(
+            chain.from_iterable(
+                (
+                    [arg]
+                    if isinstance(arg, FunctionClosure)
+                    else (
+                        arg
+                        if isinstance(arg, list)
+                        and any(isinstance(item, FunctionClosure) for item in arg)
+                        else []
+                    )
+                )
+                for arg in values
+            )
+        )
+        if any(func.is_lambda for func in function_inputs):
+            return False
+        dependencies = [func.name for func in function_inputs if not func.is_lambda]
+        return self._are_identifiers_purely_declarative(dependencies)
+
+    def _are_identifiers_purely_declarative(self, dependencies: list[str]) -> bool:
+        return not any(
+            isinstance(self._current_scope[dep].value, GenerativeClosure)
+            for dep in dependencies
+        )

classiq/model_expansions/quantum_operations/emitter.py

@@ -0,0 +1,181 @@
+import ast
+from abc import abstractmethod
+from typing import (
+    TYPE_CHECKING,
+    Generic,
+    Optional,
+    TypeVar,
+    Union,
+)
+
+import sympy
+
+from classiq.interface.debug_info.debug_info import DebugInfoCollection
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.evaluated_expression import (
+    EvaluatedExpression,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+)
+from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
+
+from classiq.model_expansions.closure import Closure, GenerativeClosure
+from classiq.model_expansions.function_builder import (
+    OperationBuilder,
+    OperationContext,
+)
+from classiq.model_expansions.scope import QuantumSymbol, Scope
+from classiq.model_expansions.sympy_conversion.sympy_to_python import (
+    translate_sympy_quantum_expression,
+)
+from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
+from classiq.model_expansions.visitors.variable_references import VarRefCollector
+from classiq.qmod.quantum_function import GenerativeQFunc
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
+QuantumStatementT = TypeVar("QuantumStatementT", bound=QuantumStatement)
+
+
+class Emitter(Generic[QuantumStatementT]):
+    def __init__(self, interpreter: "BaseInterpreter") -> None:
+        self._interpreter = interpreter
+
+        self._machine_precision = self._interpreter._model.preferences.machine_precision
+        self._expanded_functions_compilation_metadata = (
+            self._interpreter._expanded_functions_compilation_metadata
+        )
+        self._functions_compilation_metadata = (
+            self._interpreter._functions_compilation_metadata
+        )
+
+    @abstractmethod
+    def emit(self, statement: QuantumStatementT, /) -> None:
+        pass
+
+    def _expand_operation(self, closure: Closure) -> OperationContext:
+        return self._interpreter._expand_operation(closure)
+
+    @property
+    def _builder(self) -> OperationBuilder:
+        return self._interpreter._builder
+
+    @property
+    def _current_scope(self) -> Scope:
+        return self._builder.current_scope
+
+    @property
+    def _top_level_scope(self) -> Scope:
+        return self._interpreter._top_level_scope
+
+    @property
+    def _expanded_functions(self) -> dict[str, NativeFunctionDefinition]:
+        return self._interpreter._expanded_functions
+
+    @property
+    def _expanded_functions_by_name(self) -> dict[str, NativeFunctionDefinition]:
+        return nameables_to_dict(list(self._interpreter._expanded_functions.values()))
+
+    @property
+    def _counted_name_allocator(self) -> CountedNameAllocator:
+        return self._interpreter._counted_name_allocator
+
+    @property
+    def _debug_info(self) -> DebugInfoCollection:
+        return self._interpreter._model.debug_info
+
+    def _expand_generative_context(
+        self,
+        op: QuantumOperation,
+        context_name: str,
+        block_names: Union[None, str, list[str]] = None,
+        func_decl: Optional[NamedParamsQuantumFunctionDeclaration] = None,
+    ) -> OperationContext:
+        if isinstance(block_names, str):
+            block_names = [block_names]
+        block_names = block_names or ["body"]
+        func_decl = func_decl or NamedParamsQuantumFunctionDeclaration(
+            name=context_name
+        )
+        gen_closure = GenerativeClosure(
+            name=func_decl.name,
+            scope=Scope(parent=self._interpreter._builder.current_scope),
+            blocks={},
+            generative_blocks={
+                block_name: GenerativeQFunc(
+                    op.get_generative_block(block_name), func_decl
+                )
+                for block_name in block_names
+            },
+        )
+        context = self._interpreter._expand_operation(gen_closure)
+        op.clear_generative_blocks()
+        return context
+
+    def _evaluate_expression(
+        self, expression: Expression, preserve_bool_ops: bool = False
+    ) -> Expression:
+        evaluated_expression = self._interpreter.evaluate(expression)
+        if isinstance(evaluated_expression.value, sympy.Basic):
+            new_expression = Expression(
+                expr=translate_sympy_quantum_expression(
+                    evaluated_expression.value,
+                    preserve_bool_ops=preserve_bool_ops,
+                )
+            )
+        else:
+            new_expression = Expression(expr=str(evaluated_expression.value))
+        new_expression._evaluated_expr = EvaluatedExpression(
+            value=evaluated_expression.value
+        )
+        return new_expression
+
+    def emit_statement(self, statement: QuantumStatement) -> None:
+        if isinstance(statement, QuantumOperation):
+            self._update_captured_vars(statement)
+        self._builder.emit_statement(statement)
+
+    def _update_captured_vars(self, op: QuantumOperation) -> None:
+        handles = (
+            [(handle, PortDeclarationDirection.Input) for handle in op.inputs]
+            + [(handle, PortDeclarationDirection.Output) for handle in op.outputs]
+            + [(handle, PortDeclarationDirection.Inout) for handle in op.inouts]
+        )
+        for handle, direction in handles:
+            self._capture_handle(handle, direction)
+
+    def _capture_handle(
+        self, handle: HandleBinding, direction: PortDeclarationDirection
+    ) -> None:
+        if handle.name not in self._current_scope:
+            return
+        defining_function = self._current_scope[handle.name].defining_function
+        if defining_function is None:
+            raise ClassiqInternalExpansionError
+        symbol: QuantumSymbol = self._interpreter.evaluate(handle).value
+        self._builder.current_block.captured_vars.capture_handle(
+            handle=symbol.handle,
+            quantum_type=symbol.quantum_type,
+            defining_function=defining_function,
+            direction=direction,
+        )
+
+    def capture_handles_in_expression(self, expr: Expression) -> None:
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(expr.expr))
+        handles = dict.fromkeys(
+            handle
+            for handle in vrc.var_handles
+            if isinstance(self._current_scope[handle.name].value, QuantumSymbol)
+        )
+        for handle in handles:
+            self._capture_handle(handle, PortDeclarationDirection.Inout)

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -0,0 +1,33 @@
+from typing import TYPE_CHECKING
+
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+
+from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
+from classiq.model_expansions.quantum_operations.declarative_call_emitter import (
+    DeclarativeCallEmitter,
+)
+from classiq.qmod.semantics.error_manager import ErrorManager
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
+
+class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
+    def __init__(self, interpreter: "BaseInterpreter") -> None:
+        super().__init__(interpreter)
+        self._model = self._interpreter._model
+
+    def emit(self, call: QuantumFunctionCall, /) -> None:
+        function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
+        args = call.positional_args
+        with ErrorManager().call(function.name):
+            self._emit_quantum_function_call(
+                function, args, self._debug_info.get(call.uuid)
+            )
+
+
+class DeclarativeQuantumFunctionCallEmitter(
+    QuantumFunctionCallEmitter, DeclarativeCallEmitter
+):
+    pass

classiq/model_expansions/quantum_operations/repeat.py

@@ -0,0 +1,56 @@
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.builtins.internal_operators import (
+    REPEAT_OPERATOR_NAME,
+)
+from classiq.interface.generator.functions.classical_type import Integer
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
+from classiq.interface.model.repeat import Repeat
+
+from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
+from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
+from classiq.model_expansions.scope import Scope
+from classiq.qmod.quantum_function import GenerativeQFunc
+
+
+class RepeatEmitter(CallEmitter[Repeat]):
+    def emit(self, repeat: Repeat, /) -> None:
+        count = self._interpreter.evaluate(repeat.count).as_type(int)
+        if count < 0:
+            raise ClassiqExpansionError(
+                f"repeat count must be non-negative, got {count}"
+            )
+        op_name = self._counted_name_allocator.allocate(REPEAT_OPERATOR_NAME)
+        for i in range(count):
+            self._emit_iteration(repeat, i, op_name)
+
+    def _emit_iteration(self, repeat: Repeat, i: int, op_name: str) -> 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=op_name,
+            positional_arg_declarations=[
+                ClassicalParameterDeclaration(
+                    name=repeat.iter_var, classical_type=Integer()
+                )
+            ],
+            body=repeat.body,
+            scope=Scope(parent=self._current_scope),
+            is_lambda=True,
+            **extra_args,
+        )
+        self._emit_quantum_function_call(iteration_function, [Expression(expr=str(i))])

classiq/model_expansions/quantum_operations/shallow_emitter.py

@@ -0,0 +1,180 @@
+import ast
+from typing import TYPE_CHECKING, Any, Optional, TypeVar
+
+from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.allocate import Allocate
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+    ArithmeticOperationKind,
+)
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumAssignmentOperation,
+)
+from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
+
+from classiq.model_expansions.closure import Closure
+from classiq.model_expansions.evaluators.quantum_type_utils import (
+    copy_type_information,
+    set_size,
+)
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import QuantumSymbol, Scope
+from classiq.model_expansions.transformers.ast_renamer import rename_variables
+from classiq.model_expansions.visitors.variable_references import VarRefCollector
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
+
+QuantumOperationT = TypeVar("QuantumOperationT", bound=QuantumOperation)
+_BLOCK_RENAMES = {
+    "compute": "within",
+    "action": "apply",
+}
+_REVERSE_BLOCK_RENAMES = {rename: name for name, rename in _BLOCK_RENAMES.items()}
+
+
+class ShallowEmitter(Emitter[QuantumOperation]):
+    def __init__(
+        self,
+        interpreter: "BaseInterpreter",
+        operation_name: str,
+        *,
+        components: Optional[list[str]] = None,
+    ) -> None:
+        super().__init__(interpreter)
+        self._operation_name = operation_name
+        self._components: list[str] = components or []
+
+    def emit(self, op: QuantumOperation, /) -> None:
+        expanded_components: dict[str, Any] = {}
+        blocks, expressions, handles = self._split_components(op)
+
+        if len(blocks) > 0:
+            if op.is_generative():
+                expanded_blocks = self.expand_generative_blocks(op)
+            else:
+                expanded_blocks = self.expand_blocks(op, blocks)
+            expanded_components.update(expanded_blocks)
+
+        for expression_name in expressions:
+            expression = getattr(op, expression_name)
+            expression = self._evaluate_expression(expression, preserve_bool_ops=True)
+            self.capture_handles_in_expression(expression)
+            expanded_components[expression_name] = expression
+
+        for handle_name in handles:
+            handle = getattr(op, handle_name)
+            expanded_components[handle_name] = self._interpreter.evaluate(
+                handle
+            ).value.handle
+
+        op = op.model_copy(update=expanded_components)
+        if isinstance(op, QuantumAssignmentOperation):
+            self._post_process_assignment(op)
+        if isinstance(op, Allocate):
+            self._post_process_allocate(op)
+        self._builder.emit_statement(op)
+
+    def _post_process_assignment(self, op: QuantumAssignmentOperation) -> None:
+        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)
+
+    def _post_process_allocate(self, allocate: Allocate) -> None:
+        target_symbol = self._interpreter.evaluate(allocate.target).value
+        if not isinstance(target_symbol, QuantumSymbol):
+            return
+        self._capture_handle(target_symbol.handle, PortDeclarationDirection.Output)
+        if allocate.size is None or not allocate.size.is_evaluated():
+            return
+        set_size(
+            target_symbol.quantum_type,
+            allocate.size.to_int_value(),
+            str(target_symbol.handle),
+        )
+
+    def _split_components(
+        self, op: QuantumOperation
+    ) -> tuple[list[str], list[str], list[str]]:
+        blocks = self._filter_components(op, list)
+        expressions = self._filter_components(op, Expression)
+        handles = self._filter_components(op, HandleBinding)
+        return blocks, expressions, handles
+
+    def _filter_components(
+        self, op: QuantumOperation, component_type: type
+    ) -> list[str]:
+        return [
+            component
+            for component in self._components
+            if isinstance(getattr(op, component, None), component_type)
+        ]
+
+    def expand_blocks(
+        self, op: QuantumOperation, block_names: list[str]
+    ) -> dict[str, list[QuantumStatement]]:
+        blocks = {
+            _BLOCK_RENAMES.get(block, block): block_statements
+            for block in block_names
+            if (block_statements := getattr(op, block)) is not None
+        }
+        block_closure = Closure(
+            name=self._operation_name,
+            scope=Scope(parent=self._current_scope),
+            blocks=blocks,
+        )
+        context = self._expand_operation(block_closure)
+        return {
+            block: context.statements(_BLOCK_RENAMES.get(block, block))
+            for block in block_names
+        }
+
+    def expand_generative_blocks(
+        self, op: QuantumOperation
+    ) -> dict[str, list[QuantumStatement]]:
+        blocks = [block for block in self._components if op.has_generative_block(block)]
+        context = self._expand_generative_context(op, self._operation_name, blocks)
+        return {
+            _REVERSE_BLOCK_RENAMES.get(block, block): context.statements(block)
+            for block in blocks
+        }
+
+    def _update_result_type(self, op: ArithmeticOperation) -> None:
+        expr = str(self._evaluate_expression(op.expression))
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(expr))
+        symbols: list[QuantumSymbol] = [
+            symbol
+            for handle in vrc.var_handles
+            if isinstance(
+                symbol := self._interpreter.evaluate(handle).value, QuantumSymbol
+            )
+        ]
+        expr = rename_variables(
+            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 = expr.replace(symbol.handle.qmod_expr, symbol.handle.identifier)
+        result_type = compute_arithmetic_result_type(
+            expr,
+            {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/variable_decleration.py

@@ -0,0 +1,28 @@
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+
+from classiq.model_expansions.evaluators.parameter_types import (
+    evaluate_type_in_quantum_symbol,
+)
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+
+
+class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement]):
+    def emit(self, variable_declaration: VariableDeclarationStatement, /) -> None:
+        var_decl = variable_declaration.model_copy()
+        var_decl.quantum_type = variable_declaration.quantum_type.model_copy()
+        self._current_scope[variable_declaration.name] = Evaluated(
+            value=QuantumSymbol(
+                handle=HandleBinding(name=var_decl.name),
+                quantum_type=evaluate_type_in_quantum_symbol(
+                    var_decl.quantum_type,
+                    self._current_scope,
+                    var_decl.name,
+                ),
+            ),
+            defining_function=self._builder.current_function,
+        )
+        self.emit_statement(var_decl)