Quantum Imaginary-Time Evolution#

QITE(qarg, U_0, exp_H, s, k, method='GC')[source]#

Performs Double-Braket Quantum Imaginary-Time Evolution (DB-QITE). Given a Hamiltonian Operator $H$ , this method implements the unitary $U_{k}$ that is recursively defined by either of

Group commutator (GQ) approximation:

U_{k + 1} = e^{i \sqrt{s_{k}} H} e^{i \sqrt{s_{k}} ω_{k}} e^{- i \sqrt{s_{k}} H} U_{k}

Higher-order product formula (HOPF) approximation:

U_{k + 1} = e^{i ϕ \sqrt{s_{k}} H} e^{i ϕ \sqrt{s_{k}} ω_{k}} e^{- i \sqrt{s_{k}} H} e^{- i (1 + ϕ) \sqrt{s_{k}} ω_{k}} e^{i (1 - ϕ) \sqrt{s_{k}} H} U_{k}

where $e^{- i t ω_{k}} = U_{k} e^{i t | 0 ⟩ ⟨ 0 |} U_{k}^{†}$ is the refection around the state $| ω_{k} ⟩ = U_{k} | 0 ⟩$ .

Parameters:

qargQuantumVariable or QuantumArray: The quantum argument on which quantum imaginary time evolution is performed.
U_0function: A Python function that takes a QuantumVariable or QuantumArray qarg as input, and prepares the initial state.
exp_Hfunction: A Python function that takes a QuantumVariable or QuantumArray qarg and time t as input, and performs forward evolution $e^{- i t H}$ .
slist[float] or list[Sympy.Symbol]: A list of evolution times for each step.
kint: The number of steps.
methodstr, optional: The method for approximating the double-bracket flow (DBF). Available are GC and HOPF. The default is GC.

Examples

We utilize QITE to approximate the ground state energy of a Heisenberg chain. We start by defining the lattice graph $G$ :

import networkx as nx

# Create a graph
N = 4
G = nx.Graph()
G.add_edges_from([(k,k+1) for k in range(N-1)]) 

Next, we set up the Heisenberg Hamiltonian and calculate the ground state energy classically:

from qrisp.operators import X, Y, Z

def create_heisenberg_hamiltonian(G):
    H = sum(X(i)*X(j)+Y(i)*Y(j)+Z(i)*Z(j) for (i,j) in G.edges())
    return H

H = create_heisenberg_hamiltonian(G)
print(H)
print(H.ground_state_energy())

As explained in this example, a suitable initial approximation for the ground state is given by a tensor product of singlet states $\frac{1}{\sqrt{2}} (| 10 ⟩ - | 01 ⟩)$ corresponding to a maximal matching of the graph $G$ . Accordingly, we define the function U_0:

from qrisp import QuantumVariable   
from qrisp.vqe.problems.heisenberg import create_heisenberg_init_function

M = nx.maximal_matching(G)
U_0 = create_heisenberg_init_function(M)

qv = QuantumVariable(N)
U_0(qv)
E_0 = H.get_measurement(qv)
print(E_0)

For the function exp_H that performs forward evolution $e^{- i t H}$ , we use the trotterization method with 5 Trotter steps:

def exp_H(qv, t):
    H.trotterization(method='commuting')(qv,t,5)

With all the necessary ingredients, we use QITE to approximate the ground state:

import numpy as np
import sympy as sp
from qrisp.qite import QITE

steps = 4
s_values = np.linspace(.01,.3,10)

theta = sp.Symbol('theta')
optimal_s = [theta]
optimal_energies = [E_0]

for k in range(1,steps+1):

    # Perform k steps of QITE
    qv = QuantumVariable(N)
    QITE(qv, U_0, exp_H, optimal_s, k)
    qc = qv.qs.compile()

    # Find optimal evolution time 
    # Use "precompliled_qc" keyword argument to avoid repeated compilation of the QITE circuit
    energies = [H.get_measurement(qv,subs_dic={theta:s_},precompiled_qc=qc,diagonalisation_method='commuting') for s_ in s_values]
    index = np.argmin(energies)
    s_min = s_values[index]

    optimal_s.insert(-1,s_min)
    optimal_energies.append(energies[index])

print(optimal_energies)

Finally, we visualize the results:

import matplotlib.pyplot as plt

evolution_times = [sum(optimal_s[i] for i in range(k)) for k in range(steps+1)]

plt.xlabel('Evolution time', fontsize=15, color='#444444')
plt.ylabel('Energy', fontsize=15, color='#444444')
plt.axhline(y=H.ground_state_energy(), color='#6929C4', linestyle='--', linewidth=2, label='Exact energy')
plt.plot(evolution_times, optimal_energies, c='#20306f', marker="o", linestyle='solid', linewidth=3, zorder=3, label='DB-QITE')
plt.legend(fontsize=12, labelcolor='linecolor')
plt.tick_params(axis='both', labelsize=12)
plt.grid()
plt.show()

In the Examples, we also show how to solve MaxCut with QITE.