classiq 0.46.0__py3-none-any.whl → 0.47.0__py3-none-any.whl

classiq/interface/generator/arith/register_user_input.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Tuple
 
 import pydantic
 
@@ -14,6 +14,7 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
     size: pydantic.PositiveInt
     is_signed: bool = pydantic.Field(default=False)
     fraction_places: pydantic.NonNegativeInt = pydantic.Field(default=0)
+    bypass_bounds_validation: bool = pydantic.Field(default=False)
     bounds: PydanticFloatTuple = pydantic.Field(default=None)
 
     @pydantic.root_validator(pre=True)
@@ -22,32 +23,39 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
             values.pop("name")
         return values
 
+    @staticmethod
+    def get_maximal_bounds(
+        *, size: int, is_signed: bool, fraction_places: int
+    ) -> Tuple[float, float]:
+        lb = 0 if not is_signed else -(2 ** (size - 1))
+        ub = 2**size - 1 if not is_signed else 2 ** (size - 1) - 1
+        fraction_factor = float(2**-fraction_places)
+        return (lb * fraction_factor, ub * fraction_factor)
+
     @pydantic.validator("bounds", always=True)
     def _validate_bounds(
         cls, bounds: Optional[PydanticFloatTuple], values: Dict[str, Any]
     ) -> PydanticFloatTuple:
-        if bounds is not None:
-            if min(bounds) < 0:
-                assert values.get("is_signed")
-            fraction_places = values.get("fraction_places")
-            if not isinstance(fraction_places, int):
-                raise ClassiqValueError(
-                    "RegisterUserInput must have an integer fraction_places"
-                )
-            return number_utils.limit_fraction_places(
-                min(bounds), machine_precision=fraction_places
-            ), number_utils.limit_fraction_places(
-                max(bounds), machine_precision=fraction_places
-            )
-
         size = values.get("size")
+        is_signed = values.get("is_signed", False)
+        fraction_places = values.get("fraction_places", 0)
         if not isinstance(size, int):
-            raise ClassiqValueError("RegisterUserInput must have an integer size")
-        is_signed: bool = values.get("is_signed", False)
-        lb = 0 if not is_signed else -(2 ** (size - 1))
-        ub = 2**size - 1 if not is_signed else 2 ** (size - 1) - 1
-        fraction_factor = float(2 ** -values.get("fraction_places", 0))
-        return (lb * fraction_factor, ub * fraction_factor)
+            raise ClassiqValueError("RegisterArithmeticInfo must have an integer size")
+
+        maximal_bounds = cls.get_maximal_bounds(
+            size=size, is_signed=is_signed, fraction_places=fraction_places
+        )
+        if bounds is None:
+            return maximal_bounds
+
+        trimmed_bounds = (
+            number_utils.limit_fraction_places(min(bounds), fraction_places),
+            number_utils.limit_fraction_places(max(bounds), fraction_places),
+        )
+        if not values.get("bypass_bounds_validation", False):
+            assert min(trimmed_bounds) >= min(maximal_bounds), "Illegal bound min"
+            assert max(trimmed_bounds) <= max(maximal_bounds), "Illegal bound max"
+        return trimmed_bounds
 
     def limit_fraction_places(self, machine_precision: int) -> "RegisterArithmeticInfo":
         truncated_bits: int = max(self.fraction_places - machine_precision, 0)
@@ -56,6 +64,7 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
             is_signed=self.is_signed,
             fraction_places=self.fraction_places - truncated_bits,
             bounds=self.bounds,
+            bypass_bounds_validation=self.bypass_bounds_validation,
         )
 
     @property

classiq/interface/generator/arith/unary_ops.py

@@ -5,6 +5,7 @@ import pydantic
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith import argument_utils, number_utils
 from classiq.interface.generator.arith.arithmetic_operations import (
+    MODULO_WITH_FRACTION_PLACES_ERROR_MSG,
     ArithmeticOperationParams,
 )
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
@@ -74,6 +75,9 @@ class BitwiseInvert(UnaryOpParams):
 
 
 class Negation(UnaryOpParams):
+    bypass_bounds_validation: bool = pydantic.Field(
+        default=False
+    )  # True for efficient subtraction
     output_name = "negated"
 
     @staticmethod
