classiq 0.93.0__py3-none-any.whl → 0.100.0__py3-none-any.whl

classiq/model_expansions/visitors/symbolic_param_inference.py

@@ -2,7 +2,7 @@ import ast
 from collections.abc import Iterator, Mapping, Sequence
 from contextlib import contextmanager
 from itertools import chain, zip_longest
-from typing import Optional, cast
+from typing import cast
 
 from classiq.interface.generator.expressions.atomic_expression_functions import (
     CLASSICAL_ATTRIBUTES,
@@ -19,7 +19,7 @@ from classiq.interface.model.classical_parameter_declaration import (
     AnonClassicalParameterDeclaration,
 )
 from classiq.interface.model.handle_binding import FieldHandleBinding, HandleBinding
-from classiq.interface.model.model_visitor import ModelVisitor
+from classiq.interface.model.model_visitor import ModelStatementsVisitor
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_call import ArgValue, QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
@@ -84,13 +84,13 @@ def _get_param_expressions(param: AnonPositionalArg) -> list[Expression]:
     return param.quantum_type.expressions
 
 
-class SymbolicParamInference(ModelVisitor):
+class SymbolicParamInference(ModelStatementsVisitor):
     def __init__(
         self,
         functions: list[NativeFunctionDefinition],
-        additional_signatures: Optional[
+        additional_signatures: None | (
             list[NamedParamsQuantumFunctionDeclaration]
-        ] = None,
+        ) = None,
     ) -> None:
         self._functions = nameables_to_dict(functions)
         self._additional_signatures = (
@@ -166,7 +166,7 @@ class SymbolicParamInference(ModelVisitor):
             else:
                 for expr in _get_expressions(arg):
                     self._process_nested_compile_time_expression(expr.expr)
-        self.generic_visit(call)
+        self.visit(call.positional_args)
 
     def _get_params(self, call: QuantumFunctionCall) -> Sequence[AnonPositionalArg]:
         name = call.func_name

classiq/model_expansions/visitors/uncomputation_signature_inference.py

@@ -0,0 +1,328 @@
+import warnings
+from collections import defaultdict
+from collections.abc import Iterator
+from contextlib import contextmanager
+from typing import NamedTuple
+
+from classiq.interface.ast_node import ASTNode
+from classiq.interface.exceptions import (
+    ClassiqDeprecationWarning,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.compiler_keywords import EXPANDED_KEYWORD
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.generator.functions.type_modifier import TypeModifier
+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.classical_if import ClassicalIf
+from classiq.interface.model.control import Control
+from classiq.interface.model.invert import Invert
+from classiq.interface.model.model_visitor import ModelStatementsVisitor
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+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,
+)
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.skip_control import SkipControl
+from classiq.interface.model.within_apply_operation import WithinApply
+from classiq.interface.source_reference import SourceReference
+
+
+class _BoundVars(NamedTuple):
+    in_identifiers: list[str]
+    out_identifiers: list[str]
+    source_ref: SourceReference | None
+
+    def reverse(self) -> "_BoundVars":
+        return _BoundVars(
+            in_identifiers=self.out_identifiers,
+            out_identifiers=self.in_identifiers,
+            source_ref=self.source_ref,
+        )
+
+
+class UncomputationSignatureInference(ModelStatementsVisitor):
+    """
+    Infers the uncomputation signature of a function (permutation/non-permutation for
+    the function, and const/non-const for each parameter).
+
+    A function is a permutation if and only if all its body operations are permutations
+    (note that amplitude loading operation is not a permutation).
+
+    A parameter is const if and only if it is used as a const argument in all the
+    body operations (including when binding it to a different variable). An exception
+    for this rule is that a const parameter can be used as a non-const argument to a
+    permutation function inside a `within` block.
+
+    This class assumes that dependent functions are already inferred, so it doesn't
+    recursively inferring function calls.
+    """
+
+    def __init__(self) -> None:
+        self._is_permutation: bool = True
+        self._non_permutation_reasons: list[SourceReference | None] = []
+        self._non_const_with_reasons: dict[str, list[SourceReference | None]] = (
+            defaultdict(list)
+        )
+
+        self._in_conjugation: bool = False
+        self._source_ref: SourceReference | None = None
+
+        # remember bound vars inside `within` to invert their effect after the `apply`
+        self._bound_vars_list: list[_BoundVars] = []
+
+    def run(self, func_def: NativeFunctionDefinition) -> None:
+        self._is_permutation = True
+        self._non_permutation_reasons.clear()
+        self._non_const_with_reasons.clear()
+        self.visit(func_def.body)
+
+    def is_permutation(self) -> bool:
+        return self._is_permutation
+
+    def non_permutation_reasons(self) -> list[SourceReference | None]:
+        if self._is_permutation:
+            raise ClassiqInternalExpansionError("Function is a permutation")
+        return self._non_permutation_reasons
+
+    def is_const(self, port: str) -> bool:
+        return port not in self._non_const_with_reasons
+
+    def non_const_reasons(self, port: str) -> list[SourceReference | None]:
+        if port not in self._non_const_with_reasons:
+            raise ClassiqInternalExpansionError("Parameter is constant")
+        return self._non_const_with_reasons[port]
+
+    def visit(self, node: NodeType) -> None:
+        if isinstance(node, ASTNode):
+            with self._source_reference_context(node.source_ref):
+                super().visit(node)
+        else:
+            super().visit(node)
+
+    def visit_QuantumFunctionCall(self, call: QuantumFunctionCall) -> None:
+        if not call.func_decl.permutation:
+            self._mark_as_non_permutation()
+
+        in_identifiers: list[str] = []
+        out_identifiers: list[str] = []
+
+        for handle, port in call.handles_with_params:
+            if port.type_modifier is not TypeModifier.Const:
+                self._mark_as_non_const(handle.name, call.func_decl.permutation)
+
+            if port.direction is PortDeclarationDirection.Input:
+                in_identifiers.append(handle.name)
+            elif port.direction is PortDeclarationDirection.Output:
+                out_identifiers.append(handle.name)
+
+        if in_identifiers or out_identifiers:
+            bound_vars = _BoundVars(in_identifiers, out_identifiers, call.source_ref)
+            self._mark_bind_outputs(bound_vars)
+            self._bound_vars_list.append(bound_vars)
+
+    def visit_Allocate(self, alloc: Allocate) -> None:
+        self._mark_as_non_const(alloc.target.name, True)
+
+    def visit_BindOperation(self, bind_op: BindOperation) -> None:
+        in_identifiers = [handle.name for handle in bind_op.in_handles]
+        out_identifiers = [handle.name for handle in bind_op.out_handles]
+        bound_vars = _BoundVars(in_identifiers, out_identifiers, bind_op.source_ref)
+        self._mark_bind_outputs(bound_vars)
+        self._bound_vars_list.append(bound_vars)
+
+    def visit_ArithmeticOperation(self, arith: ArithmeticOperation) -> None:
+        if arith.classical_assignment:
+            if arith.var_handles:
+                self._mark_as_non_permutation()
+                for handle in arith.var_handles:
+                    self._mark_as_non_const(handle.name, False)
+        else:
+            self._mark_as_non_const(arith.result_var.name, True)
+
+    def visit_AmplitudeLoadingOperation(
+        self, amp_load: AmplitudeLoadingOperation
+    ) -> None:
+        self._mark_as_non_permutation()
+        self._mark_as_non_const(amp_load.result_var.name, False)
+
+    def visit_Control(self, control: Control) -> None:
+        self.visit(control.body)
+        if control.else_block is not None:
+            self.visit(control.else_block)
+
+    def visit_Invert(self, invert: Invert) -> None:
+        self.visit(invert.body)
+
+    def visit_Power(self, power: Power) -> None:
+        self.visit(power.body)
+
+    def visit_WithinApply(self, within_apply: WithinApply) -> None:
+        with self._conjugation_context() as bound_vars_list:
+            self.visit(within_apply.compute)
+        self.visit(within_apply.action)
+
+        for bound_vars in reversed(bound_vars_list):
+            self._mark_bind_outputs(bound_vars.reverse())
+
+    def visit_Block(self, block: Block) -> None:
+        self.visit(block.statements)
+
+    def visit_SkipControl(self, block: SkipControl) -> None:
+        self.visit(block.body)
+
+    def visit_ClassicalIf(self, classical_if: ClassicalIf) -> None:
+        self.visit(classical_if.then)
+        self.visit(classical_if.else_)
+
+    def _mark_as_non_permutation(self) -> None:
+        self._is_permutation = False
+        self._non_permutation_reasons.append(self._source_ref)
+
+    def _mark_as_non_const(
+        self,
+        identifier: str,
+        permutation_op: bool,
+        source_ref: SourceReference | None = None,
+    ) -> None:
+        if self._in_conjugation and permutation_op:
+            return
+        self._non_const_with_reasons[identifier].append(source_ref or self._source_ref)
+
+    def _mark_bind_outputs(self, bound_vars: _BoundVars) -> None:
+        if all(self.is_const(identifier) for identifier in bound_vars.in_identifiers):
+            return
+        for identifier in bound_vars.out_identifiers:
+            self._mark_as_non_const(identifier, False, bound_vars.source_ref)
+
+    @contextmanager
+    def _conjugation_context(self) -> Iterator[list[_BoundVars]]:
+        previous_bound_vars = self._bound_vars_list
+        previous_context = self._in_conjugation
+        self._bound_vars_list = []
+        self._in_conjugation = True
+        try:
+            yield self._bound_vars_list
+        finally:
+            self._in_conjugation = previous_context
+            self._bound_vars_list = previous_bound_vars
+
+    @contextmanager
+    def _source_reference_context(
+        self, source_ref: SourceReference | None
+    ) -> Iterator[None]:
+        previous_source_ref = self._source_ref
+        self._source_ref = source_ref
+        try:
+            yield
+        finally:
+            self._source_ref = previous_source_ref
+
+
+def infer_and_validate_uncomputation_signature(
+    func_def: NativeFunctionDefinition,
+    disable_perm_check: bool = False,
+    disable_const_checks: list[str] | bool = False,
+    tighten_signature: bool = False,
+) -> None:
+    """
+    Runs the uncomputation signature inference in order to validate the function signature
+    and tighten it when requested (changing non-permutation to permutation and non-const
+    to const).
+    """
+    for port in func_def.port_declarations:
+        if port.type_modifier is TypeModifier.Const and port.direction in (
+            PortDeclarationDirection.Input,
+            PortDeclarationDirection.Output,
+        ):
+            warnings.warn(
+                _input_output_const(port.name, port.direction, func_def.name),
+                ClassiqDeprecationWarning,
+                stacklevel=1,
+            )
+
+    if disable_perm_check and (disable_const_checks is True) and not tighten_signature:
+        return
+
+    visitor = UncomputationSignatureInference()
+    visitor.run(func_def)
+
+    if not disable_perm_check and func_def.permutation and not visitor.is_permutation():
+        for source_ref in visitor.non_permutation_reasons():
+            warnings.warn(
+                _non_permutation_usage(func_def.name, source_ref),
+                ClassiqDeprecationWarning,
+                stacklevel=1,
+            )
+
+    if tighten_signature and not func_def.permutation and visitor.is_permutation():
+        func_def.permutation = True
+
+    unchecked = (
+        set(disable_const_checks) if isinstance(disable_const_checks, list) else set()
+    )
+    for port in func_def.port_declarations:
+        if (
+            not ((disable_const_checks is True) or port.name in unchecked)
+            and port.type_modifier is TypeModifier.Const
+            and not visitor.is_const(port.name)
+        ):
+            for source_ref in visitor.non_const_reasons(port.name):
+                warnings.warn(
+                    _non_const_usage(port.name, source_ref),
+                    ClassiqDeprecationWarning,
+                    stacklevel=1,
+                )
+
+        if (
+            tighten_signature
+            and port.type_modifier is not TypeModifier.Const
+            and visitor.is_const(port.name)
+        ):
+            port.type_modifier = TypeModifier.Const
+
+
+def _input_output_const(
+    port_name: str,
+    direction: PortDeclarationDirection,
+    function_name: str,
+) -> str:
+    return (
+        f"{direction.capitalize()} parameters cannot be defined as constants"
+        f" (parameter {port_name!r} in function {function_name.split('_' + EXPANDED_KEYWORD)[0]!r}).\n"
+        "The deprecation warning will be elevated to an error starting 2025-12-03, at the earliest."
+    )
+
+
+def _non_const_usage(
+    port_name: str,
+    source_ref: SourceReference | None = None,
+) -> str:
+    source_ref_str = f"\n\tat {source_ref}" if source_ref else ""
+    return (
+        f"Non-constant usage of a constant parameter {port_name!r}.{source_ref_str}\n"
+        "Tip: if the commulative use of the parameter in the function is constant, "
+        "use the `disable_const_checks` flag to instruct the compiler to disregard individual operations.\n"
+        "The deprecation warning will be elevated to an error starting 2025-12-03, at the earliest."
+    )
+
+
+def _non_permutation_usage(
+    function_name: str,
+    source_ref: SourceReference | None = None,
+) -> str:
+    source_ref_str = f"\n\tat {source_ref}" if source_ref else ""
+    return (
+        f"Non-permutation operation used in a permutation function {function_name.split('_' + EXPANDED_KEYWORD)[0]!r}.{source_ref_str}\n"
+        "Tip: if the commulative effect of the function is a permutation, "
+        "use the `disable_perm_check` flag to instruct the compiler to disregard individual operations.\n"
+        "The deprecation warning will be elevated to an error starting 2025-12-03, at the earliest."
+    )

classiq/model_expansions/visitors/variable_references.py

@@ -1,7 +1,6 @@
 import ast
 from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import Optional, Union
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -46,13 +45,15 @@ class VarRefCollector(ast.NodeVisitor):
             handle for handle, in_subscript in self._var_handles.items() if in_subscript
         ]
 
-    def visit(self, node: ast.AST) -> Union[
-        SubscriptHandleBinding,
-        SlicedHandleBinding,
-        FieldHandleBinding,
-        HandleBinding,
-        None,
-    ]:
+    def visit(
+        self, node: ast.AST
+    ) -> (
+        SubscriptHandleBinding
+        | SlicedHandleBinding
+        | FieldHandleBinding
+        | HandleBinding
+        | None
+    ):
         res = super().visit(node)
         if not self._ignore_duplicated_handles and len(self._var_handles) != len(
             {handle.name for handle in self._var_handles}
@@ -62,13 +63,13 @@ class VarRefCollector(ast.NodeVisitor):
             )
         return res
 
-    def visit_Subscript(self, node: ast.Subscript) -> Union[HandleBinding, None]:
+    def visit_Subscript(self, node: ast.Subscript) -> HandleBinding | None:
         return self._get_subscript_handle(node.value, node.slice)
 
-    def visit_Attribute(self, node: ast.Attribute) -> Optional[FieldHandleBinding]:
+    def visit_Attribute(self, node: ast.Attribute) -> FieldHandleBinding | None:
         return self._get_field_handle(node.value, node.attr)
 
-    def visit_Call(self, node: ast.Call) -> Optional[HandleBinding]:
+    def visit_Call(self, node: ast.Call) -> HandleBinding | None:
         if not isinstance(node.func, ast.Name):
             return self.generic_visit(node)
         if node.func.id == "get_field":
@@ -89,7 +90,7 @@ class VarRefCollector(ast.NodeVisitor):
 
     def _get_field_handle(
         self, subject: ast.expr, field: str
-    ) -> Optional[FieldHandleBinding]:
+    ) -> FieldHandleBinding | None:
         with self.set_nested():
             base_handle = self.visit(subject)
         if base_handle is None:
