classiq 0.86.1__py3-none-any.whl → 0.88.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/allocate.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, Union
 import sympy
 
 from classiq.interface.debug_info.debug_info import FunctionDebugInfo
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqExpansionError, ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.handle_binding import NestedHandleBinding
@@ -12,7 +12,9 @@ from classiq.interface.model.quantum_type import (
     QuantumNumeric,
 )
 
-from classiq.evaluators.quantum_type_utils import copy_type_information
+from classiq.evaluators.qmod_type_inference.quantum_type_inference import (
+    inject_quantum_type_attributes_inplace,
+)
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import QuantumSymbol
 
@@ -76,7 +78,7 @@ class AllocateEmitter(Emitter[Allocate]):
         target: QuantumSymbol,
         op_update_dict: dict[str, Expression],
     ) -> None:
-        if target.quantum_type.is_evaluated:
+        if target.quantum_type.has_size_in_bits:
             expr = str(target.quantum_type.size_in_bits)
         elif self._allow_symbolic_attrs:
             expr = f"{target.handle}.size"
@@ -95,11 +97,14 @@ class AllocateEmitter(Emitter[Allocate]):
         size_value = self._interpret_size(size, str(target.handle))
         op_update_dict["size"] = Expression(expr=str(size_value))
 
-        if not isinstance(size_value, sympy.Basic):
-            copy_type_information(
-                QuantumBitvector(length=op_update_dict["size"]),
-                target.quantum_type,
-                str(target.handle),
+        if not isinstance(
+            size_value, sympy.Basic
+        ) and not inject_quantum_type_attributes_inplace(
+            QuantumBitvector(length=op_update_dict["size"]), target.quantum_type
+        ):
+            raise ClassiqExpansionError(
+                f"Cannot allocate {op_update_dict['size']} qubits for variable "
+                f"{str(target)!r} of type {target.quantum_type.qmod_type_name}"
             )
 
     def _handle_with_numeric_attrs(
@@ -127,15 +132,17 @@ class AllocateEmitter(Emitter[Allocate]):
             isinstance(size_value, sympy.Basic)
             or isinstance(is_signed_value, sympy.Basic)
             or isinstance(fraction_digits_value, sympy.Basic)
+        ) and not inject_quantum_type_attributes_inplace(
+            QuantumNumeric(
+                size=op_update_dict["size"],
+                is_signed=op_update_dict["is_signed"],
+                fraction_digits=op_update_dict["fraction_digits"],
+            ),
+            target.quantum_type,
         ):
-            copy_type_information(
-                QuantumNumeric(
-                    size=op_update_dict["size"],
-                    is_signed=op_update_dict["is_signed"],
-                    fraction_digits=op_update_dict["fraction_digits"],
-                ),
-                target.quantum_type,
-                var_name,
+            raise ClassiqExpansionError(
+                f"Cannot allocate {op_update_dict['size']} qubits for variable "
+                f"{var_name!r} of type {target.quantum_type.qmod_type_name}"
             )
 
     def _interpret_size(

classiq/model_expansions/quantum_operations/arithmetic/explicit_boolean_expressions.py

@@ -44,9 +44,7 @@ def convert_inplace_op_bool_expression(
     if not is_bool(op.expression.expr):
         return
     _validate_target_type(target, op.expression.expr, op.operation_kind)
-    op.expression = op.expression.model_copy(
-        update=dict(expr="1" if op.expression.expr == "True" else "0")
-    )
+    op.expression = Expression(expr="1" if op.expression.expr == "True" else "0")
 
 
 def _supported_types() -> tuple[str, ...]:

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -27,7 +27,9 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq.evaluators.quantum_type_utils import copy_type_information
+from classiq.evaluators.qmod_type_inference.quantum_type_inference import (
+    inject_quantum_type_attributes_inplace,
+)
 from classiq.model_expansions.quantum_operations.arithmetic.explicit_boolean_expressions import (
     convert_assignment_bool_expression,
     validate_assignment_bool_expression,
@@ -67,30 +69,38 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         )
         convert_assignment_bool_expression(op)
 
-        inferred_result_type = self._infer_result_type(op)
-        if inferred_result_type is None:
+        expression_type = self._infer_expression_type(op)
+        if expression_type is None:
             return False
 
-        if not isinstance(result_type, QuantumNumeric):
-            copy_type_information(
-                inferred_result_type, result_symbol.quantum_type, str(op.result_var)
-            )
+        if not result_type.is_instantiated:
+            if not inject_quantum_type_attributes_inplace(expression_type, result_type):
+                raise ClassiqExpansionError(
+                    f"Cannot assign expression of type "
+                    f"{expression_type.qmod_type_name} to variable "
+                    f"{str(result_symbol)!r} of type "
+                    f"{result_symbol.quantum_type.qmod_type_name}"
+                )
             return False
 
-        self._copy_numeric_attributes(result_type, inferred_result_type)
-        if self._same_numeric_attributes(result_type, inferred_result_type):
+        if isinstance(result_type, QuantumNumeric) and isinstance(
+            expression_type, QuantumNumeric
+        ):
+            result_type.set_bounds(expression_type.get_bounds())
+        if self._same_numeric_attributes(result_type, expression_type):
             return False
-
         self._validate_declared_attributes(
-            result_type, inferred_result_type, str(op.result_var)
+            result_type, expression_type, str(op.result_var)
         )
-        if self._replace_assignment_if_needed:
-            self._assign_to_inferred_var_and_bind(op, result_type, inferred_result_type)
-            return True
-        else:
+        if not self._replace_assignment_if_needed:
             return False
 
-    def _infer_result_type(self, op: ArithmeticOperation) -> Optional[QuantumNumeric]:
+        self._assign_to_inferred_var_and_bind(op, result_type, expression_type)
+        return True
+
+    def _infer_expression_type(
+        self, op: ArithmeticOperation
+    ) -> Optional[QuantumNumeric]:
         expr = self._evaluate_expression(op.expression)
         if len(self._get_classical_vars_in_expression(expr)):
             return None
@@ -114,96 +124,72 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
             self._machine_precision,
         )
 
-    @staticmethod
-    def _copy_numeric_attributes(
-        result_type: QuantumNumeric, inferred_result_type: QuantumNumeric
-    ) -> None:
-        if not result_type.has_size_in_bits:
-            result_type.size = Expression(expr=str(inferred_result_type.size_in_bits))
-        if not result_type.has_sign:
-            result_type.is_signed = Expression(
-                expr=str(inferred_result_type.sign_value)
-            )
-        if not result_type.has_fraction_digits:
-            result_type.fraction_digits = Expression(
-                expr=str(inferred_result_type.fraction_digits_value)
-            )
-        result_type.set_bounds(inferred_result_type.get_bounds())
-
     @staticmethod
     def _same_numeric_attributes(
-        result_type: QuantumNumeric, inferred_result_type: QuantumNumeric
+        result_type: QuantumNumeric, expression_type: QuantumNumeric
     ) -> bool:
         return (
-            result_type.size_in_bits == inferred_result_type.size_in_bits
-            and result_type.sign_value == inferred_result_type.sign_value
+            result_type.size_in_bits == expression_type.size_in_bits
+            and result_type.sign_value == expression_type.sign_value
             and result_type.fraction_digits_value
-            == inferred_result_type.fraction_digits_value
+            == expression_type.fraction_digits_value
         )
 
     @classmethod
     def _validate_declared_attributes(
-        cls, result_type: QuantumNumeric, inferred_result_type: QuantumNumeric, var: str
+        cls, result_type: QuantumNumeric, expression_type: QuantumNumeric, var: str
     ) -> None:
         result_size, result_sign, result_fractions = (
             result_type.size_in_bits,
             result_type.sign_value,
             result_type.fraction_digits_value,
         )
-        inferred_size, inferred_sign, inferred_fractions = (
-            inferred_result_type.size_in_bits,
-            inferred_result_type.sign_value,
-            inferred_result_type.fraction_digits_value,
+        expression_size, expression_sign, expression_fractions = (
+            expression_type.size_in_bits,
+            expression_type.sign_value,
+            expression_type.fraction_digits_value,
         )
         result_integers = result_size - result_fractions
-        inferred_integers = inferred_size - inferred_fractions
+        expression_integers = expression_size - expression_fractions
 
         if (
-            (result_integers < inferred_integers)
-            or (result_fractions < inferred_fractions)
-            or (not result_sign and inferred_sign)
+            (result_integers < expression_integers)
+            or (result_fractions < expression_fractions)
+            or (not result_sign and expression_sign)
             or (
                 result_sign
-                and not inferred_sign
-                and result_integers == inferred_integers
+                and not expression_sign
+                and result_integers == expression_integers
             )
         ):
             if (
                 not result_sign
                 and result_fractions == 0
-                and not inferred_sign
-                and inferred_fractions == 0
+                and not expression_sign
+                and expression_fractions == 0
             ):
                 result_size_str = f"size {result_size}"
-                inferred_size_str = f"size {inferred_size}"
+                expression_size_str = f"size {expression_size}"
                 hint = f"Hint: increase the size in the declaration of {var!r} or omit it to enable automatic inference."
             else:
                 result_size_str = f"size {result_size}, {'signed' if result_sign else 'unsigned'}, and {result_fractions} fraction digits"
-                inferred_size_str = f"size {inferred_size}, {'signed' if inferred_sign else 'unsigned'}, and {inferred_fractions} fraction digits"
+                expression_size_str = f"size {expression_size}, {'signed' if expression_sign else 'unsigned'}, and {expression_fractions} fraction digits"
                 hint = f"Hint: omit the numeric attributes from the declaration of {var!r} to enable automatic inference."
             raise ClassiqExpansionError(
-                f"Cannot assign an expression with inferred {inferred_size_str} to variable {var!r} with declared {result_size_str}. {hint}"
+                f"Cannot assign an expression with inferred {expression_size_str} to variable {var!r} with declared {result_size_str}. {hint}"
             )
 
-    @staticmethod
-    def _craft_size_string(size: int, is_signed: bool, fraction_digits: int) -> str:
-        extra = (
-            f", with {fraction_digits} fraction digits" if fraction_digits > 0 else ""
-        )
-        return f"{size} ({'signed' if is_signed else 'unsigned'}{extra})"
-
     def _assign_to_inferred_var_and_bind(
         self,
         op: ArithmeticOperation,
         result_type: QuantumNumeric,
-        inferred_result_type: QuantumNumeric,
+        expression_type: QuantumNumeric,
     ) -> None:
         stmts: StatementBlock = []
         handles: list[HandleBinding] = []
 
         extra_fraction_digits = (
-            result_type.fraction_digits_value
-            - inferred_result_type.fraction_digits_value
+            result_type.fraction_digits_value - expression_type.fraction_digits_value
         )
         if extra_fraction_digits > 0:
             handles.append(
@@ -216,7 +202,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         inferred_result_handle = HandleBinding(name=inferred_result_name)
         stmts.append(
             VariableDeclarationStatement(
-                name=inferred_result_name, qmod_type=inferred_result_type
+                name=inferred_result_name, qmod_type=expression_type
             )
         )
         handles.append(inferred_result_handle)
@@ -228,8 +214,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
             result_type.size_in_bits - result_type.fraction_digits_value
         )
         inferred_result_integer_size = (
-            inferred_result_type.size_in_bits
-            - inferred_result_type.fraction_digits_value
+            expression_type.size_in_bits - expression_type.fraction_digits_value
         )
         extra_integers = result_integer_size - inferred_result_integer_size
         if extra_integers > 0:
@@ -239,17 +224,13 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
 
         stmts.append(BindOperation(in_handles=handles, out_handles=[op.result_var]))
 
-        if (
-            result_type.sign_value
-            and inferred_result_type.sign_value
-            and extra_integers > 0
-        ):
+        if result_type.sign_value and expression_type.sign_value and extra_integers > 0:
             sign_idx = result_type.size_in_bits - extra_integers - 1
             self._sign_extension(
                 op.result_var, sign_idx, result_type.size_in_bits, stmts
             )
 
-        if (inferred_bounds := inferred_result_type.get_bounds()) is not None:
+        if (inferred_bounds := expression_type.get_bounds()) is not None:
             lower_bound = Expression(expr=str(inferred_bounds[0]))
             upper_bound = Expression(expr=str(inferred_bounds[1]))
         else:

classiq/model_expansions/quantum_operations/bind.py

@@ -5,14 +5,17 @@ from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.bind_operation import BindOperation
-from classiq.interface.model.quantum_type import QuantumNumeric
+from classiq.interface.model.quantum_type import QuantumBitvector, QuantumNumeric
 
 from classiq.evaluators.parameter_types import (
     evaluate_types_in_quantum_symbols,
 )
+from classiq.evaluators.qmod_type_inference.quantum_type_inference import (
+    inject_quantum_type_attributes_inplace,
+)
 from classiq.evaluators.quantum_type_utils import (
-    set_size,
     validate_bind_targets,
 )
 from classiq.model_expansions.quantum_operations.emitter import Emitter
@@ -134,11 +137,16 @@ class BindEmitter(Emitter[BindOperation]):
             if output.quantum_type.has_size_in_bits
         )
         if len(unsized_outputs) == 1:
-            set_size(
-                unsized_outputs[0].quantum_type,
-                input_size - output_size,
-                str(unsized_outputs[0].handle),
-            )
+            unsized_type = unsized_outputs[0].quantum_type
+            new_size = input_size - output_size
+            if not inject_quantum_type_attributes_inplace(
+                QuantumBitvector(length=Expression(expr=str(new_size))), unsized_type
+            ):
+                raise ClassiqExpansionError(
+                    f"Cannot bind {new_size} qubits to variable "
+                    f"{str(unsized_outputs[0])!r} of type "
+                    f"{unsized_type.qmod_type_name}"
+                )
         elif input_size != output_size:
             raise ClassiqExpansionError(
                 f"The total size for the input and output of the bind operation must be the same. The in size is {input_size} and the out size is {output_size}"

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -1,7 +1,6 @@
 from collections.abc import Sequence
 from itertools import chain, combinations
 from typing import (
-    TYPE_CHECKING,
     Any,
     Generic,
     Optional,
@@ -80,18 +79,15 @@ from classiq.model_expansions.scope import (
     QuantumVariable,
     Scope,
 )
+from classiq.model_expansions.transformers.model_renamer import ModelRenamer
 from classiq.model_expansions.transformers.type_modifier_inference import (
     TypeModifierValidation,
 )
-from classiq.model_expansions.transformers.var_splitter import VarSplitter
 from classiq.qmod.pretty_print.expression_to_python import transform_expression
 from classiq.qmod.semantics.validation.signature_validation import (
     validate_function_signature,
 )
 
-if TYPE_CHECKING:
-    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
-
 
 def _validate_cloning(evaluated_args: list[Evaluated]) -> None:
     handles = chain.from_iterable(
@@ -145,11 +141,7 @@ def _validate_gen_args(
             )
 
 
-class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSplitter):
-    def __init__(self, interpreter: "BaseInterpreter") -> None:
-        Emitter.__init__(self, interpreter)
-        VarSplitter.__init__(self, interpreter._builder.current_scope)
-
+class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelRenamer):
     @staticmethod
     def _should_wrap(body: Sequence[QuantumStatement]) -> bool:
         # This protects shadowing of captured variables (i.e, bad user code) by wrapping the body in a function

classiq/model_expansions/quantum_operations/classical_var_emitter.py

@@ -1,3 +1,6 @@
+import re
+
+from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
 )
@@ -12,5 +15,8 @@ class ClassicalVarEmitter(Emitter[ArithmeticOperation]):
         if not isinstance(result_symbol, ClassicalSymbol):
             return False
         op._classical_assignment = True
+        match = re.search(r"measure\((.*?)\)", op.expression.expr)
+        if match is not None:
+            op.set_var_handles([HandleBinding(name=match.group(1))])
         self.emit_statement(op)
         return True

classiq/model_expansions/quantum_operations/handle_evaluator.py

@@ -19,11 +19,5 @@ class HandleEvaluator(Emitter[QuantumOperation]):
         if not isinstance(handle, HandleBinding):
             return False
         evaluated_handle = self._interpreter.evaluate(handle).value.handle.collapse()
-        if handle == evaluated_handle:
-            return False
-        op = op.model_copy(
-            update={self._handle_name: evaluated_handle, "back_ref": op.uuid}
-        )
-        self._interpreter.add_to_debug_info(op)
-        self._interpreter.emit(op)
-        return True
+        setattr(op, self._handle_name, evaluated_handle)
+        return False

classiq/open_library/functions/__init__.py

@@ -8,6 +8,7 @@ from .discrete_sine_cosine_transform import _qct_d_operator, _qct_pi_operator
 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
@@ -100,6 +101,8 @@ __all__ = [
     "inplace_c_modular_multiply",
     "inplace_prepare_complex_amplitudes",
     "inplace_prepare_int",
+    "lcu",
+    "lcu_pauli",
     "linear_pauli_rotations",
     "modular_exp",
     "modular_increment",
@@ -113,6 +116,7 @@ __all__ = [
     "prepare_exponential_state",
     "prepare_ghz_state",
     "prepare_int",
+    "prepare_linear_amplitudes",
     "prepare_uniform_interval_state",
     "prepare_uniform_trimmed_state",
     "projector_controlled_double_phase",

classiq/open_library/functions/lcu.py

@@ -0,0 +1,117 @@
+from typing import Literal
+
+import numpy as np
+
+from classiq.open_library.functions.state_preparation import (
+    apply_phase_table,
+)
+from classiq.open_library.functions.utility_functions import switch
+from classiq.qmod.builtins.functions import IDENTITY, X, Y, Z, inplace_prepare_state
+from classiq.qmod.builtins.operations import (
+    control,
+    repeat,
+    within_apply,
+)
+from classiq.qmod.builtins.structs import IndexedPauli, SparsePauliOp
+from classiq.qmod.cparam import CArray
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_variable import QArray, QBit, QNum
+from classiq.qmod.quantum_callable import QCallableList
+
+
+@qfunc
+def apply_pauli_term(pauli_string: CArray[IndexedPauli], x: QArray[QBit]) -> None:
+    repeat(
+        count=pauli_string.len,
+        iteration=lambda i: switch(
+            pauli_string[i].pauli,
+            [
+                lambda: IDENTITY(x[pauli_string[i].index]),
+                lambda: X(x[pauli_string[i].index]),
+                lambda: Y(x[pauli_string[i].index]),
+                lambda: Z(x[pauli_string[i].index]),
+            ],
+        ),
+    )
+
+
+@qfunc
+def lcu(
+    coefficients: list[float],
+    unitaries: QCallableList,
+    block: QNum[Literal["max(ceiling(log(coefficients.len, 2)), 1)"]],
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Implements a general linear combination of unitaries (LCU) procedure. The algorithm prepares a superposition
+    over the `unitaries` according to `magnitudes`, and then conditionally applies each unitary controlled by the `block`.
+
+    The operation is of the form:
+
+    $$\\sum_j \\alpha_j U_j$$
+
+    where $U_j$ is a unitary operation applied to `data`.
+
+    Args:
+        coefficients: L1-normalized array of  $\\{ \\alpha_j \\}$ of the LCU coefficients.
+        unitaries: A list of quantum callable functions to be applied conditionally.
+        block: Quantum variable that holds the superposition index used for conditional application of each unitary.
+    """
+    coefficients = coefficients + [0] * (
+        2**block.size - len(coefficients)  # type:ignore[operator]
+    )
+    magnitudes = [np.abs(c) for c in coefficients]
+    magnitudes = (np.array(magnitudes) / np.sum(magnitudes)).tolist()
+    phases = [np.angle(complex(c)) for c in coefficients]
+
+    within_apply(
+        lambda: inplace_prepare_state(magnitudes, 0, block),
+        lambda: [
+            repeat(
+                count=unitaries.len,
+                iteration=lambda i: control(block == i, lambda: unitaries[i]()),
+            ),
+            # TODO: replace to sparse constant phase
+            apply_phase_table(phases, block),
+        ],
+    )
+
+
+@qfunc
+def lcu_pauli(
+    operator: SparsePauliOp,
+    data: QArray[QBit, Literal["operator.num_qubits"]],
+    block: QNum[Literal["max(ceiling(log(operator.terms.len, 2)), 1)"]],
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies a linear combination of unitaries (LCU) where each unitary is a Pauli term,
+    represented as a tensor product of Pauli operators. The function prepares a superposition
+    over the unitaries according to the given magnitudes and phases, and applies the corresponding
+    Pauli operators conditionally.
+
+    This is useful for implementing Hamiltonian terms of the form:
+
+    $$H=\\sum_j \\alpha_j P_j$$
+
+    where $P_j$ is a tensor product of Pauli operators.
+
+    Args:
+        operator: Operator consists of pauli strings with their coefficients, represented in a sparse format.
+        data: Quantum Variable on which the Pauli operators act. Its size must match the number of qubits required by the Pauli operator.
+        block: Quantum variable that holds the superposition index used for conditional application of each term.
+    """
+    coefficients = [
+        operator.terms[i].coefficient
+        for i in range(operator.terms.len)  # type:ignore[attr-defined]
+    ]
+    lcu(
+        coefficients,
+        [
+            lambda i=i: apply_pauli_term(operator.terms[i].paulis, data)
+            for i in range(operator.terms.len)  # type:ignore[attr-defined]
+        ],
+        block,
+    )

classiq/open_library/functions/state_preparation.py

@@ -13,8 +13,8 @@ from classiq.open_library.functions.utility_functions import (
 from classiq.qmod.builtins.functions import (
     CX,
     IDENTITY,
+    PHASE,
     RY,
-    RZ,
     H,
     X,
     inplace_prepare_amplitudes,
@@ -324,7 +324,7 @@ def _classical_hadamard_transform(arr: list[float]) -> np.ndarray:
 
 
 @qfunc
-def _load_phases(
+def apply_phase_table(
     phases: list[float],
     target: QArray[QBit, Literal["log(get_field(phases, 'len'), 2)"]],
 ) -> None:
@@ -333,10 +333,10 @@ def _load_phases(
     for i in range(1, len(alphas) - 1):
         gray = _graycode(i)
         next_gray = _graycode(i + 1)
-        RZ(alphas[gray], target[_msb(gray)])
+        PHASE(alphas[gray], target[_msb(gray)])
         CX(target[_control_qubit(i)], target[_msb(next_gray)])
 
-    RZ(alphas[_graycode(len(phases) - 1)], target[target.len - 1])
+    PHASE(alphas[_graycode(len(phases) - 1)], target[target.len - 1])
 
 
 @qfunc
@@ -358,7 +358,7 @@ def inplace_prepare_complex_amplitudes(
         target: The quantum variable to act upon.
     """
     inplace_prepare_amplitudes(magnitudes, 0, target)
-    _load_phases(phases, target)
+    apply_phase_table(phases, target)
 
 
 @qfunc
@@ -469,3 +469,45 @@ def prepare_basis_state(state: list[bool], arr: Output[QArray]) -> None:
     for idx, value in enumerate(state):
         if value:
             X(arr[idx])
+
+
+def linear_hadamard_walsh_coefficients(n: int) -> np.ndarray:
+    coeffs = np.zeros(n + 1)
+    coeffs[0] = 2 ** (n / 2) * ((2**n - 1) / 2)
+    for k in range(1, n + 1):
+        coeffs[k] = -(2 ** (k - 1 + n / 2) / 2)
+    return coeffs / np.linalg.norm(coeffs)
+
+
+@qfunc
+def _zero_ctrl_rot(ctrl: QNum, target: QBit, theta: CReal) -> None:
+    control(ctrl == 0, lambda: RY(theta, target))
+
+
+@qfunc
+def prepare_linear_amplitudes(x: QArray) -> None:
+    """ "
+    [Qmod Classiq-library function]
+
+    Initializes a quantum variable in a state with linear amplitudes:
+    $$|\\psi\rangle = \frac{1}{Z}\\sum_{x=0}^{2^n-1}{x|x\rangle}$$
+    Where $Z$ is a normalization constant.
+
+    Based on the paper https://quantum-journal.org/papers/q-2024-03-21-1297/pdf/
+
+    Args:
+        x: The quantum register to prepare.
+    """
+    coeffs = linear_hadamard_walsh_coefficients(x.size)  # type: ignore[arg-type]
+    thetas = np.zeros(x.size + 1)  # type: ignore[arg-type]
+    for i in range(x.size):  # type: ignore[arg-type]
+        thetas[i] = 2 * np.arcsin(
+            coeffs[i + 1] / np.sqrt(1 - np.linalg.norm(coeffs[1 : i + 1]) ** 2)
+        )
+    for k in range(x.len):
+        if k == 0:
+            RY(thetas[k], x[k])
+        else:
+            _zero_ctrl_rot(x[0:k], x[k], thetas[k])
+
+    hadamard_transform(x)

classiq/qmod/builtins/__init__.py

@@ -1,5 +1,3 @@
-from classiq.interface.finance.function_input import FinanceFunctionInput
-
 from .classical_execution_primitives import *  # noqa: F403
 from .classical_execution_primitives import (
     __all__ as _builtin_classical_execution_primitives,
@@ -17,7 +15,6 @@ from .operations import __all__ as _builtin_operations
 from .structs import *  # noqa: F403
 from .structs import __all__ as _builtin_structs
 
-FinanceFunctionInput.model_rebuild()
 BUILTIN_CONSTANTS = [
     constant._get_constant_node()
     for constant in [