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

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

classiq/model_expansions/sympy_conversion/expression_to_sympy.py

@@ -0,0 +1,179 @@
+import ast
+from typing import TYPE_CHECKING, cast
+
+from classiq.interface.exceptions import ClassiqExpansionError
+
+MISSING_SLICE_VALUE_PLACEHOLDER = "MISSING_SLICE_VALUE"
+
+
+def translate_to_sympy(expr: str) -> str:
+    node = ast.parse(expr)
+    node = ExpressionSympyTranslator().visit(node)
+    # node is a Module, we want an Expression
+    if TYPE_CHECKING:
+        assert isinstance(node.body[0], ast.Expr)
+    expression = ast.Expression(node.body[0].value)
+
+    return ast.unparse(ast.fix_missing_locations(expression))
+
+
+class ExpressionSympyTranslator(ast.NodeTransformer):
+    BINARY_OPERATORS: dict[type[ast.AST], str] = {
+        ast.BitOr: "BitwiseOr",
+        ast.BitAnd: "BitwiseAnd",
+        ast.BitXor: "BitwiseXor",
+        ast.Div: "do_div",
+    }
+
+    UNARY_OPERATORS: dict[type[ast.AST], str] = {
+        ast.Invert: "BitwiseNot",
+        ast.Not: "Not",
+    }
+
+    BOOLEAN_OPERATORS: dict[type[ast.AST], str] = {
+        ast.Or: "Or",
+        ast.And: "And",
+    }
+
+    COMPARE_OPERATORS: dict[type[ast.AST], str] = {
+        ast.Eq: "Eq",
+        ast.NotEq: "Ne",
+    }
+
+    SPECIAL_FUNCTIONS: dict[str, str] = {
+        "max": "Max",
+        "min": "Min",
+    }
+
+    def visit_BinOp(self, node: ast.BinOp) -> ast.AST:
+        sympy_class = self.BINARY_OPERATORS.get(node.op.__class__)
+        if sympy_class is not None:
+            left = self.visit(node.left)
+            right = self.visit(node.right)
+
+            new_node = ast.Call(
+                func=ast.Name(id=sympy_class, ctx=ast.Load()),
+                args=[left, right],
+                starargs=None,
+                keywords=[],
+                kwargs=None,
+            )
+
+            return new_node
+        return self.generic_visit(node)
+
+    def visit_Compare(self, node: ast.Compare) -> ast.AST:
+        if len(node.ops) > 1:
+            raise ClassiqExpansionError(
+                f"Qmod expressions do not support chained comparison, as done in {ast.unparse(node)}"
+            )
+        sympy_class = self.COMPARE_OPERATORS.get(node.ops[0].__class__)
+        if sympy_class is not None:
+            left = self.visit(node.left)
+            right = self.visit(node.comparators[0])
+
+            new_node = ast.Call(
+                func=ast.Name(id=sympy_class, ctx=ast.Load()),
+                args=[left, right],
+                starargs=None,
+                keywords=[],
+                kwargs=None,
+            )
+
+            return new_node
+        return self.generic_visit(node)
+
+    def visit_BoolOp(self, node: ast.BoolOp) -> ast.AST:
+        sympy_class = self.BOOLEAN_OPERATORS.get(node.op.__class__)
+        if sympy_class is not None:
+            values = [self.visit(value) for value in node.values]
+
+            new_node = ast.Call(
+                func=ast.Name(id=sympy_class, ctx=ast.Load()),
+                args=values,
+                starargs=None,
+                keywords=[],
+                kwargs=None,
+            )
+
+            return new_node
+        return self.generic_visit(node)
+
+    def visit_UnaryOp(self, node: ast.UnaryOp) -> ast.AST:
+        sympy_class = self.UNARY_OPERATORS.get(node.op.__class__)
+        if sympy_class is not None:
+            operand = self.visit(node.operand)
+
+            new_node = ast.Call(
+                func=ast.Name(id=sympy_class, ctx=ast.Load()),
+                args=[operand],
+                starargs=None,
+                keywords=[],
+                kwargs=None,
+            )
+
+            return new_node
+        return self.generic_visit(node)
+
+    def visit_Call(self, node: ast.Call) -> ast.AST:
+        if isinstance(node.func, ast.Name) and node.func.id == "Piecewise":
+            return self._visit_piecewise(node)
+
+        if (
+            not isinstance(node.func, ast.Name)
+            or node.func.id not in self.SPECIAL_FUNCTIONS
+        ):
+            return self.generic_visit(node)
+
+        return ast.Call(
+            func=ast.Name(self.SPECIAL_FUNCTIONS[node.func.id]),
+            args=[self.visit(arg) for arg in (node.args)],
+            keywords=[self.visit(arg) for arg in node.keywords],
+        )
+
+    def _visit_piecewise(self, node: ast.Call) -> ast.AST:
+        # sympy Piecewise expression may include bitwise operations:
+        # Piecewise((0, Eq(x, 0)), (0.5, Eq(x, 1) | Eq(x, 2)), (1, True))
+        #                                         ^
+        # We should avoid converting these to 'BitwiseOr' and such.
+        return ast.Call(
+            func=node.func,
+            args=[
+                ast.Tuple(
+                    elts=(
+                        self.generic_visit(cast(ast.Tuple, arg).elts[0]),
+                        cast(ast.Tuple, arg).elts[1],
+                    )
+                )
+                for arg in node.args
+            ],
+            keywords=node.keywords,
+        )
+
+    def visit_Subscript(self, node: ast.Subscript) -> ast.AST:
+        if isinstance(node.slice, ast.Slice):
+            if node.slice.lower is not None:
+                lower = self.visit(node.slice.lower)
+            else:
+                lower = ast.Name(MISSING_SLICE_VALUE_PLACEHOLDER)
+            if node.slice.upper is not None:
+                upper = self.visit(node.slice.upper)
+            else:
+                upper = ast.Name(MISSING_SLICE_VALUE_PLACEHOLDER)
+            return ast.Call(
+                func=ast.Name("do_slice"),
+                args=[self.visit(node.value), lower, upper],
+                keywords=[],
+            )
+        return ast.Call(
+            func=ast.Name("do_subscript"),
+            args=[self.visit(node.value), self.visit(node.slice)],
+            keywords=[],
+        )
+
+    def visit_Attribute(self, node: ast.Attribute) -> ast.Call:
+        return ast.Call(
+            func=ast.Name("get_field"),
+            args=[node.value, ast.Constant(value=node.attr)],
+            keywords=[],
+        )