Grover

grover

Functions:

Name	Description
`phase_oracle`	[Qmod Classiq-library function]
`reflect_about_zero`	`[Qmod Classiq-library function]`
`grover_diffuser`	[Qmod Classiq-library function]
`grover_operator`	[Qmod Classiq-library function]
`grover_search`	[Qmod Classiq-library function]

phase_oracle

phase_oracle(
    predicate: QCallable[QArray[QBit], QBit],
    target: QArray[QBit],
) -> None

[Qmod Classiq-library function]

Creates a phase oracle operator based on a predicate function.

Applies a predicate function and marks "good" and "bad" states with a phase flip. If the predicate is marked as $\chi$, and the oracle is marked as $S_\chi$, then:

\[ S_\chi\lvert x angle = egin{cases} -\lvert x angle & ext{if } \chi(x) = 1 \ \phantom{-} \lvert x angle & ext{if } \chi(x) = 0 \end{cases} \]

Parameters:

Name	Type	Description	Default
`predicate`	`QCallable[QArray[QBit], QBit]`	A predicate function that takes a QArray of QBits and sets a single QBit \|1> if the predicate is true, and \|0> otherwise.	required
`target`	`QArray[QBit]`	The target QArray of QBits to apply the phase oracle to.	required

reflect_about_zero

reflect_about_zero(packed_vars: QArray[QBit]) -> None

[Qmod Classiq-library function]

Reflects the state about the |0> state (i.e. applies a (-1) phase to all states
besides the |0> state). Implements the operator $S_0$:

$$
egin{equation}
S_0|{x}

angle = (-1)^{(x e0)}|{x} angle= (2|{0} angle\langle{0}|-I)|{x} angle \end{equation} $$

Args:
    packed_vars: The quantum state to reflect.

grover_diffuser

grover_diffuser(
    space_transform: QCallable[QArray[QBit]],
    packed_vars: QArray[QBit],
) -> None

[Qmod Classiq-library function]

Reflects the given state about the A|0> state, where A is the space_transform parameter. It is defined as:

\[ egin{equation} D = A S_0 A^{\dagger} \end{equation} \]

where $S_0$ is the reflection about the |0> state (see reflect_about_zero).

Parameters:

Name	Type	Description	Default
`space_transform`	`QCallable[QArray[QBit]]`	The operator which encodes the axis of reflection.	required
`packed_vars`	`QArray[QBit]`	The state to which to apply the diffuser.	required

grover_operator

grover_operator(
    oracle: QCallable[QArray[QBit]],
    space_transform: QCallable[QArray[QBit]],
    packed_vars: QArray[QBit],
) -> None

[Qmod Classiq-library function]

Applies the grover operator, defined by:

\[ Q=S_{\psi_0}S_{\psi_1} \]

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 angle = A|0 angle$.

Parameters:

Name	Type	Description	Default
`oracle`	`QCallable[QArray[QBit]]`	A unitary operator which adds a phase of (-1) to marked states.	required
`space_transform`	`QCallable[QArray[QBit]]`	The operator which creates $\|\psi_0 angle$, the initial state, used by the diffuser to reflect about it.	required
`packed_vars`	`QArray[QBit]`	The state to which to apply the grover operator.	required

grover_search

grover_search(
    reps: CInt,
    oracle: QCallable[QArray[QBit]],
    packed_vars: QArray[QBit],
) -> None

[Qmod Classiq-library function]

Applies Grover search algorithm.

Parameters:

Name	Type	Description	Default
`reps`	`CInt`	Number of repetitions of the grover operator.	required
`oracle`	`QCallable[QArray[QBit]]`	An oracle that marks the solution.	required
`packed_vars`	`QArray[QBit]`	Packed form of the variable to apply the grover operator on.	required

Returns: None