classiq 0.45.0__py3-none-any.whl → 0.46.0__py3-none-any.whl

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -0,0 +1,250 @@
+from enum import Enum
+from typing import Any, Callable, List, Mapping, Union
+
+from sympy import Eq, Expr, Number, Piecewise, Symbol
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.expression_types import (
+    ExpressionValue,
+    QmodStructInstance,
+)
+from classiq.interface.generator.expressions.qmod_qscalar_proxy import QmodQNumProxy
+from classiq.interface.generator.expressions.qmod_qstruct_proxy import QmodQStructProxy
+from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.generator.expressions.type_proxy import TypeProxy
+from classiq.interface.generator.functions.classical_function_declaration import (
+    ClassicalFunctionDeclaration,
+)
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+    ClassicalList,
+    ClassicalType,
+    OpaqueHandle,
+    QmodPyObject,
+    Real,
+    StructMetaType,
+)
+from classiq.interface.generator.functions.type_name import TypeName
+
+from classiq.model_expansions.model_tables import (
+    HandleIdentifier,
+    HandleTable,
+    SymbolTable,
+)
+from classiq.model_expansions.sympy_conversion.arithmetics import (
+    BitwiseAnd,
+    BitwiseNot,
+    BitwiseOr,
+    BitwiseXor,
+    LogicalXor,
+)
+from classiq.model_expansions.sympy_conversion.expression_to_sympy import (
+    MISSING_SLICE_VALUE_PLACEHOLDER,
+)
+from classiq.model_expansions.sympy_conversion.sympy_to_python import (
+    sympy_to_python,
+)
+
+
+def qmod_val_to_python(val: ExpressionValue, qmod_type: ClassicalType) -> Any:
+    if isinstance(qmod_type, TypeName):
+        if (
+            isinstance(val, QmodStructInstance)
+            and val.struct_declaration == SymbolTable.type_table[qmod_type.name]
+        ):
+            return {
+                field_name: qmod_val_to_python(val.fields[field_name], field_type)
+                for field_name, field_type in val.struct_declaration.variables.items()
+            }
+
+        if isinstance(val, Enum):
+            return val
+
+    elif isinstance(qmod_type, ClassicalList):
+        if isinstance(val, list):
+            return [qmod_val_to_python(elem, qmod_type.element_type) for elem in val]
+
+    elif isinstance(qmod_type, OpaqueHandle):
+        if isinstance(val, HandleIdentifier):
+            return HandleTable.get_handle_object(val)
+
+    elif isinstance(val, Expr):
+        return sympy_to_python(val)
+
+    elif isinstance(qmod_type, Real):
+        if isinstance(val, (float, int)):
+            return val
+
+    elif isinstance(qmod_type, Bool):
+        if isinstance(val, bool):
+            return val
+
+    elif isinstance(qmod_type, StructMetaType):
+        if isinstance(val, TypeProxy):
+            return val.struct_declaration
+
+    elif isinstance(val, int):  # other scalars are represented as int
+        return val
+
+    raise ClassiqInternalExpansionError(
+        f"Bad value {val!r} of type {type(val)!r} for {qmod_type!r}"
+    )
+
+
+def python_val_to_qmod(val: Any, qmod_type: ClassicalType) -> ExpressionValue:
+    if isinstance(qmod_type, TypeName):
+        if qmod_type.name in SymbolTable.enum_table:
+            return val
+
+        struct_decl = SymbolTable.type_table[qmod_type.name]
+        if not isinstance(val, Mapping):
+            raise ClassiqInternalExpansionError(
+                f"Bad value for struct {struct_decl.name}"
+            )
+        qmod_dict = {
+            field_name: python_val_to_qmod(val[field_name], field_type)
+            for field_name, field_type in struct_decl.variables.items()
+        }
+        return QmodStructInstance(struct_decl, qmod_dict)
+
+    if isinstance(qmod_type, ClassicalList):
+        if not isinstance(val, list):
+            raise ClassiqInternalExpansionError("Bad value for list")
+        return [python_val_to_qmod(elem, qmod_type.element_type) for elem in val]
+
+    if isinstance(qmod_type, OpaqueHandle):
+        if not isinstance(val, QmodPyObject):
+            raise ClassiqInternalExpansionError("Bad value opaque handle")
+        return HandleTable.set_handle_object(val)
+
+    return val
+
+
+def python_call_wrapper(func: Callable, *args: ExpressionValue) -> Any:
+    func_decl = ClassicalFunctionDeclaration.FOREIGN_FUNCTION_DECLARATIONS[
+        func.__name__
+    ]
+    python_args = [
+        qmod_val_to_python(args[idx], param_type.classical_type)
+        for idx, param_type in enumerate(func_decl.param_decls)
+    ]
+    assert func_decl.return_type is not None
+    return python_val_to_qmod(func(*python_args), func_decl.return_type)
+
+
+def struct_literal(struct_type_symbol: Symbol, **kwargs: Any) -> QmodStructInstance:
+    return QmodStructInstance(
+        SymbolTable.type_table[struct_type_symbol.name],
+        {field: sympy_to_python(field_value) for field, field_value in kwargs.items()},
+    )
+
+
+def get_field(
+    proxy: Union[QmodSizedProxy, QmodStructInstance, QmodQStructProxy, list],
+    field: str,
+) -> ExpressionValue:
+    if isinstance(proxy, Symbol) and not isinstance(proxy, QmodSizedProxy):
+        raise ClassiqExpansionError(
+            f"Cannot evaluate '{proxy}.{field}': Variable {str(proxy)!r} is not "
+            f"initialized"
+        )
+    if isinstance(proxy, list):
+        if field != "len":
+            raise ClassiqExpansionError(
+                f"List {str(proxy)!r} has no attribute {field!r}. "
+                f"Available attributes: len"
+            )
+        return len(proxy)
+    if field not in proxy.fields:
+        if isinstance(proxy, (QmodStructInstance, QmodQStructProxy)):
+            property_name = "field"
+        else:
+            property_name = "attribute"
+        suffix = (
+            f". Available {property_name}s: {', '.join(proxy.fields.keys())}"
+            if len(proxy.fields) > 0
+            else ""
+        )
+        proxy_str = proxy.__name__ if isinstance(proxy, type) else f"{str(proxy)!r}"
+        raise ClassiqExpansionError(
+            f"{proxy.type_name} {proxy_str} has no {property_name} {field!r}{suffix}"
+        )
+    return proxy.fields[field]
+
+
+def get_type(struct_type: Symbol) -> TypeProxy:
+    return TypeProxy(SymbolTable.type_table[struct_type.name])
+
+
+def _unwrap_sympy_numeric(n: Any) -> Any:
+    if not isinstance(n, Number) or not n.is_constant():
+        return n
+    if n.is_Integer:
+        return int(n)
+    return float(n)
+
+
+def do_div(lhs: Any, rhs: Any) -> Any:
+    lhs = _unwrap_sympy_numeric(lhs)
+    rhs = _unwrap_sympy_numeric(rhs)
+    return lhs / rhs
+
+
+def do_subscript(value: Any, index: Any) -> Any:
+    if not isinstance(value, list) or not isinstance(index, QmodQNumProxy):
+        if isinstance(index, (QmodSizedProxy, QmodStructInstance)):
+            raise ClassiqExpansionError(
+                f"Subscript {value}[{index}] is not supported. Supported subscripts "
+                f"include:\n"
+                f"\t1. `qbv[idx]`, where `qbv` is a quantum array and `idx` is a "
+                f"classical integer.\n"
+                f"\t2. `l[n]`, where `l` is a list of classical real numbers and `n` "
+                f"is a classical or quantum integer."
+            )
+        return value[index]
+    if index.is_signed or index.fraction_digits > 0:
+        raise ClassiqExpansionError(
+            "Quantum numeric subscript must be an unsigned integer (is_signed=False, "
+            "fraction_digits=0)"
+        )
+    if len(value) != 2**index.size:
+        raise ClassiqExpansionError(
+            f"Quantum numeric subscript size mismatch: The quantum numeric has "
+            f"{index.size} qubits but the list size is {len(value)} != 2**{index.size}"
+        )
+    return Piecewise(
+        *[(item, Eq(index, idx)) for idx, item in enumerate(value[:-1])],
+        (value[-1], True),
+    )
+
+
+def do_slice(value: Any, lower: Any, upper: Any) -> Any:
+    if isinstance(lower, Symbol) and str(lower) == MISSING_SLICE_VALUE_PLACEHOLDER:
+        lower = None
+    if isinstance(upper, Symbol) and str(upper) == MISSING_SLICE_VALUE_PLACEHOLDER:
+        upper = None
+    return do_subscript(value, slice(lower, upper))
+
+
+CORE_LIB_FUNCTIONS_LIST: List[Callable] = [
+    print,
+    sum,
+    struct_literal,
+    get_field,
+    get_type,
+    do_div,
+    do_slice,
+    do_subscript,
+    BitwiseAnd,
+    BitwiseXor,
+    BitwiseNot,
+    BitwiseOr,
+    LogicalXor,
+]
+
+ATOMIC_EXPRESSION_FUNCTIONS = {
+    **{core_func.__name__: core_func for core_func in CORE_LIB_FUNCTIONS_LIST},
+}