@@ -88,11 +92,19 @@ class Negation(UnaryOpParams):
         eff_arg = self.arg.limit_fraction_places(self.machine_precision)
         is_signed = max(eff_arg.bounds) > 0 and self._include_sign
         bounds = (-max(eff_arg.bounds), -min(eff_arg.bounds))
+        if self.output_size and not self.bypass_bounds_validation:
+            if eff_arg.fraction_places:
+                raise ValueError(MODULO_WITH_FRACTION_PLACES_ERROR_MSG)
+            max_bounds = RegisterArithmeticInfo.get_maximal_bounds(
+                size=self.output_size, is_signed=False, fraction_places=0
+            )
+            bounds = number_utils.bounds_cut(bounds, max_bounds)
         return RegisterArithmeticInfo(
             size=self.output_size or self._expected_result_size(eff_arg),
             fraction_places=eff_arg.fraction_places,
             is_signed=is_signed,
-            bounds=bounds if (is_signed or min(bounds) >= 0) else None,
+            bypass_bounds_validation=self.bypass_bounds_validation,
+            bounds=bounds,
         )
 
     def zero_input_for_extension(self) -> pydantic.NonNegativeInt:

classiq/interface/generator/generated_circuit_data.py

@@ -1,4 +1,5 @@
-from typing import Dict, List, Literal, Optional, Tuple, Union
+import logging
+from typing import Any, Dict, List, Literal, Optional, Tuple, Union
 
 import pydantic
 from typing_extensions import TypeAlias
@@ -10,10 +11,10 @@ from classiq.interface.generator.synthesis_metadata.synthesis_execution_data imp
 )
 from classiq.interface.ide.visual_model import OperationParameter
 
+_logger = logging.getLogger(__name__)
 ParameterName = str
 IOQubitMapping: TypeAlias = Dict[str, Tuple[int, ...]]
 
-
 CLASSIQ_HIERARCHY_SEPARATOR: Literal["."] = "."
 
 VISUALIZATION_HIDE_LIST = [
@@ -102,6 +103,7 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
     absolute_qubits: Optional[Tuple[int, ...]]
     is_basis_gate: Optional[bool]
     parameters: List[OperationParameter] = list()
+    port_to_passed_variable_map: Dict[str, str] = pydantic.Field(default_factory=dict)
 
     @property
     def registers(self) -> List[GeneratedRegister]:
@@ -120,3 +122,46 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         if self.generated_function is None:
             return list()
         return self.generated_function.control_states
+
+    @staticmethod
+    def create_parameters_from_dict(
+        parameters: Dict[str, str]
+    ) -> List[OperationParameter]:
+        return [
+            OperationParameter(label=key, value=value)
+            for key, value in parameters.items()
+        ]
+
+    def update(self, **kwargs: Any) -> None:
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+    def propagate_absolute_qubits(self) -> None:
+        if self.absolute_qubits is None:
+            return
+
+        for register in self.registers:
+            register.qubit_indexes_absolute = list(
+                _get_absolute_from_relative(
+                    self.absolute_qubits, tuple(register.qubit_indexes_relative)
+                )
+            )
+
+        for child in self.children:
+            child.absolute_qubits = _get_absolute_from_relative(
+                self.absolute_qubits, child.relative_qubits
+            )
+            child.propagate_absolute_qubits()
+
+
+def _get_absolute_from_relative(
+    absolute_qubits: Tuple[int, ...], relative_qubits: Tuple[int, ...]
+) -> Tuple[int, ...]:
+    if max(relative_qubits) >= len(absolute_qubits):
+        _logger.warning(
+            "Invalid qubit computation (relative qubits: %s, absolute qubits: %s)",
+            relative_qubits,
+            absolute_qubits,
+        )
+        return tuple()
+    return tuple(absolute_qubits[relative_qubit] for relative_qubit in relative_qubits)

classiq/interface/generator/quantum_program.py

@@ -1,5 +1,5 @@
 import uuid
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple, Union
 
@@ -10,6 +10,7 @@ from classiq.interface.exceptions import (
     ClassiqMissingOutputFormatError,
     ClassiqStateInitializationError,
 )
+from classiq.interface.execution.primitives import PrimitivesInput
 from classiq.interface.executor import quantum_code
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.executor.register_initialization import RegisterInitialization
@@ -50,16 +51,23 @@ def get_uuid_as_str() -> str:
     return str(uuid.uuid4())
 
 
+def _get_formatted_utc_current_time() -> str:
+    # The purpose of this method is to replicate the behavior of
+    # datetime.utcnow().isoformat(), since `utcnow` is now deprecated
+    return datetime.now(timezone.utc).isoformat().split("+")[0]
+
+
 class QuantumProgram(VersionedModel, CircuitCodeInterface):
     hardware_data: SynthesisHardwareData
     initial_values: Optional[InitialConditions]
     data: GeneratedCircuitData
     model: ExecutionModel
     transpiled_circuit: Optional[TranspiledCircuitData]
-    creation_time: str = pydantic.Field(default_factory=datetime.utcnow().isoformat)
+    creation_time: str = pydantic.Field(default_factory=_get_formatted_utc_current_time)
     synthesis_duration: Optional[SynthesisStepDurations]
     debug_info: Optional[List[FunctionDebugInfoInterface]]
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
+    execution_primitives_input: Optional[PrimitivesInput] = pydantic.Field(default=None)
 
     def _hardware_agnostic_program_code(self) -> CodeAndSyntax:
         circuit_code = self.program_circuit.get_code_by_priority()

classiq/interface/ide/visual_model.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 import pydantic
 
@@ -38,6 +38,7 @@ class OperationParameter(pydantic.BaseModel):
 
 class OperationLink(pydantic.BaseModel):
     label: str
+    inner_label: Optional[str] = None
     qubits: Tuple[int, ...]
     type: str
 
@@ -47,6 +48,11 @@ class OperationLink(pydantic.BaseModel):
     def __hash__(self) -> int:
         return hash((type(self), self.label, self.qubits, self.type))
 
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, OperationLink):
+            return False
+        return hash(self) == hash(other)
+
 
 class OperationLinks(pydantic.BaseModel):
     inputs: List[OperationLink]

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "2"
+INTERFACE_VERSION = "3"

