classiq 0.73.0__py3-none-any.whl → 0.75.0__py3-none-any.whl

classiq/model_expansions/visitors/symbolic_param_inference.py

@@ -0,0 +1,197 @@
+import ast
+from collections.abc import Iterator, Mapping, Sequence
+from contextlib import contextmanager
+from itertools import chain, zip_longest
+from typing import Optional, cast
+
+from classiq.interface.generator.expressions.atomic_expression_functions import (
+    CLASSICAL_ATTRIBUTES,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_type import ClassicalType
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
+from classiq.interface.model.classical_parameter_declaration import (
+    AnonClassicalParameterDeclaration,
+)
+from classiq.interface.model.handle_binding import FieldHandleBinding, HandleBinding
+from classiq.interface.model.model_visitor import ModelVisitor
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.quantum_function_call import ArgValue, QuantumFunctionCall
+from classiq.interface.model.quantum_function_declaration import (
+    AnonPositionalArg,
+    AnonQuantumFunctionDeclaration,
+    AnonQuantumOperandDeclaration,
+    NamedParamsQuantumFunctionDeclaration,
+    QuantumOperandDeclaration,
+)
+from classiq.interface.model.quantum_lambda_function import (
+    OperandIdentifier,
+    QuantumLambdaFunction,
+)
+
+from classiq.model_expansions.visitors.variable_references import VarRefCollector
+
+
+def _get_expressions(arg: ArgValue) -> list[Expression]:
+    if isinstance(arg, Expression):
+        return [arg]
+    if isinstance(arg, HandleBinding):
+        return arg.expressions()
+    if isinstance(arg, OperandIdentifier):
+        return [arg.index]
+    if isinstance(arg, list):
+        return list(chain.from_iterable(_get_expressions(item) for item in arg))
+    return []
+
+
+def _get_param_expressions(param: AnonPositionalArg) -> list[Expression]:
+    if isinstance(param, AnonClassicalParameterDeclaration):
+        return param.classical_type.expressions
+    if isinstance(param, AnonQuantumOperandDeclaration):
+        return list(
+            chain.from_iterable(
+                _get_param_expressions(nested_param)
+                for nested_param in param.positional_arg_declarations
+            )
+        )
+    return param.quantum_type.expressions
+
+
+class SymbolicParamInference(ModelVisitor):
+    def __init__(
+        self,
+        functions: list[NativeFunctionDefinition],
+        additional_signatures: (
+            list[NamedParamsQuantumFunctionDeclaration] | None
+        ) = None,
+    ) -> None:
+        self._functions = nameables_to_dict(functions)
+        self._additional_signatures = (
+            {}
+            if additional_signatures is None
+            else nameables_to_dict(additional_signatures)
+        )
+        self._inferred_funcs: set[str] = set()
+        self._call_stack: list[str] = []
+        self._scope: Mapping[str, ClassicalType] = {}
+        self._scope_operands: dict[str, QuantumOperandDeclaration] = {}
+
+    def infer(self) -> None:
+        for func in self._functions.values():
+            self._infer_func_params(func)
+
+    def _is_recursive_call(self, func: str) -> bool:
+        return func in self._call_stack
+
+    @contextmanager
+    def function_context(
+        self,
+        func_name: Optional[str],
+        scope: Mapping[str, ClassicalType],
+        scope_operands: dict[str, QuantumOperandDeclaration],
+    ) -> Iterator[None]:
+        if func_name is not None:
+            self._call_stack.append(func_name)
+        prev_scope = self._scope
+        self._scope = scope
+        prev_scope_ops = self._scope_operands
+        self._scope_operands = scope_operands
+        yield
+        self._scope = prev_scope
+        self._scope_operands = prev_scope_ops
+        if func_name is not None:
+            self._call_stack.pop()
+
+    def _infer_func_params(self, func: NativeFunctionDefinition) -> None:
+        if func.name in self._inferred_funcs:
+            return
+        scope = {param.name: param.classical_type for param in func.param_decls}
+        scope_operands = func.operand_declarations_dict
+        with self.function_context(func.name, scope, scope_operands):
+            for param in func.positional_arg_declarations:
+                for expr in _get_param_expressions(param):
+                    self._process_compile_time_expression(expr.expr)
+            self._set_enums_generative(func)
+            self.visit(func.body)
+        self._inferred_funcs.add(func.name)
+
+    def _set_enums_generative(self, decl: AnonQuantumFunctionDeclaration) -> None:
+        for param in decl.positional_arg_declarations:
+            if (
+                isinstance(param, AnonClassicalParameterDeclaration)
+                and param.name is not None
+                and isinstance(param.classical_type, TypeName)
+                and param.classical_type.is_enum
+            ):
+                self._scope[param.name].set_generative()
+
+    def visit_QuantumLambdaFunction(self, func: QuantumLambdaFunction) -> None:
+        func.set_op_decl(func.func_decl.model_copy(deep=True))
+        scope = dict(self._scope) | {
+            cast(str, param.name): param.classical_type
+            for param in func.named_func_decl.param_decls
+        }
+        scope_operands = self._scope_operands | nameables_to_dict(
+            cast(
+                Sequence[QuantumOperandDeclaration],
+                func.named_func_decl.operand_declarations,
+            )
+        )
+        with self.function_context(None, scope, scope_operands):
+            self._set_enums_generative(func.named_func_decl)
+            self.visit(func.body)
+
+    def visit_QuantumFunctionCall(self, call: QuantumFunctionCall) -> None:
+        self._process_compile_time_expressions(call.function)
+        name = call.func_name
+        if self._is_recursive_call(name):
+            return  # Recursion is not fully supported
+        params = self._get_params(call)
+        for param, arg in zip_longest(params, call.positional_args):
+            if (
+                not isinstance(param, AnonClassicalParameterDeclaration)
+                or param.classical_type.is_generative
+            ):
+                self._process_compile_time_expressions(arg)
+            else:
+                for expr in _get_expressions(arg):
+                    self._process_nested_compile_time_expression(expr.expr)
+        self.generic_visit(call)
+
+    def _get_params(self, call: QuantumFunctionCall) -> Sequence[AnonPositionalArg]:
+        name = call.func_name
+        if name in self._scope_operands:
+            return self._scope_operands[name].positional_arg_declarations
+        elif name in self._functions:
+            func = self._functions[name]
+            self._infer_func_params(func)
+            return func.positional_arg_declarations
+        elif name in self._additional_signatures:
+            return self._additional_signatures[name].positional_arg_declarations
+        return call.func_decl.positional_arg_declarations
+
+    def _process_compile_time_expressions(self, arg: ArgValue) -> None:
+        for expr in _get_expressions(arg):
+            self._process_compile_time_expression(expr.expr)
+
+    def _process_compile_time_expression(self, expr: str) -> None:
+        vrc = VarRefCollector(
+            ignore_duplicated_handles=True, ignore_sympy_symbols=True, unevaluated=True
+        )
+        vrc.visit(ast.parse(expr))
+        for handle in vrc.var_handles:
+            if handle.name in self._scope and (
+                not isinstance(handle, FieldHandleBinding)
+                or handle.field not in CLASSICAL_ATTRIBUTES
+            ):
+                self._scope[handle.name].set_generative()
+
+    def _process_nested_compile_time_expression(self, expr: str) -> None:
+        vrc = VarRefCollector(
+            ignore_duplicated_handles=True, ignore_sympy_symbols=True, unevaluated=True
+        )
+        vrc.visit(ast.parse(expr))
+        for handle in vrc.var_handles:
+            for nested_expr in handle.expressions():
+                self._process_compile_time_expression(nested_expr.expr)

classiq/open_library/functions/__init__.py

@@ -98,6 +98,7 @@ __all__ = [
     "grover_search",
     "hadamard_transform",
     "inplace_c_modular_multiply",
+    "inplace_prepare_complex_amplitudes",
     "inplace_prepare_int",
     "linear_pauli_rotations",
     "modular_exp",
@@ -105,6 +106,7 @@ __all__ = [
     "multiswap",
     "phase_oracle",
     "prepare_bell_state",
+    "prepare_complex_amplitudes",
     "prepare_exponential_state",
     "prepare_ghz_state",
     "prepare_int",

classiq/open_library/functions/amplitude_amplification.py

@@ -1,3 +1,5 @@
+import numpy as np
+
 from classiq.open_library.functions.grover import grover_operator
 from classiq.qmod.builtins.functions.standard_gates import RY
 from classiq.qmod.builtins.operations import (
@@ -11,7 +13,7 @@ from classiq.qmod.cparam import CInt, CReal
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import QArray, QBit
 from classiq.qmod.quantum_callable import QCallable
-from classiq.qmod.symbolic import acos, asin, ceiling, pi, sin
+from classiq.qmod.symbolic import acos, asin, ceiling, sin
 
 
 @qfunc
@@ -67,8 +69,8 @@ def exact_amplitude_amplification(
         packed_vars: The variable that holds the state to be amplified. Assumed to be in the zero state at the beginning of the algorithm.
     """
     aux = QBit()
-    k = ceiling((pi / (4 * asin(amplitude))) - 0.5)
-    theta = pi / (4 * k + 2)
+    k = ceiling((np.pi / (4 * asin(amplitude))) - 0.5)
+    theta = np.pi / (4 * k + 2)
     rot_phase = 2 * acos(sin(theta) / amplitude)
 
     extended_qvars: QArray = QArray()

classiq/open_library/functions/state_preparation.py

@@ -1,12 +1,23 @@
 import warnings
 from typing import Literal
 
+import numpy as np
+import sympy
+
 from classiq.interface.exceptions import ClassiqDeprecationWarning
 
 from classiq.open_library.functions.utility_functions import hadamard_transform
-from classiq.qmod.builtins.functions.standard_gates import CX, IDENTITY, RY, H, X
+from classiq.qmod.builtins.functions import (
+    CX,
+    IDENTITY,
+    RY,
+    RZ,
+    H,
+    X,
+    inplace_prepare_amplitudes,
+)
 from classiq.qmod.builtins.operations import allocate, control, if_, inplace_add, repeat
-from classiq.qmod.cparam import CBool, CInt
+from classiq.qmod.cparam import CArray, CBool, CInt, CReal
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
 from classiq.qmod.symbolic import (
@@ -298,3 +309,85 @@ def prepare_int(
         stacklevel=1,
     )
     out |= value
+
+
+def _control_qubit(i: int) -> int:
+    if _msb(_graycode(i)) < _msb(_graycode(i + 1)):
+        return (_graycode(i) & _graycode(i + 1)).bit_length() - 1
+    return (_graycode(i) ^ _graycode(i + 1)).bit_length() - 1
+
+
+def _graycode(i: int) -> int:
+    return i ^ (i >> 1)
+
+
+def _msb(x: int) -> int:
+    """
+    largest non zero bit
+    """
+    if x == 0:
+        return 0
+    return x.bit_length() - 1
+
+
+def _classical_hadamard_transform(arr: list[float]) -> np.ndarray:
+    return 1 / np.sqrt(len(arr)) * np.array(sympy.fwht(np.array(arr)))
+
+
+@qfunc(generative=True)
+def _load_phases(
+    phases: list[float],
+    target: QArray[QBit, Literal["log(get_field(phases, 'len'), 2)"]],
+) -> None:
+    alphas = -2 * _classical_hadamard_transform(phases) / np.sqrt(len(phases))
+
+    for i in range(1, len(alphas) - 1):
+        gray = _graycode(i)
+        next_gray = _graycode(i + 1)
+        RZ(alphas[gray], target[_msb(gray)])
+        CX(target[_control_qubit(i)], target[_msb(next_gray)])
+
+    RZ(alphas[_graycode(len(phases) - 1)], target[target.len - 1])
+
+
+@qfunc
+def inplace_prepare_complex_amplitudes(
+    magnitudes: CArray[CReal],
+    phases: CArray[CReal],
+    target: QArray[QBit, Literal["log(get_field(magnitudes, 'len'), 2)"]],
+) -> None:
+    """
+
+    [Qmod Classiq-library function]
+
+    Prepares a quantum state with amplitudes and phases for each state according to the given parameters, in polar representation.
+    Expects to act on an initialized zero state $|0\\rangle$.
+
+    Args:
+        magnitudes: Absolute values of the state amplitudes.
+        phases: phases of the state amplitudes. should be of the same size as `amplitudes`.
+        target: The quantum variable to act upon.
+    """
+    inplace_prepare_amplitudes(magnitudes, 0, target)
+    _load_phases(phases, target)
+
+
+@qfunc
+def prepare_complex_amplitudes(
+    magnitudes: CArray[CReal],
+    phases: CArray[CReal],
+    out: Output[QArray[QBit, Literal["log(get_field(magnitudes, 'len'), 2)"]]],
+) -> None:
+    """
+
+    [Qmod Classiq-library function]
+
+    Initializes and prepares a quantum state with amplitudes and phases for each state according to the given parameters, in polar representation.
+
+    Args:
+        magnitudes: Absolute values of the state amplitudes.
+        phases: phases of the state amplitudes. should be of the same size as `amplitudes`.
+        out: The allocated quantum variable. Must be uninitialized.
+    """
+    allocate(out)
+    inplace_prepare_complex_amplitudes(magnitudes, phases, out)

classiq/qmod/model_state_container.py

@@ -24,13 +24,16 @@ class ModelStateContainer:
     generative_functions: dict[str, "GenerativeQFunc"]
     function_dependencies: dict[str, list[str]]
 
+    def reset(self) -> None:
+        self.enum_decls = {}
+        self.type_decls = {}
+        self.qstruct_decls = {}
+        self.native_defs = {}
+        self.constants = {}
+        self.functions_compilation_metadata = {}
+        self.generative_functions = {}
+        self.function_dependencies = defaultdict(list)
+
 
 QMODULE = ModelStateContainer()
-QMODULE.enum_decls = {}
-QMODULE.type_decls = {}
-QMODULE.qstruct_decls = {}
-QMODULE.native_defs = {}
-QMODULE.constants = {}
-QMODULE.functions_compilation_metadata = {}
-QMODULE.generative_functions = {}
-QMODULE.function_dependencies = defaultdict(list)
+QMODULE.reset()

classiq/qmod/qmod_variable.py

@@ -22,7 +22,12 @@ from typing import (  # type: ignore[attr-defined]
 
 from typing_extensions import ParamSpec, Self, _AnnotatedAlias
 
-from classiq.interface.exceptions import ClassiqInternalError, ClassiqValueError
+from classiq.interface.exceptions import (
+    ClassiqInternalError,
+    ClassiqNotImplementedError,
+    ClassiqValueError,
+)
+from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
 from classiq.interface.generator.expressions.proxies.quantum.qmod_qarray_proxy import (
@@ -340,6 +345,23 @@ class QNum(Generic[_P], QScalar):
                 return interpret_expression(str(self.is_signed))
         return CParamScalar(f"get_field({self}, 'is_signed')")
 
+    def get_maximal_bounds(self) -> tuple[float, float]:
+        if not is_generative_mode():
+            raise ClassiqNotImplementedError(
+                "get_maximal_bounds() is supported in generative mode only"
+            )
+
+        if TYPE_CHECKING:
+            assert isinstance(self.size, int)
+            assert isinstance(self.is_signed, bool)
+            assert isinstance(self.fraction_digits, int)
+
+        return RegisterArithmeticInfo.get_maximal_bounds(
+            size=self.size,
+            is_signed=self.is_signed,
+            fraction_places=self.fraction_digits,
+        )
+
     # Support comma-separated generic args in older Python versions
     if sys.version_info[0:2] < (3, 10):
 

classiq/qmod/quantum_function.py

@@ -1,7 +1,6 @@
 import ast
 import functools
 from abc import abstractmethod
-from collections import defaultdict
 from dataclasses import is_dataclass
 from enum import EnumMeta
 from inspect import isclass
@@ -120,14 +119,7 @@ class QFunc(BaseQFunc):
         preferences: Optional[Preferences] = None,
         classical_execution_function: Optional[CFunc] = None,
     ) -> Model:
-        self._qmodule.enum_decls = dict()
-        self._qmodule.type_decls = dict()
-        self._qmodule.qstruct_decls = dict()
-        self._qmodule.native_defs = dict()
-        self._qmodule.constants = dict()
-        self._qmodule.functions_compilation_metadata = dict()
-        self._qmodule.generative_functions = dict()
-        self._qmodule.function_dependencies = defaultdict(list)
+        self._qmodule.reset()
         QConstant.set_current_model(self._qmodule)
         self.expand()
         model_extra_settings: list[tuple[str, Any]] = [

classiq/qmod/symbolic_expr.py

@@ -4,6 +4,8 @@ import ast
 from enum import Enum as PythonEnum
 from typing import Any
 
+import sympy
+
 from classiq.qmod.utilities import qmod_val_to_expr_str
 
 
@@ -33,10 +35,14 @@ class SymbolicExpr(Symbolic):
 
     @staticmethod
     def _binary_op(lhs: Any, rhs: Any, op: str) -> SymbolicExpr:
-        if not isinstance(lhs, (SymbolicExpr, int, float, bool, PythonEnum)):
+        if not isinstance(
+            lhs, (SymbolicExpr, int, float, bool, PythonEnum, sympy.Basic)
+        ):
             raise TypeError(f"Invalid lhs argument {lhs!r} for binary operation {op!r}")
 
-        if not isinstance(rhs, (SymbolicExpr, int, float, bool, PythonEnum)):
+        if not isinstance(
+            rhs, (SymbolicExpr, int, float, bool, PythonEnum, sympy.Basic)
+        ):
             raise TypeError(f"Invalid lhs argument {rhs!r} for binary operation {op!r}")
 
         lhs_str = qmod_val_to_expr_str(lhs)

classiq/qmod/write_qmod.py

@@ -1,6 +1,6 @@
 import json
 from pathlib import Path
-from typing import Optional, Union
+from typing import Any, Optional, Union
 
 from classiq.interface.model.model import Model, SerializedModel
 
@@ -17,6 +17,8 @@ def write_qmod(
     name: str,
     directory: Optional[Path] = None,
     decimal_precision: int = DEFAULT_DECIMAL_PRECISION,
+    *args: Any,
+    **kwargs: Any,
 ) -> None:
     """
     Creates a native Qmod file from a serialized model and outputs the synthesis options (Preferences and Constraints) to a file.
@@ -27,6 +29,8 @@ def write_qmod(
         name: The name to save the file by.
         directory: The directory to save the files in. If None, the current working directory is used.
         decimal_precision: The number of decimal places to use for numbers, set to 4 by default.
+        args: (placeholder)
+        kwargs: (placeholder)
 
     Returns:
         None

{classiq-0.73.0.dist-info → classiq-0.75.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: classiq
-Version: 0.73.0
+Version: 0.75.0
 Summary: Classiq's Python SDK for quantum computing
 License: Proprietary
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL
@@ -53,6 +53,7 @@ Requires-Dist: tabulate (>=0.8.9,<1)
 Requires-Dist: torch ; extra == "qml"
 Requires-Dist: torchvision ; extra == "qml"
 Requires-Dist: tqdm (>=4.67.1,<5.0.0)
+Requires-Dist: zstandard (>=0.23.0,<0.24.0)
 Description-Content-Type: text/markdown
 
 <p align="center">