classiq/model_expansions/capturing/captured_var_manager.py

@@ -0,0 +1,50 @@
+from typing import Dict, List
+
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.port_declaration import PortDeclaration
+
+
+def update_captured_vars(captured_vars: List[PortDeclaration]) -> List[PortDeclaration]:
+    if not captured_vars:
+        return []
+    return _update_declarations(captured_vars)
+
+
+def _update_declarations(
+    captured_vars: List[PortDeclaration],
+) -> List[PortDeclaration]:
+    updated_vars: Dict[str, PortDeclaration] = {
+        var.name: PortDeclaration(
+            name=var.name,
+            quantum_type=var.quantum_type,
+            direction=PortDeclarationDirection.Inout,
+        )
+        for var in captured_vars
+    }
+    for var in captured_vars:
+        updated_vars[var.name].direction = _update_var_declaration(
+            var.direction, updated_vars[var.name].direction
+        )
+    return list(updated_vars.values())
+
+
+def _update_var_declaration(
+    stmt_direction: PortDeclarationDirection,
+    existing_direction: PortDeclarationDirection,
+) -> PortDeclarationDirection:
+    if stmt_direction is PortDeclarationDirection.Input:
+        if existing_direction is PortDeclarationDirection.Output:
+            # This will fail semantically because the inout variable is not initialized.
+            # We will get rid of this scenario by unifying variable declaration and allocation.
+            return PortDeclarationDirection.Inout
+        else:
+            return PortDeclarationDirection.Input
+    elif stmt_direction is PortDeclarationDirection.Output:
+        if existing_direction is PortDeclarationDirection.Input:
+            return PortDeclarationDirection.Inout
+        else:
+            return PortDeclarationDirection.Output
+    else:
+        return PortDeclarationDirection.Inout