classiq/interface/model/phase_operation.py

@@ -0,0 +1,11 @@
+from typing import Literal
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
+)
+
+
+class PhaseOperation(QuantumExpressionOperation):
+    kind: Literal["PhaseOperation"]
+    theta: Expression

classiq/interface/model/statement_block.py

@@ -9,6 +9,7 @@ from classiq.interface.model.control import Control
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
 from classiq.interface.model.invert import Invert
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.power import Power
 from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
     AmplitudeLoadingOperation,
@@ -38,6 +39,7 @@ ConcreteQuantumStatement = Annotated[
         ClassicalIf,
         Control,
         WithinApply,
+        PhaseOperation,
     ],
     Field(..., discriminator="kind"),
 ]
@@ -52,3 +54,4 @@ Invert.update_forward_refs(StatementBlock=StatementBlock)
 WithinApply.update_forward_refs(StatementBlock=StatementBlock)
 ClassicalIf.update_forward_refs(StatementBlock=StatementBlock)
 NativeFunctionDefinition.update_forward_refs(StatementBlock=StatementBlock)
+PhaseOperation.update_forward_refs(StatementBlock=StatementBlock)

classiq/interface/server/routes.py

@@ -17,9 +17,6 @@ ANALYZER_HC_TABLE_GRAPH_FULL_PATH = ANALYZER_PREFIX + ANALYZER_HC_TABLE_GRAPH
 
 ANALYZER_HC_GRAPH_NEW = "/graphs/hardware_connectivity/new"
 
-ANALYZER_OPTIONAL_DEVICES = "/graphs/available_devices"
-ANALYZER_OPTIONAL_DEVICES_FULL_PATH = ANALYZER_PREFIX + ANALYZER_OPTIONAL_DEVICES
-
 TASKS_SUFFIX = "/tasks"
 RB = "/rb"
 ANALYZER_DATA_TASK = f"{TASKS_SUFFIX}/data"

classiq/model_expansions/interpreter.py

@@ -24,6 +24,7 @@ from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperat
 from classiq.interface.model.invert import Invert
 from classiq.interface.model.model import Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.power import Power
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumAssignmentOperation,
@@ -74,6 +75,7 @@ from classiq.model_expansions.quantum_operations import (
     VariableDeclarationStatementEmitter,
     WithinApplyEmitter,
 )
