Skip to content

State Preparation

search: boost: 2

state_preparation

Functions:

Name Description
prepare_uniform_trimmed_state

[Qmod Classiq-library function]
prepare_uniform_interval_state

[Qmod Classiq-library function]
prepare_ghz_state

[Qmod Classiq-library function]
prepare_exponential_state

[Qmod Classiq-library function]
prepare_bell_state

[Qmod Classiq-library function]
inplace_prepare_int

[Qmod Classiq-library function]
prepare_int

[Qmod Classiq-library function]
prepare_complex_amplitudes

[Qmod Classiq-library function]
inplace_prepare_complex_amplitudes

[Qmod Classiq-library function]
prepare_dicke_state

[Qmod Classiq-library function]
prepare_dicke_state_unary_input

[Qmod Classiq-library function]

prepare_uniform_trimmed_state 

prepare_uniform_trimmed_state(
    m: CInt, q: QArray[QBit]
) -> None

[Qmod Classiq-library function]

Initializes a quantum variable in a uniform superposition of the first m computational basis states:

\[ \left|\text{q}\right\rangle = \frac{1}{\sqrt{m}}\sum_{i=0}^{m-1}{|i\rangle} \]

The number of allocated qubits would be \(\left\lceil\log_2{m}\right\rceil\). The function is especially useful when m is not a power of 2.

Parameters:

Name Type Description Default
m CInt

The number of states to load in the superposition.

 required
q QArray[QBit]

The quantum variable that will receive the initialized state. Must be uninitialized.

 required
Notes
  1. If the output variable has been declared with a specific number of qubits, it must match the number of allocated qubits.
  2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.

prepare_uniform_interval_state 

prepare_uniform_interval_state(
    start: CInt, end: CInt, q: QNum
) -> None

[Qmod Classiq-library function]

Initializes a quantum variable in a uniform superposition of the specified interval in the computational basis states:

\[ \left|\text{q}\right\rangle = \frac{1}{\sqrt{\text{end} - \text{start}}}\sum_{i=\text{start}}^{\text{end}-1}{|i\rangle} \]

The number of allocated qubits would be \(\left\lceil\log_2{\left(\text{end}\right)}\right\rceil\).

Parameters:

Name Type Description Default
start CInt

The lower bound of the interval to load (inclusive).

 required
end CInt

The upper bound of the interval to load (exclusive).

 required
q QNum

The quantum variable that will receive the initialized state. Must be uninitialized.

 required
Notes
  1. If the output variable has been declared with a specific number of qubits, it must match the number of allocated qubits.
  2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.

prepare_ghz_state 

prepare_ghz_state(
    size: CInt, q: Output[QArray[QBit]]
) -> None

[Qmod Classiq-library function]

Initializes a quantum variable in a Greenberger-Horne-Zeilinger (GHZ) state. i.e., a balanced superposition of all ones and all zeros, on an arbitrary number of qubits..

Parameters:

Name Type Description Default
size CInt

The number of qubits in the GHZ state. Must be a positive integer.

 required
q Output[QArray[QBit]]

The quantum variable that will receive the initialized state. Must be uninitialized.

 required
Notes

The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.

prepare_exponential_state 

prepare_exponential_state(
    rate: CInt, q: QArray[QBit]
) -> None

[Qmod Classiq-library function]

Prepares a quantum state with exponentially decreasing amplitudes. The state is prepared in the computational basis, with the amplitudes of the states decreasing exponentially with the index of the state:

\[ P(n) = \frac{1}{Z} e^{- \text{rate} \cdot n} \]

Parameters:

Name Type Description Default
rate CInt

The rate of the exponential decay.

 required
q QArray[QBit]

The quantum register to prepare.

 required

prepare_bell_state 

prepare_bell_state(
    state_num: CInt, qpair: Output[QArray[QBit, Literal[2]]]
) -> None

[Qmod Classiq-library function]

Initializes a quantum array of size 2 in one of the four Bell states.

Parameters:

Name Type Description Default
state_num CInt

The number of the Bell state to be prepared. Must be an integer between 0 and 3.

 required
qpair Output[QArray[QBit, Literal[2]]]

The quantum variable that will receive the initialized state. Must be uninitialized.

 required
Bell States

The four Bell states are defined as follows (each state correlates to an integer between 0 and 3 as defined by the state_num argument):

If state_num = 0 the function prepares the Bell state:

\[ \left|\Phi^+\right\rangle = \frac{1}{\sqrt{2}} \left( \left| 00 \right\rangle + \left| 11 \right\rangle \right) \]

If state_num = 1 the function prepares the Bell state:

\[ \left|\Phi^-\right\rangle = \frac{1}{\sqrt{2}} \left( \left| 00 \right\rangle - \left| 11 \right\rangle \right) \]

If state_num = 2 the function prepares the Bell state:

\[ \left|\Psi^+\right\rangle = \frac{1}{\sqrt{2}} \left( \left| 01 \right\rangle + \left| 10 \right\rangle \right) \]

If state_num = 3 the function prepares the Bell state:

\[ \left|\Psi^-\right\rangle = \frac{1}{\sqrt{2}} \left( \left| 01 \right\rangle - \left| 10 \right\rangle \right) \]
Notes

