classiq 0.94.2__py3-none-any.whl → 0.96.0__py3-none-any.whl

classiq/qmod/builtins/operations.py

@@ -1,11 +1,15 @@
 import inspect
 import sys
 from collections.abc import Callable, Mapping
+from functools import wraps
+from itertools import product
 from types import FrameType
 from typing import (
     Any,
     Final,
     NoReturn,
+    ParamSpec,
+    TypeVar,
     overload,
 )
 
@@ -45,16 +49,37 @@ from classiq.interface.model.skip_control import SkipControl
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.within_apply_operation import WithinApply
 
+from classiq.qmod.builtins.functions import H, S
 from classiq.qmod.generative import is_generative_mode
 from classiq.qmod.qmod_constant import QConstant
 from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum, QScalar, QVar
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_expandable import prepare_arg
+from classiq.qmod.semantics.error_manager import ErrorManager
 from classiq.qmod.symbolic_expr import SymbolicExpr
-from classiq.qmod.utilities import Statements, get_source_ref, suppress_return_value
+from classiq.qmod.utilities import (
+    RealFunction,
+    Statements,
+    get_source_ref,
+    qnum_values,
+    suppress_return_value,
+)
 
 _MISSING_VALUE: Final[int] = -1
 
+_Params = ParamSpec("_Params")
+_RetType = TypeVar("_RetType")
+
+
+def qmod_statement(func: Callable[_Params, _RetType]) -> Callable[_Params, _RetType]:
+    @wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        source_ref = get_source_ref(sys._getframe(1))
+        with ErrorManager().source_ref_context(source_ref):
+            return func(*args, **kwargs)
+
+    return wrapper
+
 
 @overload
 def allocate(num_qubits: int | SymbolicExpr, out: Output[QVar]) -> None:
@@ -77,6 +102,7 @@ def allocate(
 
 
 @suppress_return_value
+@qmod_statement
 def allocate(*args: Any, **kwargs: Any) -> None:
     """
     Initialize a quantum variable to a new quantum object in the zero state:
@@ -100,29 +126,34 @@ def allocate(*args: Any, **kwargs: Any) -> None:
         2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     if len(args) == 0:
         size = kwargs.get("num_qubits", None)
         is_signed = kwargs.get("is_signed", None)
         fraction_digits = kwargs.get("fraction_digits", None)
-        target = kwargs["out"]
+        out = kwargs["out"]
     elif len(args) == 1:
         if "out" in kwargs:
             size = args[0]
             is_signed = kwargs.get("is_signed", None)
             fraction_digits = kwargs.get("fraction_digits", None)
-            target = kwargs["out"]
+            out = kwargs["out"]
         else:
             size = None
             is_signed = None
             fraction_digits = None
-            target = args[0]
+            out = args[0]
     elif len(args) == 2:
-        size, target = args
+        size, out = args
         is_signed = kwargs.get("is_signed", None)
         fraction_digits = kwargs.get("fraction_digits", None)
     else:
-        size, is_signed, fraction_digits, target = args
+        size, is_signed, fraction_digits, out = args
+    if not isinstance(out, QVar):
+        raise ClassiqValueError(
+            f"Argument 'out' of operator 'allocate' must be a quantum variable, got "
+            f"{type(out).__name__}"
+        )
     if isinstance(size, QConstant):
         size.add_to_model()
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
@@ -134,13 +165,14 @@ def allocate(*args: Any, **kwargs: Any) -> None:
                 if fraction_digits is None
                 else Expression(expr=str(fraction_digits))
             ),
-            target=target.get_handle_binding(),
+            target=out.get_handle_binding(),
             source_ref=source_ref,
         )
     )
 
 
 @suppress_return_value
+@qmod_statement
 def bind(
     source: Input[QVar] | list[Input[QVar]],
     destination: Output[QVar] | list[Output[QVar]],
@@ -162,7 +194,7 @@ def bind(
     For more details, see [Qmod Reference](https://docs.classiq.io/latest/qmod-reference/language-reference/statements/bind).
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     if not isinstance(source, list):
         source = [source]
     if not isinstance(destination, list):
@@ -177,6 +209,7 @@ def bind(
 
 
 @suppress_return_value
+@qmod_statement
 def if_(
     condition: SymbolicExpr | bool,
     then: QCallable | Callable[[], Statements],
@@ -198,7 +231,7 @@ def if_(
     if else_ != _MISSING_VALUE:
         _validate_operand(else_)
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
 
     if_stmt = ClassicalIf(
         condition=Expression(expr=str(condition)),
@@ -214,6 +247,7 @@ def if_(
 
 
 @suppress_return_value
+@qmod_statement
 def control(
     ctrl: SymbolicExpr | QBit | QArray[QBit] | list[QVar],
     stmt_block: QCallable | Callable[[], Statements],
@@ -237,7 +271,7 @@ def control(
     """
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     control_stmt = Control(
         expression=Expression(expr=str(ctrl)),
         body=_operand_to_body(stmt_block, "stmt_block"),
@@ -252,6 +286,7 @@ def control(
 
 
 @suppress_return_value
+@qmod_statement
 def skip_control(stmt_block: QCallable | Callable[[], Statements]) -> None:
     """
     Applies quantum statements unconditionally.
@@ -263,7 +298,7 @@ def skip_control(stmt_block: QCallable | Callable[[], Statements]) -> None:
     """
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     sc_stmt = SkipControl(
         body=_operand_to_body(stmt_block, "stmt_block"),
         source_ref=source_ref,
@@ -274,6 +309,7 @@ def skip_control(stmt_block: QCallable | Callable[[], Statements]) -> None:
 
 
 @suppress_return_value
+@qmod_statement
 def assign(expression: SymbolicExpr, target_var: QScalar) -> None:
     """
     Initialize a scalar quantum variable using an arithmetic expression.
@@ -287,7 +323,7 @@ def assign(expression: SymbolicExpr, target_var: QScalar) -> None:
         target_var: An uninitialized scalar quantum variable
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         ArithmeticOperation(
             expression=Expression(expr=str(expression)),
@@ -299,6 +335,7 @@ def assign(expression: SymbolicExpr, target_var: QScalar) -> None:
 
 
 @suppress_return_value
+@qmod_statement
 def assign_amplitude(expression: SymbolicExpr, target_var: QScalar) -> None:
     """
     Perform an amplitude-encoding assignment operation on a quantum variable and a
@@ -311,7 +348,7 @@ def assign_amplitude(expression: SymbolicExpr, target_var: QScalar) -> None:
         target_var: A scalar quantum variable
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         AmplitudeLoadingOperation(
             expression=Expression(expr=str(expression)),
@@ -322,6 +359,7 @@ def assign_amplitude(expression: SymbolicExpr, target_var: QScalar) -> None:
 
 
 @suppress_return_value
+@qmod_statement
 def inplace_add(expression: SymbolicExpr, target_var: QScalar) -> None:
     """
     Add an arithmetic expression to a quantum variable.
@@ -333,7 +371,7 @@ def inplace_add(expression: SymbolicExpr, target_var: QScalar) -> None:
         target_var: A scalar quantum variable
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         ArithmeticOperation(
             expression=Expression(expr=str(expression)),
@@ -345,6 +383,7 @@ def inplace_add(expression: SymbolicExpr, target_var: QScalar) -> None:
 
 
 @suppress_return_value
+@qmod_statement
 def inplace_xor(expression: SymbolicExpr, target_var: QScalar) -> None:
     """
     Bitwise-XOR a quantum variable with an arithmetic expression.
@@ -356,7 +395,7 @@ def inplace_xor(expression: SymbolicExpr, target_var: QScalar) -> None:
         target_var: A scalar quantum variable
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         ArithmeticOperation(
             expression=Expression(expr=str(expression)),
@@ -368,6 +407,7 @@ def inplace_xor(expression: SymbolicExpr, target_var: QScalar) -> None:
 
 
 @suppress_return_value
+@qmod_statement
 def within_apply(
     within: Callable[[], Statements],
     apply: Callable[[], Statements],
@@ -387,7 +427,7 @@ def within_apply(
     _validate_operand(within)
     _validate_operand(apply)
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     within_apply_stmt = WithinApply(
         compute=_operand_to_body(within, "within"),
         action=_operand_to_body(apply, "apply"),
@@ -400,6 +440,7 @@ def within_apply(
 
 
 @suppress_return_value
+@qmod_statement
 def repeat(count: SymbolicExpr | int, iteration: Callable[[int], Statements]) -> None:
     """
     Executes a quantum loop a specified number of times, applying a quantum operation on each iteration.
@@ -426,7 +467,7 @@ def repeat(count: SymbolicExpr | int, iteration: Callable[[int], Statements]) ->
     """
     _validate_operand(iteration, num_params=1)
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     iteration_operand = prepare_arg(
         QuantumOperandDeclaration(
             name=REPEAT_OPERATOR_NAME,
@@ -455,6 +496,7 @@ def repeat(count: SymbolicExpr | int, iteration: Callable[[int], Statements]) ->
 
 
 @suppress_return_value
+@qmod_statement
 def power(
     exponent: SymbolicExpr | int,
     stmt_block: QCallable | Callable[[], Statements],
@@ -489,7 +531,7 @@ def power(
     """
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     power_stmt = Power(
         power=Expression(expr=str(exponent)),
         body=_operand_to_body(stmt_block, "stmt_block"),
@@ -501,6 +543,7 @@ def power(
 
 
 @suppress_return_value
+@qmod_statement
 def invert(stmt_block: QCallable | Callable[[], Statements]) -> None:
     """
     Apply the inverse of a quantum gate.
@@ -525,7 +568,7 @@ def invert(stmt_block: QCallable | Callable[[], Statements]) -> None:
     """
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     invert_stmt = Invert(
         body=_operand_to_body(stmt_block, "stmt_block"), source_ref=source_ref
     )
@@ -535,6 +578,7 @@ def invert(stmt_block: QCallable | Callable[[], Statements]) -> None:
 
 
 @suppress_return_value
+@qmod_statement
 def phase(
     phase_expr: SymbolicExpr | float | None = None,
     theta: SymbolicExpr | float = 1.0,
@@ -557,7 +601,7 @@ def phase(
         they are equivalent when the phase_expr is a single-qubit variable.
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         PhaseOperation(
             expression=Expression(expr=str(phase_expr)),
@@ -568,12 +612,13 @@ def phase(
 
 
 @suppress_return_value
+@qmod_statement
 def block(
     statements: QCallable | Callable[[], Statements],
 ) -> None:
     _validate_operand(statements)
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
 
     block_stmt = Block(
         statements=_operand_to_body(statements, "statements"),
@@ -601,13 +646,14 @@ def reset_bounds(
 
 
 @suppress_return_value
+@qmod_statement
 def reset_bounds(
     target_var: QNum,
     lower_bound: float | SymbolicExpr | None = None,
     upper_bound: float | SymbolicExpr | None = None,
 ) -> None:
     assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(1))
+    source_ref = get_source_ref(sys._getframe(2))
 
     lower_bound_expr = (
         None if lower_bound is None else Expression(expr=str(lower_bound))
@@ -733,10 +779,65 @@ def _operand_to_body(
         raise ValueError(f"Unexpected operand type: {type(to_operand)}")
 
 
+def assign_amplitude_poly_sin(indicator: QBit, expr: Callable, *vars: QNum) -> None:
+    """
+    Encodes the value of the sine/cosine of a polynomial into the amplitude of the
+    respective computational basis state:
+    \\( |x_1, x_2, \\ldots, x_n\\rangle|0\\rangle \\rightarrow cos(poly(x_1, x_2, \\ldots, x_n)) + sin(poly(x_1, x_2, \\ldots, x_n))|x_1, x_2, \\ldots, x_n\\rangle|1\\rangle \\)
+
+    Args:
+        indicator: The quantum indicator qubit
+        expr: A polynomial function over `len(vars)` QNums
+        *vars: Quantum numerics
+    """
+    phase(-expr(*vars))
+    within_apply(
+        lambda: H(indicator),
+        lambda: control(indicator, lambda: phase(2 * expr(*vars))),
+    )
+    S(indicator)
+
+
+def _get_qnum_values(num: QNum) -> list[float]:
+    size = num.size
+    is_signed = num.is_signed
+    fraction_digits = num.fraction_digits
+    if (
+        not isinstance(size, int)
+        or not isinstance(is_signed, bool)
+        or not isinstance(fraction_digits, int)
+    ):
+        raise ClassiqValueError(f"QNum argument {str(num)!r} has symbolic attributes")
+
+    return qnum_values(size, is_signed, fraction_digits)
+
+
+def lookup_table(func: RealFunction, targets: QNum | list[QNum]) -> list[float]:
+    """
+    Reduces a classical function into a lookup table over all the possible values
+    of the quantum numbers.
+
+    Args:
+        func: A Python function
+        targets: One or more initialized quantum numbers
+
+    Returns:
+        The function's lookup table
+
+    Notes:
+        The QNum arguments must have generative attributes
+    """
+    if not isinstance(targets, list):
+        targets = [targets]
+    target_vals = [_get_qnum_values(target) for target in targets]
+    return [func(*vals[::-1]) for vals in product(*target_vals[::-1])]
+
+
 __all__ = [
     "allocate",
     "assign",
     "assign_amplitude",
+    "assign_amplitude_poly_sin",
     "bind",
     "block",
     "control",
@@ -744,6 +845,7 @@ __all__ = [
     "inplace_add",
     "inplace_xor",
     "invert",
+    "lookup_table",
     "phase",
     "power",
     "repeat",

classiq/qmod/builtins/structs.py

@@ -3,6 +3,7 @@ from typing import Union
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.helpers.datastructures import LenList
 from classiq.interface.helpers.text_utils import are, readable_list, s
 
 from classiq.qmod.builtins.enums import Pauli
@@ -69,13 +70,15 @@ class SparsePauliOp:
     def __mul__(self, obj: Union[float, "SparsePauliOp"]) -> "SparsePauliOp":
         if isinstance(obj, (int, float, complex)):
             return SparsePauliOp(
-                terms=[
-                    SparsePauliTerm(
-                        paulis=term.paulis,
-                        coefficient=obj * term.coefficient,  # type:ignore[arg-type]
-                    )
-                    for term in self.terms
-                ],
+                terms=LenList(
+                    [
+                        SparsePauliTerm(
+                            paulis=term.paulis,
+                            coefficient=obj * term.coefficient,  # type:ignore[arg-type]
+                        )
+                        for term in self.terms
+                    ]
+                ),
                 num_qubits=self.num_qubits,
             )
         if len(self.terms) != 1 or len(obj.terms) != 1:
@@ -97,14 +100,17 @@ class SparsePauliOp:
                 f"already assigned"
             )
         return SparsePauliOp(
-            terms=[
-                SparsePauliTerm(
-                    paulis=self.terms[0].paulis
-                    + obj.terms[0].paulis,  # type:ignore[arg-type]
-                    coefficient=self.terms[0].coefficient
-                    * obj.terms[0].coefficient,  # type:ignore[arg-type]
-                )
-            ],
+            terms=LenList(
+                [
+                    SparsePauliTerm(
+                        paulis=LenList(  # type:ignore[call-overload]
+                            self.terms[0].paulis + obj.terms[0].paulis
+                        ),
+                        coefficient=self.terms[0].coefficient
+                        * obj.terms[0].coefficient,  # type:ignore[arg-type]
+                    )
+                ]
+            ),
             num_qubits=max(self.num_qubits, obj.num_qubits),
         )
 
@@ -113,7 +119,7 @@ class SparsePauliOp:
 
     def __add__(self, other: "SparsePauliOp") -> "SparsePauliOp":
         return SparsePauliOp(
-            terms=self.terms + other.terms,
+            terms=LenList(self.terms + other.terms),
             num_qubits=max(self.num_qubits, other.num_qubits),
         )
 
@@ -156,21 +162,6 @@ class LogNormalModel:
     sigma: CReal
 
 
-@dataclass
-class QsvmResult:
-    test_score: CReal
-    predicted_labels: CArray[CReal]
-
-
-@dataclass
-class QSVMFeatureMapPauli:
-    feature_dimension: CInt
-    reps: CInt
-    entanglement: CInt
-    alpha: CReal
-    paulis: CArray[CArray[Pauli]]
-
-
 BUILTIN_STRUCT_DECLARATIONS = {
     struct_decl.__name__: StructDeclaration(
         name=struct_decl.__name__,
@@ -190,8 +181,6 @@ __all__ = [
     "IndexedPauli",
     "LogNormalModel",
     "PauliTerm",
-    "QSVMFeatureMapPauli",
-    "QsvmResult",
     "SparsePauliOp",
     "SparsePauliTerm",
 ]

classiq/qmod/semantics/annotation/call_annotation.py

@@ -4,7 +4,7 @@ from typing import Any
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.model.model import Model
-from classiq.interface.model.model_visitor import ModelVisitor
+from classiq.interface.model.model_visitor import ModelStatementsVisitor
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
@@ -47,7 +47,7 @@ def _annotate_function_call_decl(
                 qlambda.set_op_decl(param)
 
 
-class _CallLambdaAnnotator(ModelVisitor):
+class _CallLambdaAnnotator(ModelStatementsVisitor):
     def __init__(
         self, quantum_functions: Mapping[str, QuantumFunctionDeclaration]
     ) -> None:
@@ -76,7 +76,7 @@ class _CallLambdaAnnotator(ModelVisitor):
         _annotate_function_call_decl(
             call, self._quantum_functions | self._current_operands
         )
-        self.generic_visit(call)
+        self.visit(call.positional_args)
 
 
 def resolve_function_calls(

classiq/qmod/semantics/error_manager.py

@@ -1,7 +1,6 @@
 from collections.abc import Iterator
 from contextlib import contextmanager
 
-from classiq.interface.ast_node import ASTNode
 from classiq.interface.exceptions import CLASSIQ_SLACK_COMMUNITY_LINK
 from classiq.interface.source_reference import SourceReference, SourceReferencedError
 
@@ -18,14 +17,14 @@ class ErrorManager:
         self._instantiated = True
         self._errors: list[SourceReferencedError] = []
         self._warnings: list[SourceReferencedError] = []
-        self._current_nodes_stack: list[ASTNode] = []
+        self._current_refs_stack: list[SourceReference | None] = []
         self._call_stack: list[str] = []
         self._ignore_errors: bool = False
 
     @property
     def _current_source_ref(self) -> SourceReference | None:
-        if self._current_nodes_stack:
-            return self._current_nodes_stack[-1].source_ref
+        if self._current_refs_stack:
+            return self._current_refs_stack[-1]
         return None
 
     @contextmanager
@@ -79,7 +78,7 @@ class ErrorManager:
         self.clear_warnings()
 
     def clear_errors(self) -> None:
-        self._current_nodes_stack = []
+        self._current_refs_stack = []
         self._errors = []
 
     def clear_warnings(self) -> None:
@@ -108,10 +107,10 @@ class ErrorManager:
         return self._call_stack[-1] if self._call_stack else None
 
     @contextmanager
-    def node_context(self, node: ASTNode) -> Iterator[None]:
-        self._current_nodes_stack.append(node)
+    def source_ref_context(self, ref: SourceReference | None) -> Iterator[None]:
+        self._current_refs_stack.append(ref)
         yield
-        self._current_nodes_stack.pop()
+        self._current_refs_stack.pop()
 
     @contextmanager
     def call(self, func_name: str) -> Iterator[None]:

classiq/qmod/utilities.py

@@ -3,7 +3,6 @@ import inspect
 import itertools
 import keyword
 import sys
-from collections import Counter
 from collections.abc import Callable, Iterable
 from enum import Enum as PythonEnum
 from types import FrameType
@@ -195,13 +194,4 @@ def qnum_attributes(max_size: int) -> list[tuple[int, bool, int]]:
     ]
 
 
-_VAR_NAME_COUNTER: Counter[str] = Counter()
-
-
-def get_temp_var_name(var_name: str = "temp") -> str:
-    n = _VAR_NAME_COUNTER[var_name]
-    _VAR_NAME_COUNTER[var_name] += 1
-    return f"{var_name}_{n}"
-
-
 RealFunction = Callable[Params, float]

{classiq-0.94.2.dist-info → classiq-0.96.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: classiq
-Version: 0.94.2
+Version: 0.96.0
 Summary: Classiq's Python SDK for quantum computing
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL
 Author: Classiq Technologies