+from classiq.model_expansions.quantum_operations.phase import PhaseEmitter
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.model_expansions.scope_initialization import (
     add_entry_point_params_to_scope,
@@ -307,6 +309,10 @@ class Interpreter:
     def emit_power(self, power: Power) -> None:
         PowerEmitter(self).emit(power)
 
+    @emit.register
+    def emit_phase(self, phase: PhaseOperation) -> None:
+        PhaseEmitter(self).emit(phase)
+
     def _expand_block(self, block: Sequence[QuantumStatement], block_name: str) -> None:
         with self._builder.block_context(block_name):
             for statement in block:

classiq/model_expansions/quantum_operations/emitter.py

@@ -131,16 +131,22 @@ class Emitter(Generic[QuantumStatementT]):
             or new_call.func_name == free.func_decl.name
         )
         parameters = {
-            arg_decl.name: FunctionDebugInfo.param_controller(value=valuated_arg.value)
-            for arg_decl, valuated_arg in zip(new_positional_arg_decls, evaluated_args)
+            arg_decl.name: FunctionDebugInfo.param_controller(value=evaluated_arg.value)
+            for arg_decl, evaluated_arg in zip(new_positional_arg_decls, evaluated_args)
             if isinstance(arg_decl, ClassicalParameterDeclaration)
         }
 
+        port_to_passed_variable_map = {
+            arg_decl.name: evaluated_arg.value.handle.name
+            for arg_decl, evaluated_arg in zip(new_positional_arg_decls, evaluated_args)
+            if isinstance(arg_decl, PortDeclaration)
+        }
         self._interpreter._model.debug_info[new_call.uuid] = FunctionDebugInfo(
             name=new_call.func_name,
             level=OperationLevel.QMOD_FUNCTION_CALL,
             parameters=parameters,
             is_allocate_or_free=is_allocate_or_free,
+            port_to_passed_variable_map=port_to_passed_variable_map,
         )
         if is_atomic:
             new_call.set_func_decl(new_declaration)

classiq/model_expansions/quantum_operations/phase.py