The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.

inplace_prepare_int 

inplace_prepare_int(value: CInt, target: QNum) -> None

[Qmod Classiq-library function]

This function is deprecated. Use in-place-xor assignment statement in the form target-var ^= quantum-expression or inplace_xor(quantum-expression, target-var) instead.

Transitions a quantum variable in the zero state \(|0\rangle\) into the computational basis state \(|\text{value}\rangle\). In the general case, the function performs a bitwise-XOR, i.e. transitions the state \(|\psi\rangle\) into \(|\psi \oplus \text{value}\rangle\).

Parameters:

Name Type Description Default
value CInt

The value to assign to the quantum variable.

 required
target QNum

The quantum variable to act upon.

 required
Note

If the value cannot fit into the quantum variable, it is truncated, i.e. treated as the value modulo \(2^\text{target.size}\).

prepare_int 

prepare_int(
    value: CInt,
    out: Output[QNum[Literal["floor(log(value, 2)) + 1"]]],
) -> None

[Qmod Classiq-library function]

This function is deprecated. Use assignment statement in the form target-var |= quantum-expression or assign(quantum-expression, target-var) instead.

Initializes a quantum variable to the computational basis state \(|\text{value}\rangle\). The number of allocated qubits is automatically computed from the value, and is the minimal number required for representation in the computational basis.

Parameters:

Name Type Description Default
value CInt

The value to assign to the quantum variable.

 required
out Output[QNum[Literal['floor(log(value, 2)) + 1']]]

The allocated quantum variable. Must be uninitialized.

 required
Note

If the output variable has been declared with a specific number of qubits, it must match the number of allocated qubits.

prepare_complex_amplitudes 

prepare_complex_amplitudes(
    magnitudes: CArray[CReal],
    phases: list[float],
    out: Output[
        QArray[
            QBit,
            Literal["log(get_field(magnitudes, 'len'), 2)"],
        ]
    ],
) -> None

[Qmod Classiq-library function]

Initializes and prepares a quantum state with amplitudes and phases for each state according to the given parameters, in polar representation.

Parameters:

Name Type Description Default
magnitudes CArray[CReal]

Absolute values of the state amplitudes.

 required
phases list[float]

phases of the state amplitudes. should be of the same size as amplitudes.

 required
out Output[QArray[QBit, Literal["log(get_field(magnitudes, 'len'), 2)"]]]

The allocated quantum variable. Must be uninitialized.

 required

inplace_prepare_complex_amplitudes 

inplace_prepare_complex_amplitudes(
    magnitudes: CArray[CReal],
    phases: list[float],
    target: QArray[
        QBit,
        Literal["log(get_field(magnitudes, 'len'), 2)"],
    ],
) -> None

[Qmod Classiq-library function]

Prepares a quantum state with amplitudes and phases for each state according to the given parameters, in polar representation. Expects to act on an initialized zero state \(|0\rangle\).

Parameters:

Name Type Description Default
magnitudes CArray[CReal]

Absolute values of the state amplitudes.

 required
phases list[float]

phases of the state amplitudes. should be of the same size as amplitudes.

 required
target QArray[QBit, Literal["log(get_field(magnitudes, 'len'), 2)"]]

The quantum variable to act upon.

 required

prepare_dicke_state 

prepare_dicke_state(k: int, qvar: QArray[QBit]) -> None

[Qmod Classiq-library function]

Prepares a Dicke state with k excitations over the provided quantum register.

A Dicke state of n qubits with k excitations is an equal superposition of all basis states with exactly k qubits in the \(|1\rangle\) state and \((n - k)\) qubits in the \(|0\rangle\) state. For example, \(\mathrm{Dicke}(2, 1) = (|01\rangle + |10\rangle) / \sqrt(2)\).

In the general case it is defined to be:

\[\mathrm{Dicke}(n, k) = \frac{1}{\sqrt{\binom{n}{k}}} \sum_{x \in \{0,1\}^n,\, |x| = k} |x\rangle\]

Parameters:

Name Type Description Default
k int

The number of excitations (i.e., number of qubits in state \(|1\rangle\)).

 required
qvar QArray[QBit]

The quantum register (array of qubits) to initialize. Must be uninitialized and have length >= k.

 required

prepare_dicke_state_unary_input 

prepare_dicke_state_unary_input(
    max_k: int, qvar: QArray[QBit]
) -> None

[Qmod Classiq-library function]

Prepares a Dicke state with a variable number of excitations based on an unary-encoded input.

The Dicke state is defined to be:

\[\mathrm{Dicke}(n, k) = \frac{1}{\sqrt{\binom{n}{k}}} \sum_{x \in \{0,1\}^n,\, |x| = k} |x\rangle\]

The input register qvar is expected to already be initialized in a unary encoding: the value k is represented by a string of k ones followed by zeros, e.g., k = 3 -> |11100...0>. The function generates a Dicke state with k excitations over a new quantum register, where 0 <= k < max_k.

Parameters:

Name Type Description Default
max_k int

The maximum number of allowed excitations (upper bound for k).

 required
qvar QArray[QBit]

Unary-encoded quantum input register of length >= max_k. Must be pre-initialized.

 required