classiq 0.52.0__py3-none-any.whl → 0.54.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -1,15 +1,54 @@
+from typing import TYPE_CHECKING
+
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 
+from classiq.model_expansions.call_to_model_converter import (
+    BlockFunctionInfo,
+    CallToModelConverter,
+)
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.qmod.semantics.error_manager import ErrorManager
 
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreter import Interpreter
+
 
 class QuantumFunctionCallEmitter(Emitter[QuantumFunctionCall]):
+    def __init__(self, interpreter: "Interpreter") -> None:
+        super().__init__(interpreter)
+        self._model = self._interpreter._model
+        self._synthesized_separately_blocks = (
+            self._interpreter._synthesized_separately_blocks
+        )
+
     def emit(self, call: QuantumFunctionCall, /) -> None:
-        function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
+        function: FunctionClosure = self._interpreter.evaluate(call.function).as_type(
+            FunctionClosure
+        )
         args = call.positional_args
         with ErrorManager().call(
             function.name
         ), function.scope.freeze(), self._propagated_var_stack.capture_variables(call):
-            self._emit_quantum_function_call(function, args)
+            new_call = self._emit_quantum_function_call(function, args)
+            if function.synthesis_data.should_synthesize_separately:
+                interpreted_call_converter = CallToModelConverter(
+                    call,
+                    function.positional_arg_declarations,
+                    function.scope.data,
+                    self._model,
+                )
+                self._update_synthesized_separately_models(
+                    interpreted_call_converter, new_call.func_name
+                )
+
+    def _update_synthesized_separately_models(
+        self, call_converter: CallToModelConverter, call_name: str
+    ) -> None:
+        synthesized_separately_blocks = self._synthesized_separately_blocks
+        block_id = call_converter.block_id
+        block_function = synthesized_separately_blocks.get(block_id)
+        if block_function is None:
+            block_function = BlockFunctionInfo.from_call_converter(call_converter)
+            synthesized_separately_blocks[block_id] = block_function
+        block_function.calls.add(call_name)

classiq/model_expansions/quantum_operations/repeat.py

@@ -1,5 +1,3 @@
-from typing import Type
-
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
     REPEAT_OPERATOR_NAME,
@@ -24,7 +22,7 @@ class RepeatEmitter(Emitter[Repeat]):
                 self._emit_propagated(repeat, i)
 
     def _emit_propagated(self, repeat: Repeat, i: int) -> None:
-        closure_constructor: Type[FunctionClosure]
+        closure_constructor: type[FunctionClosure]
         extra_args: dict
         if repeat.is_generative():
             closure_constructor = GenerativeFunctionClosure

classiq/model_expansions/scope.py

@@ -1,9 +1,10 @@
 import itertools
 from collections import UserDict
+from collections.abc import Iterator
 from contextlib import contextmanager
 from dataclasses import dataclass
 from functools import singledispatch
-from typing import TYPE_CHECKING, Any, Dict, Iterator, Optional, Type, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -104,7 +105,7 @@ class QuantumSymbol:
         )
 
     @property
