classiq 0.80.1__py3-none-any.whl → 0.82.0__py3-none-any.whl

classiq/model_expansions/transformers/type_qualifier_inference.py

@@ -1,10 +1,17 @@
 import ast
 import functools
 import itertools
+import warnings
 from collections.abc import Collection, Iterator, Sequence
 from contextlib import contextmanager
 
-from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.exceptions import (
+    ClassiqDeprecationWarning,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
 from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
@@ -30,7 +37,32 @@ from classiq.interface.model.within_apply_operation import WithinApply
 from classiq.model_expansions.visitors.variable_references import VarRefCollector
 
 
-class TypeQualifierInference(ModelVisitor):
+def _inconsistent_type_qualifier_error(
+    port_name: str, expected: TypeQualifier, actual: TypeQualifier
+) -> str:
+    return (
+        f"The type modifier of variable '{port_name}' does not conform to the function signature: "
+        f"expected '{expected.name}', but found '{actual.name}'.\n"
+        f"Tip: If the final role of the variable in the function matches '{expected.name}', "
+        f"you may use the `unchecked` flag to instruct the compiler to disregard individual operations.\n"
+        # TODO add earliest date of enforcement. See https://classiq.atlassian.net/browse/CLS-2709.
+    )
+
+
+def _inconsistent_type_qualifier_in_binding_error(
+    expected: TypeQualifier, known_qualifiers: dict[str, TypeQualifier]
+) -> str:
+    actual = ", ".join(
+        f"{name}: {qualifier.name}" for name, qualifier in known_qualifiers.items()
+    )
+    return (
+        f"The variable binding has inconsistent type modifiers: "
+        f"Expected modifier: {expected.name}, Actual modifiers: {actual}"
+        # TODO add earliest date of enforcement. See https://classiq.atlassian.net/browse/CLS-2709.
+    )
+
+
+class TypeQualifierValidation(ModelVisitor):
     """
     This class assumes that function calls are topologically sorted, so it traverses
     the list of function calls and infers the type qualifiers for each function call
@@ -38,26 +70,54 @@ class TypeQualifierInference(ModelVisitor):
     The function definition ports are modified inplace.
     """
 
-    def __init__(self, support_unused_ports: bool = True) -> None:
+    def __init__(
+        self, *, skip_validation: bool = False, support_unused_ports: bool = True
+    ) -> None:
         self._signature_ports: dict[str, PortDeclaration] = dict()
         self._inferred_ports: dict[str, PortDeclaration] = dict()
+        self._unchecked: set[str] = set()
+
+        self._initialized_vars: dict[str, TypeQualifier] = dict()
+        self._bound_vars: list[set[str]] = []
+
+        self._conjugation_context: bool = False
         self._support_unused_ports = (
             support_unused_ports  # could be turned off for debugging
         )
+        self._skip_validation = skip_validation
 
     @contextmanager
-    def infer_ports(self, ports: Collection[PortDeclaration]) -> Iterator[bool]:
+    def validate_ports(
+        self, ports: Collection[PortDeclaration], unchecked: Collection[str]
+    ) -> Iterator[bool]:
         for port in ports:
             if port.type_qualifier is TypeQualifier.Inferred:
                 self._inferred_ports[port.name] = port
             else:
                 self._signature_ports[port.name] = port
+        self._unchecked.update(unchecked)
 
-        yield len(self._inferred_ports) > 0
+        yield len(self._inferred_ports) > 0 or (
+            any(
+                port.type_qualifier is not TypeQualifier.Quantum
+                for port in self._signature_ports.values()
+            )
+            and not self._skip_validation
+        )
 
         self._set_unused_as_const()
         self._signature_ports.clear()
         self._inferred_ports.clear()
+        self._unchecked.clear()
+
+    @contextmanager
+    def conjugation_context(self) -> Iterator[None]:
+        previous_context = self._conjugation_context
+        self._conjugation_context = True
+        try:
+            yield
+        finally:
+            self._conjugation_context = previous_context
 
     def _set_unused_as_const(self) -> None:
         unresolved_ports = [
@@ -73,71 +133,144 @@ class TypeQualifierInference(ModelVisitor):
         for port in unresolved_ports:
             port.type_qualifier = TypeQualifier.Const
 
-    def _reduce_qualifier(self, candidate: str, qualifier: TypeQualifier) -> None:
+    def _validate_qualifier(self, candidate: str, qualifier: TypeQualifier) -> None:
+        if self._conjugation_context and qualifier is TypeQualifier.QFree:
+            qualifier = TypeQualifier.Const
+
         if candidate in self._inferred_ports:
             self._inferred_ports[candidate].type_qualifier = TypeQualifier.and_(
                 self._inferred_ports[candidate].type_qualifier, qualifier
             )
+            return
+
+        if self._skip_validation or candidate in self._unchecked:
+            return
+
+        if candidate in self._signature_ports:
+            self._validate_signature_qualifier(candidate, qualifier)
+
+        elif candidate in self._initialized_vars:
+            self._initialized_vars[candidate] = TypeQualifier.and_(
+                self._initialized_vars[candidate], qualifier
+            )
+
+    def _validate_signature_qualifier(
+        self, candidate: str, qualifier: TypeQualifier
+    ) -> None:
+        signature_qualifier = self._signature_ports[candidate].type_qualifier
+        if signature_qualifier is not TypeQualifier.and_(
+            signature_qualifier, qualifier
+        ):
+            warnings.warn(
+                _inconsistent_type_qualifier_error(
+                    candidate, signature_qualifier, qualifier
+                ),
+                ClassiqDeprecationWarning,
+                stacklevel=1,
+            )
+
+    def _add_initialized_qualifier(self, var: str, qualifier: TypeQualifier) -> None:
+        if var in self._inferred_ports or var in self._signature_ports:
+            return
+        if self._conjugation_context and qualifier is TypeQualifier.QFree:
+            qualifier = TypeQualifier.Const
+        self._initialized_vars[var] = qualifier
 
     def run(
-        self, ports: Collection[PortDeclaration], body: Sequence[QuantumStatement]
+        self,
+        ports: Collection[PortDeclaration],
+        body: Sequence[QuantumStatement],
+        unchecked: Collection[str],
     ) -> None:
-        with self.infer_ports(ports) as should_infer:
-            if should_infer:
+        with self.validate_ports(ports, unchecked) as should_validate:
+            if should_validate:
                 self.visit(body)
+                self._update_bound_vars()
+
+    def _update_bound_vars(self) -> None:
+        merged_bound_vars = _merge_overlapping(self._bound_vars)
+        for bound_vars in merged_bound_vars:
+            reduced_qualifier = self._get_reduced_qualifier(bound_vars)
+            for var in bound_vars:
+                self._validate_qualifier(var, reduced_qualifier)
 
     def visit_QuantumFunctionCall(self, call: QuantumFunctionCall) -> None:
         for handle, port in call.handles_with_params:
-            self._reduce_qualifier(handle.name, port.type_qualifier)
+            self._validate_qualifier(handle.name, port.type_qualifier)
+            if port.direction is PortDeclarationDirection.Output:
+                self._add_initialized_qualifier(handle.name, port.type_qualifier)
+
+        if self._has_inputs(call):
+            bound_vars = {
+                handle.name
+                for handle, port in call.handles_with_params
+                if port.direction is not PortDeclarationDirection.Inout
+            }
+            self._bound_vars.append(bound_vars)
+
+    @staticmethod
+    def _has_inputs(call: QuantumFunctionCall) -> bool:
+        return any(
+            port.direction is PortDeclarationDirection.Input
+            for _, port in call.handles_with_params
+        )
 
     def visit_Allocate(self, alloc: Allocate) -> None:
-        self._reduce_qualifier(alloc.target.name, TypeQualifier.QFree)
+        self._validate_qualifier(alloc.target.name, TypeQualifier.QFree)
+        self._add_initialized_qualifier(alloc.target.name, TypeQualifier.QFree)
 
     def visit_BindOperation(self, bind_op: BindOperation) -> None:
-        reduced_qualifier = self._get_reduced_qualifier(bind_op)
-        for handle in itertools.chain(bind_op.in_handles, bind_op.out_handles):
-            self._reduce_qualifier(handle.name, reduced_qualifier)
-
-    def _get_reduced_qualifier(self, bind_op: BindOperation) -> TypeQualifier:
-        handles = itertools.chain(bind_op.in_handles, bind_op.out_handles)
-        op_vars = {handle.name for handle in handles}
+        var_names = {
+            handle.name
+            for handle in itertools.chain(bind_op.in_handles, bind_op.out_handles)
+        }
+        self._bound_vars.append(var_names)
+        for handle in bind_op.out_handles:
+            self._add_initialized_qualifier(handle.name, TypeQualifier.Inferred)
 
-        signature_ports = {
-            name: self._signature_ports[name]
-            for name in op_vars.intersection(self._signature_ports)
+    def _get_reduced_qualifier(self, bound_vars: set[str]) -> TypeQualifier:
+        signature_qualifier = {
+            name: self._signature_ports[name].type_qualifier
+            for name in bound_vars.intersection(self._signature_ports)
         }
-        known_inferred_ports = {
-            name: self._inferred_ports[name]
-            for name in op_vars.intersection(self._inferred_ports)
+        known_inferred_qualifiers = {
+            name: self._inferred_ports[name].type_qualifier
+            for name in bound_vars.intersection(self._inferred_ports)
             if self._inferred_ports[name].type_qualifier is not TypeQualifier.Inferred
         }
-        min_qualifier = self._get_min_qualifier(known_inferred_ports, signature_ports)
+        known_initialized_qualifiers = {
+            name: self._initialized_vars[name]
+            for name in bound_vars.intersection(self._initialized_vars)
+            if self._initialized_vars[name] is not TypeQualifier.Inferred
+        }
+        known_qualifiers = (
+            signature_qualifier
+            | known_inferred_qualifiers
+            | known_initialized_qualifiers
+        )
+        min_qualifier = self._get_min_qualifier(list(known_qualifiers.values()))
         if not all(
-            port.type_qualifier is min_qualifier for port in signature_ports.values()
+            type_qualifier is min_qualifier
+            for type_qualifier in signature_qualifier.values()
         ):
-            raise ClassiqInternalExpansionError(
-                f"Bind operation {bind_op} has inconsistent type qualifiers: "
-                f"{signature_ports}, {known_inferred_ports}"
+            warnings.warn(
+                _inconsistent_type_qualifier_in_binding_error(
+                    min_qualifier, known_qualifiers
+                ),
+                ClassiqDeprecationWarning,
+                stacklevel=1,
             )
 
         return min_qualifier
 
     @staticmethod
-    def _get_min_qualifier(
-        known_inferred_ports: dict[str, PortDeclaration],
-        signature_ports: dict[str, PortDeclaration],
-    ) -> TypeQualifier:
-        known_ports = tuple(
-            itertools.chain(signature_ports.values(), known_inferred_ports.values())
-        )
-        if len(known_ports) == 0:
-            return TypeQualifier.Quantum
-        elif len(known_ports) == 1:
-            return known_ports[0].type_qualifier
+    def _get_min_qualifier(qualifiers: list[TypeQualifier]) -> TypeQualifier:
+        if len(qualifiers) == 0:
+            return TypeQualifier.Const
+        elif len(qualifiers) == 1:
+            return qualifiers[0]
         else:
-            return functools.reduce(
-                TypeQualifier.and_, (port.type_qualifier for port in known_ports)
-            )
+            return functools.reduce(TypeQualifier.and_, qualifiers)
 
     @staticmethod
     def _extract_expr_vars(expr_op: QuantumExpressionOperation) -> list[str]:
@@ -149,25 +282,27 @@ class TypeQualifierInference(ModelVisitor):
 
     def visit_ArithmeticOperation(self, arith: ArithmeticOperation) -> None:
         result_var = arith.result_var.name
-        self._reduce_qualifier(result_var, TypeQualifier.QFree)
+        self._validate_qualifier(result_var, TypeQualifier.QFree)
         for expr_var in self._extract_expr_vars(arith):
-            self._reduce_qualifier(expr_var, TypeQualifier.Const)
+            self._validate_qualifier(expr_var, TypeQualifier.Const)
+        if not arith.is_inplace:
+            self._add_initialized_qualifier(result_var, TypeQualifier.QFree)
 
     def visit_AmplitudeLoadingOperation(
         self, amp_load: AmplitudeLoadingOperation
     ) -> None:
         result_var = amp_load.result_var.name
-        self._reduce_qualifier(result_var, TypeQualifier.Quantum)
+        self._validate_qualifier(result_var, TypeQualifier.Quantum)
         for expr_var in self._extract_expr_vars(amp_load):
-            self._reduce_qualifier(expr_var, TypeQualifier.Const)
+            self._validate_qualifier(expr_var, TypeQualifier.Const)
 
     def visit_PhaseOperation(self, phase_op: PhaseOperation) -> None:
         for expr_var in self._extract_expr_vars(phase_op):
-            self._reduce_qualifier(expr_var, TypeQualifier.Const)
+            self._validate_qualifier(expr_var, TypeQualifier.Const)
 
     def visit_Control(self, control: Control) -> None:
         for control_var in self._extract_expr_vars(control):
-            self._reduce_qualifier(control_var, TypeQualifier.Const)
+            self._validate_qualifier(control_var, TypeQualifier.Const)
         self.visit(control.body)
         if control.else_block is not None:
             self.visit(control.else_block)
@@ -179,5 +314,40 @@ class TypeQualifierInference(ModelVisitor):
         self.visit(power.body)
 
     def visit_WithinApply(self, within_apply: WithinApply) -> None:
-        self.visit(within_apply.compute)
+        with self.conjugation_context():
+            self.visit(within_apply.compute)
         self.visit(within_apply.action)
+
+
+def _merge_overlapping(bound_vars: Sequence[Collection[str]]) -> list[set[str]]:
+    """
+    Merges overlapping sets of bound variables.
+    Two sets overlap if they share at least one variable.
+    """
+    all_bound_vars = bound_vars
+    merged_bound_vars: list[set[str]] = []
+    loop_guard: int = 10
+    idx: int = 0
+
+    for _ in range(loop_guard):
+        idx += 1
+
+        merged_bound_vars = []
+        modified: bool = False
+        for current_bound_vars in all_bound_vars:
+            for existing in merged_bound_vars:
+                if existing.intersection(current_bound_vars):
+                    existing.update(current_bound_vars)
+                    modified = True
+                    break
+            else:
+                merged_bound_vars.append(set(current_bound_vars))
+
+        if not modified:
+            break
+        all_bound_vars = merged_bound_vars
+
+    if idx == loop_guard - 1:
+        raise ClassiqInternalExpansionError
+
+    return merged_bound_vars

classiq/model_expansions/visitors/symbolic_param_inference.py

@@ -152,16 +152,10 @@ class SymbolicParamInference(ModelVisitor):
             ):
                 self._process_compile_time_expressions(arg)
             else:
-                if isinstance(arg, Expression):
-                    for expr_part in self.get_generative_expression_parts(arg.expr):
-                        self._process_compile_time_expression(expr_part)
                 for expr in _get_expressions(arg):
                     self._process_nested_compile_time_expression(expr.expr)
         self.generic_visit(call)
 
-    def get_generative_expression_parts(self, expr: str) -> list[str]:
-        return []
-
     def _get_params(self, call: QuantumFunctionCall) -> Sequence[AnonPositionalArg]:
         name = call.func_name
         if name in self._scope_operands:

classiq/open_library/functions/amplitude_amplification.py

@@ -1,5 +1,3 @@
-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 (
@@ -13,7 +11,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, sin
+from classiq.qmod.symbolic import acos, asin, ceiling, pi, sin
 
 
 @qfunc
@@ -69,8 +67,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((np.pi / (4 * asin(amplitude))) - 0.5)
-    theta = np.pi / (4 * k + 2)
+    k = ceiling((pi / (4 * asin(amplitude))) - 0.5)
+    theta = pi / (4 * k + 2)
     rot_phase = 2 * acos(sin(theta) / amplitude)
 
     extended_qvars: QArray = QArray()

classiq/open_library/functions/state_preparation.py

@@ -57,6 +57,10 @@ def allocate_num(
     """
     [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:
@@ -64,6 +68,11 @@ def allocate_num(
         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)
 
 

classiq/qmod/builtins/functions/__init__.py

@@ -70,8 +70,9 @@ CORE_LIB_DECLS = [
         inplace_prepare_amplitudes_approx,
         single_pauli_exponent,
         commuting_paulis_exponent,
-        sparse_suzuki_trotter,
         suzuki_trotter,
+        parametric_suzuki_trotter,
+        sparse_suzuki_trotter,
         qdrift,
         exponentiation_with_depth_constraint,
         RESET,
@@ -131,6 +132,7 @@ __all__ = [  # noqa: RUF022
     "molecule_hartree_fock",
     "molecule_hva",
     "molecule_ucc",
+    "parametric_suzuki_trotter",
     "pauli_feature_map",
     "permute",
     "prepare_amplitudes",

classiq/qmod/builtins/functions/exponentiation.py

@@ -66,7 +66,9 @@ def suzuki_trotter(
     """
     [Qmod core-library function]
 
-    Applies the Suzuki-Trotter decomposition to a Pauli operator. The Suzuki-Trotter decomposition is a method for approximating the exponential of a sum of operators by a product of exponentials of each operator.
+    Applies the Suzuki-Trotter decomposition to a Pauli operator.
+
+    The Suzuki-Trotter decomposition is a method for approximating the exponential of a sum of operators by a product of exponentials of each operator.
     The Suzuki-Trotter decomposition of a given order nullifies the error of the Taylor series expansion of the product of exponentials up to that order.
     The error of a Suzuki-Trotter decomposition decreases as the order and number of repetitions increase.
 
@@ -80,6 +82,37 @@ def suzuki_trotter(
     pass
 
 
+@qfunc(external=True)
+def parametric_suzuki_trotter(
+    paulis: CArray[CArray[Pauli]],
+    coefficients: CArray[CReal, Literal["get_field(paulis, 'len')"]],
+    evolution_coefficient: CReal,
+    order: CInt,
+    repetitions: CInt,
+    qbv: QArray[QBit, Literal["get_field(paulis[0], 'len')"]],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Applies the Suzuki-Trotter decomposition to a Pauli operator represented by two
+    separate lists of paulis and coefficients.
+    Supports symbolic coefficients, including execution parameters.
+
+    The Suzuki-Trotter decomposition is a method for approximating the exponential of a sum of operators by a product of exponentials of each operator.
+    The Suzuki-Trotter decomposition of a given order nullifies the error of the Taylor series expansion of the product of exponentials up to that order.
+    The error of a Suzuki-Trotter decomposition decreases as the order and number of repetitions increase.
+
+    Args:
+        paulis: The Paulis of the Pauli operator.
+        coefficients: The coefficients of the Pauli operator.
+        evolution_coefficient: A global evolution coefficient multiplying the Pauli operator.
+        order: The order of the Suzuki-Trotter decomposition.
+        repetitions: The number of repetitions of the Suzuki-Trotter decomposition.
+        qbv: The target quantum variable of the exponentiation.
+    """
+    pass
+
+
 @qfunc(external=True)
 def sparse_suzuki_trotter(
     pauli_operator: SparsePauliOp,
@@ -89,8 +122,13 @@ def sparse_suzuki_trotter(
     qbv: QArray[QBit, Literal["get_field(pauli_operator, 'num_qubits')"]],
 ) -> None:
     """
-    Applies the Suzuki-Trotter decomposition to a sparse Pauli operator. For more details,
-    See about Suzuki-Trotter decomposition in `suzuki_trotter` `qfunc`.
+    [Qmod core-library function]
+
+    Applies the Suzuki-Trotter decomposition to a sparse Pauli operator.
+
+    The Suzuki-Trotter decomposition is a method for approximating the exponential of a sum of operators by a product of exponentials of each operator.
+    The Suzuki-Trotter decomposition of a given order nullifies the error of the Taylor series expansion of the product of exponentials up to that order.
+    The error of a Suzuki-Trotter decomposition decreases as the order and number of repetitions increase.
 
      Args:
          pauli_operator: The Pauli operator to be exponentiated, in sparse representation (See: SparsePauliOp).

classiq/qmod/builtins/operations.py

@@ -6,6 +6,7 @@ from typing import (
     Any,
     Callable,
     Final,
+    NoReturn,
     Union,
     overload,
 )
@@ -16,6 +17,7 @@ from classiq.interface.generator.functions.builtins.internal_operators import (
     REPEAT_OPERATOR_NAME,
 )
 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.classical_if import ClassicalIf
@@ -322,7 +324,7 @@ def within_apply(
 def repeat(
     count: Union[SymbolicExpr, int], iteration: Callable[[int], Statements]
 ) -> None:
-    _validate_operand(iteration)
+    _validate_operand(iteration, num_params=1)
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
     iteration_operand = prepare_arg(
@@ -396,54 +398,80 @@ def phase(expr: SymbolicExpr, theta: float = 1.0) -> None:
     )
 
 
-def _validate_operand(stmt_block: Any) -> None:
-    if stmt_block is not None:
+def _validate_operand(stmt_block: Any, num_params: int = 0) -> None:
+    if stmt_block is None:
+        _raise_operand_error(
+            lambda operation_name, operand_arg_name: (
+                f"{operation_name!r} is missing required argument for "
+                f"parameter {operand_arg_name!r}"
+            ),
+            num_params,
+        )
+    if isinstance(stmt_block, QCallable):
         return
-    currentframe: FrameType = inspect.currentframe()  # type: ignore[assignment]
+    op_spec = inspect.getfullargspec(stmt_block)
+    params = op_spec.args[: len(op_spec.args) - len(op_spec.defaults or ())]
+    if len(params) > num_params or (
+        len(params) < num_params and op_spec.varargs is None
+    ):
+        _raise_operand_error(
+            lambda operation_name, operand_arg_name: (
+                f"{operation_name!r} argument for {operand_arg_name!r} has "
+                f"{len(params)} parameter{s(params)} but {num_params} expected"
+            ),
+            num_params,
+        )
+
+
+def _raise_operand_error(
+    error_template: Callable[[str, str], str], num_params: int
+) -> NoReturn:
+    currentframe: FrameType = inspect.currentframe().f_back  # type: ignore[assignment,union-attr]
     operation_frame: FrameType = currentframe.f_back  # type: ignore[assignment]
     operation_frame_info: inspect.Traceback = inspect.getframeinfo(operation_frame)
     operation_name: str = operation_frame_info.function
-
     context = operation_frame_info.code_context
     assert context is not None
-    operand_arg_name = context[0].split("_validate_operand(")[1].split(")")[0]
-
-    error_message = (
-        f"{operation_name!r} is missing required argument for {operand_arg_name!r}."
+    operand_arg_name = (
+        context[0].split("_validate_operand(")[1].split(")")[0].split(",")[0]
     )
-    error_message += _get_operand_hint(
-        operation_name=operation_name,
-        operand_arg_name=operand_arg_name,
-        params=inspect.signature(operation_frame.f_globals[operation_name]).parameters,
-    )
-    raise ClassiqValueError(error_message)
-
-
-def _get_operand_hint_args(
-    params: Mapping[str, inspect.Parameter], operand_arg_name: str, operand_value: str
-) -> str:
-    return ", ".join(
-        [
-            (
-                f"{param.name}={operand_value}"
-                if param.name == operand_arg_name
-                else f"{param.name}=..."
-            )
-            for param in params.values()
-            if param.name != "operand"  # FIXME: Remove compatibility (CAD-21932)
-        ]
+    operation_parameters = inspect.signature(
+        operation_frame.f_globals[operation_name]
+    ).parameters
+    raise ClassiqValueError(
+        error_template(operation_name, operand_arg_name)
+        + _get_operand_hint(
+            operation_name=operation_name,
+            operand_arg_name=operand_arg_name,
+            params=operation_parameters,
+            num_params=num_params,
+        )
     )
 
 
 def _get_operand_hint(
-    operation_name: str, operand_arg_name: str, params: Mapping[str, inspect.Parameter]
+    operation_name: str,
+    operand_arg_name: str,
+    params: Mapping[str, inspect.Parameter],
+    num_params: int,
 ) -> str:
-    return (
-        f"\nHint: To call a function under {operation_name!r} use a lambda function as in "
-        f"'{operation_name}({_get_operand_hint_args(params, operand_arg_name, 'lambda: f(q)')})' "
-        f"or pass the quantum function directly as in "
-        f"'{operation_name}({_get_operand_hint_args(params, operand_arg_name, 'f')})'."
-    )
+    if operation_name == "repeat":
+        operand_params = " i"
+    else:
+        operand_params = (
+            ""
+            if num_params == 0
+            else f" {', '.join([f'p{i}' for i in range(num_params)])}"
+        )
+    args = [
+        (
+            f"{param.name}=lambda{operand_params}: ..."
+            if param.name == operand_arg_name
+            else f"{param.name}=..."
+        )
+        for param in params.values()
+    ]
+    return f"\nHint: Write '{operation_name}({', '.join(args)})'"
 
 
 def _operand_to_body(

classiq/qmod/declaration_inferrer.py

@@ -175,7 +175,8 @@ def _get_param_name(py_type_args: Any) -> Optional[str]:
 def _validate_annotations(py_type_args: Any, py_type: Any) -> None:
     for arg in py_type_args[1:-1]:
         if (
-            isinstance(arg, str) and not isinstance(arg, PortDeclarationDirection)
+            isinstance(arg, str)
+            and not isinstance(arg, (PortDeclarationDirection, TypeQualifier))
         ) or arg is Literal:
             raise ClassiqValueError(
                 f"Operand parameter declaration must be of the form <param-type> or "