@@ -104,7 +105,7 @@ class VarRefCollector(ast.NodeVisitor):
 
     def _get_subscript_handle(
         self, subject: ast.expr, subscript: ast.expr
-    ) -> Optional[HandleBinding]:
+    ) -> HandleBinding | None:
         with self.set_in_subscript():
             self.visit(subscript)
         with self.set_nested():
@@ -138,7 +139,7 @@ class VarRefCollector(ast.NodeVisitor):
             self._add_handle(handle)
         return handle
 
-    def visit_Name(self, node: ast.Name) -> Optional[HandleBinding]:
+    def visit_Name(self, node: ast.Name) -> HandleBinding | None:
         if not self._ignore_sympy_symbols and node.id in set(
             SYMPY_SUPPORTED_EXPRESSIONS
         ) | set(DEFAULT_SUPPORTED_FUNC_NAMES):

classiq/open_library/functions/__init__.py

@@ -1,30 +1,34 @@
+from classiq.qmod.quantum_function import BaseQFunc
+
 from .amplitude_amplification import (
     amplitude_amplification,
     exact_amplitude_amplification,
 )
 from .amplitude_estimation import *
+from .amplitude_loading import assign_amplitude_table
 from .discrete_sine_cosine_transform import *
 from .discrete_sine_cosine_transform import _qct_d_operator, _qct_pi_operator
