classiq 0.84.0__py3-none-any.whl → 0.86.0__py3-none-any.whl

classiq/open_library/functions/__init__.py

@@ -52,7 +52,6 @@ OPEN_LIBRARY_FUNCTIONS = [
     qsvt_inversion,
     qsvt_lcu,
     qsvt_lcu_step,
-    allocate_num,
     qaoa_mixer_layer,
     qaoa_cost_layer,
     qaoa_layer,
@@ -85,7 +84,6 @@ OPEN_LIBRARY_FUNCTIONS = [
 
 __all__ = [
     "_single_pauli",
-    "allocate_num",
     "amplitude_amplification",
     "amplitude_estimation",
     "apply_to_all",

classiq/open_library/functions/qaoa_penalty.py

@@ -1,5 +1,8 @@
+import warnings
 from typing import Literal
 
+from classiq.interface.exceptions import ClassiqDeprecationWarning
+
 from classiq.qmod.builtins.functions import RX, H, suzuki_trotter
 from classiq.qmod.builtins.operations import repeat
 from classiq.qmod.builtins.structs import PauliTerm
@@ -42,7 +45,11 @@ def qaoa_cost_layer(
         hamiltonian: The Hamiltonian terms for the QAOA model.
         target: The target quantum array variable.
     """
-    suzuki_trotter(hamiltonian, g, 1, 1, target)
+    with warnings.catch_warnings():  # FIXME: Remove (CLS-2912)
+        warnings.simplefilter(
+            "ignore", category=ClassiqDeprecationWarning
+        )  # FIXME: Remove (CLS-2912)
+        suzuki_trotter(hamiltonian, g, 1, 1, target)
 
 
 @qfunc

classiq/open_library/functions/state_preparation.py

@@ -27,7 +27,7 @@ from classiq.qmod.builtins.operations import (
     repeat,
     within_apply,
 )
-from classiq.qmod.cparam import CArray, CBool, CInt, CReal
+from classiq.qmod.cparam import CArray, CInt, CReal
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
 from classiq.qmod.symbolic import (
@@ -45,37 +45,6 @@ from classiq.qmod.symbolic import (
 )
 
 
-@qfunc
-def allocate_num(
-    num_qubits: CInt,
-    is_signed: CBool,
-    fraction_digits: CInt,
-    out: Output[
-        QNum[Literal["num_qubits"], Literal["is_signed"], Literal["fraction_digits"]]
-    ],
-) -> None:
-    """
-    [Qmod Classiq-library function]
-
-    This function is **deprecated** and will no longer be supported starting on
-    16/06/2025 at the earliest. Instead, use `allocate` which supports the same
-    parameters.
-
-    Initializes a quantum number with the given number of qubits, sign, and fractional digits.
-
-    Args:
-        num_qubits: The number of qubits to allocate.
-        is_signed: Whether the number is signed or unsigned.
-        fraction_digits: The number of fractional digits.
-    """
-    warnings.warn(
-        "Function `allocate_num` is deprecated and will no longer be supported starting on 16/06/2025 at the earliest. Instead, use `allocate` which supports the same parameters. ",
-        ClassiqDeprecationWarning,
-        stacklevel=1,
-    )
-    allocate(num_qubits, out)
-
-
 def _prepare_uniform_trimmed_state_apply_rotation(
     size_lsb: CInt, lsbs_val: CInt, rotation_var: QBit
 ) -> None:

classiq/qmod/__init__.py

@@ -1,6 +1,7 @@
 from .builtins import *  # noqa: F403
 from .builtins import __all__ as _builtins_all
 from .cfunc import cfunc
+from .classical_variable import measure
 from .create_model_function import create_model
 from .expression_query import get_expression_numeric_attributes
 from .qfunc import qfunc
@@ -29,6 +30,7 @@ __all__ = [
     "QStruct",
     "cfunc",
     "create_model",
+    "measure",
     "get_expression_numeric_attributes",
     "qfunc",
     "write_qmod",

classiq/qmod/builtins/operations.py

@@ -7,6 +7,7 @@ from typing import (
     Callable,
     Final,
     NoReturn,
+    Optional,
     Union,
     overload,
 )
@@ -20,6 +21,8 @@ from classiq.interface.generator.functions.classical_type import Integer
 from classiq.interface.helpers.text_utils import s
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.block import Block
+from classiq.interface.model.bounds import SetBoundsStatement
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
@@ -46,7 +49,7 @@ from classiq.interface.model.within_apply_operation import WithinApply
 
 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, QScalar, QVar
+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.symbolic_expr import SymbolicExpr
@@ -186,7 +189,7 @@ def if_(
 
 @suppress_return_value
 def control(
-    ctrl: Union[SymbolicExpr, QBit, QArray[QBit]],
+    ctrl: Union[SymbolicExpr, QBit, QArray[QBit], list[QVar]],
     stmt_block: Union[QCallable, Callable[[], Statements]],
     else_block: Union[QCallable, Callable[[], Statements], None] = None,
 ) -> None:
@@ -398,6 +401,65 @@ def phase(expr: SymbolicExpr, theta: float = 1.0) -> None:
     )
 
 
+@suppress_return_value
+def block(
+    statements: Union[QCallable, Callable[[], Statements]],
+) -> None:
+    _validate_operand(statements)
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
+
+    block_stmt = Block(
+        statements=_operand_to_body(statements, "statements"),
+        source_ref=source_ref,
+    )
+    if is_generative_mode():
+        block_stmt.set_generative_block("statements", statements)
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(block_stmt)
+
+
+@overload
+def reset_bounds(
+    target_var: QNum,
+) -> None:
+    pass
+
+
+@overload
+def reset_bounds(
+    target_var: QNum,
+    lower_bound: Union[float, SymbolicExpr],
+    upper_bound: Union[float, SymbolicExpr],
+) -> None:
+    pass
+
+
+@suppress_return_value
+def reset_bounds(
+    target_var: QNum,
+    lower_bound: Optional[Union[float, SymbolicExpr]] = None,
+    upper_bound: Optional[Union[float, SymbolicExpr]] = None,
+) -> None:
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
+
+    lower_bound_expr = (
+        None if lower_bound is None else Expression(expr=str(lower_bound))
+    )
+    upper_bound_expr = (
+        None if upper_bound is None else Expression(expr=str(upper_bound))
+    )
+
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        SetBoundsStatement(
+            target=target_var.get_handle_binding(),
+            lower_bound=lower_bound_expr,
+            upper_bound=upper_bound_expr,
+            source_ref=source_ref,
+        )
+    )
+
+
 def _validate_operand(stmt_block: Any, num_params: int = 0) -> None:
     if stmt_block is None:
         _raise_operand_error(
@@ -502,6 +564,7 @@ __all__ = [
     "assign",
     "assign_amplitude",
     "bind",
+    "block",
     "control",
     "if_",
     "inplace_add",
@@ -510,6 +573,7 @@ __all__ = [
     "phase",
     "power",
     "repeat",
+    "reset_bounds",
     "within_apply",
 ]
 

classiq/qmod/classical_variable.py

@@ -0,0 +1,74 @@
+import sys
+from typing import TYPE_CHECKING, Any
+
+from classiq.interface.exceptions import ClassiqInternalError
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_type import Bool, ClassicalType
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+    ArithmeticOperationKind,
+)
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+
+from classiq.qmod.cparam import CBool, CParam, CParamScalar
+from classiq.qmod.qmod_variable import QBit, _infer_variable_name
+from classiq.qmod.quantum_callable import QCallable
+from classiq.qmod.symbolic import symbolic_function
+from classiq.qmod.symbolic_type import SYMBOLIC_TYPES
+from classiq.qmod.utilities import get_source_ref
+
+
+def declare_classical_variable(
+    name: str, classical_type: ClassicalType, frame_depth: int
+) -> None:
+    if TYPE_CHECKING:
+        assert QCallable.CURRENT_EXPANDABLE is not None
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        VariableDeclarationStatement(
+            name=name,
+            qmod_type=classical_type,
+            source_ref=get_source_ref(sys._getframe(frame_depth)),
+        )
+    )
+
+
+def assign_classical_variable(target: CParam, value: Any, frame_depth: int) -> None:
+    if not isinstance(value, SYMBOLIC_TYPES):
+        raise TypeError(f"Invalid argument {value!r} for classical variable assignment")
+
+    if TYPE_CHECKING:
+        assert QCallable.CURRENT_EXPANDABLE is not None
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        ArithmeticOperation(
+            expression=Expression(expr=str(value)),
+            result_var=HandleBinding(name=str(target)),
+            operation_kind=ArithmeticOperationKind.Assignment,
+            source_ref=get_source_ref(sys._getframe(frame_depth)),
+        )
+    )
+
+
+def measure(var: QBit) -> CParamScalar:
+    """
+    Measures the given qubit. `measure` is a non-unitary operation.
+
+    Args:
+        var: a qubit variable
+
+    Returns:
+        the measurement result (a symbolic boolean variable)
+    """
+    name = _infer_variable_name(None, 2)
+    if name is None:
+        raise ClassiqInternalError("Could not infer measure var name")
+    declare_classical_variable(name, Bool(), 2)
+    res_var = CParamScalar(name)
+    res_val = symbolic_function(
+        var,
+        return_type=CBool,  # type:ignore[type-abstract]
+    )
+    assign_classical_variable(res_var, res_val, 2)
+    return res_var

classiq/qmod/declaration_inferrer.py

@@ -40,6 +40,7 @@ from classiq.qmod.model_state_container import ModelStateContainer
 from classiq.qmod.python_classical_type import PythonClassicalType
 from classiq.qmod.qmod_variable import QVar, get_port_from_type_hint
 from classiq.qmod.quantum_callable import QCallableList
+from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
 from classiq.qmod.semantics.validation.type_hints import validate_annotation
 from classiq.qmod.semantics.validation.types_validation import (
     check_duplicate_types,
@@ -74,9 +75,9 @@ class _PythonClassicalType(PythonClassicalType):
             return classical_type
         all_decls = BUILTIN_STRUCT_DECLARATIONS | self.qmodule.type_decls
         if py_type.__name__ in all_decls:
-            classical_type.set_classical_struct_decl(
-                all_decls[py_type.__name__].model_copy(deep=True)
-            )
+            decl = all_decls[py_type.__name__].model_copy(deep=True)
+            QStructAnnotator().visit(decl)
+            classical_type.set_classical_struct_decl(decl)
             return classical_type
 
         struct_decl = StructDeclaration(
@@ -89,6 +90,7 @@ class _PythonClassicalType(PythonClassicalType):
         check_duplicate_types([struct_decl, *self.qmodule.user_types()])
         self.qmodule.type_decls[py_type.__name__] = struct_decl
         validate_cstruct(struct_decl)
+        QStructAnnotator().visit(struct_decl)
 
         classical_type.set_classical_struct_decl(struct_decl)
         return classical_type

classiq/qmod/native/pretty_printer.py

@@ -29,6 +29,7 @@ from classiq.interface.generator.visitor import NodeType
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.block import Block
+from classiq.interface.model.bounds import SetBoundsStatement
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.classical_parameter_declaration import (
     AnonClassicalParameterDeclaration,
@@ -76,9 +77,6 @@ from classiq.interface.model.quantum_type import (
     QuantumBitvector,
     QuantumNumeric,
 )
-from classiq.interface.model.quantum_variable_declaration import (
-    QuantumVariableDeclaration,
-)
 from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.variable_declaration_statement import (
@@ -189,11 +187,6 @@ class DSLPrettyPrinter(ModelVisitor):
         self._level -= 1
         return variables_str
 
-    def visit_QuantumVariableDeclaration(
-        self, var_decl: QuantumVariableDeclaration
-    ) -> str:
-        return f"{var_decl.name}: {self.visit(var_decl.quantum_type)}"
-
     def visit_AnonPortDeclaration(self, port_decl: AnonPortDeclaration) -> str:
         modifier_str = (
             f"{port_decl.type_modifier} "
@@ -263,9 +256,9 @@ class DSLPrettyPrinter(ModelVisitor):
         return type_.name
 
     def visit_VariableDeclarationStatement(
-        self, local_decl: VariableDeclarationStatement
+        self, var_decl: VariableDeclarationStatement
     ) -> str:
-        return f"{self._indent}{self.visit_QuantumVariableDeclaration(local_decl)};\n"
+        return f"{self._indent}{var_decl.name}: {self.visit(var_decl.qmod_type)};\n"
 
     def visit_AnonQuantumOperandDeclaration(
         self, op_decl: AnonQuantumOperandDeclaration
@@ -361,10 +354,10 @@ class DSLPrettyPrinter(ModelVisitor):
         return invert_code
 
     def visit_Block(self, block: Block) -> str:
-        invert_code = f"{self._indent}block {{\n"
-        invert_code += self._visit_body(block.statements)
-        invert_code += f"{self._indent}}}\n"
-        return invert_code
+        block_code = f"{self._indent}{{\n"
+        block_code += self._visit_body(block.statements)
+        block_code += f"{self._indent}}}\n"
+        return block_code
 
     def _visit_body(self, body: StatementBlock) -> str:
         code = ""
@@ -443,6 +436,17 @@ class DSLPrettyPrinter(ModelVisitor):
     def visit_OperandIdentifier(self, op: OperandIdentifier) -> str:
         return str(op)
 
+    def visit_SetBoundsStatement(self, op: SetBoundsStatement) -> str:
+        target = self.visit(op.target)
+        if op.lower_bound is None or op.upper_bound is None:
+            return f"{self._indent}reset_bounds({target});\n"
+        else:
+            lower_bound = self.visit(op.lower_bound)
+            upper_bound = self.visit(op.upper_bound)
+            return (
+                f"{self._indent}reset_bounds({target}, {lower_bound}, {upper_bound});\n"
+            )
+
     @property
     def _indent(self) -> str:
         return "  " * self._level

classiq/qmod/pretty_print/pretty_printer.py

@@ -30,6 +30,8 @@ from classiq.interface.generator.types.struct_declaration import StructDeclarati
 from classiq.interface.generator.visitor import NodeType, Visitor
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.block import Block
+from classiq.interface.model.bounds import SetBoundsStatement
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.classical_parameter_declaration import (
     AnonClassicalParameterDeclaration,
@@ -75,9 +77,6 @@ from classiq.interface.model.quantum_type import (
     QuantumBitvector,
     QuantumNumeric,
 )
-from classiq.interface.model.quantum_variable_declaration import (
-    QuantumVariableDeclaration,
-)
 from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.variable_declaration_statement import (
@@ -91,6 +90,8 @@ from classiq.qmod.pretty_print.expression_to_python import transform_expression
 
 
 class VariableDeclarationAssignment(Visitor):
+    # FIXME: Support classical variable types
+
     def __init__(self, pretty_printer: "PythonPrettyPrinter") -> None:
         self.pretty_printer = pretty_printer
 
@@ -251,11 +252,6 @@ class PythonPrettyPrinter(ModelVisitor):
         self._level -= 1
         return variables_str
 
-    def visit_QuantumVariableDeclaration(
-        self, var_decl: QuantumVariableDeclaration
-    ) -> str:
-        return f"{var_decl.name}: {self.visit(var_decl.quantum_type)}"
-
     def visit_AnonPortDeclaration(self, port_decl: AnonPortDeclaration) -> str:
         var_type = self._extract_port_type(port_decl)
         return f"{port_decl.name}: {var_type}"
@@ -361,14 +357,23 @@ class PythonPrettyPrinter(ModelVisitor):
             self._imports[type_.name] = 1
 
     def visit_VariableDeclarationStatement(
-        self, local_decl: VariableDeclarationStatement
+        self,
+        local_decl: VariableDeclarationStatement,
+        walrus: bool = False,
     ) -> str:
         type_name, params = VariableDeclarationAssignment(self).visit(
-            local_decl.quantum_type
+            local_decl.qmod_type
         )
         params = [f'"{local_decl.name}"'] + params
         param_args = ", ".join(params)
-        return f"{self._indent}{self.visit_QuantumVariableDeclaration(local_decl)} = {type_name}({param_args})\n"
+
+        res = f"{self._indent}{local_decl.name}"
+        if walrus:
+            res += " := "
+        else:
+            res += f": {self.visit(local_decl.qmod_type)} = "
+        res += f"{type_name}({param_args})\n"
+        return res
 
     def _visit_operand_arg_decl(self, arg_decl: AnonPositionalArg) -> str:
         if isinstance(arg_decl, AnonPortDeclaration):
@@ -476,6 +481,10 @@ class PythonPrettyPrinter(ModelVisitor):
         self._imports["invert"] = 1
         return f"{self._indent}invert({self._visit_body(invert.body)})\n"
 
+    def visit_Block(self, block: Block) -> str:
+        self._imports["block"] = 1
+        return f"{self._indent}block({self._visit_body(block.statements)})\n"
+
     def _visit_body(
         self, body: StatementBlock, operand_arguments: Optional[list[str]] = None
     ) -> str:
@@ -488,10 +497,8 @@ class PythonPrettyPrinter(ModelVisitor):
         self._level += 1
         for i, statement in enumerate(body):
             if isinstance(statement, VariableDeclarationStatement):
-                raise AssertionError(
-                    "pretty printing variable declaration statements in quantum lambda function is unsupported."
-                )
-            if isinstance(statement, AmplitudeLoadingOperation):
+                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)
@@ -574,6 +581,18 @@ class PythonPrettyPrinter(ModelVisitor):
     def visit_OperandIdentifier(self, op: OperandIdentifier) -> str:
         return str(op)
 
+    def visit_SetBoundsStatement(self, op: SetBoundsStatement) -> str:
+        self._imports["reset_bounds"] = 1
+        target = self.visit(op.target)
+        if op.lower_bound is None or op.upper_bound is None:
+            return f"{self._indent}reset_bounds({target})\n"
+        else:
+            lower_bound = self.visit(op.lower_bound)
+            upper_bound = self.visit(op.upper_bound)
+            return (
+                f"{self._indent}reset_bounds({target}, {lower_bound}, {upper_bound})\n"
+            )
+
     @property
     def _indent(self) -> str:
         return "    " * self._level

classiq/qmod/qfunc.py

@@ -1,7 +1,6 @@
-import warnings
 from typing import Callable, Literal, Optional, Union, overload
 
-from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqInternalError
+from classiq.interface.exceptions import ClassiqInternalError
 
 from classiq.qmod.global_declarative_switch import get_global_declarative_switch
 from classiq.qmod.quantum_callable import QCallable
@@ -57,23 +56,7 @@ def qfunc(
     synthesize_separately: bool = False,
     unchecked: Optional[list[str]] = None,
 ) -> Union[Callable[[Callable], QCallable], QCallable]:
-    if generative is True:
-        warnings.warn(
-            "The use of `generative=True` is no longer required. Note that the "
-            "treatment of parameters of Qmod types will change from Python value to "
-            "symbolic in a near release. Change Qmod types to the corresponding Python "
-            "built-in types in order to use the parameters in Python expression "
-            "contexts.\n"
-            "Recommended changes:\n"
-            "@qfunc(generative=True) -> @qfunc\n"
-            "CInt->int\n"
-            "CReal->float\n"
-            "CArray->list\n\n"
-            "For more information see https://docs.classiq.io/latest/qmod-reference/language-reference/generative-descriptions/",
-            ClassiqDeprecationWarning,
-            stacklevel=2,
-        )
-    elif generative is None:
+    if generative is None:
         generative = True
     if get_global_declarative_switch():
         generative = False

classiq/qmod/qmod_variable.py

@@ -74,7 +74,7 @@ from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
 from classiq.qmod.semantics.validation.types_validation import validate_qstruct
 from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
-from classiq.qmod.symbolic_type import SymbolicTypes
+from classiq.qmod.symbolic_type import SYMBOLIC_TYPES, SymbolicTypes
 from classiq.qmod.utilities import (
     get_source_ref,
     unwrap_forward_ref,
@@ -104,9 +104,6 @@ def _infer_variable_name(name: Any, depth: int) -> Any:
     return name
 
 
-_SYMBOLIC_TYPES = tuple(get_origin(t) or t for t in get_args(SymbolicTypes))
-
-
 class QVar(Symbolic):
     CONSTRUCTOR_DEPTH: int = 1
 
@@ -230,7 +227,7 @@ class QScalar(QVar, SymbolicExpr):
         )
 
     def __ior__(self, other: Any) -> Self:
-        if not isinstance(other, _SYMBOLIC_TYPES):
+        if not isinstance(other, SYMBOLIC_TYPES):
             raise TypeError(
                 f"Invalid argument {other!r} for out-of-place arithmetic operation"
             )
@@ -241,7 +238,7 @@ class QScalar(QVar, SymbolicExpr):
         return self
 
     def __ixor__(self, other: Any) -> Self:
-        if not isinstance(other, _SYMBOLIC_TYPES):
+        if not isinstance(other, SYMBOLIC_TYPES):
             raise TypeError(
                 f"Invalid argument {other!r} for in-place arithmetic operation"
             )
@@ -252,7 +249,7 @@ class QScalar(QVar, SymbolicExpr):
         return self
 
     def __iadd__(self, other: Any) -> Self:
-        if not isinstance(other, _SYMBOLIC_TYPES):
+        if not isinstance(other, SYMBOLIC_TYPES):
             raise TypeError(
                 f"Invalid argument {other!r} for in-place arithmetic operation"
             )
@@ -263,7 +260,7 @@ class QScalar(QVar, SymbolicExpr):
         return self
 
     def __imul__(self, other: Any) -> Self:
-        if not isinstance(other, _SYMBOLIC_TYPES):
+        if not isinstance(other, SYMBOLIC_TYPES):
             raise TypeError(
                 f"Invalid argument {other!r} for out of ampltiude encoding operation"
             )

classiq/qmod/quantum_expandable.py

@@ -135,7 +135,7 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
     ) -> None:
         self.append_statement_to_body(
             VariableDeclarationStatement(
-                name=name, quantum_type=qtype, source_ref=source_ref
+                name=name, qmod_type=qtype, source_ref=source_ref
             )
         )
 

classiq/qmod/quantum_function.py

@@ -1,12 +1,13 @@
 import ast
 import functools
+import warnings
 from abc import abstractmethod
 from dataclasses import is_dataclass
 from enum import EnumMeta
 from inspect import isclass
 from typing import Any, Callable, Optional, get_origin
 
-from classiq.interface.exceptions import ClassiqError
+from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -28,7 +29,7 @@ from classiq.qmod.declaration_inferrer import infer_func_decl, is_qvar
 from classiq.qmod.generative import set_frontend_interpreter
 from classiq.qmod.global_declarative_switch import get_global_declarative_switch
 from classiq.qmod.qmod_constant import QConstant
-from classiq.qmod.qmod_parameter import CArray
+from classiq.qmod.qmod_parameter import CArray, CParamList
 from classiq.qmod.quantum_callable import QCallable, QCallableList
 from classiq.qmod.quantum_expandable import QExpandable, QTerminalCallable
 from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
@@ -218,6 +219,7 @@ class QFunc(BaseQFunc):
 
 
 class ExternalQFunc(QTerminalCallable):
+    FRAME_DEPTH = 2  # FIXME: Remove (CLS-2912)
     _decl: NamedParamsQuantumFunctionDeclaration
 
     def __init__(self, py_callable: Callable) -> None:
@@ -242,6 +244,44 @@ class ExternalQFunc(QTerminalCallable):
     def pure_decl(self) -> NamedParamsQuantumFunctionDeclaration:
         return self.func_decl
 
+    def __call__(self, *args: Any, **kwargs: Any) -> None:
+        if self._py_callable.__name__ == "parametric_suzuki_trotter":
+            warnings.warn(
+                (
+                    "Function 'parametric_suzuki_trotter' is deprecated and will no "
+                    "longer be supported starting on 21/7/2025 at the earliest. "
+                    "Instead, use 'multi_suzuki_trotter'."
+                ),
+                ClassiqDeprecationWarning,
+                stacklevel=2,
+            )
+        if self._py_callable.__name__ == "sparse_suzuki_trotter":
+            warnings.warn(
+                (
+                    "Function 'sparse_suzuki_trotter' is deprecated and will no "
+                    "longer be supported starting on 21/7/2025 at the earliest. "
+                    "Instead, use 'suzuki_trotter'."
+                ),
+                ClassiqDeprecationWarning,
+                stacklevel=2,
+            )
+        if (
+            self._py_callable.__name__ == "suzuki_trotter"
+            and len(args) > 0
+            and isinstance(args[0], (list, CParamList))
+        ):
+            warnings.warn(
+                (
+                    "Parameter type CArray[PauliTerm] to function 'suzuki_trotter' is "
+                    "deprecated and will no longer be supported starting on 21/7/2025 "
+                    "at the earliest. Instead, send a 'SparsePauliOp' (see "
+                    "https://docs.classiq.io/latest/qmod-reference/language-reference/classical-types/#hamiltonians)."
+                ),
+                ClassiqDeprecationWarning,
+                stacklevel=2,
+            )
+        super().__call__(*args, **kwargs)
+
 
 class GenerativeQFunc(BaseQFunc):
     FRAME_DEPTH = 3