@@ -0,0 +1,177 @@
+from typing import TYPE_CHECKING, Dict, List, Tuple
+
+import sympy
+from sympy import sympify
+
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.handle_binding import HANDLE_ID_SEPARATOR, HandleBinding
+from classiq.interface.model.phase_operation import PhaseOperation
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_type import (
+    QuantumBitvector,
+    QuantumNumeric,
+    QuantumScalar,
+)
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+from classiq.interface.model.within_apply_operation import WithinApply
+
+from classiq.applications.combinatorial_helpers.transformations.ising_converter import (
+    _find_sub_list_items,
+    _get_coeff_from_expr,
+    _get_vars,
+    _refine_ising_expr,
+    _to_ising_symbolic_objective_function,
+)
+from classiq.model_expansions.quantum_operations.expression_operation import (
+    ExpressionOperationEmitter,
+)
+from classiq.qmod.builtins.functions.exponentiation import suzuki_trotter
+from classiq.qmod.semantics.error_manager import ErrorManager
+
+
+class PhaseEmitter(ExpressionOperationEmitter[PhaseOperation]):
+    def emit(self, phase_op: PhaseOperation, /) -> None:
+        phase_expression = self._evaluate_op_expression(phase_op)
+        phase_op = phase_op.copy(update=dict(expression=phase_expression))
+        arrays_with_subscript = self._get_symbols_to_split(phase_op.expression)
+        if len(arrays_with_subscript) > 0:
+            self._emit_with_split(phase_op, phase_op.expression, arrays_with_subscript)
+            return
+
+        phase_op = self._evaluate_types_in_expression(phase_op, phase_op.expression)
+        if len(phase_op.var_handles) == 0:
+            ErrorManager().add_error(
+                "Cannot perform phase operation on an expression with no quantum variables."
+            )
+            return
+
+        aux_name = self._counted_name_allocator.allocate("phase_aux")
+        if len(phase_op.var_handles) > 1:
+            split_join = True
+            evolution_variable = HandleBinding(name=aux_name)
+        else:
+            split_join = False
+            evolution_variable = phase_op.var_handles[0]
+        expression = self._evaluate_op_expression(phase_op)
+        expression_evolution_function = QuantumFunctionCall(
+            function=suzuki_trotter.func_decl.name,
+            positional_args=[
+                _convert_cost_expression_to_hamiltonian(
+                    expression.expr,
+                    {
+                        var.name: self._current_scope[var.name].value.quantum_type
+                        for var in phase_op.var_handles
+                    },
+                ),
+                phase_op.theta,
+                Expression(expr="1"),
+                Expression(expr="1"),
+                evolution_variable,
+            ],
+            source_ref=phase_op.source_ref,
+        )
+        expression_evolution_function.set_func_decl(suzuki_trotter.func_decl)
+
+        if split_join:
+            self._interpreter.emit_statement(
+                VariableDeclarationStatement(
+                    name=aux_name, quantum_type=QuantumBitvector()
+                )
+            )
+            self._interpreter.emit_statement(
+                WithinApply(
+                    compute=[
+                        BindOperation(
+                            in_handles=phase_op.var_handles,
+                            out_handles=[HandleBinding(name=aux_name)],
+                        )
+                    ],
+                    action=[expression_evolution_function],
+                    source_ref=phase_op.source_ref,
+                )
+            )
+        else:
+            self._interpreter.emit_statement(
+                expression_evolution_function,
+            )
+
+
+def _get_single_bit_vars_expression(
+    expr: sympy.Expr, vars_info: Dict[str, QuantumScalar]
+) -> Tuple[sympy.Expr, List[sympy.Symbol]]:
+    bit_vars = []
+    for var_name, var_info in vars_info.items():
+        size = var_info.size_in_bits
+        var = sympy.Symbol(var_name)
+        if size == 1:
+            bits = [var]
+            is_signed = False
+            fraction_places = 0
+        else:
+            if TYPE_CHECKING:
+                assert isinstance(var_info, QuantumNumeric)
+            bits = [
+                sympy.Symbol(f"{var_name}{HANDLE_ID_SEPARATOR}{i}__split__")
+                for i in range(size)
+            ]
+            is_signed = var_info.sign_value
+            fraction_places = var_info.fraction_digits_value
+        bit_vars.extend(bits)
+        split_var = 0
+        for i, bit in enumerate(bits):
+            if is_signed and i == size - 1:  # sign bit (MSB)
+                split_var -= bit * 2 ** (size - 1 - fraction_places)
+            else:
+                split_var += bit * 2 ** (i - fraction_places)
+        expr = expr.subs(var, split_var)
+    return expr, bit_vars
+
+
+def _convert_ising_sympy_to_pauli_terms(
+    ising_expr: sympy.Expr, ordered_sympy_vars: List[sympy.Symbol]
+) -> str:
+    pauli_terms: List[str] = []
+    for expr_term in ising_expr.args:
+        expr_vars = _get_vars(expr_term)
+        z_vec = _find_sub_list_items(ordered_sympy_vars, expr_vars)
+        pauli_elements = ["I"] * len(z_vec)
+        for index, is_z_op in enumerate(z_vec):
+            if is_z_op:
+                pauli_elements[len(z_vec) - index - 1] = (
+                    "Z"  # reminder: Pauli reverses the order!
+                )
+        coeff = _get_coeff_from_expr(expr_term)
+        paulis = [f"Pauli.{pauli}" for pauli in pauli_elements]
+        pauli_terms.append(
+            # fmt: off
+                    "struct_literal("
+                    "PauliTerm,"
+                    f"pauli=[{', '.join(paulis)}],"
+                    f"coefficient={Expression(expr=str(coeff))},"
+                    ")"
+            # fmt: on,
+        )
+    return f"[{', '.join(pauli_terms)}]"
+
+
+def _convert_cost_expression_to_hamiltonian(
+    expr: str,
+    vars: Dict[str, QuantumScalar],
+) -> Expression:
+    sympy_expr = sympify(expr)
+    single_bit_vars_expression, single_bit_vars = _get_single_bit_vars_expression(
+        sympy_expr, vars
+    )
+    if not single_bit_vars_expression.is_polynomial():
+        raise ClassiqExpansionError(f"phased expression {expr!r} is not polynomial")
+
+    ising_expr = _to_ising_symbolic_objective_function(single_bit_vars_expression)
+    ising_expr = _refine_ising_expr(ising_expr)
+
+    return Expression(
+        expr=_convert_ising_sympy_to_pauli_terms(ising_expr, single_bit_vars)
+    )

classiq/qmod/builtins/functions/amplitude_estimation.py