+from .encodings import *
 from .grover import *
 from .grover import _cond_phase_flip
 from .hea import *
 from .lcu import *
 from .linear_pauli_rotation import *
 from .linear_pauli_rotation import _single_pauli
-from .lookup_table import span_lookup_table
 from .modular_exponentiation import *
 from .modular_exponentiation import _check_msb
 from .qaoa_penalty import *
 from .qft_functions import *
 from .qpe import *
-from .qsvt import *
+from .qsvt import gqsp
+from .qsvt_temp import *  # change to .qsvt after deprecation
 from .state_preparation import *
 from .state_preparation import _prepare_uniform_trimmed_state_step
 from .swap_test import *
 from .utility_functions import *
 from .variational import *
 
-OPEN_LIBRARY_FUNCTIONS = [
+OPEN_LIBRARY_FUNCTIONS: list[BaseQFunc] = [
     qpe_flexible,
     qpe,
     _single_pauli,
@@ -46,13 +50,20 @@ OPEN_LIBRARY_FUNCTIONS = [
     multiswap,
     inplace_c_modular_multiply,
     modular_exp,
-    qsvt_step,
-    qsvt,
-    projector_controlled_double_phase,
-    projector_controlled_phase,
-    qsvt_inversion,
-    qsvt_lcu,
-    qsvt_lcu_step,
+    qsvt_step_old,
+    qsvt_step_new,
+    qsvt_old,
+    qsvt_new,
+    projector_controlled_double_phase_old,
+    projector_controlled_double_phase_new,
+    projector_controlled_phase_old,
+    projector_controlled_phase_new,
+    qsvt_inversion_old,
+    qsvt_inversion_new,
+    qsvt_lcu_old,
+    qsvt_lcu_new,
+    qsvt_lcu_step_old,
+    qsvt_lcu_step_new,
     gqsp,
     qaoa_mixer_layer,
     qaoa_cost_layer,
@@ -82,6 +93,12 @@ OPEN_LIBRARY_FUNCTIONS = [
     encode_in_angle,
     encode_on_bloch,
     _cond_phase_flip,
+    inplace_modular_multiply,
+    modular_multiply,
+    modular_add_qft_space,
+    one_hot_to_unary,
+    inplace_one_hot_to_unary,
+    unary_to_one_hot,
 ]
 
 __all__ = [
@@ -89,6 +106,9 @@ __all__ = [
     "amplitude_amplification",
     "amplitude_estimation",
     "apply_to_all",
+    "assign_amplitude_table",
+    "binary_to_one_hot",
+    "binary_to_unary",
     "c_modular_multiply",
     "cc_modular_add",
     "encode_in_angle",
@@ -100,16 +120,24 @@ __all__ = [
     "grover_operator",
     "grover_search",
     "hadamard_transform",
+    "inplace_binary_to_one_hot",
     "inplace_c_modular_multiply",
+    "inplace_modular_multiply",
+    "inplace_one_hot_to_unary",
     "inplace_prepare_complex_amplitudes",
     "inplace_prepare_int",
     "inplace_prepare_sparse_amplitudes",
     "lcu",
     "lcu_pauli",
     "linear_pauli_rotations",
+    "modular_add_qft_space",
     "modular_exp",
     "modular_increment",
+    "modular_multiply",
     "multiswap",
+    "one_hot_to_binary",
+    "one_hot_to_unary",
+    "pad_zeros",
     "phase_oracle",
     "prepare_basis_state",
     "prepare_bell_state",
@@ -120,6 +148,7 @@ __all__ = [
     "prepare_ghz_state",
     "prepare_int",
     "prepare_linear_amplitudes",
+    "prepare_select",
     "prepare_sparse_amplitudes",
     "prepare_uniform_interval_state",
     "prepare_uniform_trimmed_state",
@@ -145,8 +174,9 @@ __all__ = [
     "qsvt_lcu_step",
     "qsvt_step",
     "reflect_about_zero",
-    "span_lookup_table",
     "suzuki_trotter",
     "swap_test",
     "switch",
+    "unary_to_binary",
+    "unary_to_one_hot",
 ]

classiq/open_library/functions/amplitude_loading.py

@@ -0,0 +1,81 @@
+from typing import cast
+
+import numpy as np
+from sympy import fwht
+
+from classiq.interface.exceptions import ClassiqValueError
+
+from classiq.qmod.builtins.functions import CX, RY
+from classiq.qmod.builtins.operations import skip_control
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_variable import Const, QArray, QBit
+
+
+def _get_graycode(size: int, i: int) -> int:
+    if i == 2**size:
+        return _get_graycode(size, 0)
+    return i ^ (i >> 1)
+
+
+def _get_graycode_angles_wh(size: int, angles: list[float]) -> list[float]:
+    transformed_angles = fwht(np.array(angles) / 2**size)
+    return [transformed_angles[_get_graycode(size, j)] for j in range(2**size)]
+
+
+def _get_graycode_ctrls(size: int) -> list[int]:
+    return [
+        (_get_graycode(size, i) ^ _get_graycode(size, i + 1)).bit_length() - 1
+        for i in range(2**size)
+    ]
+
+
+@qfunc
+def assign_amplitude_table(
+    amplitudes: list[float], index: Const[QArray], indicator: QBit
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Load a specified list of real amplitudes into a quantum variable using an extra indicator qubit:
+    \\( |i\\rangle|0\\rangle \\rightarrow a(i)\\ |i\\rangle|1\\rangle + \\sqrt{1 - a(i)^2}\\ |i\\rangle|0\\rangle \\).
+    Here, \\(a(i)\\) is the i-th amplitude, determined by the QNum when the index is in state \\(i\\).
+    A list extracted from a given classical function \\(f(x)\\), with indexing according to a given QNum, can be obtained via the utility SDK function `lookup_table`.
+    This function expects the indicator qubit to be initialized to \\(|0\\rangle\\).
+
+    Args:
+        amplitudes: Real values for the amplitudes. Must be between -1 and 1
+        index: The quantum variable used for amplitude indexing
+        indicator: The quantum indicator qubit
+
+    Example:
+        ```python
+        from classiq import *
+
+
+        @qfunc
+        def main(x: Output[QNum[5, UNSIGNED, 5]], ind: Output[QBit]) -> None:
+            allocate(x)
+            hadamard_transform(x)
+            allocate(ind)
+
+            assign_amplitude_table(lookup_table(lambda x: x**2, x), x, ind)
+        ```
+    """
+    size = index.len
+    if len(amplitudes) != 2**size:
+        raise ClassiqValueError(
+            f"The number of amplitudes must be 2**index.size={2 ** size}, got "
+            f"{len(amplitudes)}"
+        )
+    if not all(-1 <= amp <= 1 for amp in amplitudes):
+        raise ClassiqValueError("All amplitudes must be between -1 and 1")
+
+    angles_to_load = cast(list[float], 2 * np.arcsin(amplitudes))
+    transformed_angles = _get_graycode_angles_wh(size, angles_to_load)
+    controllers = _get_graycode_ctrls(size)
+
+    for k in range(2**size):
+        RY(transformed_angles[k], indicator)
+        skip_control(
+            lambda k=k: CX(index[controllers[k]], indicator)  # type:ignore[misc]
+        )

classiq/open_library/functions/discrete_sine_cosine_transform.py

@@ -10,8 +10,8 @@ from classiq.qmod.builtins.operations import (
     repeat,
     within_apply,
 )
-from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_variable import Const, Permutable, QArray, QBit, QNum
+from classiq.qmod.qfunc import qfunc, qperm
+from classiq.qmod.qmod_variable import Const, QArray, QBit, QNum
 from classiq.qmod.symbolic import pi
 from classiq.qmod.utilities import suppress_return_value
 
@@ -27,8 +27,8 @@ def _qct_d_operator(x: Const[QNum], q: QBit) -> None:
     control(x == 0, lambda: invert(lambda: _b_operator(q)))
 
 
-@qfunc
-def _qct_pi_operator(x: Permutable[QNum], q: Const[QBit]) -> None:
+@qperm
+def _qct_pi_operator(x: QNum, q: Const[QBit]) -> None:
     control(
         q == 1,
         lambda: [
@@ -125,7 +125,7 @@ def qct_qst_type1(x: QArray[QBit]) -> None:
     within_apply(lambda: _t_operator(x), lambda: qft(x))
 
 
-@qfunc(unchecked=["q"])
+@qfunc(disable_const_checks=["q"])
 def qct_qst_type2(x: QArray[QBit], q: Const[QBit]) -> None:
     """
     [Qmod Classiq-library function]