> ## Documentation Index
> Fetch the complete documentation index at: https://prod-mint.classiq.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Linear Combination Of Unitaries

Functions:

| Name             | Description                       |
| ---------------- | --------------------------------- |
| `lcu`            | \[Qmod Classiq-library function]. |
| `lcu_pauli`      | \[Qmod Classiq-library function]. |
| `prepare_select` | \[Qmod Classiq-library function]. |

### lcu

<pre><code>lcu(
coefficients: list\[float],
unitaries: QCallableList,
block: QNum\[Literal\['max(ceiling(log(coefficients.len, 2)), 1)']]
) -> None</code></pre>

\[Qmod Classiq-library function]

Implements a general linear combination of unitaries (LCU) procedure. The algorithm prepares a superposition
over the `unitaries` according to the given `coefficients`, 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`.

**Parameters:**

| Name           | Type                                                         | Description                                                                                           | Default    |
| -------------- | ------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------- | ---------- |
| `coefficients` | `list[float]`                                                | L1-normalized array of $\\{ \alpha_j \\}$ of the LCU coefficients.                                    | *required* |
| `unitaries`    | `QCallableList`                                              | A list of quantum callable functions to be applied conditionally.                                     | *required* |
| `block`        | `QNum[Literal['max(ceiling(log(coefficients.len, 2)), 1)']]` | Quantum variable that holds the superposition index used for conditional application of each unitary. | *required* |

### lcu\_pauli

<pre><code>lcu\_pauli(
operator: SparsePauliOp,
data: QArray\[QBit, Literal\['operator.num\_qubits']],
block: QNum\[Literal\['max(ceiling(log(operator.terms.len, 2)), 1)']]
) -> None</code></pre>

\[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.

**Parameters:**

| Name       | Type                                                           | Description                                                                                                                 | Default    |
| ---------- | -------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | ---------- |
| `operator` | `SparsePauliOp`                                                | Operator consists of pauli strings with their coefficients, represented in a sparse format.                                 | *required* |
| `data`     | `QArray[QBit, Literal['operator.num_qubits']]`                 | Quantum Variable on which the Pauli operators act. Its size must match the number of qubits required by the Pauli operator. | *required* |
| `block`    | `QNum[Literal['max(ceiling(log(operator.terms.len, 2)), 1)']]` | Quantum variable that holds the superposition index used for conditional application of each term.                          | *required* |

### prepare\_select

<pre><code>prepare\_select(
coefficients: list\[float],
select: QCallable\[QNum],
block: QNum\[Literal\['max(ceiling(log(coefficients.len, 2)), 1)']]
) -> None</code></pre>

\[Qmod Classiq-library function]

Applies the 'Prepare-Select' scheme used for Linear Combination of Unitaries (LCU).
Compared to the `lcu` function, here the Select operator should be provided directly, allowing to take advantage of some structure for
the unitaries of the LCU.
The select operator is defined by: $\mathrm\{SELECT\} = \sum_\{j=0\}^\{m-1\} |j\rangle\!\langle j|_\{block\} \otimes U_j$.

**Parameters:**

| Name           | Type                                                         | Description                                                                                                                                                        | Default    |
| -------------- | ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------- |
| `coefficients` | `list[float]`                                                | L1-normalized array of $\\{ \alpha_j \\}$ of the LCU coefficients.                                                                                                 | *required* |
| `select`       | `QCallable[QNum]`                                            | A quantum callable to be applied between the state preparation and its inverse. Its input is the `block` variable, labeling the index of the unitaries in the LCU. | *required* |
| `block`        | `QNum[Literal['max(ceiling(log(coefficients.len, 2)), 1)']]` | A Quantum variable that holds the index used as input for the 'select' operator.                                                                                   | *required* |