@@ -12,7 +12,8 @@ def amplitude_estimation(
 ) -> None:
     """
     [Qmod Classiq-library function]
-    Amplitude estimation function is used to estimate the probability of a state being marked by the operand `oracle` as a "good state."
+
+    Estimate the probability of a state being marked by the operand `oracle` as a "good state."
 
     The algorithm prepares the state in the `packed_vars` register and estimates the probability of this state being marked by the oracle as a "good state."
     This is done using the Quantum Phase Estimation (QPE) algorithm, where the unitary for QPE is the Grover operator, which is composed of the `oracle` and `space_transform` operators.

classiq/qmod/builtins/functions/arithmetic.py

@@ -14,7 +14,7 @@ def unitary(
     """
     [Qmod core-library function]
 
-    Apply a unitary matrix on a quantum state.
+    Applies a unitary matrix on a quantum state.
 
     Args:
         elements:  A 2d array of complex numbers representing the unitary matrix. This matrix must be unitary.
@@ -51,7 +51,7 @@ def integer_xor(left: QArray[QBit], right: QArray[QBit]) -> None:
 @qfunc(external=True)
 def modular_increment(a: CInt, x: QNum) -> None:
     """
-    Qmod Classiq-library function.
+    [Qmod Classiq-library function]
 
     Adds $a$ to $x$ modulo the range of $x$, assumed that $x$ is a non-negative integer and $a$ is an integer.
     Mathematically it is described as:

classiq/qmod/builtins/functions/discrete_sine_cosine_transform.py

@@ -14,22 +14,22 @@ def _qct_pi_operator(x: QArray[QBit], q: QBit) -> None:
 
 @qfunc(external=True)
 def qct_qst_type1(x: QArray[QBit]) -> None:
-    r"""
-    Qmod Classiq-library function.
+    """
+    [Qmod Classiq-library function]
 
     Applies the quantum discrete cosine (DCT) and sine (DST)
     transform of type 1 to the qubit array `x`.
-    Corresponds to the matrix (with $n\equiv$`x.len`):
+    Corresponds to the matrix (with $n\\equiv$`x.len`):
 
     $$
-    \left(
+    \\left(
     \begin{array}{ccc|c}
     {} &{} &{} \\
       {}&{\rm DCT}^{(1)}(2^{n-1}+1) & {}& 0\\
       {} &{} &{} \\
-      \hline
+      \\hline
       {} & 0 & {} & i{\rm DST}^{(1)}(2^{n-1}-1)
-    \end{array}
+    \\end{array}
     \right)
     $$
 
@@ -44,20 +44,20 @@ def qct_qst_type1(x: QArray[QBit]) -> None:
 
 @qfunc(external=True)
 def qct_qst_type2(x: QArray[QBit], q: QBit) -> None:
-    r"""
-    Qmod Classiq-library function.
+    """
+    [Qmod Classiq-library function]
 
     Applies the quantum discrete cosine (DCT) and sine (DST)
     transform of type 2 to the qubit array `x` concatenated with `q`, with `q` being the MSB.
-    Corresponds to the matrix (with $n\equiv$`x.len`+1):
+    Corresponds to the matrix (with $n\\equiv$`x.len`+1):
 
     $$
-    \left(
+    \\left(
     \begin{array}{c|c}
       {\rm DCT}^{(2)}(2^{n-1}) & 0\\
-      \hline
+      \\hline
       0 & -{\rm DST}^{(2)}(2^{n-1})
-    \end{array}
+    \\end{array}
     \right)
     $$
 
@@ -73,8 +73,8 @@ def qct_qst_type2(x: QArray[QBit], q: QBit) -> None:
 
 @qfunc(external=True)
 def qct_type2(x: QArray[QBit]) -> None:
-    r"""
-    Qmod Classiq-library function.
+    """
+    [Qmod Classiq-library function]
 
     Applies the quantum discrete cosine (DCT)
     transform of type 2, ${\rm DCT}^{(2)}$, to the qubit array `x`.
@@ -90,8 +90,8 @@ def qct_type2(x: QArray[QBit]) -> None:
 
 @qfunc(external=True)
 def qst_type2(x: QArray[QBit]) -> None:
-    r"""
-    Qmod Classiq-library function.
+    """
+    [Qmod Classiq-library function]
 
     Applies the quantum discrete sine (DST)
     transform of type 2, ${\rm DST}^{(2)}$, to the qubit array `x`.