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

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)

classiq/model_expansions/scope.py

@@ -0,0 +1,240 @@
+import itertools
+import re
+from collections import UserDict
+from collections.abc import Iterator
+from dataclasses import dataclass
+from functools import singledispatch
+from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
+
+from sympy import Symbol
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.evaluated_expression import (
+    EvaluatedExpression,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.expression_constants import (
+    CPARAM_EXECUTION_SUFFIX_PATTERN,
+)
+from classiq.interface.generator.expressions.qmod_struct_instance import (
+    QmodStructInstance,
+)
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.model.handle_binding import (
+    FieldHandleBinding,
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
+from classiq.interface.model.quantum_function_call import ArgValue
+from classiq.interface.model.quantum_type import (
+    QuantumBitvector,
+    QuantumType,
+)
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.closure import FunctionClosure
+
+T = TypeVar("T")
+
+
+@dataclass(frozen=True)
+class QuantumSymbol:
+    handle: HandleBinding
+    quantum_type: QuantumType
+
+    @property
+    def is_subscript(self) -> bool:
+        return isinstance(self.handle, (SubscriptHandleBinding, SlicedHandleBinding))
+
+    def emit(self) -> HandleBinding:
+        return self.handle
+
+    def __getitem__(self, item: Union[slice, int]) -> "QuantumSymbol":
+        if isinstance(item, int):
+            return self._subscript(item)
+
+        return self._slice(item.start, item.stop)
+
+    def _slice(self, start: int, end: int) -> "QuantumSymbol":
+        if not isinstance(self.quantum_type, QuantumBitvector):
+            raise ClassiqExpansionError(
+                f"{self.quantum_type.type_name} is not subscriptable"
+            )
+        if start >= end:
+            raise ClassiqExpansionError(
+                f"{self.quantum_type.type_name} slice '{self.handle}[{start}:{end}]' "
+                f"has non-positive length"
+            )
+        array_length = self.quantum_type.length_value
+        if start < 0 or end > array_length:
+            raise ClassiqExpansionError(
+                f"Slice [{start}:{end}] is out of bounds of "
+                f"{self.quantum_type.type_name} {str(self.handle)!r} of length "
+                f"{array_length}"
+            )
+        return QuantumSymbol(
+            handle=SlicedHandleBinding(
+                base_handle=self.handle,
+                start=Expression(expr=str(start)),
+                end=Expression(expr=str(end)),
+            ),
+            quantum_type=QuantumBitvector(
+                element_type=self.quantum_type.element_type,
+                length=Expression(expr=str(end - start)),
+            ),
+        )
+
+    def _subscript(self, index: int) -> "QuantumSymbol":
+        if not isinstance(self.quantum_type, QuantumBitvector):
+            raise ClassiqExpansionError(
+                f"{self.quantum_type.type_name} is not subscriptable"
+            )
+        array_length = self.quantum_type.length_value
+        if index < 0 or index >= array_length:
+            raise ClassiqExpansionError(
+                f"Subscript {index} is out of bounds of {self.quantum_type.type_name} "
+                f"{str(self.handle)!r} of length {array_length}"
+            )
+        return QuantumSymbol(
+            handle=SubscriptHandleBinding(
+                base_handle=self.handle,
+                index=Expression(expr=str(index)),
+            ),
+            quantum_type=self.quantum_type.element_type,
+        )
+
+    @property
+    def fields(self) -> dict[str, "QuantumSymbol"]:
+        quantum_type = self.quantum_type
+        if not isinstance(quantum_type, TypeName):
+            raise ClassiqExpansionError(
+                f"{self.quantum_type.type_name} is not a struct"
+            )
+        return {
+            field_name: QuantumSymbol(
+                handle=FieldHandleBinding(base_handle=self.handle, field=field_name),
+                quantum_type=field_type,
+            )
+            for field_name, field_type in quantum_type.fields.items()
+        }
+
+
+@singledispatch
+def evaluated_to_str(value: Any) -> str:
+    return str(value)
+
+
+@evaluated_to_str.register
+def _evaluated_to_str_list(value: list) -> str:
+    return f"[{', '.join(evaluated_to_str(x) for x in value)}]"
+
+
+@evaluated_to_str.register
+def _evaluated_to_str_struct_literal(value: QmodStructInstance) -> str:
+    return f"struct_literal({value.struct_declaration.name}, {', '.join(f'{k}={evaluated_to_str(v)}' for k, v in value.fields.items())})"
+
+
+@dataclass(frozen=True)
+class Evaluated:  # FIXME: Merge with EvaluatedExpression if possible
+    value: Any
+    defining_function: Optional["FunctionClosure"] = None
+
+    def as_type(self, t: type[T]) -> T:
+        if t is int:
+            return self._as_int()  # type: ignore[return-value]
+
+        if not isinstance(self.value, t):
+            raise ClassiqExpansionError(
+                f"Invalid access to expression {self.value!r} as {t}"
+            )
+
+        return self.value
+
+    def _as_int(self) -> int:
+        if not isinstance(self.value, (int, float)):
+            raise ClassiqExpansionError(
+                f"Invalid access to expression {self.value!r} as {int}"
+            )
+
+        return int(self.value)
+
+    def emit(self) -> ArgValue:
+        from classiq.model_expansions.closure import FunctionClosure
+
+        if isinstance(self.value, (QuantumSymbol, FunctionClosure)):
+            return self.value.emit()
+        if isinstance(self.value, list) and all(
+            isinstance(item, FunctionClosure) for item in self.value
+        ):
+            return [item.emit() for item in self.value]
+
+        ret = Expression(expr=evaluated_to_str(self.value))
+        ret._evaluated_expr = EvaluatedExpression(value=self.value)
+        return ret
+
+
+if TYPE_CHECKING:
+    EvaluatedUserDict = UserDict[str, Evaluated]
+else:
+    EvaluatedUserDict = UserDict
+
+
+class Scope(EvaluatedUserDict):
+    def __init__(
+        self,
+        data: Optional[dict[str, Evaluated]] = None,
+        /,
+        *,
+        parent: Optional["Scope"] = None,
+    ) -> None:
+        super().__init__(data or {})
+        self._parent: Optional["Scope"] = parent
+
+    @property
+    def parent(self) -> Optional["Scope"]:
+        return self._parent
+
+    def __getitem__(self, name: str) -> Evaluated:
+        if name in self.data:
+            return self.data[name]
+        if self._parent is not None:
+            return self._parent[name]
+        if re.search(CPARAM_EXECUTION_SUFFIX_PATTERN, name):
+            return Evaluated(value=Symbol(name))
+        raise ClassiqExpansionError(f"Variable {name!r} is undefined")
+
+    def __contains__(self, item: Any) -> bool:
+        return item in self.data or (self._parent is not None and item in self._parent)
+
+    def __iter__(self) -> Iterator[str]:
+        if self._parent is None:
+            return iter(self.data)
+        return iter(itertools.chain(self.data, self._parent))
+
+    def iter_without_top_level(self) -> Iterator[str]:
+        if self.parent is None:
+            return iter(tuple())
+        return iter(itertools.chain(self.data, self.parent.iter_without_top_level()))
+
+    def __or__(self, other: Any) -> "Scope":  # type: ignore[override]
+        if not (isinstance(other, Scope) and isinstance(self, Scope)):
+            raise ClassiqInternalExpansionError
+
+        if self.parent is None:
+            parent = other.parent
+        elif other.parent is None:
+            parent = self.parent
+        else:
+            parent = self.parent | other.parent
+
+        return Scope(
+            (self.data or {}) | (other.data or {}),
+            parent=parent,
+        )
+
+    def clone(self) -> "Scope":
+        return Scope(self.data, parent=self._parent)

classiq/model_expansions/scope_initialization.py

@@ -0,0 +1,150 @@
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
+
+from classiq.interface.exceptions import ClassiqError
+from classiq.interface.generator.constant import Constant
+from classiq.interface.generator.expressions.expression_constants import (
+    CPARAM_EXECUTION_SUFFIX,
+)
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
+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 (
+    NamedParamsQuantumFunctionDeclaration,
+    PositionalArg,
+    QuantumFunctionDeclaration,
+)
+
+from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
+from classiq.model_expansions.evaluators.classical_expression import (
+    evaluate_classical_expression,
+)
+from classiq.model_expansions.evaluators.parameter_types import (
+    evaluate_type_in_quantum_symbol,
+)
+from classiq.model_expansions.expression_renamer import ExpressionRenamer
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.qmod.builtins import BUILTIN_CONSTANTS
+from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
+from classiq.qmod.builtins.functions import (
+    CORE_LIB_DECLS,
+    STD_QMOD_OPERATORS,
+)
+from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
+from classiq.qmod.model_state_container import QMODULE
+from classiq.qmod.quantum_function import GenerativeQFunc
+
+
+def get_main_renamer(
+    func_decls: Sequence[QuantumFunctionDeclaration],
+) -> ExpressionRenamer:
+    for func_decl in func_decls:
+        if func_decl.name == MAIN_FUNCTION_NAME:
+            if TYPE_CHECKING:
+                assert isinstance(func_decl, NamedParamsQuantumFunctionDeclaration)
+            return ExpressionRenamer.from_positional_arg_declarations(
+                func_decl.positional_arg_declarations, CPARAM_EXECUTION_SUFFIX
+            )
+    return ExpressionRenamer(var_mapping={})
+
+
+def add_constants_to_scope(constants: list[Constant], scope: Scope) -> None:
+    for constant in constants:
+        scope[constant.name] = Evaluated(
+            value=evaluate_classical_expression(constant.value, scope).value
+        )
+
+
+def add_functions_to_scope(
+    functions: Sequence[NativeFunctionDefinition], scope: Scope
+) -> None:
+    for function in functions:
+        if function.name not in scope:
+            scope[function.name] = Evaluated(
+                value=FunctionClosure.create(
+                    name=function.name,
+                    positional_arg_declarations=function.positional_arg_declarations,
+                    body=function.body,
+                    scope=Scope(parent=scope),
+                )
+            )
+
+
+def add_generative_functions_to_scope(
+    functions: Sequence[GenerativeQFunc], scope: Scope
+) -> None:
+    for function in functions:
+        name = function.func_decl.name
+        if name == MAIN_FUNCTION_NAME or name not in scope:
+            scope[function.func_decl.name] = Evaluated(
+                value=GenerativeFunctionClosure.create(
+                    name=function.func_decl.name,
+                    positional_arg_declarations=function.func_decl.positional_arg_declarations,
+                    scope=Scope(parent=scope),
+                    generative_blocks={"body": function},
+                )
+            )
+
+
+def _init_builtins_scope(scope: Scope) -> None:
+    for builtin_function in CORE_LIB_DECLS:
+        scope[builtin_function.name] = Evaluated(
+            value=FunctionClosure.create(
+                name=builtin_function.name,
+                positional_arg_declarations=builtin_function.positional_arg_declarations,
+                scope=Scope(parent=scope),
+                is_atomic=True,
+            )
+        )
+    for builtin_function in STD_QMOD_OPERATORS:
+        scope[builtin_function.name] = Evaluated(
+            value=FunctionClosure.create(
+                name=builtin_function.name,
+                positional_arg_declarations=builtin_function.positional_arg_declarations,
+                scope=Scope(parent=scope),
+            )
+        )
+    for constant in BUILTIN_CONSTANTS:
+        value = constant.value
+        if not value.is_evaluated():
+            raise ClassiqError(
+                f"Unevaluated built-in constants not supported. Offending constant: "
+                f"{constant.name} = {value}"
+            )
+        scope[constant.name] = Evaluated(value=value.value.value)
+
+
+def add_entry_point_params_to_scope(
+    parameters: Sequence[PositionalArg], main_closure: FunctionClosure
+) -> None:
+    for parameter in parameters:
+        if isinstance(parameter, PortDeclaration):
+            main_closure.scope[parameter.name] = Evaluated(
+                value=QuantumSymbol(
+                    handle=HandleBinding(name=parameter.name),
+                    quantum_type=evaluate_type_in_quantum_symbol(
+                        parameter.quantum_type, main_closure.scope, parameter.name
+                    ),
+                ),
+                defining_function=main_closure,
+            )
+        elif isinstance(parameter, ClassicalParameterDeclaration):
+            main_closure.scope[parameter.name] = Evaluated(
+                value=parameter.classical_type.as_symbolic(parameter.name),
+                defining_function=main_closure,
+            )
+
+
+def init_top_level_scope(model: Model, scope: Scope) -> None:
+    add_functions_to_scope(model.functions, scope)
+    add_constants_to_scope(model.constants, scope)
+    _init_builtins_scope(scope)
+
+
+def init_builtin_types() -> None:
+    QMODULE.enum_decls |= BUILTIN_ENUM_DECLARATIONS
+    QMODULE.type_decls |= BUILTIN_STRUCT_DECLARATIONS

classiq/model_expansions/sympy_conversion/arithmetics.py

@@ -0,0 +1,49 @@
+from typing import Any, Optional
+
+from sympy import Function, Integer
+from sympy.logic.boolalg import BooleanFunction
+
+
+class BitwiseAnd(Function):
+    @classmethod
+    def eval(cls, a: Any, b: Any) -> Optional[int]:
+        if isinstance(a, Integer) and isinstance(b, Integer):
+            return a & b
+
+        return None
+
+
+class BitwiseXor(Function):
+    @classmethod
+    def eval(cls, a: Any, b: Any) -> Optional[int]:
+        if isinstance(a, Integer) and isinstance(b, Integer):
+            return a ^ b
+
+        return None
+
+
+class LogicalXor(BooleanFunction):
+    @classmethod
+    def eval(cls, a: Any, b: Any) -> Optional[bool]:
+        if isinstance(a, bool) and isinstance(b, bool):
+            return a ^ b
+
+        return None
+
+
+class BitwiseOr(Function):
+    @classmethod
+    def eval(cls, a: Any, b: Any) -> Optional[int]:
+        if isinstance(a, Integer) and isinstance(b, Integer):
+            return a | b
+
+        return None
+
+
+class BitwiseNot(Function):
+    @classmethod
+    def eval(cls, a: Any) -> Optional[int]:
+        if isinstance(a, Integer):
+            return ~a
+
+        return None