-    def fields(self) -> Dict[str, "QuantumSymbol"]:
+    def fields(self) -> dict[str, "QuantumSymbol"]:
         quantum_type = self.quantum_type
         if not isinstance(quantum_type, TypeName):
             raise ClassiqExpansionError(
@@ -120,18 +121,18 @@ class QuantumSymbol:
 
 
 @singledispatch
-def _evaluated_to_str(value: Any) -> str:
+def evaluated_to_str(value: Any) -> str:
     return str(value)
 
 
-@_evaluated_to_str.register
+@evaluated_to_str.register
 def _evaluated_to_str_list(value: list) -> str:
-    return f"[{', '.join(_evaluated_to_str(x) for x in value)}]"
+    return f"[{', '.join(evaluated_to_str(x) for x in value)}]"
 
 
-@_evaluated_to_str.register
+@evaluated_to_str.register
 def _evaluated_to_str_struct_literal(value: QmodStructInstance) -> str:
-    return f"struct_literal({value.struct_declaration.name}, {', '.join(f'{k}={_evaluated_to_str(v)}' for k, v in value.fields.items())})"
+    return f"struct_literal({value.struct_declaration.name}, {', '.join(f'{k}={evaluated_to_str(v)}' for k, v in value.fields.items())})"
 
 
 @dataclass(frozen=True)
@@ -139,7 +140,7 @@ class Evaluated:  # FIXME: Merge with EvaluatedExpression if possible
     value: Any
     defining_function: Optional["Closure"] = None
 
-    def as_type(self, t: Type[T]) -> T:
+    def as_type(self, t: type[T]) -> T:
         if t is int:
             return self._as_int()  # type: ignore[return-value]
 
@@ -162,7 +163,7 @@ class Evaluated:  # FIXME: Merge with EvaluatedExpression if possible
         if isinstance(self.value, QuantumSymbol):
             return self.value.emit()
 
-        ret = Expression(expr=_evaluated_to_str(self.value))
+        ret = Expression(expr=evaluated_to_str(self.value))
         ret._evaluated_expr = EvaluatedExpression(value=self.value)
         return ret
 
@@ -176,7 +177,7 @@ else:
 class Scope(EvaluatedUserDict):
     def __init__(
         self,
-        data: Optional[Dict[str, Evaluated]] = None,
+        data: Optional[dict[str, Evaluated]] = None,
         /,
         *,
         parent: Optional["Scope"] = None,

classiq/model_expansions/scope_initialization.py

@@ -1,4 +1,4 @@
-from typing import List, Sequence
+from collections.abc import Sequence
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.constant import Constant
@@ -43,7 +43,7 @@ def get_main_renamer(
     return ExpressionRenamer(var_mapping={})
 
 
-def _add_constants_to_scope(constants: List[Constant], scope: Scope) -> None:
+def _add_constants_to_scope(constants: list[Constant], scope: Scope) -> None:
     for constant in constants:
         scope[constant.name] = Evaluated(
             value=evaluate_classical_expression(constant.value, scope).value
@@ -51,7 +51,7 @@ def _add_constants_to_scope(constants: List[Constant], scope: Scope) -> None:
 
 
 def _add_functions_to_scope(
-    functions: List[NativeFunctionDefinition], scope: Scope
+    functions: list[NativeFunctionDefinition], scope: Scope
 ) -> None:
     for function in functions:
         scope[function.name] = Evaluated(
@@ -60,12 +60,13 @@ def _add_functions_to_scope(
                 positional_arg_declarations=function.positional_arg_declarations,
                 body=function.body,
                 scope=Scope(parent=scope),
+                synthesis_data=function.synthesis_data,
             )
         )
 
 
 def _add_generative_functions_to_scope(
-    functions: List[GenerativeQFunc], scope: Scope
+    functions: list[GenerativeQFunc], scope: Scope
 ) -> None:
     for function in functions:
         scope[function.func_decl.name] = Evaluated(
@@ -138,7 +139,7 @@ def add_entry_point_params_to_scope(
 
 
 def init_top_level_scope(
-    model: Model, generative_functions: List[GenerativeQFunc], scope: Scope
+    model: Model, generative_functions: list[GenerativeQFunc], scope: Scope
 ) -> None:
     _add_functions_to_scope(model.functions, scope)
     _add_generative_functions_to_scope(generative_functions, scope)

classiq/model_expansions/sympy_conversion/expression_to_sympy.py

@@ -1,5 +1,5 @@
 import ast
-from typing import TYPE_CHECKING, Dict, Type, cast
+from typing import TYPE_CHECKING, cast
 
 from classiq.interface.exceptions import ClassiqExpansionError
 
@@ -18,29 +18,29 @@ def translate_to_sympy(expr: str) -> str:
 
 
 class ExpressionSympyTranslator(ast.NodeTransformer):
-    BINARY_OPERATORS: Dict[Type[ast.AST], str] = {
+    BINARY_OPERATORS: dict[type[ast.AST], str] = {
         ast.BitOr: "BitwiseOr",
         ast.BitAnd: "BitwiseAnd",
         ast.BitXor: "BitwiseXor",
         ast.Div: "do_div",
     }
 
-    UNARY_OPERATORS: Dict[Type[ast.AST], str] = {
+    UNARY_OPERATORS: dict[type[ast.AST], str] = {
         ast.Invert: "BitwiseNot",
         ast.Not: "Not",
     }
 
-    BOOLEAN_OPERATORS: Dict[Type[ast.AST], str] = {
+    BOOLEAN_OPERATORS: dict[type[ast.AST], str] = {
         ast.Or: "Or",
         ast.And: "And",
     }
 
-    COMPARE_OPERATORS: Dict[Type[ast.AST], str] = {
+    COMPARE_OPERATORS: dict[type[ast.AST], str] = {
         ast.Eq: "Eq",
         ast.NotEq: "Ne",
     }
 
-    SPECIAL_FUNCTIONS: Dict[str, str] = {
+    SPECIAL_FUNCTIONS: dict[str, str] = {
         "max": "Max",
         "min": "Min",
     }

classiq/model_expansions/sympy_conversion/sympy_to_python.py

@@ -1,5 +1,5 @@
 import functools
-from typing import Any, Dict, Optional, get_args
+from typing import Any, Optional, get_args
 
 from sympy import (
     Array,
@@ -22,7 +22,7 @@ from classiq.model_expansions.sympy_conversion.arithmetics import LogicalXor
 
 
 def sympy_to_python(
-    value: Any, locals: Optional[Dict[str, ExpressionValue]] = None
+    value: Any, locals: Optional[dict[str, ExpressionValue]] = None
 ) -> ExpressionValue:
     if isinstance(value, Integer):
         value = int(value)

classiq/model_expansions/visitors/variable_references.py

@@ -1,6 +1,7 @@
 import ast
+from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import Dict, Iterator, List, Optional, Union
+from typing import Optional, Union
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -23,12 +24,12 @@ from classiq.interface.model.handle_binding import (
 
 class VarRefCollector(ast.NodeVisitor):
     def __init__(self, ignore_duplicated_handles: bool = False) -> None:
-        self._var_handles: Dict[HandleBinding, bool] = {}
+        self._var_handles: dict[HandleBinding, bool] = {}
         self._ignore_duplicated_handles = ignore_duplicated_handles
         self._is_nested = False
 
     @property
-    def var_handles(self) -> List[HandleBinding]:
+    def var_handles(self) -> list[HandleBinding]:
         return list(self._var_handles)
 
     def visit(self, node: ast.AST) -> Union[
@@ -110,7 +111,7 @@ class VarRefCollector(ast.NodeVisitor):
 
 
 class VarRefTransformer(ast.NodeTransformer):
-    def __init__(self, var_mapping: Dict[str, str]) -> None:
+    def __init__(self, var_mapping: dict[str, str]) -> None:
         self.var_mapping = var_mapping
 
     def visit_Name(self, node: ast.Name) -> ast.Name:

classiq/qmod/__init__.py

@@ -8,6 +8,7 @@ from .qmod_constant import QConstant
 from .qmod_parameter import Array, CArray, CBool, CInt, CReal
 from .qmod_variable import Input, Output, QArray, QBit, QNum, QStruct
 from .quantum_callable import QCallable, QCallableList
+from .synthesize_separately import synthesize_separately
 from .write_qmod import write_qmod
 
 __all__ = [
@@ -30,4 +31,5 @@ __all__ = [
     "get_expression_numeric_attributes",
     "qfunc",
     "write_qmod",
+    "synthesize_separately",
 ] + _builtins_all

classiq/qmod/builtins/classical_execution_primitives.py

@@ -1,4 +1,4 @@
-from typing import Dict, Final, List, Optional, Union
+from typing import Final, Optional, Union
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.execution_preferences import QaeWithQpeEstimationMethod
@@ -15,7 +15,7 @@ from classiq.interface.generator.functions.qmod_python_interface import QmodPySt
 from classiq.applications.qsvm.qsvm import Data, Labels
 from classiq.qmod.builtins.enums import Optimizer
 
-ExecutionParams = Dict[str, Union[float, int, List[int], List[float]]]
+ExecutionParams = dict[str, Union[float, int, list[int], list[float]]]
 
 _CALL_IN_QFUNC_ERROR = (
     'Cannot call "{}" in a quantum context. "{}" is a classical execution primitive.'
@@ -39,28 +39,28 @@ def sample(  # type: ignore[return]
 
 
 def batch_sample(  # type: ignore[return]
-    batch_execution_params: List[ExecutionParams],
+    batch_execution_params: list[ExecutionParams],
 ) -> MultipleExecutionDetails:
     _raise_error("batch_sample")
 
 
 def estimate(  # type: ignore[return]
-    hamiltonian: List[QmodPyStruct], execution_params: Optional[ExecutionParams] = None
+    hamiltonian: list[QmodPyStruct], execution_params: Optional[ExecutionParams] = None
 ) -> EstimationResult:
     _raise_error("estimate")
 
 
 def batch_estimate(  # type: ignore[return]
-    hamiltonian: List[QmodPyStruct],
-    batch_execution_params: List[ExecutionParams],
+    hamiltonian: list[QmodPyStruct],
+    batch_execution_params: list[ExecutionParams],
 ) -> EstimationResults:
     _raise_error("batch_estimate")
 
 
 def vqe(  # type: ignore[return]
-    hamiltonian: List[QmodPyStruct],
+    hamiltonian: list[QmodPyStruct],
     maximize: bool,
-    initial_point: List[float],
+    initial_point: list[float],
     optimizer: Optimizer,
     max_iteration: int,
     tolerance: float,
@@ -118,5 +118,5 @@ __all__ = [
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/qmod/builtins/functions/__init__.py

@@ -1,3 +1,6 @@
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+
+from ...quantum_function import GenerativeQFunc
 from .amplitude_estimation import *
 from .arithmetic import *
 from .benchmarking import *
@@ -14,7 +17,7 @@ from .modular_exponentiation import *
 from .modular_exponentiation import _check_msb, _ctrl_x
 from .operators import *
 from .qaoa_penalty import *
-from .qft import *
+from .qft_functions import *
 from .qpe import *
 from .qsvm import *
 from .qsvt import *
@@ -22,6 +25,8 @@ from .standard_gates import *
 from .state_preparation import *
 from .state_preparation import _prepare_uniform_trimmed_state_step
 from .swap_test import *
+from .utility_functions import *
+from .variational import *
 
 CORE_LIB_DECLS = [
     func.func_decl
@@ -85,60 +90,75 @@ CORE_LIB_DECLS = [
     )
 ]
 
+OPEN_LIBRARY_UNPROCESSED_FUNCTIONS = [
+    qpe_flexible,
+    qpe,
+    _single_pauli,
+    linear_pauli_rotations,
+    amplitude_estimation,
+    phase_oracle,
+    reflect_about_zero,
+    grover_diffuser,
+    grover_operator,
+    grover_search,
+    hadamard_transform,
+    apply_to_all,
+    qft_no_swap,
+    qft_space_add_const,
+    cc_modular_add,
+    c_modular_multiply,
+    multiswap,
+    inplace_c_modular_multiply,
+    modular_exp,
+    qsvt_step,
+    qsvt,
+    projector_controlled_phase,
+    qsvt_inversion,
+    allocate_num,
+    qaoa_mixer_layer,
+    qaoa_cost_layer,
+    qaoa_layer,
+    qaoa_init,
+    qaoa_penalty,
+    full_hea,
+    swap_test,
+    prepare_uniform_trimmed_state,
+    prepare_uniform_interval_state,
+    prepare_ghz_state,
+    prepare_exponential_state,
+    prepare_bell_state,
+    inplace_prepare_int,
+    prepare_int,
+    switch,
+    qct_qst_type1,
+    qct_qst_type2,
+    qct_type2,
+    qst_type2,
+    modular_increment,
+    qft,
+    _ctrl_x,
+    _prepare_uniform_trimmed_state_step,
+    _qct_d_operator,
+    _qct_pi_operator,
+    _check_msb,
+    encode_in_angle,
+    encode_on_bloch,
+]
+
+OPEN_LIBRARY_FUNCTIONS: list[NativeFunctionDefinition] = []
+
+
+def load_open_library_implementations() -> None:
+    OPEN_LIBRARY_FUNCTIONS.extend(
+        [func.get_implementation() for func in OPEN_LIBRARY_UNPROCESSED_FUNCTIONS]
+    )
+
+
+OPEN_LIBRARY_GENERATIVE_FUNCTIONS: list[GenerativeQFunc] = []
+
 OPEN_LIB_DECLS = [
     func.func_decl
-    for func in (
-        qpe_flexible,
-        qpe,
-        _single_pauli,
-        linear_pauli_rotations,
-        amplitude_estimation,
-        phase_oracle,
-        reflect_about_zero,
-        grover_diffuser,
-        grover_operator,
-        grover_search,
-        hadamard_transform,
-        apply_to_all,
-        qft_no_swap,
-        qft_space_add_const,
-        cc_modular_add,
-        c_modular_multiply,
-        multiswap,
-        inplace_c_modular_multiply,
-        modular_exp,
-        qsvt_step,
-        qsvt,
-        projector_controlled_phase,
-        qsvt_inversion,
-        allocate_num,
-        qaoa_mixer_layer,
-        qaoa_cost_layer,
-        qaoa_layer,
-        qaoa_init,
-        qaoa_penalty,
-        full_hea,
-        swap_test,
-        prepare_uniform_trimmed_state,
-        prepare_uniform_interval_state,
-        prepare_ghz_state,
-        prepare_exponential_state,
-        prepare_bell_state,
-        inplace_prepare_int,
-        prepare_int,
-        switch,
-        qct_qst_type1,
-        qct_qst_type2,
-        qct_type2,
-        qst_type2,
-        modular_increment,
-        qft,
-        _ctrl_x,
-        _prepare_uniform_trimmed_state_step,
-        _qct_d_operator,
-        _qct_pi_operator,
-        _check_msb,
-    )
+    for func in OPEN_LIBRARY_GENERATIVE_FUNCTIONS + OPEN_LIBRARY_UNPROCESSED_FUNCTIONS
 ]
 
 STD_QMOD_OPERATORS = [func.func_decl for func in (apply, permute)]
@@ -252,4 +272,6 @@ __all__ = [
     "qst_type2",
     "modular_increment",
     "qft",
+    "encode_in_angle",
+    "encode_on_bloch",
 ]

classiq/qmod/builtins/functions/amplitude_estimation.py

@@ -1,3 +1,5 @@
+from classiq.qmod.builtins.functions.grover import grover_operator
+from classiq.qmod.builtins.functions.qpe import qpe
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import QArray, QBit, QNum
 from classiq.qmod.quantum_callable import QCallable
@@ -24,4 +26,5 @@ def amplitude_estimation(
         phase: Assuming this variable starts from the zero state -this variable output holds the $phase=\\theta$ result in the [0,1] domain, which relates to the estimated probability $a$ through $a=\\sin^2(\\pi \\theta)$.
         packed_vars: The variable that holds the state to be estimated. Assumed to be in the zero state at the beginning of the algorithm.
     """
-    pass
+    space_transform(packed_vars)
+    qpe(lambda: grover_operator(oracle, space_transform, packed_vars), phase)

classiq/qmod/builtins/functions/arithmetic.py

@@ -1,9 +1,13 @@
 from typing import Literal
 
+from classiq.qmod.builtins.functions.qft_functions import qft
+from classiq.qmod.builtins.functions.standard_gates import PHASE
+from classiq.qmod.builtins.operations import bind, repeat, within_apply
 from classiq.qmod.cparam import CInt
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CReal
 from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
+from classiq.qmod.symbolic import pi
 
 
 @qfunc(external=True)
@@ -75,4 +79,13 @@ def modular_increment(a: CInt, x: QNum) -> None:
         x: A quantum number that is assumed to be non-negative integer.
 
     """
-    pass
+    array_cast: QArray = QArray("array_cast")
+    within_apply(
+        lambda: (  # type:ignore[arg-type]
+            bind(x, array_cast),  # type:ignore[func-returns-value]
+            qft(array_cast),
+        ),
+        lambda: repeat(
+            x.size, lambda i: PHASE(a * 2 * pi * 2**i / (2**x.size), array_cast[i])
+        ),
+    )

classiq/qmod/builtins/functions/discrete_sine_cosine_transform.py

@@ -1,15 +1,85 @@
+from classiq.qmod.builtins.functions.arithmetic import modular_increment
+from classiq.qmod.builtins.functions.qft_functions import qft
+from classiq.qmod.builtins.functions.standard_gates import PHASE, H, S, X, Z
+from classiq.qmod.builtins.functions.state_preparation import allocate
+from classiq.qmod.builtins.functions.utility_functions import apply_to_all
+from classiq.qmod.builtins.operations import bind, control, invert, repeat, within_apply
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import QArray, QBit, QNum
+from classiq.qmod.symbolic import pi
+
+
+def _b_operator(q: QBit) -> None:
+    S(q)
+    H(q)
 
 
 @qfunc(external=True)
 def _qct_d_operator(x: QNum, q: QBit) -> None:
-    pass
+    _b_operator(q)
+    control(x == 0, lambda: invert(lambda: _b_operator(q)))
 
 
 @qfunc(external=True)
 def _qct_pi_operator(x: QArray[QBit], q: QBit) -> None:
-    pass
+    control(q == 1, lambda: apply_to_all(X, x))
+    control(q == 1, lambda: modular_increment(1, x))
+
+
+def _t_operator(x: QArray) -> None:
+    _qct_d_operator(x[0 : x.len - 1], x[x.len - 1])
+    _qct_pi_operator(x[0 : x.len - 1], x[x.len - 1])
+
+
+def _vn_operator(x: QArray[QBit], q: QBit) -> None:
+    H(q)
+    control(q == 1, lambda: apply_to_all(X, x))
+
+
+def _d1_operator(x: QArray[QBit], q: QBit) -> None:
+    omega_exp = 2 * pi / (4 * 2**x.len)
+
+    # Li
+    control(q == 0, lambda: repeat(x.len, lambda k: PHASE(omega_exp * (2**k), x[k])))
+    # Ki
+    control(
+        q == 1,
+        lambda: repeat(
+            x.len,
+            lambda k: within_apply(
+                lambda: X(x[k]), lambda: PHASE(-omega_exp * (2**k), x[k])
+            ),
+        ),
+    )
+    PHASE(-omega_exp, q)
+
+
+def _pi2_operator(x: QArray[QBit], q: QBit) -> None:
+    control(q == 1, lambda: modular_increment(1, x))
+
+
+def _j_operator(q: QBit) -> None:
+    within_apply(lambda: Z(q), lambda: (S(q), H(q), S(q)))  # type:ignore[arg-type]
+
+
+def _b_t_operator(q: QBit) -> None:
+    H(q)
+    S(q)
+
+
+def _d0dt_operator(x: QArray, q: QBit) -> None:
+    x_num: QNum = QNum("x_num", x.len, False, 0)
+    bind(x, x_num)
+    _b_t_operator(q)
+    control(x_num == 0, lambda: _j_operator(q))
+    bind(x_num, x)
+
+
+def _un_dag_operator(x: QArray[QBit], q: QBit) -> None:
+    _d1_operator(x, q)
+    invert(lambda: _qct_pi_operator(x, q))
+    _d0dt_operator(x, q)
+    invert(lambda: _pi2_operator(x, q))
 
 
 @qfunc(external=True)
@@ -39,7 +109,7 @@ def qct_qst_type1(x: QArray[QBit]) -> None:
     Links:
         - [Quantum Sine and Cosine Transforms](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/open-library-functions/qct_qst/qct_qst/)
     """
-    pass
+    within_apply(lambda: _t_operator(x), lambda: qft(x))
 
 
 @qfunc(external=True)
@@ -68,7 +138,12 @@ def qct_qst_type2(x: QArray[QBit], q: QBit) -> None:
     Links:
         - [Quantum Sine and Cosine Transforms](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/open-library-functions/qct_qst/qct_qst/)
     """
-    pass
+    extended_state: QArray = QArray("extended_state")
+    _vn_operator(x, q)
+    bind([x, q], extended_state)
+    qft(extended_state)
+    bind(extended_state, [x, q])
+    _un_dag_operator(x, q)
 
 
 @qfunc(external=True)
@@ -85,7 +160,8 @@ def qct_type2(x: QArray[QBit]) -> None:
     Links:
         - [Quantum Sine and Cosine Transforms](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/open-library-functions/qct_qst/qct_qst/)
     """
-    pass
+    q = QBit("q")
+    within_apply(lambda: allocate(1, q), lambda: qct_qst_type2(x, q))
 
 
 @qfunc(external=True)
@@ -102,4 +178,8 @@ def qst_type2(x: QArray[QBit]) -> None:
     Links:
         - [Quantum Sine and Cosine Transforms](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/open-library-functions/qct_qst/qct_qst/)
     """
-    pass
+    q = QBit("q")
+    within_apply(
+        lambda: (allocate(1, q), X(q)),  # type:ignore[arg-type]
+        lambda: qct_qst_type2(x, q),
+    )