classiq/model_expansions/capturing/mangling_utils.py

@@ -0,0 +1,17 @@
+import re
+
+from classiq.interface.generator.compiler_keywords import CAPTURE_SUFFIX
+
+IDENTIFIER_PATTERN = r"[a-zA-Z_][a-zA-Z0-9_]*"
+CAPTURE_PATTERN = re.compile(
+    rf"({IDENTIFIER_PATTERN}){CAPTURE_SUFFIX}{IDENTIFIER_PATTERN}__"
+)
+
+
+def mangle_captured_var_name(var_name: str, defining_function: str) -> str:
+    return f"{var_name}{CAPTURE_SUFFIX}{defining_function}__"
+
+
+def demangle_name(name: str) -> str:
+    match = re.match(CAPTURE_PATTERN, name)
+    return match.group(1) if match else name

classiq/model_expansions/capturing/propagated_var_stack.py

@@ -0,0 +1,180 @@
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import Dict, Iterable, Iterator, List, Sequence
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.handle_binding import HANDLE_ID_SEPARATOR, HandleBinding
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_call import ArgValue
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+from classiq.model_expansions.capturing.mangling_utils import mangle_captured_var_name
+from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.function_builder import OperationBuilder
+from classiq.model_expansions.scope import QuantumSymbol, Scope
+
+
+@dataclass(frozen=True)
+class PropagatedVariable:
+    symbol: QuantumSymbol
+    direction: PortDeclarationDirection
+    defining_function: str
+
+    @property
+    def name(self) -> str:
+        return self.symbol.handle.name
+
+
+class PropagatedVarStack:
+    def __init__(self, scope: Scope, builder: OperationBuilder) -> None:
+        # We use dictionary instead of set to maintain the order of insertion
+        self._stack: List[Dict[PropagatedVariable, None]] = [dict()]
+        self._current_scope = scope
+        self._builder = builder
+        self._to_mangle: Dict[PropagatedVariable, str] = dict()
+
+    def set_scope(self, scope: Scope) -> None:
+        self._current_scope = scope
+
+    @contextmanager
+    def capture_variables(self, op: QuantumOperation) -> Iterator[None]:
+        self._stack.append(dict())
+        yield
+        self._post_handle_propagated_vars(op)
+
+    def _post_handle_propagated_vars(self, qop: QuantumOperation) -> None:
+        self._halt_propagation_for_vars_in_scope()
+        currently_captured_vars = self._get_captured_vars(qop)
+        self._stack[-1].update(currently_captured_vars)
+        self._update_port_declarations_for_captured_vars()
+
+    def _halt_propagation_for_vars_in_scope(self) -> None:
+        currently_propagated = self._stack.pop()
+        self._stack[-1].update(
+            {var: None for var in currently_propagated if self._should_propagate(var)}
+        )
+
+    def _should_propagate(self, var: PropagatedVariable) -> bool:
+        # The second case is in case the captured variable was defined in another function,
+        # but the current scope has a variable with the same name
+        return (
+            var.name not in self._current_scope.data
+            or isinstance(self._builder.current_operation, FunctionClosure)
+            and var.defining_function != self._builder.current_function.name
+        )
+
+    def _get_captured_vars(
+        self, qop: QuantumOperation
+    ) -> Dict[PropagatedVariable, None]:
+        input_captured = self._get_captured_vars_with_direction(
+            qop.inputs,
+            (
+                PortDeclarationDirection.Input
+                if not self._builder.is_compute_context()
+                else PortDeclarationDirection.Inout
+            ),
+        )
+        output_captured = self._get_captured_vars_with_direction(
+            qop.outputs,
+            (
+                PortDeclarationDirection.Output
+                if not self._builder.is_compute_context()
+                else PortDeclarationDirection.Inout
+            ),
+        )
+        inout_captured = self._get_captured_vars_with_direction(
+            qop.inouts, PortDeclarationDirection.Inout
+        )
+        return inout_captured | input_captured | output_captured
+
+    def _get_captured_vars_with_direction(
+        self,
+        variables: Iterable[HandleBinding],
+        direction: PortDeclarationDirection,
+    ) -> Dict[PropagatedVariable, None]:
+        return {
+            self._get_captured_var_with_direction(var.name, direction): None
+            for var in variables
+            if self._is_captured(var.name)
+        }
+
+    def _get_captured_var_with_direction(
+        self, var_name: str, direction: PortDeclarationDirection
+    ) -> PropagatedVariable:
+        defining_function = self._current_scope[var_name].defining_function
+        if defining_function is None:
+            raise ClassiqInternalExpansionError
+        return PropagatedVariable(
+            symbol=self._current_scope[var_name].as_type(QuantumSymbol),
+            direction=direction,
+            defining_function=defining_function.name,
+        )
+
+    def _is_captured(self, var_name: str) -> bool:
+        return (
+            self._current_scope.parent is not None
+            and var_name in self._current_scope.parent
+            and var_name not in self._current_scope.data
+        )
+
+    def _update_port_declarations_for_captured_vars(self) -> None:
+        self._builder.add_captured_vars(
+            PortDeclaration(
+                name=self._to_mangle.get(var, var.name),
+                direction=var.direction,
+                quantum_type=var.symbol.quantum_type,
+            )
+            for var in self._stack[-1]
+        )
+
+    def get_propagated_variables(self) -> List[HandleBinding]:
+        propagated_var_names: List[str] = [
+            self._get_propagated_var_name(var) for var in self._stack[-1]
+        ]
+        return [
+            HandleBinding(name=name) for name in dict.fromkeys(propagated_var_names)
+        ]
+
+    def _get_propagated_var_name(self, var: PropagatedVariable) -> str:
+        if (
+            var.defining_function == self._builder.current_function.name
+            or self._no_name_conflict(var)
+        ):
+            handle_name = var.name
+            if var in self._to_mangle:
+                self._to_mangle.pop(var)
+        else:
+            handle_name = mangle_captured_var_name(var.name, var.defining_function)
+            self._to_mangle[var] = handle_name
+        return handle_name
+
+    def _no_name_conflict(self, var: PropagatedVariable) -> bool:
+        return var.name not in self._builder.current_function.colliding_variables
+
+
+def validate_args_are_not_propagated(
+    args: Sequence[ArgValue], captured_vars: Sequence[HandleBinding]
+) -> None:
+    if not captured_vars:
+        return
+    captured_var_names = {var.name for var in captured_vars}
+    arg_names = {
+        demangle_suffixes(arg.name) for arg in args if isinstance(arg, HandleBinding)
+    }
+    if not captured_var_names.isdisjoint(arg_names):
+        vars_msg = f"Explicitly passed variables: {arg_names}, captured variables: {captured_var_names}"
+        raise ClassiqExpansionError(
+            f"Cannot capture variables that are explicitly passed as arguments. "
+            f"{vars_msg}"
+        )
+
+
+# TODO this is not a good long-term solution
+def demangle_suffixes(name: str) -> str:
+    return name.split(HANDLE_ID_SEPARATOR)[0]

