classiq 0.102.0__py3-none-any.whl → 0.104.0__py3-none-any.whl

classiq/qmod/builtins/operations.py

@@ -1,6 +1,5 @@
 import inspect
 import sys
-import warnings
 from collections.abc import Callable, Mapping
 from functools import wraps
 from itertools import product
@@ -14,7 +13,7 @@ from typing import (
     overload,
 )
 
-from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqValueError
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
     REPEAT_OPERATOR_NAME,
@@ -33,9 +32,6 @@ from classiq.interface.model.control import Control
 from classiq.interface.model.invert import BlockKind, Invert
 from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.power import Power
-from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
-    AmplitudeLoadingOperation,
-)
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
     ArithmeticOperationKind,
@@ -336,37 +332,6 @@ 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
-    quantum expression.
-
-    Equivalent to `<target_var> *= <expression>`.
-
-    Args:
-        expression: A quantum arithmetic expression
-        target_var: A scalar quantum variable
-    """
-    warnings.warn(
-        "The 'assign_amplitude' function is deprecated and will no longer be "
-        "supported starting on 2025-12-03 at the earliest. Use 'assign_amplitude_table' "
-        "instead",
-        ClassiqDeprecationWarning,
-        stacklevel=3,
-    )
-    assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(2))
-    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        AmplitudeLoadingOperation(
-            expression=Expression(expr=str(expression)),
-            result_var=target_var.get_handle_binding(),
-            source_ref=source_ref,
-        )
-    )
-
-
 @suppress_return_value
 @qmod_statement
 def inplace_add(expression: SymbolicExpr, target_var: QScalar) -> None:
@@ -553,7 +518,7 @@ def power(
 
 @suppress_return_value
 @qmod_statement
-def invert(stmt_block: QCallable | Callable[[], Statements]) -> Callable | None:
+def invert(stmt_block: QCallable | Callable[[], Statements]) -> Any:
     """
     Apply the inverse of a quantum gate.
 
@@ -868,7 +833,6 @@ def lookup_table(func: RealFunction, targets: QNum | list[QNum]) -> list[float]:
 __all__ = [
     "allocate",
     "assign",
-    "assign_amplitude",
     "assign_amplitude_poly_sin",
     "bind",
     "block",

classiq/qmod/native/pretty_printer.py

@@ -51,9 +51,6 @@ from classiq.interface.model.port_declaration import (
     AnonPortDeclaration,
 )
 from classiq.interface.model.power import Power
-from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
-    AmplitudeLoadingOperation,
-)
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
     ArithmeticOperationKind,
@@ -367,12 +364,9 @@ class DSLPrettyPrinter(ModelVisitor):
         return power_code
 
     def visit_Invert(self, invert: Invert) -> str:
+        invert.validate_node()
         match invert.block_kind:
             case BlockKind.SingleCall:
-                if len(invert.body) != 1 or not isinstance(
-                    invert.body[0], QuantumFunctionCall
-                ):
-                    raise ClassiqInternalError("Malformed single-call invert")
                 invert_code = f"{self._indent}invert "
                 invert_code += self.visit(invert.body[0]).lstrip()
             case BlockKind.Compound:
@@ -446,11 +440,6 @@ class DSLPrettyPrinter(ModelVisitor):
             op = "+="
         return f"{self._indent}{self.visit(arith_op.result_var)} {op} {self.visit(arith_op.expression)};\n"
 
-    def visit_AmplitudeLoadingOperation(
-        self, amplitude_loading_op: AmplitudeLoadingOperation
-    ) -> str:
-        return f"{self._indent}{self.visit(amplitude_loading_op.result_var)} *= {self.visit(amplitude_loading_op.expression)};\n"
-
     def _print_bind_handles(self, handles: list[HandleBinding]) -> str:
         if len(handles) == 1:
             return self.visit(handles[0])

classiq/qmod/pretty_print/pretty_printer.py

@@ -52,9 +52,6 @@ from classiq.interface.model.native_function_definition import NativeFunctionDef
 from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.power import Power
-from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
-    AmplitudeLoadingOperation,
-)
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
     ArithmeticOperationKind,
@@ -508,13 +505,10 @@ class PythonPrettyPrinter(ModelVisitor):
         return f"{self._indent}power({self.visit(power.power)}, {self._visit_body(power.body)})\n"
 
     def visit_Invert(self, invert: Invert) -> str:
+        invert.validate_node()
         self._imports["invert"] = 1
         match invert.block_kind:
             case BlockKind.SingleCall:
