State preparation

state_preparation

Functions:

Name	Description
`allocate_num`	[Qmod Classiq-library function]
`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]

allocate_num

allocate_num(
    num_qubits: CInt,
    is_signed: CBool,
    fraction_digits: CInt,
    out: Output[
        QNum[
            Literal["num_qubits"],
            Literal["is_signed"],
            Literal["fraction_digits"],
        ]
    ],
) -> None

[Qmod Classiq-library function]

Initializes a quantum number with the given number of qubits, sign, and fractional digits.

Parameters:

Name	Type	Description	Default
`num_qubits`	`CInt`	The number of qubits to allocate.	required
`is_signed`	`CBool`	Whether the number is signed or unsigned.	required
`fraction_digits`	`CInt`	The number of fractional digits.	required

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

If the output variable has been declared with a specific number of qubits, it must match the number of allocated qubits.
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

If the output variable has been declared with a specific number of qubits, it must match the number of allocated qubits.
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: CArray[CReal],
    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`	`CArray[CReal]`	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: CArray[CReal],
    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`	`CArray[CReal]`	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