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

classiq/model_expansions/quantum_operations/expression_operation.py

@@ -1,7 +1,7 @@
 import ast
 from abc import abstractmethod
 from itertools import chain
-from typing import TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING, TypeVar, Union
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -12,7 +12,9 @@ from classiq.interface.generator.expressions.evaluated_expression import (
 )
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.generator.visitor import NodeType, Transformer
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.control import Control
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     HandleBinding,
@@ -20,6 +22,7 @@ from classiq.interface.model.handle_binding import (
     SubscriptHandleBinding,
 )
 from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumAssignmentOperation,
     QuantumExpressionOperation,
 )
 from classiq.interface.model.quantum_type import (
@@ -38,6 +41,7 @@ from classiq.model_expansions.scope import QuantumSymbol
 from classiq.model_expansions.visitors.variable_references import VarRefCollector
 
 ExpressionOperationT = TypeVar("ExpressionOperationT", bound=QuantumExpressionOperation)
+AST_NODE = TypeVar("AST_NODE", bound=NodeType)
 
 
 class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
@@ -49,7 +53,7 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
         self,
         op: ExpressionOperationT,
         expression: Expression,
-        symbols_to_split: list[QuantumSymbol],
+        symbols_to_split: dict[QuantumSymbol, set[HandleBinding]],
     ) -> None:
         symbols_parts, bind_ops = self._get_bind_ops(symbols_to_split)
 
@@ -79,8 +83,8 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
             )
         )
 
-    @staticmethod
     def _get_updated_op_split_symbols(
+        self,
         op: ExpressionOperationT,
         symbol_mapping: dict[HandleBinding, tuple[str, QuantumType]],
     ) -> ExpressionOperationT:
@@ -109,11 +113,10 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
         )
         return new_expr
 
-    @staticmethod
-    def _check_all_handles_were_replaced(new_expr_str: str) -> None:
+    def _check_all_handles_were_replaced(self, new_expr_str: str) -> None:
         vrc = VarRefCollector(ignore_duplicated_handles=True)
         vrc.visit(ast.parse(new_expr_str))