-                if len(invert.body) != 1 or not isinstance(
-                    invert.body[0], QuantumFunctionCall
-                ):
-                    raise ClassiqInternalError("Malformed single-call invert")
                 call_str = self.visit(invert.body[0])
                 call_str = call_str.replace("(", ")(", 1)
                 return f"{self._indent}invert({call_str}\n"
@@ -540,8 +534,6 @@ class PythonPrettyPrinter(ModelVisitor):
         for i, statement in enumerate(body):
             if isinstance(statement, VariableDeclarationStatement):
                 code += self.visit_VariableDeclarationStatement(statement, walrus=True)
-            elif isinstance(statement, AmplitudeLoadingOperation):
-                code += self.visit_AmplitudeLoadingOperation(statement, in_lambda=True)
             elif isinstance(statement, ArithmeticOperation):
                 code += self.visit_ArithmeticOperation(statement, in_lambda=True)
             else:
@@ -599,14 +591,6 @@ class PythonPrettyPrinter(ModelVisitor):
             return f"{func}({self.visit(arith_op.expression)}, {self._indent}{self.visit(arith_op.result_var)})\n"
         return f"{self._indent}{self.visit(arith_op.result_var)} {op} {self.visit(arith_op.expression)}\n"
 
-    def visit_AmplitudeLoadingOperation(
-        self, amplitude_loading_op: AmplitudeLoadingOperation, in_lambda: bool = False
-    ) -> str:
-        if in_lambda:
-            self._imports["assign_amplitude"] = 1
-            return f"assign_amplitude({self.visit(amplitude_loading_op.expression)}, {self._indent}{self.visit(amplitude_loading_op.result_var)})\n"
-        return f"{self._indent}{self.visit(amplitude_loading_op.result_var)} *= {self.visit(amplitude_loading_op.expression)}\n"
-
     def _print_bind_handles(self, handles: list[HandleBinding]) -> str:
         if len(handles) == 1:
             return self.visit(handles[0])

classiq/qmod/qmod_parameter.py

@@ -63,6 +63,10 @@ class CParamList(CParam):
             else:
                 param_type = self._list_type.element_type
         else:
+            if key.start is None:
+                key = slice(0, key.stop, None)
+            if key.stop is None:
+                key = slice(key.start, self.len, None)
             if not isinstance(self._list_type, ClassicalTuple):
                 param_type = self._list_type
             else:

classiq/qmod/qmod_variable.py

@@ -1,6 +1,5 @@
 import abc
 import sys
