Skip to main content

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.

View on GitHub

Open this notebook in GitHub to run it yourself
The quantum phase estimation (QPE) function estimates the phase of an eigenvector of a unitary function. More precisely, given a unitary function FF and an input containing a quantum variable with a state ∣ψ⟩|\psi\rangle such that F(∣ψ⟩)=e2πiν∣ψ⟩F(|\psi\rangle)=e^{2\pi i\nu}|\psi\rangle, the phase estimation function outputs an estimation of ν\nu as a fixed-point binary number. Phase estimation is frequently used as a subroutine in other quantum algorithms such as Shor’s algorithm and quantum algorithms for solving linear systems of equations (HHL algorithm). Theoretical details are in Ref. [1]. Function: qpe Arguments:
  • unitary: QCallable
  • The unitary operation for which the qpe estimation the eigenvalues
  • phase: QNum
  • The output of the qpe, holding the phase as a number in the range [0,1)[0, 1)
Function: qpe_flexible The function is suitable when one wants to specialize the way the power of a unitary is defined, other than using the naive power. For example it can be used to obtain the time evolution of hamiltonians or for Shor’s algorithm. Arguments:
  • unitary_with_power: QCallable[CInt]
  • Power of a unitary.
Accepts as argument the power of the unitary to apply.
  • phase: QNum

​
Examples

​

​
Example 1: QPE of a function

This example shows how to perform a simple phase estimation:
  1. Initialize the state ∣3⟩|3\rangle over two qubits.
  2. Apply a phase estimation on the the controlled-RZ gate, represeneted by the unitary matrix:
(10000e−iλ2000010000eiλ2)\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & e^{-i\frac{\lambda}{2}} & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & e^{i\frac{\lambda}{2}} \end{pmatrix} The expected phase variable should encode λ4π\frac{\lambda}{4\pi}, the phase of the eigenvalue of the ∣3⟩|3\rangle state. Choosing λ=π\lambda = \pi, the expected result is 14\frac{1}{4}, represented in binary by 01. 
from classiq import *
from classiq.qmod.symbolic import pi

QPE_RESOLUTION = 2


@qfunc
def main(
    state: Output[QArray[QBit]],
    phase: Output[QNum[QPE_RESOLUTION, UNSIGNED, QPE_RESOLUTION]],
):
    allocate(phase)
    allocate(2, state)

    X(state[0])
    X(state[1])

    qpe(unitary=lambda: CRZ(pi, state[0], state[1]), phase=phase)


qmod = create_model(main)


qprog = synthesize(qmod)
Show the actual results: 
result = execute(qprog).result_value()
print("Results:", result.parsed_counts)
Output:

Results: [{'state': [1, 1], 'phase': 0.25}: 2048]

​

​
Example 2: Flexible QPE

The following examples will specifiy directly how to take powers in the QPE. The unitary function is suzuki_trotter, where the number of repetitions will be
  1. In the case of diagonal hamiltonian it be exact exponentiation of the hamiltoian.
Take the following matrix: (0000014000012000034)\begin{pmatrix} 0 & 0 & 0 & 0 \\ 0 & \tfrac{1}{4} & 0 & 0 \\ 0 & 0 & \tfrac{1}{2} & 0 \\ 0 & 0 & 0 & \tfrac{3}{4} \\ \end{pmatrix} Represented by the hamiltonian: H=−18Z0I1−14I0Z1+38I0I1H = -\frac{1}{8}Z_0I_1 - \frac{1}{4}I_0Z_1 + \frac{3}{8}I_0I_1 
QPE_RESOLUTION = 2

HAMILTONIAN = [
    PauliTerm(pauli=[Pauli.I, Pauli.Z], coefficient=-0.125),
    PauliTerm(pauli=[Pauli.Z, Pauli.I], coefficient=-0.25),
    PauliTerm(pauli=[Pauli.I, Pauli.I], coefficient=0.375),
]


@qfunc
def main(
    state: Output[QArray[QBit]],
    phase: Output[QNum[QPE_RESOLUTION, UNSIGNED, QPE_RESOLUTION]],
):
    allocate(2, state)
    allocate(phase)

    hadamard_transform(state)
    qpe_flexible(
        lambda power: suzuki_trotter(
            HAMILTONIAN,
            evolution_coefficient=-2 * pi * (power),
            order=1,
            repetitions=1,
            qbv=state,
        ),
        phase,
    )


qmod = create_model(main)


qprog = synthesize(qmod)
Show the actual results: 
result = execute(qprog).result_value()
print("Results:", result.parsed_counts)
Output:

Results: [{'state': [0, 0], 'phase': 0.0}: 554, {'state': [1, 1], 'phase': 0.75}: 517, {'state': [1, 0], 'phase': 0.25}: 516, {'state': [0, 1], 'phase': 0.5}: 461]

​
References

[1] A. Yu. Kitaev Barenco et al, Quantum Measurements and the Abelian Stabilizer Problem, (1995). https://doi.org/10.48550/arXiv.quant-ph/9511026