-        for handle in vrc.var_handles:
+        for handle in self._get_handles(vrc):
             if isinstance(
                 handle,
                 (SubscriptHandleBinding, SlicedHandleBinding, FieldHandleBinding),
@@ -122,12 +125,12 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
 
     def _get_bind_ops(
         self,
-        symbols_to_split: list[QuantumSymbol],
+        symbols_to_split: dict[QuantumSymbol, set[HandleBinding]],
     ) -> tuple[list[list[tuple[QuantumSymbol, str]]], list[BindOperation]]:
         bind_ops = []
         symbols_parts = []
-        for symbol in symbols_to_split:
-            symbol_parts = self._get_symbol_parts(symbol)
+        for symbol, target_parts in symbols_to_split.items():
+            symbol_parts = self._get_symbol_parts(symbol, target_parts)
             symbols_parts.append(symbol_parts)
             bind_ops.append(
                 BindOperation(
@@ -141,11 +144,14 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
         return symbols_parts, bind_ops
 
     def _get_symbol_parts(
-        self, symbol: QuantumSymbol
+        self, symbol: QuantumSymbol, target_parts: set[HandleBinding]
     ) -> list[tuple[QuantumSymbol, str]]:
         quantum_type = symbol.quantum_type
 
-        if isinstance(quantum_type, (QuantumBit, QuantumNumeric)):
+        if all(
+            symbol.handle == target_part or symbol.handle not in target_part.prefixes()
+            for target_part in target_parts
+        ) or isinstance(quantum_type, (QuantumBit, QuantumNumeric)):
             return [
                 (
                     symbol,
@@ -161,7 +167,7 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
                 )
             return list(
                 chain.from_iterable(
-                    self._get_symbol_parts(symbol[idx])
+                    self._get_symbol_parts(symbol[idx], target_parts)
                     for idx in range(quantum_type.length_value)
                 )
             )
@@ -171,27 +177,33 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
 
         return list(
             chain.from_iterable(
-                self._get_symbol_parts(field_symbol)
+                self._get_symbol_parts(field_symbol, target_parts)
                 for field_symbol in symbol.fields.values()
             )
         )
 
-    def _get_symbols_to_split(self, expression: Expression) -> list[QuantumSymbol]:
+    def _get_symbols_to_split(
+        self, expression: Expression
+    ) -> dict[QuantumSymbol, set[HandleBinding]]:
         vrc = VarRefCollector(ignore_duplicated_handles=True)
         vrc.visit(ast.parse(expression.expr))
         symbol_names_to_split = dict.fromkeys(
             handle.name
-            for handle in vrc.var_handles
+            for handle in self._get_handles(vrc)
             if isinstance(handle, (SubscriptHandleBinding, FieldHandleBinding))
         )
-        return [
-            symbol
+        return {
+            symbol: {
+                handle.collapse()
+                for handle in vrc.var_handles
+                if handle.name == symbol.handle.name
+            }
             for symbol_name in symbol_names_to_split
             if isinstance(
                 symbol := self._current_scope[symbol_name].value,
                 QuantumSymbol,
             )
-        ]
+        }
 
     def _evaluate_op_expression(self, op: ExpressionOperationT) -> Expression:
         return self._evaluate_expression(op.expression)
@@ -214,3 +226,53 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
             self._machine_precision,
         )
         return op_with_evaluated_types
+
+    @staticmethod
+    def _all_vars_boolean(op: QuantumExpressionOperation) -> bool:
+        if not all(
+            var_type.has_size_in_bits and var_type.size_in_bits == 1
+            for var_type in op.var_types.values()
+        ):
+            return False
+        return not any(
+            isinstance(var_type, QuantumNumeric)
+            and (var_type.sign_value or var_type.fraction_digits_value > 0)
+            for var_type in op.var_types.values()
+        )
+
+    @staticmethod
+    def _is_res_boolean(op: Union[QuantumAssignmentOperation, Control]) -> bool:
+        if not (op.result_type.has_size_in_bits and op.result_type.size_in_bits == 1):
+            return False
+        return not (
+            isinstance(op.result_type, QuantumNumeric)
+            and (op.result_type.sign_value or op.result_type.fraction_digits_value > 0)
+        )
+
+    def _get_handles(self, collector: VarRefCollector) -> list[HandleBinding]:
+        return [
+            handle
+            for handle in collector.var_handles
+            if isinstance(self._interpreter.evaluate(handle.name).value, QuantumSymbol)
+        ]
+
+    def _rewrite(
+        self,
+        subject: AST_NODE,
+        symbol_mapping: dict[HandleBinding, tuple[str, QuantumType]],
+    ) -> AST_NODE:
+        class ReplaceSplitVars(Transformer):
+            @staticmethod
+            def visit_HandleBinding(handle: HandleBinding) -> HandleBinding:
+                handle = handle.collapse()
+                for handle_to_replace, replacement in symbol_mapping.items():
+                    handle = handle.replace_prefix(
+                        handle_to_replace, HandleBinding(name=replacement[0])
+                    )
+                return handle
+
+            @staticmethod
+            def visit_Expression(expr: Expression) -> Expression:
+                return self._update_op_expression(symbol_mapping, expr)
+
+        return ReplaceSplitVars().visit(subject)

classiq/model_expansions/quantum_operations/power.py

@@ -2,6 +2,7 @@ from typing import Union
 
 import sympy
 
+from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
@@ -72,4 +73,8 @@ class PowerEmitter(Emitter[Power]):
 
     def _get_power_value(self) -> Union[int, sympy.Basic]:
         power_value = self._interpreter.evaluate(self._power.power).value
+        if isinstance(power_value, int) and power_value < 0:
+            raise ClassiqExpansionError(
+                f"power exponent must be non-negative, got {power_value}"
+            )
         return power_value

classiq/model_expansions/quantum_operations/quantum_assignment_operation.py

@@ -29,6 +29,7 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
+from classiq.model_expansions.capturing.mangling_utils import demangle_handle
 from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
 from classiq.model_expansions.quantum_operations.expression_operation import (
     ExpressionOperationEmitter,
@@ -101,7 +102,7 @@ class QuantumAssignmentOperationEmitter(
         if (
             op.operation_kind != ArithmeticOperationKind.InplaceXor
             or op.result_type.size_in_bits > 1
-            or not _is_res_boolean(op)
+            or not self._is_res_boolean(op)
             or target.quantum_type.size_in_bits > 1
             or _is_constant(expression.expr)
         ):
@@ -141,7 +142,8 @@ class QuantumAssignmentOperationEmitter(
                 ArithmeticOperationKind.Assignment,
                 ArithmeticOperationKind.InplaceXor,
             )
-            or not _all_vars_boolean(op)
+            or not self._all_vars_boolean(op)
+            or not self._is_res_boolean(op)
         ):
             return op, expression, False
         optimizer = BooleanExpressionOptimizer()
@@ -227,50 +229,18 @@ class QuantumAssignmentOperationEmitter(
         self._interpreter.emit_statement(allocate_call)
         return True
 
-    @staticmethod
     def _get_updated_op_split_symbols(
+        self,
         op: QuantumAssignmentOperation,
         symbol_mapping: dict[HandleBinding, tuple[str, QuantumType]],
     ) -> QuantumAssignmentOperation:
-        if op.result_var not in symbol_mapping:
-            return op
-        handle_str, quantum_type = symbol_mapping[op.result_var]
-        if handle_str in op.expression.expr:
-            raise ClassiqExpansionError(
-                HANDLE_ERROR_MESSAGE.format(handle_str=str(op.result_var))
-            )
-        new_result_handle = HandleBinding(name=handle_str)
         return op.model_copy(
-            update=dict(result_var=new_result_handle, _result_type=quantum_type)
+            update=dict(result_var=self._rewrite(op.result_var, symbol_mapping))
         )
 
 
 def _validate_naive_inplace_handles(qe: ArithmeticOperation) -> None:
     if qe.result_var in qe.var_handles:
         raise ClassiqExpansionError(
-            HANDLE_ERROR_MESSAGE.format(handle_str=str(qe.result_var))
+            HANDLE_ERROR_MESSAGE.format(handle_str=str(demangle_handle(qe.result_var)))
         )
-
-
-def _all_vars_boolean(op: ArithmeticOperation) -> bool:
-    if not all(
-        var_type.has_size_in_bits and var_type.size_in_bits == 1
-        for var_type in op.var_types.values()
-    ):
-        return False
-    if any(
-        isinstance(var_type, QuantumNumeric)
-        and (var_type.sign_value or var_type.fraction_digits_value > 0)
-        for var_type in op.var_types.values()
-    ):
-        return False
-    return _is_res_boolean(op)
-
-
-def _is_res_boolean(op: ArithmeticOperation) -> bool:
-    if not (op.result_type.has_size_in_bits and op.result_type.size_in_bits == 1):
-        return False
-    return not (
-        isinstance(op.result_type, QuantumNumeric)
-        and (op.result_type.sign_value or op.result_type.fraction_digits_value > 0)
-    )

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -2,10 +2,6 @@ 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
@@ -18,37 +14,11 @@ 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: FunctionClosure = self._interpreter.evaluate(call.function).as_type(
-            FunctionClosure
-        )
+        function = 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):
-            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)
+            self._emit_quantum_function_call(function, args)

classiq/model_expansions/quantum_operations/repeat.py

@@ -1,3 +1,4 @@
+from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
     REPEAT_OPERATOR_NAME,
@@ -17,6 +18,10 @@ from classiq.qmod.quantum_function import GenerativeQFunc
 class RepeatEmitter(Emitter[Repeat]):
     def emit(self, repeat: Repeat, /) -> None:
         count = self._interpreter.evaluate(repeat.count).as_type(int)
+        if count < 0:
+            raise ClassiqExpansionError(
+                f"repeat count must be non-negative, got {count}"
+            )
         for i in range(count):
             with self._propagated_var_stack.capture_variables(repeat):
                 self._emit_propagated(repeat, i)

classiq/model_expansions/quantum_operations/within_apply.py

@@ -1,5 +1,4 @@
 from classiq.interface.generator.functions.builtins.internal_operators import (
-    COMPUTE_OPERATOR_NAME,
     WITHIN_APPLY_NAME,
 )
 from classiq.interface.model.within_apply_operation import WithinApply
@@ -26,10 +25,6 @@ class WithinApplyEmitter(Emitter[WithinApply]):
                 }
             )
 
-        if self._should_wrap(within_apply.compute):
-            self._emit_wrapped(within_apply)
-            return
-
         self._emit_as_operation(within_apply)
 
     def _emit_as_operation(self, within_apply: WithinApply) -> None:
@@ -46,14 +41,3 @@ class WithinApplyEmitter(Emitter[WithinApply]):
                 source_ref=within_apply.source_ref,
             )
         )