-import warnings
 from collections.abc import Iterator, Mapping
 from contextlib import contextmanager
 from typing import (  # type: ignore[attr-defined]
@@ -23,7 +22,6 @@ from typing import (  # type: ignore[attr-defined]
 from typing_extensions import ParamSpec, Self, _AnnotatedAlias
 
 from classiq.interface.exceptions import (
-    ClassiqDeprecationWarning,
     ClassiqInternalError,
     ClassiqNotImplementedError,
     ClassiqValueError,
@@ -45,9 +43,6 @@ from classiq.interface.model.handle_binding import (
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
-from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
-    AmplitudeLoadingOperation,
-)
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
     ArithmeticOperationKind,
@@ -161,37 +156,6 @@ class QVar(Symbolic):
     def type_name(self) -> str:
         return self.get_qmod_type().type_name
 
-
-class QmodExpressionCreator(Protocol):
-    """
-    A callable that creates a Qmod expression from the provided QVars.
-    """
-
-    def __call__(self, **kwargs: QVar) -> SymbolicExpr: ...
-
-
-_Q = TypeVar("_Q", bound=QVar)
-Output = Annotated[_Q, PortDeclarationDirection.Output]
-Input = Annotated[_Q, PortDeclarationDirection.Input]
-Const = Annotated[
-    _Q, TypeModifier.Const
-]  # A constant variable, up to a phase dependent on the computational basis state
-
-
-class QScalar(QVar, SymbolicExpr):
-    CONSTRUCTOR_DEPTH: int = 2
-
-    def __init__(
-        self,
-        origin: None | str | HandleBinding = None,
-        *,
-        _expr_str: str | None = None,
-        depth: int = 2,
-    ) -> None:
-        origin = _infer_variable_name(origin, self.CONSTRUCTOR_DEPTH)
-        QVar.__init__(self, origin, expr_str=_expr_str, depth=depth)
-        SymbolicExpr.__init__(self, str(origin), True)
-
     def _insert_arith_operation(
         self,
         expr: SymbolicTypes,
@@ -210,19 +174,6 @@ class QScalar(QVar, SymbolicExpr):
             )
         )
 
-    def _insert_amplitude_loading(
-        self, expr: SymbolicTypes, source_ref: SourceReference
-    ) -> None:
-        if TYPE_CHECKING:
-            assert QCallable.CURRENT_EXPANDABLE is not None
-        QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-            AmplitudeLoadingOperation(
-                expression=Expression(expr=str(expr)),
-                result_var=self.get_handle_binding(),
-                source_ref=source_ref,
-            )
-        )
-
     def __ior__(self, other: Any) -> Self:
         if not isinstance(other, SYMBOLIC_TYPES):
             raise ClassiqValueError(
@@ -245,6 +196,37 @@ class QScalar(QVar, SymbolicExpr):
         )
         return self
 
+
+class QmodExpressionCreator(Protocol):
+    """
+    A callable that creates a Qmod expression from the provided QVars.
+    """
+
+    def __call__(self, **kwargs: QVar) -> SymbolicExpr: ...
+
+
+_Q = TypeVar("_Q", bound=QVar)
+Output = Annotated[_Q, PortDeclarationDirection.Output]
+Input = Annotated[_Q, PortDeclarationDirection.Input]
+Const = Annotated[
+    _Q, TypeModifier.Const
+]  # A constant variable, up to a phase dependent on the computational basis state
+
+
+class QScalar(QVar, SymbolicExpr):
+    CONSTRUCTOR_DEPTH: int = 2
+
+    def __init__(
+        self,
+        origin: None | str | HandleBinding = None,
+        *,
+        _expr_str: str | None = None,
+        depth: int = 2,
+    ) -> None:
+        origin = _infer_variable_name(origin, self.CONSTRUCTOR_DEPTH)
+        QVar.__init__(self, origin, expr_str=_expr_str, depth=depth)
+        SymbolicExpr.__init__(self, str(origin), True)
+
     def __iadd__(self, other: Any) -> Self:
         if not isinstance(other, SYMBOLIC_TYPES):
             raise ClassiqValueError(
@@ -256,21 +238,10 @@ class QScalar(QVar, SymbolicExpr):
         )
         return self
 
-    def __imul__(self, other: Any) -> Self:
-        warnings.warn(
-            "The '*=' operator is deprecated and will no longer be supported "
-            "starting on 2025-12-03 at the earliest. Use the 'assign_amplitude_table' "
-            "function instead",
-            ClassiqDeprecationWarning,
-            stacklevel=2,
+    def __imul__(self, other: Any) -> NoReturn:
+        raise ClassiqNotImplementedError(
+            f"{self.get_qmod_type().raw_qmod_type_name} does not support '*='"
         )
-        if not isinstance(other, SYMBOLIC_TYPES):
-            raise ClassiqValueError(
-                f"Invalid argument {str(other)!r} for out of ampltiude encoding operation"
-            )
-
-        self._insert_amplitude_loading(other, get_source_ref(sys._getframe(1)))
-        return self
 
     def __iand__(self, other: Any) -> NoReturn:
         raise ClassiqNotImplementedError(
@@ -558,6 +529,10 @@ class QArray(ArrayBase[_P], QVar, NonSymbolicExpr):
     def _get_slice(self, slice_: slice) -> Any:
         if slice_.step is not None:
             raise ClassiqValueError(ILLEGAL_SLICING_STEP_MSG)
+        if slice_.start is None:
+            slice_ = slice(0, slice_.stop, None)
+        if slice_.stop is None:
+            slice_ = slice(slice_.start, self.len, None)
         if not isinstance(slice_.start, (int, SymbolicExpr)) or not isinstance(
             slice_.stop, (int, SymbolicExpr)
         ):

classiq/qmod/quantum_function.py

@@ -1,5 +1,6 @@
 import ast
 import functools
+import inspect
 import warnings
 from abc import abstractmethod
 from collections.abc import Callable
@@ -8,7 +9,11 @@ from enum import EnumMeta
 from inspect import isclass
 from typing import Any, get_origin
 
-from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqError
+from classiq.interface.exceptions import (
+    ClassiqDeprecationWarning,
+    ClassiqError,
+    ClassiqExpansionError,
+)
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -276,10 +281,16 @@ class ExternalQFunc(QTerminalCallable):
                 ClassiqDeprecationWarning,
                 stacklevel=2,
             )
-        if (
-            self._py_callable.__name__ == "suzuki_trotter"
-            and len(args) > 0
-            and isinstance(args[0], (list, CParamList))
+        if self._py_callable.__name__ == "suzuki_trotter" and (
+            (
+                "pauli_operator" not in kwargs
+                and len(args) > 0
+                and isinstance(args[0], (list, CParamList))
+            )
+            or (
+                "pauli_operator" in kwargs
+                and isinstance(kwargs["pauli_operator"], (list, CParamList))
+            )
         ):
             warnings.warn(
                 (
@@ -320,6 +331,19 @@ class ExternalQFunc(QTerminalCallable):
                 ClassiqDeprecationWarning,
                 stacklevel=2,
             )
+        if (
+            self._py_callable.__name__ == "unscheduled_suzuki_trotter"
+        ):  # FIXME: remove (CLS-5391)
+            warnings.warn(
+                (
+                    "Function 'unscheduled_suzuki_trotter' was renamed to "
+                    "'sequential_suzuki_trotter'. 'unscheduled_suzuki_trotter' is "
+                    "deprecated and will no longer be supported starting on 2026-02-02 "
+                    "at the earliest."
+                ),
+                ClassiqDeprecationWarning,
+                stacklevel=2,
+            )
         super().__call__(*args, **kwargs)
 
 
@@ -348,14 +372,26 @@ class GenerativeQFunc(BaseQFunc):
         return self._inferred_func_decl
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
+        from classiq.qmod.builtins.functions import BUILTIN_FUNCTION_DECLARATIONS
+
         if get_global_declarative_switch():
             return QFunc(
                 self._py_callable,
                 self.compilation_metadata,
                 permutation=self.permutation,
             )(*args, **kwargs)
-        if self.func_decl.name not in self._qmodule.generative_functions:
-            self._qmodule.generative_functions[self.func_decl.name] = self
+        frame = inspect.currentframe()
+        caller_frame = frame.f_back if frame is not None else None
+        module = inspect.getmodule(caller_frame)
+        func_name = self.func_decl.name
+        if func_name in BUILTIN_FUNCTION_DECLARATIONS and (
+            module is None or not module.__name__.startswith("model.function_library")
+        ):
+            raise ClassiqExpansionError(
+                f"Cannot redefine built-in function {func_name!r}"
+            )
+        if func_name not in self._qmodule.generative_functions:
+            self._qmodule.generative_functions[func_name] = self
             if self._func_decl is None:
                 self._inferred_func_decl = infer_func_decl(
                     self._py_callable, self._qmodule, permutation=self.permutation

classiq/qmod/semantics/validation/function_name_collisions_validation.py

@@ -1,13 +1,16 @@
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.model.model import Model
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+)
 
-from classiq.qmod.builtins.functions import CORE_LIB_DECLS
 
-
-def check_function_name_collisions(model: Model) -> None:
+def check_function_name_collisions(
+    model: Model, builtin_functions: list[NamedParamsQuantumFunctionDeclaration]
+) -> None:
     redefined_functions = [
         function.name
-        for function in CORE_LIB_DECLS
+        for function in builtin_functions
         if function.name in model.function_dict
     ]
     if len(redefined_functions) == 1:

classiq/qmod/semantics/validation/model_validation.py

@@ -1,4 +1,7 @@
 from classiq.interface.model.model import Model
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+)
 
 from classiq.qmod.semantics.validation.constants_validation import (
     check_duplicate_constants,
@@ -14,7 +17,9 @@ from classiq.qmod.semantics.validation.types_validation import (
 )
 
 
-def validate_model(model: Model) -> None:
+def validate_model(
+    model: Model, builtin_functions: list[NamedParamsQuantumFunctionDeclaration]
+) -> None:
     check_duplicate_types([*model.enums, *model.types, *model.qstructs])
     check_duplicate_constants(model.constants)
     for qstruct in model.qstructs:
@@ -22,4 +27,4 @@ def validate_model(model: Model) -> None:
     for cstruct in model.types:
         validate_cstruct(cstruct)
     validate_main_function(model.main_func)
-    check_function_name_collisions(model)
+    check_function_name_collisions(model, builtin_functions)

classiq/qmod/symbolic_type.py

@@ -1,6 +1,8 @@
 from typing import Union, get_args, get_origin
 
-from classiq.qmod.symbolic_expr import SymbolicExpr
+from classiq.qmod.symbolic_expr import Symbolic
 
-SymbolicTypes = Union[SymbolicExpr, int, float, bool, tuple["SymbolicTypes", ...]]
+SymbolicTypes = Union[
+    Symbolic, int, float, bool, tuple["SymbolicTypes", ...], list["SymbolicTypes"]
+]
 SYMBOLIC_TYPES = tuple(get_origin(t) or t for t in get_args(SymbolicTypes))

{classiq-0.102.0.dist-info → classiq-0.104.0.dist-info}/METADATA

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