classiq/model_expansions/closure.py

@@ -0,0 +1,160 @@
+from collections import defaultdict
+from dataclasses import dataclass, field
+from functools import cached_property
+from typing import Any, Dict, List, Optional, Sequence, Set, Union
+
+from typing_extensions import Self
+
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.visitor import Visitor
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+    PositionalArg,
+)
+from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+
+from classiq.model_expansions.expression_renamer import ExpressionRenamer
+from classiq.model_expansions.scope import Scope
+from classiq.qmod.builtins.functions import permute
+from classiq.qmod.quantum_function import GenerativeQFunc
+
+
+@dataclass(frozen=True)
+class Closure:
+    name: str
+    blocks: Dict[str, Sequence[QuantumStatement]]
+    scope: Scope
+    positional_arg_declarations: Sequence[PositionalArg] = tuple()
+
+    @cached_property
+    def port_declarations(self) -> Dict[str, PortDeclaration]:
+        return {
+            param.name: param
+            for param in self.positional_arg_declarations
+            if isinstance(param, PortDeclaration)
+        }
+
+
+@dataclass(frozen=True)
+class FunctionClosure(Closure):
+    is_lambda: bool = False
+    is_atomic: bool = False
+    signature_scope: Scope = field(default_factory=Scope)
+
+    @property
+    def body(self) -> Sequence[QuantumStatement]:
+        if self.name == permute.func_decl.name:
+            # permute is an old Qmod "generative" function that doesn't have a body
+            return []
+        return self.blocks["body"]
+
+    @cached_property
+    def colliding_variables(self) -> Set[str]:
+        # Note that this has to be accessed after adding the parameters from the signature and not during
+        # initialization
+        return VariableCollector(self.scope).get_colliding_variables(self.body)
+
+    @classmethod
+    def create(
+        cls,
+        name: str,
+        scope: Scope,
+        body: Optional[Sequence[QuantumStatement]] = None,
+        positional_arg_declarations: Sequence[PositionalArg] = tuple(),
+        expr_renamer: Optional[ExpressionRenamer] = None,
+        is_lambda: bool = False,
+        is_atomic: bool = False,
+        **kwargs: Any,
+    ) -> Self:
+        if expr_renamer:
+            positional_arg_declarations = (
+                expr_renamer.rename_positional_arg_declarations(
+                    positional_arg_declarations
+                )
+            )
+            if body is not None:
+                body = expr_renamer.visit(body)
+
+        blocks = {"body": body} if body is not None else {}
+        return cls(
+            name,
+            blocks,
+            scope,
+            positional_arg_declarations,
+            is_lambda,
+            is_atomic,
+            **kwargs,
+        )
+
+    def with_new_declaration(
+        self, declaration: NamedParamsQuantumFunctionDeclaration
+    ) -> Self:
+        fields: dict = self.__dict__ | {
+            "positional_arg_declarations": declaration.positional_arg_declarations
+        }
+        return type(self)(**fields)
+
+
+@dataclass(frozen=True)
+class GenerativeFunctionClosure(FunctionClosure):
+    generative_function: GenerativeQFunc = None  # type:ignore[assignment]
+
+
+NestedFunctionClosureT = Union[FunctionClosure, List["NestedFunctionClosureT"]]
+
+
+class VariableCollector(Visitor):
+    def __init__(self, function_scope: Scope) -> None:
+        self._function_scope = function_scope
+        self._variables: defaultdict[str, Set[Optional[str]]] = defaultdict(set)
+        for var in self._function_scope.data:
+            defining_function = self._function_scope[var].defining_function
+            if defining_function is not None:
+                self._variables[var].add(defining_function.name)
+
+    def get_colliding_variables(self, body: Sequence[QuantumStatement]) -> Set[str]:
+        self.visit(body)
+        return {
+            var
+            for var, defining_functions in self._variables.items()
+            if len(defining_functions) > 1
+        }
+
+    def visit_VariableDeclarationStatement(
+        self, node: VariableDeclarationStatement
+    ) -> None:
+        self._variables[node.name].add(None)
+
+    def visit_QuantumFunctionCall(self, node: QuantumFunctionCall) -> None:
+        # The else case corresponds to operand identifiers. In case of operand identifiers, we scan
+        # the whole list of operands because we can't evaluate the index yet.
+        identifier = (
+            node.function if isinstance(node.function, str) else node.function.name
+        )
+        self._add_variables(self._function_scope[identifier].value)
+
+    def _add_variables(self, evaluated: NestedFunctionClosureT) -> None:
+        if isinstance(evaluated, list):
+            for elem in evaluated:
+                self._add_variables(elem)
+            return
+        if not isinstance(evaluated, FunctionClosure):
+            raise ClassiqInternalExpansionError
+        self._add_variables_from_closure(evaluated)
+
+    def _add_variables_from_closure(self, closure: FunctionClosure) -> None:
+        if not closure.is_lambda:
+            return
+        lambda_environment = closure.scope.parent
+        if lambda_environment is None:
+            raise ClassiqInternalExpansionError
+
+        for var in lambda_environment.iter_without_top_level():
+            defining_function = lambda_environment[var].defining_function
+            if defining_function is not None:
+                self._variables[var].add(defining_function.name)

classiq/model_expansions/debug_flag.py

@@ -0,0 +1,3 @@
+from contextvars import ContextVar
+
+debug_mode: ContextVar[bool] = ContextVar("debug_mode", default=False)