-
-    def _emit_wrapped(self, within_apply: WithinApply) -> None:
-        wrapped_compute = self._create_expanded_wrapping_function(
-            COMPUTE_OPERATOR_NAME, within_apply.compute
-        )
-        wrapped_within_apply = WithinApply(
-            compute=[wrapped_compute],
-            action=within_apply.action,
-            source_ref=within_apply.source_ref,
-        )
-        self._builder.emit_statement(wrapped_within_apply)

classiq/model_expansions/scope_initialization.py

@@ -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
@@ -60,7 +60,6 @@ def _add_functions_to_scope(
                 positional_arg_declarations=function.positional_arg_declarations,
                 body=function.body,
                 scope=Scope(parent=scope),
-                synthesis_data=function.synthesis_data,
             )
         )
 
@@ -143,5 +142,5 @@ def init_top_level_scope(
 ) -> None:
     _add_functions_to_scope(model.functions, scope)
     _add_generative_functions_to_scope(generative_functions, scope)
-    _add_constants_to_scope(model.constants, scope)
+    add_constants_to_scope(model.constants, scope)
     _init_builtins_scope(scope)

classiq/qmod/builtins/functions/arithmetic.py

@@ -23,8 +23,6 @@ def unitary(
     Args:
         elements:  A 2d array of complex numbers representing the unitary matrix. This matrix must be unitary.
         target: The quantum state to apply the unitary on. Should be of corresponding size.
-
-    Links: [Reference Manual](https://docs.classiq.io/qmod/builtins/functions/standard_gates/unitary)
     """
     pass
 

classiq/qmod/builtins/functions/discrete_sine_cosine_transform.py

@@ -105,9 +105,6 @@ def qct_qst_type1(x: QArray[QBit]) -> None:
 
     Args:
         x: The qubit array to apply the transform to.
-
-    Links:
-        - [Quantum Sine and Cosine Transforms](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/open-library-functions/qct_qst/qct_qst/)
     """
     within_apply(lambda: _t_operator(x), lambda: qft(x))
 
@@ -134,9 +131,6 @@ def qct_qst_type2(x: QArray[QBit], q: QBit) -> None:
     Args:
         x: The LSB part of the qubit array to apply the transform to.
         q: The MSB of the qubit array to apply the transform to.
-
-    Links:
-        - [Quantum Sine and Cosine Transforms](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/open-library-functions/qct_qst/qct_qst/)
     """
     extended_state: QArray = QArray("extended_state")
     _vn_operator(x, q)
@@ -156,9 +150,6 @@ def qct_type2(x: QArray[QBit]) -> None:
 
     Args:
         x: The qubit array to apply the transform to.
-
-    Links:
-        - [Quantum Sine and Cosine Transforms](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/open-library-functions/qct_qst/qct_qst/)
     """
     q = QBit("q")
     within_apply(lambda: allocate(1, q), lambda: qct_qst_type2(x, q))
@@ -174,9 +165,6 @@ def qst_type2(x: QArray[QBit]) -> None:
 
     Args:
         x: The qubit array to apply the transform to.
-
-    Links:
-        - [Quantum Sine and Cosine Transforms](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/open-library-functions/qct_qst/qct_qst/)
     """
     q = QBit("q")
     within_apply(

classiq/qmod/builtins/functions/exponentiation.py

@@ -45,8 +45,6 @@ def suzuki_trotter(
     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.
 
-    See [N. Hatano and M. Suzuki, Finding Exponential Product Formulas of Higher Orders (2005)](https://arxiv.org/abs/math-ph/0506007).
-
     Args:
         pauli_operator: The Pauli operator to be exponentiated.
         evolution_coefficient: A global evolution coefficient multiplying the Pauli operator.
@@ -73,8 +71,6 @@ def qdrift(
     The QDrift method randomizes the order of the operators in the product of exponentials to stochastically reduce the error of the approximation.
     The error of the QDrift method decreases as the number of QDrift steps increases.
 
-    See [E. Campbell, Random Compiler for Fast Hamiltonian Simulation (2019)](https://arxiv.org/abs/1811.08017).
-
     Args:
         pauli_operator: The Pauli operator to be exponentiated.
         evolution_coefficient: A global evolution coefficient multiplying the Pauli operator.
@@ -100,8 +96,6 @@ def exponentiation_with_depth_constraint(
     The Suzuki-Trotter decomposition is a method for approximating the exponential of a sum of operators by a product of exponentials of each operator.
     This function automatically determines the order and number of repetitions of the Suzuki-Trotter decomposition to minimize the error given a depth constraint.
 
-    See [A. M. Childs et al., Toward the first quantum simulation with quantum speedup (2017)](https://arxiv.org/abs/1711.10980).
-
     Args:
         pauli_operator: The Pauli operator to be exponentiated.
         evolution_coefficient: A global coefficient multiplying the Pauli operator.

classiq/qmod/builtins/functions/grover.py

@@ -39,11 +39,6 @@ def phase_oracle(
     Args:
         predicate: A predicate function that takes a QArray of QBits and sets a single QBit |1> if the predicate is true, and |0> otherwise.
         target: The target QArray of QBits to apply the phase oracle to.
-
-    Usage Examples:
-        [Grover Algorithm](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/grover_operator/grover_operator/)
-
-        [Hidden shift](https://docs.classiq.io/latest/explore/algorithms/algebraic/hidden_shift/hidden_shift/)
     """
     aux = QBit("aux")
     within_apply(
@@ -125,18 +120,10 @@ def grover_operator(
     where $S_{\\psi_1}$ is a reflection about marked states, and $S_{\\psi_0}$ is a reflection
     about a given state defined by $|\\psi_0\rangle = A|0\rangle$.
 
-
     Args:
         oracle: A unitary operator which adds a phase of (-1) to marked states.
         space_transform: The operator which creates $|\\psi_0\rangle$, the initial state, used by the diffuser to reflect about it.
         packed_vars: The state to which to apply the grover operator.
-
-
-    For further reading, see:
-
-    - [The Grover Operator notebook](../explore/functions/qmod_library_reference/classiq_open_library/grover_operator/grover_operator/)
-    - [Wikipedia page](https://en.wikipedia.org/wiki/Grover%27s_algorithm).
-
     """
     oracle(packed_vars)
     grover_diffuser(lambda qba: space_transform(qba), packed_vars)
@@ -158,10 +145,6 @@ def grover_search(
         packed_vars: Packed form of the variable to apply the grover operator on.
 
     Returns: None
-
-    Links:
-         [Grover Algorithm](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/grover_operator/grover_operator/)
-
     """
     hadamard_transform(packed_vars)
     power(

classiq/qmod/builtins/functions/linear_pauli_rotation.py

@@ -61,11 +61,6 @@ def linear_pauli_rotations(
         q: List of indicator qubits for each of the given Pauli bases.
 
     Notice that bases, slopes, offset and q should be of the same size.
-
-
-
-    Links:
-       [linear_pauli_rotations](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/linear_pauli_rotations/linear_pauli_rotations)
     """
     repeat(
         q.len,

classiq/qmod/builtins/functions/modular_exponentiation.py

@@ -186,9 +186,6 @@ def modular_exp(n: CInt, a: CInt, x: QArray[QBit], power: QArray[QBit]) -> None:
         a: The base of the exponentiation. Should be non-negative.
         x: A quantum number that multiplies the modular exponentiation and holds the output. It should be at least the size of $\\lceil \\log(n) \rceil$.
         power: The power of the exponentiation.
-
-    Usage Example:
-        [Modular Exponentiation](https://docs.classiq.io/latest/explore/functions/function_usage_examples/arithmetic/modular_exp/modular_exp_example)
     """
     repeat(
         count=power.len,

classiq/qmod/builtins/functions/qaoa_penalty.py

@@ -17,9 +17,6 @@ def qaoa_mixer_layer(b: CReal, target: QArray[QBit]) -> None:
     The mixer layer is a sequence of `X` gates applied to each qubit in the target quantum
     array variable.
 
-    Please refer to the [QAOA mixer tutorial](https://docs.classiq.io/latest/reference-manual/built-in-algorithms/combinatorial-optimization/problem-solving/) for an example
-
-
     Args:
         b: The rotation parameter for the mixer layer.
         target: The target quantum array.
@@ -40,7 +37,6 @@ def qaoa_cost_layer(
     The cost layer represents the primary objective that the QAOA algorithm seeks to optimize, such as
     minimizing energy or maximizing profit, depending on the application.
 
-    For more details on defining cost functions in QAOA models using Pyomo, see: [Problem Formulation](https://docs.classiq.io/latest/reference-manual/built-in-algorithms/combinatorial-optimization/)
     Args:
         g: The rotation parameter for the cost layer (prefactor).
         hamiltonian: The Hamiltonian terms for the QAOA model.
@@ -62,7 +58,6 @@ def qaoa_layer(
     Quantum Approximate Optimization Algorithm (QAOA). The cost layer encodes the problem's objective,
     while the mixer layer introduces quantum superposition and drives the search across the solution space.
 
-    For more details mon the QAOA problem formulation, please see the following [tutorial](https://docs.classiq.io/latest/reference-manual/built-in-algorithms/combinatorial-optimization/)
     Args:
            g: The rotation parameter for the cost layer.
            b: The rotation parameter for the mixer layer.
@@ -107,9 +102,6 @@ def qaoa_penalty(
     enforce certain constraints (e.g., binary or integer variables) during the
     optimization process.
 
-    Please refer to the [Optimization Problem tutorial](https://docs.classiq.io/latest/reference-manual/built-in-algorithms/combinatorial-optimization/problem-formulation/) for details.
-
-
     Args:
         num_qubits: The number of qubits in the quantum circuit.
         params_list The list of QAOA parameters.

classiq/qmod/builtins/functions/qft_functions.py

@@ -46,9 +46,6 @@ def qft(target: QArray[QBit]) -> None:
 
     Args:
         target: The quantum object to be transformed
-
-    Further reading in Classiq Library:
-    Link: [qft library reference](https://github.com/Classiq/classiq-library/blob/main/functions/qmod_library_reference/classiq_open_library/qft/qft.ipynb)
     """
     repeat(
         target.len / 2,  # type:ignore[arg-type]

classiq/qmod/builtins/functions/qpe.py

@@ -19,9 +19,6 @@ def qpe_flexible(unitary_with_power: QCallable[CInt], phase: QNum) -> None:
     Args:
         unitary_with_power: A callable that returns the unitary operator $U^k$ given an integer $k$. This callable is used to control the application of powers of the unitary operator.
         phase: The quantum variable that represents the estimated phase (eigenvalue), assuming initialized to zero.
-
-    Further reading in Classiq Library:
-    Link: [qpe library reference](https://github.com/Classiq/classiq-library/blob/main/functions/qmod_library_reference/classiq_open_library/qpe/qpe.ipynb)
     """
     phase_array: QArray = QArray("phase_array")
     bind(phase, phase_array)
@@ -48,8 +45,5 @@ def qpe(unitary: QCallable, phase: QNum) -> None:
     Args:
         unitary: A callable representing the unitary operator $U$, whose eigenvalue is to be estimated.
         phase: The quantum variable that represents the estimated phase (eigenvalue), assuming initialized to zero.
-
-    Further reading in Classiq Library:
-    Link: [qpe library reference](https://github.com/Classiq/classiq-library/blob/main/functions/qmod_library_reference/classiq_open_library/qpe/qpe.ipynb)
     """
     qpe_flexible(unitary_with_power=lambda k: power(k, unitary), phase=phase)