A - OpenVQE Notebooks | OpenVQE

Circuit-based quantum programming

Mon, 01 Jan 0001 00:00:00 +0000

This is the training session for the preliminary understanding about QLM language

Usage

Creating a bell pair

Let’s us create a Bell pair

 1from qat.lang import Program, H, CNOT, X, S
 2
 3# Create a Program
 4qprog = Program()
 5nbqbits = 2
 6qbits = qprog.qalloc(nbqbits)
 7
 8H(qbits[0])
 9CNOT(qbits[0], qbits[1])
10
11# Export this program into a quantum circuit
12circuit = qprog.to_circ()
13circuit.display()
14
15# Import a Quantum Processor Unit Factory (the default one)
16from qlmaas.qpus import get_default_qpu
17# from qlmaas.qpus import get_default_qpu to run on the QAPTIVA appliance
18qpu = get_default_qpu()
19
20# Create a job
21job = circuit.to_job(nbshots=100)
22result = qpu.submit(job)
23
24# Iterate over the final state vector to get all final components
25for sample in result:
26 print("State %s amplitude %s, %s (%s)" % (sample.state, sample.amplitude, sample.probability, sample.err))

Result

1State |00> amplitude None, 0.48 (0.05021167315686783)
2State |11> amplitude None, 0.52 (0.05021167315686783)

More advanced features:

nbshots in job
Measure only certain qubits
Difference between sample.amplitude and sample.probability
Difference between final measure and intermediate measure

Intermediate measurements

 1qprog = Program()
 2nbqbits = 2
 3qbits = qprog.qalloc(nbqbits)
 4H(qbits[0])
 5qprog.measure(qbits[0])
 6CNOT(qbits)
 7circuit = qprog.to_circ()
 8circuit.display()
 9
10
11qpu = get_default_qpu()
12job = circuit.to_job(nbshots=5, aggregate_data=False)
13result = qpu.submit(job)
14
15for sample in result:
16 print(sample.state, sample.intermediate_measurements)

Result

1|11> [IntermediateMeasurement(cbits=[True], gate_pos=1, probability=0.4999999999999999)]
2|00> [IntermediateMeasurement(cbits=[False], gate_pos=1, probability=0.4999999999999999)]
3|00> [IntermediateMeasurement(cbits=[False], gate_pos=1, probability=0.4999999999999999)]
4|11> [IntermediateMeasurement(cbits=[True], gate_pos=1, probability=0.4999999999999999)]
5|11> [IntermediateMeasurement(cbits=[True], gate_pos=1, probability=0.4999999999999999)]

Useful tools for gates

You can check all the gates avalable in the myQLM demo: . You can also create personal gates

Quantum routines

 1from qat.lang.AQASM import Program, QRoutine, H, CNOT
 2
 3routine = QRoutine()
 4routine.apply(H, 0)
 5routine.apply(CNOT, 0, 1)
 6
 7prog = Program()
 8qbits = prog.qalloc(4)
 9for _ in range(3):
10 for bl in range(2):
11 prog.apply(routine, qbits[2*bl:2*bl+2])
12prog.apply(routine, qbits[0], qbits[2])
13circ = prog.to_circ()
14circ.display()

1circ = prog.to_circ(box_routines=True)
2circ.display()

Using typed registers

 1## quantum adder
 2from qat.lang.AQASM.classarith import add
 3prog = Program()
 4reg_a = prog.qalloc(2, QInt)
 5reg_b = prog.qalloc(2, QInt)
 6
 7X(reg_a[0])
 8X(reg_b[1])
 9
10# |a> = |10> ("2") and |b>=|01> ("1") 
11# expect |a+b>|b> = |11>|01>
12prog.apply(add(2, 2), reg_a, reg_b)
13circ = prog.to_circ(inline=False)
14circ.display()
15
16
17qpu = get_default_qpu()
18result = qpu.submit(circ.to_job())
19for sample in result:
20 print(sample.state, sample.amplitude)

Variational computations

framework: Variational Quantum Eigensolver (VQE) is to find eigenvalues of a Hamiltonian

Our task: VQE on the following Ising model:

$$ H = \sum_{i=1}^{N} a_i X_i + \sum_{i=1}^{N} \sum_{j=1}^{i-1} J_{ij} Z_i Z_j $$

… with a “hardware-efficient” ansatz.

 1import numpy as np
 2from qat.core import Observable, Term
 3
 4def ising(N):
 5 np.random.seed(123)
 6
 7 terms = []
 8
 9 # Generate random coefficients for the transverse field term (X)
10 a_coefficients = np.random.random(N)
11 for i in range(N):
12 term = Term(coefficient=a_coefficients[i], pauli_op="X", qbits=[i])
13 terms.append(term)
14
15 # Generate random coefficients for the interaction term (ZZ)
16 J_coefficients = np.random.random((N, N))
17 for i in range(N):
18 for j in range(i):
19 if i != j: # avoid duplicate terms
20 term = Term(coefficient=J_coefficients[i, j], pauli_op="ZZ", qbits=[i, j])
21 terms.append(term)
22 ising = Observable(N, pauli_terms=terms, constant_coeff=0.0)
23 return ising

If we have the number of qubit = 4

1nqbits = 4
2model = ising(nqbits)
3print(model)

Result

 10.6964691855978616 * (X|[0]) +
 20.28613933495037946 * (X|[1]) +
 30.2268514535642031 * (X|[2]) +
 40.5513147690828912 * (X|[3]) +
 50.48093190148436094 * (ZZ|[1, 0]) +
 60.4385722446796244 * (ZZ|[2, 0]) +
 70.05967789660956835 * (ZZ|[2, 1]) +
 80.18249173045349998 * (ZZ|[3, 0]) +
 90.17545175614749253 * (ZZ|[3, 1]) +
100.5315513738418384 * (ZZ|[3, 2])

Applying for Hardware-Efficient Anazt

 1from qat.lang.AQASM import Program, QRoutine, RY, CNOT, RX, Z, H, RZ
 2from qat.core import Observable, Term, Circuit
 3from qat.lang.AQASM.gates import Gate
 4import matplotlib as mpl
 5import numpy as np
 6from typing import Optional, List
 7import warnings
 8
 9def HEA_Linear(
10 nqbits: int,
11 #theta: List[float],
12 n_cycles: int = 1,
13 rotation_gates: List[Gate] = None,
14 entangling_gate: Gate = CNOT,
15) -> Circuit: #linear entanglement
16 """
17 This Hardware Efficient Ansatz has the reference from "Nonia Vaquero Sabater et al. Simulating molecules
18 with variational quantum eigensolvers. 2022" -Figure 6 -Link
19 "https://uvadoc.uva.es/bitstream/handle/10324/57885/TFM-G1748.pdf?sequence=1"
20
21 Args:
22 nqbits (int): Number of qubits of the circuit.
23 n_cycles (int): Number of layers.
24 rotation_gates (List[Gate]): Parametrized rotation gates to include around the entangling gate. Defaults to :math:`RY`. Must
25 be of arity 1.
26 entangling_gate (Gate): The 2-qubit entangler. Must be of arity 2. Defaults to :math:`CNOT`.
27 """
28
29 if rotation_gates is None:
30 rotation_gates = [RZ]
31
32 n_rotations = len(rotation_gates)
33
34 prog = Program()
35 reg = prog.qalloc(nqbits)
36 theta = [prog.new_var(float, rf"\theta_{{{i}}}") for i in range(n_rotations * (nqbits + 2 * (nqbits - 1) * n_cycles))]
37
38 ind_theta = 0
39
40 for i in range(nqbits):
41
42 for rot in rotation_gates:
43
44 prog.apply(rot(theta[ind_theta]), reg[i])
45 ind_theta += 1
46
47 for k in range(n_cycles):
48
49 for i in range(nqbits - 1):
50 prog.apply(CNOT, reg[i], reg[i+1])
51
52 for i in range(nqbits):
53 for rot in rotation_gates:
54
55 prog.apply(rot(theta[ind_theta]), reg[i])
56 ind_theta += 1
57
58 return prog.to_circ()

Display

1n_layers = 4
2circ_Linear = HEA_Linear(nqbits, n_layers, [RX,RZ], CNOT)
3circ_Linear.display()

Variational Quantum Eigensolver

 1from qat.plugins import ScipyMinimizePlugin
 2qpu = get_default_qpu()
 3optimizer_scipy = ScipyMinimizePlugin(method="BFGS", # Methods
 4 tol=1e-6,
 5 options={"maxiter": 200},
 6 x0=np.random.rand(n_layers*nqbits))
 7stack1 = optimizer_scipy | qpu
 8
 9import numpy as np
10import matplotlib.pyplot as plt
11
12# construct a (variational) job with the variational circuit and the observable
13job = circ_Linear.to_job(observable=model)
14# we submit the job and print the optimized variational energy (the exact GS energy is -3)
15result1 = stack1.submit(job)
16print(f"Minimum VQE energy ={result1.value}")
17plt.plot(eval(result1.meta_data['optimization_trace']))
18plt.xlabel("VQE iterations")
19plt.ylabel("energy")
20plt.grid()
21plt.savefig("newfigure.pdf")

VQE - Unitary Coupled Cluster

This part is adapted from myQLM documentation demo

The Variational Quantum Eigensolver method solves the following minimization problem: $$ E = \min_{\vec{\theta}}\; \langle \psi(\vec{\theta}) \,|\, \hat{H} \,|\, \psi(\vec{\theta}) \rangle $$

Here, we use a Unitary Coupled Cluster trial state, of the form: $$ |\psi(\vec{\theta})\rangle = e^{\hat{T}(\vec{\theta}) - \hat{T}^\dagger(\vec{\theta})} |0\rangle $$

where $\hat{T}(\theta)$ is the cluster operator: $$ \hat{T}(\vec{\theta}) = \hat{T}_1(\vec{\theta}) + \hat{T}_2(\vec{\theta}) + \cdots $$

where $$ \hat{T}_1 = \sum_{a\in U}\sum_{i \in O} \theta_a^i\, \hat{a}_a^\dagger \hat{a}_i \qquad \hat{T}_2 = \sum_{a>b\in U}\sum_{i>j\in O} \theta_{a, b}^{i, j}\, \hat{a}^\dagger_a \hat{a}^\dagger_b \hat{a}_i \hat{a}_j \qquad \cdots $$

$O$ is the set of occupied orbitals and $U$, the set of unoccupied ones.

 1from qat.fermion.chemistry.pyscf_tools import perform_pyscf_computation
 2
 3geometry = [("H", (0.0, 0.0, 0.0)), ("H", (0.0, 0.0, 0.7414))]
 4basis = "sto-3g"
 5spin = 0
 6charge = 0
 7
 8(
 9 rdm1,
10 orbital_energies,
11 nuclear_repulsion,
12 n_electrons,
13 one_body_integrals,
14 two_body_integrals,
15 info,
16) = perform_pyscf_computation(geometry=geometry, basis=basis, spin=spin, charge=charge, run_fci=True)
17
18print(
19 f" HF energy : {info['HF']}\n",
20 f"MP2 energy : {info['MP2']}\n",
21 f"FCI energy : {info['FCI']}\n",
22)
23print(f"Number of qubits before active space selection = {rdm1.shape[0] * 2}")
24
25nqbits = rdm1.shape[0] * 2
26print("Number of qubits = ", nqbits)

If we make the plot amongst the HF, MP2 with FCI is the reference we obtain

In these such cases, methods like Hartree-Fock (HF) and Møller-Plesset perturbation theory (MP2) become less accurate compared to Full Configuration Interaction (FCI).However in this case for Hydrogen this difference is barely visible, because the HF energy is totally on the same path as FCI from the beginning till the minimum energy point then the curve begins to experience the bond dissociation when the two hydrogen molecules move far each other

Following to show the molecular Hamiltonian

1from qat.fermion.chemistry import MolecularHamiltonian, MoleculeInfo
2
3# Define the molecular hamiltonian
4mol_h = MolecularHamiltonian(one_body_integrals, two_body_integrals, nuclear_repulsion)
5
6print(mol_h)

MolecularHamiltonian(

constant_coeff : 0.7137539936876182
integrals shape
- one_body_integrals : (2, 2)
- two_body_integrals : (2, 2, 2, 2) )

Computation of cluster operators $T$ and good guess $\vec{\theta}_0$

We now construct the cluster operators (cluster_ops) defined in the introduction part as $\hat{T}(\vec{\theta})$, as well as a good starting parameter $\vec{\theta}$ (based on the second order Møller-Plesset perturbation theory).

 1from qat.fermion.chemistry.ucc import guess_init_params, get_hf_ket, get_cluster_ops
 2
 3# Computation of the initial parameters
 4theta_init = guess_init_params(
 5 mol_h.two_body_integrals,
 6 n_electrons,
 7 orbital_energies,
 8)
 9
10print(f"List of initial parameters : {theta_init}")
11
12# Define the initial Hartree-Fock state
13ket_hf_init = get_hf_ket(n_electrons, nqbits=nqbits)
14
15# Compute the cluster operators
16cluster_ops = get_cluster_ops(n_electrons, nqbits=nqbits)
17
18
19from qat.fermion.transforms import transform_to_jw_basis # , transform_to_bk_basis, transform_to_parity_basis
20from qat.fermion.transforms import recode_integer, get_jw_code # , get_bk_code, get_parity_code
21
22# Compute the ElectronicStructureHamiltonian
23H = mol_h.get_electronic_hamiltonian()
24
25# Transform the ElectronicStructureHamiltonian into a spin Hamiltonian
26H_sp = transform_to_jw_basis(H)
27
28# Express the cluster operator in spin terms
29cluster_ops_sp = [transform_to_jw_basis(t_o) for t_o in cluster_ops]
30
31# Encoding the initial state to new encoding
32hf_init_sp = recode_integer(ket_hf_init, get_jw_code(H_sp.nbqbits))
33
34print(H_sp)

 1(-0.09886396933545824+0j) * I^4 +
 2(0.16862219158920938+0j) * (ZZ|[0, 1]) +
 3(0.12054482205301799+0j) * (ZZ|[0, 2]) +
 4(0.165867024105892+0j) * (ZZ|[1, 2]) +
 5(0.165867024105892+0j) * (ZZ|[0, 3]) +
 6(0.17119774903432972+0j) * (Z|[0]) +
 7(0.12054482205301799+0j) * (ZZ|[1, 3]) +
 8(0.17119774903432972+0j) * (Z|[1]) +
 9(0.04532220205287398+0j) * (XYYX|[0, 1, 2, 3]) +
10(-0.04532220205287398+0j) * (XXYY|[0, 1, 2, 3]) +
11(-0.04532220205287398+0j) * (YYXX|[0, 1, 2, 3]) +
12(0.04532220205287398+0j) * (YXXY|[0, 1, 2, 3]) +
13(0.17434844185575668+0j) * (ZZ|[2, 3]) +
14(-0.22278593040418448+0j) * (Z|[2]) +
15(-0.22278593040418448+0j) * (Z|[3])

Applying the trotterization method

 1from qat.lang.AQASM import Program, X
 2from qat.fermion.trotterisation import make_trotterisation_routine
 3prog = construct_ucc_ansatz(cluster_ops_sp, hf_init_sp, n_steps=1)
 4
 5prog = Program()
 6reg = prog.qalloc(H_sp.nbqbits)
 7
 8# Initialize the Hartree-Fock state into the Program
 9for j, char in enumerate(format(hf_init_sp, "0" + str(H_sp.nbqbits) + "b")):
10 if char == "1":
11 prog.apply(X, reg[j])
12
13# Define the parameters to optimize
14theta_list = [prog.new_var(float, "\\theta_{%s}" % i) for i in range(len(cluster_ops))]
15
16# Define the parameterized Hamiltonian
17cluster_op = sum([theta * T for theta, T in zip(theta_list, cluster_ops_sp)])
18
19# Trotterize the Hamiltonian (with 1 trotter step)
20qrout = make_trotterisation_routine(cluster_op, n_trotter_steps=1, final_time=1)
21
22prog.apply(qrout, reg)
23circ = prog.to_circ()
24
25prog = construct_ucc_ansatz(cluster_ops_sp, hf_init_sp, n_steps=1)
26circ = prog.to_circ()
27circ.display()

For the molecule $H_2$, it has double qubit excitation and by using the UCC method to simulate on this molecule, I obtain the the circuit construction as bellow with the interprobility with Qiskit and this construction is based on the staire-case algorithms

Using the Gradient Based Optimizer to solve the VQE

The graphic is show:

 1job = circ.to_job(observable=H_sp, nbshots=0)
 2
 3from qat.qpus import get_default_qpu
 4from qat.plugins import ScipyMinimizePlugin
 5
 6optimizer_scipy = ScipyMinimizePlugin(method="BFGS", tol=1e-3, options={"maxiter": 1000}, x0=theta_init)
 7qpu = optimizer_scipy | get_default_qpu()
 8result = qpu.submit(job)
 9
10print("Minimum energy =", result.value)

Minimum energy = -1.1372692847285149 \

Make the plot

 1%matplotlib inline
 2import matplotlib.pyplot as plt
 3
 4plt.plot(eval(result.meta_data["optimization_trace"]), lw=3)
 5plt.plot(
 6 [info["FCI"] for _ in enumerate(eval(result.meta_data["optimization_trace"]))],
 7 "--k",
 8 label="FCI",
 9)
10
11plt.xlabel("Steps")
12plt.ylabel("Energy")
13plt.grid()

Reference

Made by Eviden "myQLM – Quantum Python Package"

About the author

Huy Binh TRAN
Master 2 Quantum Devices at Institute Paris Polytechnic, France
LinkedIn

MyQLM-Fermion

Mon, 01 Jan 0001 00:00:00 +0000

A submodule of myQLM-fermion is specifically devoted to quantum chemistry. It provides tools for selecting active spaces (based on natural-orbital occupation numbers), generating cluster operators (and thus, via the aforementioned Trotterization tools, UCC-type ansätze), and initial guesses for their variational parameters. The architecture of QLM and myQLM-fermion allows for experts in a given field to construct their own advanced modules with the QLM building blocks.
The key building block of quantum chemistry computations is the Hamiltonian. On QLM, it is described by an object ElectronicStructureHamiltonian

1 from qat . fermion import ElectronicStructureHamiltonian
2 hamiltonian = ElectronicStructureHamiltonian (h , g)

where h and g are the tensors ℎ_pq and ℎ_pqrs. Such an object also describes cluster operators

1from qat . fermion import get_cluster_ops
2cluster_ops = get_cluster_ops ( n_electrons , nqbits = nqbits )

creates the list containing the sets of single excitations and double excitations wnich can be readily converted to a spin (or qubit) representation using various fermion-spin transforms:

 1
 2 # Jordan - Wigner
 3 from qat . fermion . transforms import transform_to_jw_basis
 4 hamiltonian_jw = transform_to_jw_basis ( hamiltonian )
 5 cluster_ops_jw = [ transform_to_jw_basis ( t_o ) for t_o in cluster_ops ]
 6
 7 # Bravyi - Kitaev
 8 from qat . fermion . transforms import transform_to_bk_basis
 9 hamiltonian_bk = transform_to_bk_basis ( hamiltonian )
10 cluster_ops_bk = [ transform_to_bk_basis ( t_o ) for t_o in cluster_ops ]

With these qubit operators, one can then easily contruct a imple UCCSD ansatz via trotterization of the exponential of the parametric cluster operator defined as cluster_ops_jw

 1from qat . lang . AQASM import Program , X
 2from qat . fermion . trotterisation import make_trotterisation_routine
 3
 4prog = Program ()
 5reg = prog . qalloc ( nqbits )
 6# Create Hartree - Fock state ( assuming JW representation )
 7
 8for qb in range ( n_electrons ) :
 9prog . apply (X , reg [ qb ])
10
11 # Define the full cluster operator with its parameters
12theta_list = [ prog . new_var (float , "\\ theta_ {%s}" % i) for i in range (len ( cluster_ops_jw ) )]
13cluster_op = sum ([ theta * T for theta , T in zip( theta_list , cluster_ops_jw ) ])
14
15# Trotterize the Hamiltonian ( with 1 trotter step )
16qrout = make_trotterisation_routine ( cluster_op , n_trotter_steps =1 , final_time =1)
17prog . apply ( qrout , reg )
18circ = prog . to_circ ()

The circuit we constructed, circ, is a variational circuit that creates a variational wavefunction. Its parameters can be optimized to minimize the variational energy which can be done by a simple VQE loop with the UCC method

A simulation starts by constructing a fermionic Hamiltonian with particularly straightforward initialization as a classical mean-field state; most often as a HF product state $$ \ket{\psi_{HF}} $$ . This is required as the reference preparation for the UCC-chemically-inspired ansatz.
The fermionic Hamiltonian is mapped into a qubit Hamiltonian, represented as a sum of Pauli strings: $$ H = \sum_j \alpha_j \prod_i \sigma_i^j, $$ where $$ \sigma_i^j \in \{ \text{I}, X, Y, Z \} $$ .
A quantum circuit implementing the unitary operator $$ U(\vec{{\bm{\theta}} }) $$ is applied to $$ \ket{\psi_{HF}} $$ , mapping the initial state to a parameterized “Ansatz” state: $$ |\psi(\vec{{\bm{\theta}}}) \rangle = U(\vec{{\bm{\theta}}}) |\psi_{HF} \rangle. $$ Thus, the trial state is prepared on a quantum computer as a quantum circuit consisting of parameterized gates.
One measures the expectation value of the energy: $$ \langle H \rangle = \langle \psi_{HF}(\vec{{\bm{\theta}}}_0) | H | \psi_{HF}(\vec{{\bm{\theta}}}_0) \rangle. $$ At iteration $$ k $$ , the energy of the Hamiltonian is computed by measuring every Hamiltonian term: $$ \langle \psi(\vec{{\bm{\theta}}_k}) | P_j | \psi(\vec{{\bm{\theta}}_k}) \rangle $$ on a quantum computer and adding them on a classical computer.
The energy $$ E(\vec{{\bm{\theta}}_k}) $$ is fed into the classical algorithm that updates parameters for the next step of optimization $$ \vec{{\bm{\theta}}}_{k+1} $$ according to the chosen optimization algorithm.

 1# create a quantum job containing the variational circuit and the Hamiltonian
 2job = circ . to_job ( observable = hamiltonian_jw , nbshots =0)
 3# import a plugin to perform the optimization
 4from qat . plugins import scipyMinimizePlugin
 5optimizer_scipy = scipyMinimizePlugin ( method =" COBYLA ", tol =1e -3 , options ={" maxiter ": 1000} , x0 = theta_init )
 6
 7# import a QPU to execute the quantum circuit
 8from qat . qpus import get_default_qpu
 9
10# define the quantum stack
11stack = optimizer_scipy | get_default_qpu ()
12# submit the job and read the result
13result = stack . submit ( job )
14print (" Minimum energy =", result . value )

Active space selection

In the context of chemical properAmiensties regardless of small/large molecular systems, the lowest orbitals are assumed to be frozen and fully occupied, contributing to the core energy. The highest orbitals, on the other hand, are considered non-active and empty. Mathematically, the Quantum Learning Machine (QLM) \cite{haidar2023open} defines two subspaces: active orbitals ($\mathcal{A}$) and occupied orbitals ($\mathcal{O}$). By calculating the eigenvalues of the molecule’s reduced density matrix, the Natural Orbital Occupation Numbers $n_i$ for each molecular orbital $i$ are obtained. We use the QLM library, which contains a function that enables us to determine the population of the two subspaces, through upper and lower thresholds $\epsilon_1$ and $\epsilon_2$ to select the relevant orbitals. In fact, the choice of $\epsilon_1$ and $\epsilon_2$ is the choice of the active orbitals.

$$ \mathcal{A} = \{i \ | \ n_i \in [\epsilon_2,2-\epsilon_1] \} \cup \{i \ | \ n_i \geq 2 - \epsilon_1, \ 2(i+1) \geq N_{elec} \} $$$$ \mathcal{O} = \{i \ | \ n_i \geq 2 - \epsilon_1, \ 2(i+1) < N_{elec} \}. $$

The QLM function can then evaluate the one-body term and the core energy.

$$ \forall p,q \in \mathcal{A} $$$$ h_{pq} \text{-----} h_{pq} + \sum_{i \in \mathcal{O}} 2h_{ipqi} - h_{ipiq}, $$$$ E_{\rm core} \text{-----} E_{\rm core} + \sum_{i \in \mathcal{O}} h_{ii} + \sum_{i,j \in \mathcal{O}} 2h_{ijji} - h_{ijij}. $$

To apply CAS on UCCSD ansatz, it is required to determine the total number of electrons $n_{e}$ and the subspace of spin orbitals $\mathcal{O}$ in a molecule. Then we can determine the number of active electrons $n_{e_{act}} = n_{e} - 2|\mathcal{O}|$ as well as the number of electrons that are distributed over the active orbitals. Therefore $\mathcal{A}$ is divided into two sub-spaces : $\mathcal{I'}$ which contains the unoccupied active orbitals and $\mathcal{O'}$ containing the occupied active orbitals, and the anti-Hermitian operator is created:

$\forall i,j,p,q \in \mathcal{I'}^{2}\times\mathcal{O'}^{2}$

$$ T^{(\mathrm{CAS})}_{\mathrm{UCCSD}} = \sum_{i\in \mathcal{O^{\prime }} , p\in \mathcal{I^{\prime }}} \theta^{p}_{i} (\hat{a}^{\dagger }_{i} \hat{a}_{p} -\hat{a}^{\dagger }_{p} \hat{a}_{i}) + + \sum_{i,j\in \mathcal{O^{\prime }}, p,q\in \mathcal{I^{\prime }}} \theta^{pq}_{ij} (\hat{a}^{\dagger }_{i} \hat{a}^{\dagger }_{j} \hat{a}_{p} \hat{a}_{q} - \hat{a}^{\dagger }_{p} \hat{a}^{\dagger }_{q} \hat{a}_{i} \hat{a}_{j}) $$

Visualization of spatial orbitals in LiH molecule uisng sto-3g basis-set: 2 HUMOs and 4 LUMOs.

In this method we have the figure of the plot with respect to certain number of qubit with respect to the orbital energy

 1import matplotlib.pyplot as plt
 2
 3# Sample data (you can replace this with your actual data)
 4noons = list(reversed(noons))
 5
 6# Define the threshold couples and their corresponding labels
 7threshold_couples = [
 8 (0.02, 0.004, "4 qubit / second"),
 9 (0.02e-6, 0.002, "6 qubit"),
10 (0.02, 0.001, "10 qubit"),
11 (0.02, 0.001e-1, "12 qubit"),
12]
13
14# Initialize lists to store optimization results
15results = []
16
17# Iterate through different threshold couples
18for threshold_1, threshold_2, label in threshold_couples:
19 mol_h_active, active_indices, occupied_indices = mol_h_new_basis.select_active_space(
20 noons=noons, n_electrons=n_elec, threshold_1=threshold_1, threshold_2=threshold_2
21 )
22
23 # Rest of your code for getting theta_list and performing the optimization...
24
25 # Store the result
26 result = qpu.submit(job)
27 results.append((result, label))
28
29# Create the plot for UCCSD-VQE with multiple threshold couples
30plt.figure(figsize=(10, 6))
31for result, label in results:
32 plt.plot(eval(result.meta_data["optimization_trace"]), label=f"UCCSD-VQE ({label})", lw=3)
33
34plt.plot(
35 [info["FCI"] for _ in range(len(eval(result.meta_data["optimization_trace"])))],
36 "--k",
37 label="FCI",
38)
39plt.legend(loc="best")
40plt.xlabel("Steps")
41plt.ylabel("Energy")
42plt.grid()
43plt.title("UCCSD-VQE Optimization with Different Thresholds")
44plt.show()

If we make the plot with the threshold

 1FCI_energy = info['FCI']
 2
 3markers = ['o', 'x', '^', 's']
 4colors = ['firebrick', 'green', 'black', 'red']
 5
 6plt.figure(figsize=(10, 6))
 7for (result, label), marker, color in zip(results, markers, colors):
 8 optimization_trace = eval(result.meta_data["optimization_trace"])
 9 errors = [abs(energy - FCI_energy) for energy in optimization_trace]
10 steps = list(range(len(errors)))
11 plt.errorbar(steps, errors, fmt=marker, color=color, elinewidth=1, capsize=2, label=f"{label}")
12
13# Plot the chemical accuracy line
14plt.axhline(y=1.593e-3, color='darkblue', linestyle='-', label="Chemical Accuracy")
15
16plt.yscale('log')
17plt.legend(loc="best")
18plt.xlabel("Steps")
19plt.ylabel("Energy Error (Log Scale)")
20plt.grid()
21plt.title("UCCSD-VQE Optimization Error with Different Thresholds")
22plt.show()

About the author

Huy Binh TRAN
Master 2 Quantum Devices at Institute Paris Polytechnic, France
LinkedIn

Observables

Mon, 01 Jan 0001 00:00:00 +0000

This is the training session for the preliminary understanding about QLM language for mostly in Quantum Chemistry

Class: Observable

This can be any hermitian or non-Hermitian operators

Stores a list of Pauli chains + their coefficients

$$ H\ =\ \sum_{k}^{} c_{k}P_{k}\ \text{with} \ P_{k}=I,X,Y,Z,XX,XZ,\ XYZ,... $$

Class: Term

This class contains a Pauli chain and its coefficient

 1from qat.core import Term, Observable
 2
 3# Define a term with 4 qubits and a Pauli string
 4term = Term(1.5, # coefficient
 5 "XXYZ", # Pauli chain for 4 qubits
 6 [0, 1, 2, 3]) # qubits on which each Pauli acts
 7
 8# Define an observable acting on 4 qubits with multiple terms
 9obs = Observable(4, # total number of qubits
10 pauli_terms=[Term(2.5, "ZZ", [0, 1]),
11 Term(1.0, "YX", [2, 3]),
12 Term(0.8, "XYZ", [0, 2, 3])])
13
14# Display the term and the observable
15print(term)
16print(obs)

Result with the Hamiltonian

$$H\ =\ 2.5\times Z_{0}Z_{1}+1\times Y_{2}X_{3}+0.8\times X_{0}Y_{2}Z_{3}$$

Term(_coeff=TNumber(is_abstract=False, type=1, int_p=None, double_p=1.5, string_p=None, matrix_p=None, serialized_p=None, complex_p=None), op='XXYZ', qbits=[0, 1, 2, 3], _do_validity_check=True)
2.5 * (ZZ|[0, 1]) +
1.0 * (YX|[2, 3]) +
0.8 * (XYZ|[0, 2, 3])

Transform to matrix representation to see that the Dense matrix is exponential in number of qubits

We can show its matrix representation for the Observable

1print(obs.to_matrix()) # a scipy sparse array
2print(obs.to_matrix(sparse=False)) # a numpy array

Dense matrix is exponential in number of qubits!

Class: Fermionic System

In the context of quantum chemistry, the hamiltonian is expressed in the fermionic second-quantized form witht the ‘$c$’ (small) for annihilation operator ‘$c^{\dag }$’ or creation operator

$$ H=\sum^{}_{p,q} h_{pq}c^{\dag }_{p}c_{q}+\frac{1}{2} \sum^{}_{p,q,r,s} h_{pqrs}c^{\dag }_{p}c^{\dag }_{q}c_{r}c_{s} $$

where $h_{pq}$ and $h_{pqrs}$ are the one and two electron integrals. The one-electron integrals are obtained from the kinetic energy and electron-nuclei interactions while the two-electron integrals are obtained from the electron-electron interactions, defined with the help of some basis functions.

1from qat.fermion import ElectronicStructureHamiltonian
2import numpy as np
3h_pq = np. array([[1., 2.],
4 [2., 0.11]])
5h_pqrs = np.zeros ((2, 2, 2, 2))
6h_pqrs[0, 1, 0, 1] = -8.0
7ham = ElectronicStructureHamiltonian(h_pq, h_pqrs)
8print (ham)

Result with the Hamiltonian

$$H = c_0^\dagger c_0 + 2c_0^\dagger c_1 + 2c_1^\dagger c_0 + 4c_0^\dagger c_0 c_1^\dagger c_1 $$

In the Fock space representation, the operator can be transformed to the qubit space by three main common mapping methods: Jordan-Wigner , Parity and Bravyi-Kitaev found more details in this . . It is currently unknown which encoding method is the most noise-resilient - i.e. best for NISQ experiments. Numerical studies aiming to compare the Jordan-Wigner and Bravyi-Kitaev mappings, has found that the BK transformations was at less as efficient as the JW one, in finding the ground states of molecular systems. Most commonly, we directly use the Jordan Wigner transformation as it is the most straightforward qubit encoding; thus it is a one to one correspondence between Slater determinants and computational basis qubit states:

1ham_spin = ham.to_spin("jordan-wigner")
2print (ham_spin)

(1.5550000000000002+0j) * I^2 +
(1+0j) * (XX|[0, 1]) +
(1+0j) * (YY|[0, 1]) +
(1+0j) * (ZZ|[0, 1]) +
(-1.5+0j) * (Z|[0]) +
(-1.055+0j) * (Z|[1])

Now that we have defined the Hamiltonian in spin representatin, we can already start playing with it. We can give a try for running exact diagonalization. Firstly we can convert our Hamiltonian operator into a sparse matrix

1model_matrix_sp = ham_spin.get_matrix(sparse=True)

Since this is just a regular scipy sparse matrix, we can just use any sparse diagonalization routine in there to find the eigenstates.

1from scipy.sparse.linalg import eigsh
2eigval, eigvec = eigsh(model_matrix_sp, k = 2)
3print("eigenvalues with scipy sparse:", eigval)
4E_gs = eigval[0]

eigenvalues with scipy sparse: [5.11 2.60390825]

Reference

Made by Eviden "myQLM – Quantum Python Package"

About the author

Huy Binh TRAN
Master 2 Quantum Devices at Institute Paris Polytechnic, France
LinkedIn

OpenVQE Overall

Mon, 01 Jan 0001 00:00:00 +0000

A Openvqe extension to create cards. Cards can be shown as links or as plain text.

Usage

Shortcodes Table

Options

Parameter	Description
`molecule_symbol`	molecule examples : H2 , H4 , H6 , LiH , H2O , CO , CO2 , NH3 etc …
`type_of_generator`	user can apply type of generators , such as: uccsd , quccsd , uccgsd , k- upccgsd , etc …
`transform`	user type Jordan wigner (JW), user can also type Bravyi - Kitaev or Parity basis.
`active`	user can use AS (Active Space) method - True or non active space - False

The user specifies these parameters in a class called MoleculeFactory. This class takes those parameters as input

1from openvqe . common_files . molecule_factory import MoleculeFactory
2# returns the properties of a molecule :
3r , geometry , charge , spin , basis = MoleculeFactory . get_parameters ( molecule_symbol = ’H2O ’)

define a function named as generate_hamiltonian that generates the electronic structure Hamiltonian (hamiltonian) and other properties such as the spin hamiltonian (for example hamiltonian_jw), number of electrons (n_els), the list contains the number of natural orbital occupation numbers (noons_full), the list of orbital energies (orb_energies_full) where the orbital energies are doubled due to spin degeneracy and info which is a dictionary that stores energies of some classical methods( such as Hartree-Fock, CCSD and FCI):

1Hamiltonian , hamiltonian_jw , n_els , noons_full , orb_energies_full , info = MoleculeFactory . generate_hamiltonian (
2molecule_symbol =’H2O ’, active = False , transform =’JW ’)

*Briefing about the geometry and energy level of H20 you can visualize the geometry of the molecule on the ORCA application

In addition to that, we define another function named as generate_cluster_ops() that takes as input the name of excitation generator user need (e.g., UCCSD, QUCCSD, UCCGSD, etc.) and internally it calls the file name generator_excitations.py which allows generate_cluster_ops() to return as output the size of pool excitations, fermionic operators, and JW transformed operators denoted in our code respectively as pool_size, cluster_ops and cluster_ops_jw:

 1from . generator_excitations import ( uccsd , quccsd , singlet_gsd , singlet_sd , singlet_upccgsd , spin_complement_gsd ,
 2spin_complement_gsd_twin )
 3pool_size , cluster_ops , cluster_ops_jw = MoleculeFactory . generate_cluster_ops ( molecule_symbol =’H2O ’,
 4type_of_generator =’ spin_complement_gsd ’, transform =’JW ’, active = False )
 5# in our example ’ spin_complement_gsd ’:
 6def generate_cluster_ops () :
 7 pool_size , cluster_ops , cluster_ops_jw = None , None , None
 8 if type_of_generator == ’ spin_complement_gsd ’:
 9 pool_size , cluster_ops , cluster_ops_jw = spin_complement_gsd ( n_el , n_orb ,’JW ’)
10# elif for other excitations (uccsd , quccsd , singlet_upccgsd ...)
11# ::::
12 return pool_size , cluster_ops , cluster_ops_jw

Once these are generated, we import them as input to the UCC-family and ADAPT modules. In the example of fermionic-ADAPT sub-module, we call the function fermionic_adapt_vqe() that takes as parameters the fermionic cluster operators, spin Hamiltonian, maximum number of gradients to be taken per iteration, the type of optimizer, tolerance, threshold of norm () and the maximum number of adaptive iterations:

 1from openvqe . adapt . fermionic_adapt_vqe import fermionic_adapt_vqe
 2# choose maximum number of gradients needed (1 ,2 ,3....)
 3n_max_grads = 1
 4# choose optimizer needed ( COBYLA , BFGS , SLSQP , Nelder - Mead etc ...)
 5optimizer = ’COBYLA ’
 6tolerance = 10**( -6)
 7# according to a given norm value we stop the ADAPT - VQE loop
 8type_conver = ’norm ’
 9threshold_needed = 1e -2
10# the maximum external number of iterations to complete the ADAPT - VQE under a given threshold_needed
11max_iterations = 35
12fci = info [’FCI ’]
13# sparse the Hamiltonian and cluster operators using myQLM - fermion tools obtained from MoleculeFactory , which are
14explicitly :
15hamiltonian_sparse = hamiltonian_jw . get_matrix ( sparse = True )
16cluster_ops_sparse = cluster_ops . get_matrix ( sparse = True )
17# reference_ket and hf_init_sp can be obtained from class MoleculeFactory ():
18reference_ket , hf_init_sp = MoleculeFactory . get_reference_ket ( hf_init , nbqbits , ’JW ’)
19# when all these parameters are satisfied , then fermionic -ADAPT - VQE function is:
20fermionic_adapt_vqe ( cluster_ops , hamiltonian_sparse , cluster_ops_sparse , reference_ket , h_sp , cluster_ops_jw ,
21hf_init_sp , n_max_grads , fci , optimizer , tolerance , type_conver = type_conver , threshold_needed =
22threshold_needed , max_external_iterations = max_iterations )

The function fermionic_adapt_vqe() shows several steps (1) It prepares the trial state using prepare_state(), (2) computes the commutator between the Hamiltonian and the fermionic operator with compute_gradient() (or numerically via hamiltonian_jw | cluster_ops_sp), (3) sorts the gradients in descending order while excluding zeros using sorted_gradient(), and (4) checks if the norm meets a threshold to decide whether to exit or continue. If continuing, it optimizes the maximum gradient operator(s) using ucc_action() before appending them to the trial state. The function returns the number of classical parameters, CNOT gates, other gates, optimized energies, and energy difference from FCI. The qubit-ADAPT sub-module is similar but differs in using qubit pool generators, a distinct trial state preparation, and a different gradient calculation method, while returning the same properties as fermionic_adapt_vqe().

Demo of the fermionic adapt VQE ( Method + Algorithms )

OpenVQE algorithms have targetted the following object

Step 1

Import the librabries from the main folder

1from openvqe.common_files.molecule_factory_with_sparse import MoleculeFactory
2from openvqe.adapt.fermionic_adapt_vqe import fermionic_adapt_vqe
3molecule_factory = MoleculeFactory()

Step 2

In this step we will run the non-active case with 8 qubits

 1## non active case
 2molecule_symbol = 'H2'
 3type_of_generator = 'spin_complement_gsd'
 4transform = 'JW'
 5active = False
 6r, geometry, charge, spin, basis = molecule_factory.get_parameters(molecule_symbol)
 7print(" --------------------------------------------------------------------------")
 8print("Running in the non active case: ")
 9print(" molecule symbol: %s " %(molecule_symbol))
10print(" molecule basis: %s " %(basis))
11print(" type of generator: %s " %(type_of_generator))
12print(" transform: %s " %(transform))
13print(" --------------------------------------------------------------------------")
14
15print(" --------------------------------------------------------------------------")
16print(" ")
17print(" Generate Hamiltonians and Properties from :")
18print(" ")
19print(" --------------------------------------------------------------------------")
20print(" ")
21hamiltonian, hamiltonian_sparse, hamiltonian_sp, hamiltonian_sp_sparse, n_elec, noons_full, orb_energies_full, info = molecule_factory.generate_hamiltonian(molecule_symbol,active=active, transform=transform)
22nbqbits = len(orb_energies_full)
23print(n_elec)
24hf_init = molecule_factory.find_hf_init(hamiltonian, n_elec, noons_full, orb_energies_full)
25reference_ket, hf_init_sp = molecule_factory.get_reference_ket(hf_init, nbqbits, transform)
26print(" --------------------------------------------------------------------------")
27print(" ")
28print(" Generate Cluster OPS from :")
29print(" ")
30print(" --------------------------------------------------------------------------")
31print(" ")
32pool_size,cluster_ops, cluster_ops_sp, cluster_ops_sparse = molecule_factory.generate_cluster_ops(molecule_symbol, type_of_generator=type_of_generator, transform=transform, active=active)
33# for case of UCCSD from library
34# pool_size,cluster_ops, cluster_ops_sp, cluster_ops_sparse,theta_MP2, hf_init = molecule_factory.generate_cluster_ops(molecule_symbol, type_of_generator=type_of_generator,transform=transform, active=active)
35
36print('Pool size: ', pool_size)
37print('length of the cluster OP: ', len(cluster_ops))
38print('length of the cluster OPS: ', len(cluster_ops_sp))
39print(hf_init_sp)
40print(reference_ket)
41print(" --------------------------------------------------------------------------")
42print(" ")
43print(" Start adapt-VQE algorithm:")
44print(" ")
45print(" --------------------------------------------------------------------------")
46print(" ")
47
48
49n_max_grads = 1
50optimizer = 'COBYLA'
51tolerance = 10**(-6)
52type_conver = 'norm'
53threshold_needed = 1e-2
54max_external_iterations = 35
55fci = info['FCI']
56fermionic_adapt_vqe(hamiltonian_sparse, cluster_ops_sparse, reference_ket, hamiltonian_sp,
57 cluster_ops_sp, hf_init_sp, n_max_grads, fci,
58 optimizer,
59 tolerance,
60 type_conver = type_conver,
61 threshold_needed = threshold_needed,
62 max_external_iterations = max_external_iterations)

After the fifth iteration we obtain

 1 --------------------------------------------------------------------------
 2 Fermionic_ADAPT-VQE iteration: 5
 3 --------------------------------------------------------------------------
 4 Check gradient list chronological order
 5 Norm of the gradients in current iteration = 0.00009243
 6 Max gradient in current iteration= -0.00006448
 7 Index of the Max gradient in current iteration= 29
 8Convergence is done
 9 -----------Final ansatz-----------
10 *final converged energy iteration is -1.151688545279

 1({'energies': [-1.1327826008725905,
 2 -1.1381935787336812,
 3 -1.1446756115964445,
 4 -1.1516131561999758,
 5 -1.1516885452787875],
 6 'energies_substracted_from_FCI': [0.018905946644018012,
 7 0.01349496878292733,
 8 0.007012935920164054,
 9 7.539131663270027e-05,
10 2.2378210395856968e-09],
11 'norms': [1.1787990251924685,
12 0.8635450036709927,
13 0.6286051658725658,
14 0.5004792404827069,
15 0.044516747244794035],
16 'Max_gradients': [0.5465649202698061,
17 0.4109751817065878,
18 0.32276851883318675,
19 0.3507577344126926,
20 0.02644094985356347],
21 'fidelity': [0.9852300170572142,
22 0.9870545052389407,
23 0.9895621336258196,
24 0.9937025822193148,
25 0.9999286595965128],
26 'CNOTs': [48, 96, 288, 336, 368],
27 'Hadamard': [32, 64, 128, 160, 168],
28 'RY': [0, 4, 4, 4, 4],
29 'RX': [16, 32, 64, 80, 84]},
30 {'indices': [38, 32, 29, 23, 2],
31 'Number_operators': 5,
32 'final_norm': 9.243327155226241e-05,
33 'parameters': [-0.02140083663347611,
34 -0.025081299644836987,
35 -0.046035927664188785,
36 -0.03941898799451784,
37 -0.005705200709434039],
38 'Number_CNOT_gates': 368,
39 'Number_Hadamard_gates': 168,
40 'Number_RX_gates': 84,
41 'final_energy_last_iteration': -1.1516885452787875})

Step 3

In this step we consider the case of active space selection with the H4 molecule

 1## active case
 2from openvqe.common_files.molecule_factory_with_sparse import MoleculeFactory
 3from openvqe.adapt.fermionic_adapt_vqe import fermionic_adapt_vqe
 4
 5# initializing the variables in the case of active 
 6molecule_symbol = 'H4'
 7type_of_generator = 'spin_complement_gsd' #'spin_complement_gsd_twin'
 8transform = 'JW'
 9active = True
10
11
12r, geometry, charge, spin, basis = molecule_factory.get_parameters(molecule_symbol)
13print(" --------------------------------------------------------------------------")
14print("Running in the active case: ")
15print(" molecule symbol: %s " %(molecule_symbol))
16print(" molecule basis: %s " %(basis))
17print(" type of generator: %s " %(type_of_generator))
18print(" transform: %s " %(transform))
19print(" --------------------------------------------------------------------------")
20
21
22print(" --------------------------------------------------------------------------")
23print(" ")
24print(" Generate Hamiltonians and Properties from :")
25print(" ")
26print(" --------------------------------------------------------------------------")
27print(" ")
28hamiltonian_active, hamiltonian_active_sparse, hamiltonian_sp,hamiltonian_sp_sparse,nb_active_els,active_noons,active_orb_energies,info=molecule_factory.generate_hamiltonian(molecule_symbol,active=active,transform=transform)
29print(" --------------------------------------------------------------------------")
30print(" ")
31print(" Generate Cluster OPS from :")
32print(" ")
33print(" --------------------------------------------------------------------------")
34print(" ")
35nbqbits = hamiltonian_sp.nbqbits
36hf_init = molecule_factory.find_hf_init(hamiltonian_active, nb_active_els,active_noons, active_orb_energies)
37reference_ket, hf_init_sp = molecule_factory.get_reference_ket(hf_init, nbqbits, transform)
38pool_size,cluster_ops, cluster_ops_sp, cluster_ops_sparse = molecule_factory.generate_cluster_ops(molecule_symbol, type_of_generator=type_of_generator, transform=transform, active=active)
39print("Clusters were generated...")
40print('Pool size: ', pool_size)
41print('length of the cluster OP: ', len(cluster_ops))
42print('length of the cluster OPS: ', len(cluster_ops_sp))
43print('length of the cluster OPS_sparse: ', len(cluster_ops_sp))
44
45print(" --------------------------------------------------------------------------")
46print(" ")
47print(" Start adapt-VQE algorithm:")
48print(" ")
49print(" --------------------------------------------------------------------------")
50print(" ")
51
52n_max_grads = 1
53optimizer = 'COBYLA'
54tolerance = 10**(-7)
55type_conver = 'norm'
56threshold_needed = 1e-3
57max_external_iterations = 30
58fci = info['FCI']
59fermionic_adapt_vqe(hamiltonian_active_sparse, cluster_ops_sparse, reference_ket, hamiltonian_sp,
60 cluster_ops_sp, hf_init_sp, n_max_grads, fci,
61 optimizer,
62 tolerance,
63 type_conver = type_conver,
64 threshold_needed = threshold_needed,
65 max_external_iterations = max_external_iterations)

After the third iteration we obtain:

 1--------------------------------------------------------------------------
 2 Fermionic_ADAPT-VQE iteration: 3
 3 --------------------------------------------------------------------------
 4 Check gradient list chronological order
 5 Norm of the gradients in current iteration = 0.00000157
 6 Max gradient in current iteration= 0.00000098
 7 Index of the Max gradient in current iteration= 22
 8Convergence is done
 9 -----------Final ansatz-----------
10 *final converged energy iteration is -2.150071872977

 1({'energies': [-2.1475588531337, -2.149998032049138, -2.150071872976795],
 2 'energies_substracted_from_FCI': [0.0307547797466996,
 3 0.028315600831261722,
 4 0.02824175990360489],
 5 'norms': [0.9780904621524203, 0.44476756978359294, 0.04777693846151295],
 6 'Max_gradients': [0.5600407258694875,
 7 0.3073244780480784,
 8 0.027972834656648148],
 9 'fidelity': [0.9796754217306467, 0.9989670200933669, 0.9999401845822582],
10 'CNOTs': [48, 96, 128],
11 'Hadamard': [32, 64, 72],
12 'RY': [0, 4, 4],
13 'RX': [16, 32, 36]},
14 {'indices': [16, 22, 2],
15 'Number_operators': 3,
16 'final_norm': 1.56924035843115e-06,
17 'parameters': [-0.06970457006634999,
18 -0.015636706722331747,
19 -0.005282460997328426],
20 'Number_CNOT_gates': 128,
21 'Number_Hadamard_gates': 72,
22 'Number_RX_gates': 36,
23 'final_energy_last_iteration': -2.150071872976795})

References

Haidar, Mohammad, et al. "Open source variational quantum eigensolver extension of the quantum learning machine for quantum chemistry." Wiley Interdisciplinary Reviews: Computational Molecular Science 13.5 (2023): e1664.

About the author

Huy Binh TRAN
Master 2 Quantum Devices at Institute Paris Polytechnic, France
LinkedIn

Adapt-VQE

Mon, 01 Jan 0001 00:00:00 +0000

In 2019, ADAPT-VQE was introduced in this with the purpose of creating a more accurate, compact, and problem-customized ansatz for VQE. This version will hereby be denoted fermionic-ADAPT-VQE to distinguish it against a more recent version that will be covered shortly. The idea behind the proposal is to let the molecule in study ‘choose’ its own state preparation circuit, by creating the ansatz in a strongly system-adapted manner.

The ADAPT-VQE algorithm constructs the molecular system’s wavefunction dynamically and can in principle avoid redundant terms. It is grown iteratively in the form of a disentangled UCC ansatz as given in the below equation:

$$\prod_{k=1}^{\infty} \prod_{pq} \left( e^{\theta_{pq} (k)\hat{A}_{p,q}}\prod_{rs} e^{\theta_{pqrs} (k)\hat{A}_{pq,rs}} \right) |\psi_{\mathrm{HF}} \rangle$$

which is the in the form of a long product of one-body $\hat{A}_{p,q}$ and two-body $\hat{A}_{pq,rs}$ operators generated from the pool of excitations, where each of the variational parameters $\left\{ \theta_{pq} ,\theta_{pqrs} \right\}$

At each step, an operator or a few operators are chosen from a pool: the operator(s) contributing to the largest energy deviations is (are) chosen and added gradually to the ansatz until the exact FCI wavefunction has been reached is associated to an operator.

Algorithm Steps

Initialize Circuit: Start with the identity circuit $U^{(0)}(\theta) = I$, where the state is initialized to the Hartree-Fock state $|\Psi_{HF}\rangle$.
Gradient Measurement: For the current ansatz state $|\Psi^{(k-1)}\rangle$, compute the energy gradient for each operator $A_m$ in the operator pool using the formula:
$$ \frac{\partial E^{(k-1)}}{\partial \theta_m} = \langle \Psi(\theta_{k-1}) | [H, A_m] | \Psi(\theta_{k-1}) \rangle. $$
Check Gradient Norm: Evaluate the norm of the gradient vector $||g^{(k-1)}||$. If it is below the threshold $\epsilon$, the algorithm stops. If not, proceed to the next step.
Select Operator with Maximum Gradient: The operator with the largest gradient is chosen, and its corresponding variational parameter $\theta_k$ is added to the ansatz.
Update Ansatz: Perform a Variational Quantum Eigensolver (VQE) experiment to re-optimize all the parameters $\{\theta_k, \theta_{k-1}, \dots, \theta_1\}$ in the ansatz.
Repeat: Return to step 2 and repeat the process until convergence.

In the following numerical simulation, we used UCCGSD excitation for $H_2$ molecule in 6-31g basis set thus give us 8 qubits; we can run the following script to see the result (The result will not be shown all in here due to its long scrolled lines,you can see it yourself when running the script )

 1from openvqe.common_files.molecule_factory_with_sparse import MoleculeFactory
 2from openvqe.adapt.fermionic_adapt_vqe import fermionic_adapt_vqe
 3molecule_factory = MoleculeFactory()
 4
 5## non active case
 6molecule_symbol = 'H2'
 7type_of_generator = 'spin_complement_gsd'
 8transform = 'JW'
 9active = False
10r, geometry, charge, spin, basis = molecule_factory.get_parameters(molecule_symbol)
11print(" --------------------------------------------------------------------------")
12print("Running in the non active case: ")
13print(" molecule symbol: %s " %(molecule_symbol))
14print(" molecule basis: %s " %(basis))
15print(" type of generator: %s " %(type_of_generator))
16print(" transform: %s " %(transform))
17print(" --------------------------------------------------------------------------")
18
19print(" --------------------------------------------------------------------------")
20print(" ")
21print(" Generate Hamiltonians and Properties from :")
22print(" ")
23print(" --------------------------------------------------------------------------")
24print(" ")
25hamiltonian, hamiltonian_sparse, hamiltonian_sp, hamiltonian_sp_sparse, n_elec, noons_full, orb_energies_full, info = molecule_factory.generate_hamiltonian(molecule_symbol,active=active, transform=transform)
26nbqbits = len(orb_energies_full)
27print(n_elec)
28hf_init = molecule_factory.find_hf_init(hamiltonian, n_elec, noons_full, orb_energies_full)
29reference_ket, hf_init_sp = molecule_factory.get_reference_ket(hf_init, nbqbits, transform)
30print(" --------------------------------------------------------------------------")
31print(" ")
32print(" Generate Cluster OPS from :")
33print(" ")
34print(" --------------------------------------------------------------------------")
35print(" ")
36pool_size,cluster_ops, cluster_ops_sp, cluster_ops_sparse = molecule_factory.generate_cluster_ops(molecule_symbol, type_of_generator=type_of_generator, transform=transform, active=active)
37# for case of UCCSD from library
38# pool_size,cluster_ops, cluster_ops_sp, cluster_ops_sparse,theta_MP2, hf_init = molecule_factory.generate_cluster_ops(molecule_symbol, type_of_generator=type_of_generator,transform=transform, active=active)
39
40print('Pool size: ', pool_size)
41print('length of the cluster OP: ', len(cluster_ops))
42print('length of the cluster OPS: ', len(cluster_ops_sp))
43print(hf_init_sp)
44print(reference_ket)
45print(" --------------------------------------------------------------------------")
46print(" ")
47print(" Start adapt-VQE algorithm:")
48print(" ")
49print(" --------------------------------------------------------------------------")
50print(" ")
51
52
53n_max_grads = 1
54optimizer = 'COBYLA'
55tolerance = 10**(-6)
56type_conver = 'norm'
57threshold_needed = 1e-2
58max_external_iterations = 35
59fci = info['FCI']
60fermionic_adapt_vqe(hamiltonian_sparse, cluster_ops_sparse, reference_ket, hamiltonian_sp,
61 cluster_ops_sp, hf_init_sp, n_max_grads, fci,
62 optimizer,
63 tolerance,
64 type_conver = type_conver,
65 threshold_needed = threshold_needed,
66 max_external_iterations = max_external_iterations)

We make an analysed plot for the converged energy and the fidelity. It took 5 fermionic adapt iteration and the converged energy is -1.1516 Ha with the fidelity : 0.999 and 368 number of CNOT gates

Second version of OpenVQE (Updated code)

Parameters

Molecule Symbol: H2
Type of Generator: spin_complement_gsd
Transformation: JW
Active: False

Workflow

Initialization: Initialize the VQE algorithm with the specified parameters.
Execution: Execute the VQE algorithm to find the ground state energy.
Results: Plot the energy results and error results obtained from the VQE execution.

 1from openvqe.vqe import VQE
 2import matplotlib.pyplot as plt
 3import numpy as np
 4
 5
 6molecule_symbol = 'H2'
 7type_of_generator = 'spin_complement_gsd'
 8transform = 'JW'
 9algorithm = 'fermionic_adapt'
10
11opts = {
12 'n_max_grads': 1,
13 'optimizer': 'COBYLA',
14 'tolerance': 10**(-6),
15 'type_conver': 'norm',
16 'threshold_needed': 1e-2,
17 'max_external_iterations': 35
18 }
19
20
21vqe_non_active = VQE.algorithm(algorithm, molecule_symbol, type_of_generator, transform, False, opts)
22vqe_non_active.execute()

Make the plot

 1
 2energies_1, energies_2 = vqe_non_active.iterations['energies'], vqe_active.iterations['energies']
 3# Plot results with custom styles
 4plt.figure(figsize=(14, 8)) # Larger plot size
 5plt.plot(
 6 energies_1,
 7 "-o", # Line style with circle markers
 8 color="orange", # Use custom color
 9 label=f"Non active space"
10)
11plt.plot(
12 energies_2,
13 "-o", # Line style with circle markers
14 color="red", # Use custom color
15 label=f"Active space"
16)
17plt.plot(
18 [vqe_non_active.info['FCI']] * max([len(energies_1), len(energies_2)]),
19 "k--",
20 label="True ground state energy(FCI)"
21)
22plt.xlabel("Optimization step", fontsize=20)
23plt.ylabel("Energy (Ha)", fontsize=20)
24
25plt.xticks(fontsize=16) # Set font size for x-axis tick labels
26plt.yticks(fontsize=16)
27
28# Move the legend box outside the plot
29plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0., fontsize=12)
30plt.grid()
31plt.title(f"VQE {algorithm} energy evolution for {molecule_symbol} molecule", fontsize=20)
32plt.tight_layout() # Adjust layout to prevent clipping
33
34plt.show()

You can go to the git repo for more detail at

References

Harper R. Grimsley, Sophia E. Economou, Edwin Barnes, Nicholas J. Mayhall. "An adaptive variational algorithm for exact molecular simulations on a quantum computer." Nature communications, 10(1), 3007.

About the author

Huy Binh TRAN
Master 2 Quantum Devices at Institute Paris Polytechnic, France
LinkedIn

Parameter-Shift Rule

Mon, 01 Jan 0001 00:00:00 +0000

Let us describe below how to act the parameter-shift rules on the UCC circuit ansatz. In the present work, we use a UCC ansatz truncated at the single and double excitation levels with a single Trotter step. Off course, one can go further to triple, quadruple and further excitation, however our goal in this section is to show how to link the parameter shift rule on a unitary coupled cluster gates in a circuit, which is the most important key point. Once these approximations are performed, each exponential of a fermionic excitation operator can be directly implemented as a sequence of gates. This in practice, can be done by using the standard CNOT staircase method (described in the previous chapter). The unitary transformation carried out by the circuit can thus be broken down into a product of local unitaries

$$ U\left(x;\bm{\theta}\right)=U_N\left(\bm{\theta}_N\right)U_{N-1}\left(\bm{\theta}_{N-1}\right)\cdots U_i\left(\bm{\theta}_i\right) \cdots U_1\left(\bm{\theta}_1\right)U_0\left(x\right) $$

Each of these gates is unitary, and therefore must have the form

$$ U_j\left(\gamma_j\right)=\exp{\left(i\gamma_jH_j\right)} $$

where $H_j$ is a Hermitian operator which generates the gate and $\gamma_j$ is the gate parameter. When using CNOT staircase method, $U_j\left(\gamma_j\right)$ are typically equivalent to $R_z(\bm{\theta})$ gates. Since for any type of coupled cluster excitations, the circuit, in practice should be composed of multiple parameterized $R_z(\bm{\theta})$ gates, and some other non-parameterized gates such as (CNOT, Hadamard etc.). There should be then a tool how to make the quantum circuit function to compute gradient ($\nabla{\bm{\theta}_i}{f}(x;\bm{\theta}_i$)) for a certain $\bm{\theta}_i$:\ in fact any gates applied before gate $i$ into the initial state, can be expressed as:

$$ \left|\psi_{i-1}\right\rangle=U_{i-1}\left(\bm{\theta}_{i-1}\right)\cdots U_1\left(\bm{\theta}_1\right)U_0\left(x\right)\left|0\right\rangle $$

Similarly, any gates applied after gate $i$ are combined with the observable, which is the Hamiltonian in our case

$$ \hat{H}_{i+1}=U_N^\dag(\bm{\theta}_N)\cdot U^\dag_{i+1}(\bm{\theta}_{i+1})\hat{H}U_{i+1}(\bm{\theta}_{i+1})\cdots U_N(\bm{\theta}_N) $$

With this simplification, the quantum circuit function becomes

$$ f(x;\bm{\theta})=\left\langle\psi_{i-1}\left|U_i^\dag(\bm{\theta}_i)\hat{H}_{i+1}U_i(\bm{\theta}_i)\right|\psi_{i-1}\right\rangle $$

now suppose

$$\mathcal{M}_{\bm{\theta}_i}(\hat{H}_{i+1}) = U_i^\dag(\bm{\theta}_i)\hat{H}_{i+1}U_i(\bm{\theta}_i) $$

then its gradient takes the form

$$ \nabla_{\bm{\theta}_i}f\left(x;\bm{\theta}\right)=\left\langle\psi_{i-1}\left|\nabla_{\bm{\theta}_i}\mathcal{M}_{\bm{\theta}_i}\left(\hat{H}_{i+1}\right)\right|\psi_{i-1}\right\rangle $$

as is seen in the expression above, in terms of the circuit, one can leave all other gates as they are, and only gate
$U_i\left(\bm{\theta}_i\right)$ should be changed when question comes to differentiate it with respect to the parameter
$\bm{\theta}_i$. Let us now apply the equations above into $R_z$ gate. Consider a quantum computer with parameterized gates of the form

$$ R_i\left(\bm{\theta}_i\right)=\exp{\left(-i\frac{\bm{\theta}_i}{2}\widehat{Z_i}\right)} $$

where $\widehat{Z_i}={\widehat{Z}_i}^ \dag$ is a Pauli operator. The gradient of $R_z$ is

$$ \nabla_{\bm{\theta}_i}R_i\left(\bm{\theta}_i\right)=-\frac{i}{2}\widehat{Z_i}R_i\left(\bm{\theta}_i\right)=-\frac{i}{2}R_i\left(\bm{\theta}_i\right)\widehat{Z_i} $$

By substituting this expression into the quantum circuit function $f(x;\bm{\theta})$, we get

$$ \nabla_{\bm{\theta}_i} f\left(x;\bm{\theta}\right) = \frac{i}{2} \left\langle \psi_{i-1} \left| R_i\left(\bm{\theta}_i\right)^\dag \left( Z_i \widehat{H}_{i+1} - \widehat{H}_{i+1} Z_i \right) R_i\left(\bm{\theta}_i\right) \right| \psi_{i-1} \right\rangle $$

$$= \frac{i}{2} \left\langle \psi_{i-1} \left| R_i\left(\bm{\theta}_i\right)^\dag \left[ Z_i, \widehat{H}_{i+1} \right] R_i\left(\bm{\theta}_i\right) \right| \psi_{i-1} \right\rangle$$

where $\left[X,Y\right]=XY-YX$ is the commutator. \ \ We now make use of the following mathematical identity for commutators involving Pauli operators

$$ \left[\widehat{Z_i},\hat{H}\right] = -i\left(R_i^\dag\left(\frac{\pi}{2}\right)\hat{H}R_i\left(\frac{\pi}{2}\right) - R_i^\dag\left(-\frac{\pi}{2}\right)\hat{H}R_i\left(-\frac{\pi}{2}\right)\right). $$

Substituting this into the previous equation, we obtain the gradient expression

$$ \nabla_{\bm{\theta}_i} f\left(x;\bm{\theta}\right)= \frac{1}{2}\left\langle\psi_{i-1}\left|R_i^\dag\left(\bm{\theta}_i+\frac{\pi}{2}\right){\widehat{H}}_{i+1}R_i\left(\bm{\theta}_i+\frac{\pi}{2}\right)\right|\psi_{i-1}\right\rangle $$$$ -\frac{1}{2}\left\langle\psi_{i-1}\left|R_i^\dag\left(\bm{\theta}_i-\frac{\pi}{2}\right){\widehat{H}}_{i+1}R_i\left(\bm{\theta}_i-\frac{\pi}{2}\right)\right|\psi_{i-1}\right\rangle $$

Finally, this gradient can be rewritten in terms of quantum functions:

$$ \nabla_{\bm{\theta}_i} f\left(x;\bm{\theta}\right)=\frac{1}{2}\left[f\left(x;\bm{\theta}+\frac{\pi}{2}\right)-f\left(x;\bm{\theta}-\frac{\pi}{2}\right)\right] $$

We recognize from the comparison of equations above, that these unitaries represent instances of the initial gate, and thus shift the gate’s parameter. This leads to the parameter shift rule for circuit gradients. Below is the code for PMRS for LiH in with CAS method reduced to 6 qubits

 1import matplotlib.pyplot as plt
 2import numpy as np
 3import scipy.optimize
 4
 5# Assuming the necessary functions are defined: 
 6# get_optimization_func, get_grad_func, and the variables circ, qpu, H_sp, nqbits, psi0, theta_0, E0
 7
 8# Initialize dictionaries to store results
 9res = {}
10energy_list, fid_list = {}, {}
11
12# Define the optimization methods to use
13methods = ["CG", "BFGS", "COBYLA"]
14
15# Perform optimization for each method
16for method in methods:
17 energy_list[method], fid_list[method] = [], []
18 my_func = get_optimization_func(circ, qpu, H_sp, method, nqbits, psi0, energy_list, fid_list)
19 my_grad = get_grad_func(circ, qpu, H_sp)
20 res[method] = scipy.optimize.minimize(my_func, jac=my_grad, x0=theta_0, method=method, options={"maxiter": 50000, "disp": True})
21
22fig, ax = plt.subplots(figsize=(11, 7))
23steps = np.arange(0, 700)
24
25col = {"CG": "orange", "COBYLA": "firebrick", "BFGS": "darkcyan"}
26
27for method in ["CG", "BFGS", "COBYLA"]:
28 energy_list[method] = np.array(energy_list[method])
29 error = np.maximum(energy_list[method] - E0, 1e-6) # Ensure no values less than 1e-16
30 print(f"The error for the {method} method:", error)
31 ax.plot(error, "-o", color=col[method], label=f" Subtracted energy [{method}]")
32
33 if method == "COBYLA" and error.size > 0:
34 ax.fill_between(steps[:len(error)], 1e-6, 1e-3, color="cadetblue", alpha=0.2, interpolate=True, label="Chemical Accuracy")
35
36
37
38ax.set_xlabel("optimization step")
39ax.set_xlim(0,128)
40
41ax.set_yscale('log')
42ax.legend()
43ax.grid(True, which="both", ls="--")
44plt.savefig("error_H4.pdf")
45 # Grid lines for both major and minor ticks
46
47plt.show()

 1fig, ax = plt.subplots(figsize=(11, 7))
 2steps = np.arange(0, 700)
 3
 4col = {"CG": "orange", "COBYLA": "firebrick", "BFGS": "darkcyan"}
 5
 6for method in ["CG", "BFGS", "COBYLA"]:
 7 energy_list[method] = np.array(energy_list[method])
 8 error = np.maximum(energy_list[method] - E0, 1e-6) # Ensure no values less than 1e-16
 9 print(f"The error for the {method} method:", error)
10 ax.plot(error, "-o", color=col[method], label=f" Subtracted energy [{method}]")
11
12 if method == "COBYLA" and error.size > 0:
13 ax.fill_between(steps[:len(error)], 1e-6, 1e-3, color="cadetblue", alpha=0.2, interpolate=True, label="Chemical Accuracy")
14
15
16
17ax.set_xlabel("optimization step")
18ax.set_xlim(0,128)
19
20ax.set_yscale('log')
21ax.legend()
22ax.grid(True, which="both", ls="--")
23plt.savefig("error_LiH.pdf")
24 # Grid lines for both major and minor ticks
25
26plt.show()

 1fig, ax = plt.subplots(figsize=(11, 7))
 2steps = np.arange(0, 700)
 3
 4col = {"CG": "orange", "COBYLA": "firebrick", "BFGS": "darkcyan"}
 5
 6for method in ["CG", "BFGS", "COBYLA"]:
 7 fid_list[method] = np.array(fid_list[method])
 8
 9 ax.plot(fid_list[method], "-o", color=col[method], label= f"fidelity w.r.t true ground state [{method}]")
10
11
12ax.set_xlabel("optimization step")
13
14ax.legend()
15ax.grid(True, which="both", ls="--")
16plt.savefig("fidelity_H4_.pdf")
17 # Grid lines for both major and minor ticks
18
19plt.show()

The energy according to the chosen optimization algorithm.

About the author

Huy Binh TRAN
Master 2 Quantum Devices at Institute Paris Polytechnic, France
LinkedIn

Subspace-search variational quantum eigensolver for excited states

Mon, 01 Jan 0001 00:00:00 +0000

In Variational Quantum Eigensolver (VQE), the real parameters $\theta$ for the ansatz states $|\psi \left( \theta \right) \rangle $ are classically optimised with respect to the expectation value of the Hamiltonian in the equation ; it is computed using a lowdepth quantum circuit. As a result of the variational principle, finding the global minimum of $E\left( \theta \right) $ is equivalent to finding the ground state energy of $H$

In this section, our goal is to extend to calculate find excited states from HEA ansatz model, using subspace-search VQE (SSVQE). The SSVQE takes two or more orthogonal states as inputs to a parametrized quantum circuit, and minimizes the expectation value of the energy in the space spanned by those states. In this work, the proposed algorithm can find the $k$-th excited state state that works on an $n$-qubit quantum computer; SSVQE runs as follows:

Algorithm

Construct an ansatz circuit $ U(\bm{\theta}) $ and choose input states $ \left\{ \ket{\varphi_j} \right\}_{j=0}^k $ whic
Minimize
\[ \mathcal{L}_1(\bm{\theta}) = \sum_{j=0}^k \langle \varphi_{j} | U^\dagger(\bm{\theta}) H U(\bm{\theta}) | \varphi_{j} \rangle. \]
We denote the optimal $ \bm{\theta} $ by $ \bm{\theta}^* $.
Construct another parametrized quantum circuit $ V(\bm{\phi}) $ that only acts on the space spanned by $ \left\{ \ket{\varphi_j} \right\}_{j=0}^k $.
Choose an arbitrary index $ s \in \{0, \ldots, k\} $, and maximize

\[ \mathcal{L}_2(\bm{\phi}) = \langle \varphi_{s} | V^\dagger(\bm{\phi}) U^\dagger(\bm{\theta}^*) H U(\bm{\theta}^*) V(\bm{\phi}) | \varphi_{s} \rangle. \]
We note that, in practice, the input states $ \left\{ \ket{\varphi_j} \right\}_{j=0}^k $ will be chosen from a set of states which are easily preparable, such as the computational basis (in our work, we use the binary representation technique for generating the basis). Additionally, in step 2, we can find the subspace which includes $ \ket{E_k} $ as the highest energy state, using a carefully constructed ansatz $U(\boldsymbol{\theta})$. The unitary $ V(\bm{\phi}) $ is responsible for searching in that subspace. By maximizing $ \mathcal{L}_2(\bm{\phi}) $, we find the $ k $-th excited state $ \ket{E_k} $.

A particular instance of the “hardware-efficient ansatz” - the entanglement pattern with 6 CX gates and depth = 1 is shown. The parameters $\boldsymbol{\theta}$ are optimized to to minimize the cost function $\mathcal{L}_{1}$ then the ansatz structure will be updated the parameters, called $\boldsymbol{\phi }$ thus to optimize $\mathcal{L}_{2}$

 1import numpy as np
 2import scipy.optimize
 3import matplotlib.pyplot as plt
 4from numpy import binary_repr
 5from qat.qpus import get_default_qpu
 6
 7qpu = get_default_qpu()
 8method = "BFGS"
 9model = hamiltonian_sp
10vals = 15
11
12eigenvec_input_tar = calculate_eigen_vectors(model, vals)
13eigenvec_input = [eigenvec_input_tar[2],eigenvec_input_tar[8], eigenvec_input_tar[13]]
14
15
16energy_lists = {f"energy_circ_{i}": {method: []} for i in range(len(circuits_store))}
17fidelity_lists = {f"fidelity_circ_{i}": {method: []} for i in range(len(circuits_store))}
18
19def opt_funct(circuits, model, qpu, nqbits, energy_lists, fidelity_lists, weight, eigenvec_input):
20 def input_funct(x):
21 total_energy = 0
22 for i, circ in enumerate(circuits):
23 bound_circ = circ.bind_variables({k: v for k, v in zip(sorted(circ.get_variables()), x)})
24 result = qpu.submit(bound_circ.to_job(observable=model))
25 energy = result.value
26 energy_lists[f"energy_circ_{i}"][method].append(energy)
27
28 # Calculate fidelity
29 fidelity = fun_fidelity(bound_circ, eigenvec_input[i], nqbits)
30 fidelity_lists[f"fidelity_circ_{i}"][method].append(fidelity)
31 #print(fidelity)
32
33 total_energy += weight[i] * energy
34 return total_energy
35
36 def callback(x):
37 for i, circ in enumerate(circuits):
38 bound_circ = circ.bind_variables({k: v for k, v in zip(sorted(circ.get_variables()), x)})
39 result = qpu.submit(bound_circ.to_job(observable=model))
40 energy = result.value
41 energy_lists[f"energy_circ_{i}"][method].append(energy)
42
43 # Calculate fidelity
44 fidelity = fun_fidelity(bound_circ, eigenvec_input[i], nqbits)
45 fidelity_lists[f"fidelity_circ_{i}"][method].append(fidelity)
46
47 return input_funct, callback
48
49
50input_funct, callback = opt_funct(circuits_store, model, qpu, nqbits, energy_lists, fidelity_lists, weight, eigenvec_input)
51options = {"disp": True, "maxiter": 5000, "gtol": 1e-7}
52Optimizer = scipy.optimize.minimize(input_funct, x0=init_theta_list, method=method, callback=callback, options=options)
53
54# Plot energy
55plt.rcParams["font.size"] = 18
56all_energy_lists = []
57
58for i in range(len(circuits_store)):
59 energy_list = energy_lists[f"energy_circ_{i}"][method]
60 all_energy_lists.append(energy_list)
61 plt.plot(range(len(energy_list)), energy_list, label=f"Energy for k={binary_repr(k_lst[i]).zfill(4)}")
62
63 # Print the final energy for each k
64 final_energy = energy_list[-1]
65 print(f"Final energy for k={binary_repr(k_lst[i]).zfill(4)}: {final_energy}")
66
67plt.xlabel("Iterations")
68plt.ylabel("Energy")
69plt.title("Energy Evolution")
70plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0, fontsize=18)
71plt.show()
72
73
74
75
76# Plot fidelity
77plt.figure()
78all_fidelity_lists = []
79
80for i in range(len(circuits_store)):
81 fidelity_list = fidelity_lists[f"fidelity_circ_{i}"][method]
82 all_fidelity_lists.append(fidelity_list)
83 plt.plot(range(len(fidelity_list)), fidelity_list, label=f"Fidelity for k={binary_repr(k_lst[i]).zfill(4)}")
84
85 # Print the final fidelity for each k
86 final_fidelity = fidelity_list[-1]
87 print(f"Final fidelity for k={binary_repr(k_lst[i]).zfill(4)}: {final_fidelity}")
88
89plt.xlabel("Iterations")
90plt.ylabel("Fidelity")
91plt.title("Fidelity Evolution")
92plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', borderaxespad=0, fontsize=18)
93plt.show()

We implement the SSVQE on the molecular Hamiltonians such as H$_2$ molecule ( with a fixed distance between two hydrogen atoms $r=0.85 $ at the STO-3G minimal basis set. We choose our own weight (W) for the minimization; We obtain accurate energies with height fidelity rate $\left[ 0,978\longrightarrow 0,998 \right] $. Meaning that the algorithms assures assures the orthogonality of the states at the input of the ansatz circuit

The energy levels of the Hamiltonian of H$_2$ in the STO-3g basis set: four qubits. The fidelity is close to one. It is the Overlap $\langle\Psi_j(\vec{\theta}) |\Psi_{k}\rangle$ between the computed VQE state at each optimization step $j$ and the theoretical ground (or excited) state $|\Psi_{k}\rangle$ of Hamiltonian $H$, where $|\Psi_{k}\rangle$ is obtained through diagonalization.

References

Nakanishi, Ken M., Kosuke Mitarai, and Keisuke Fujii. "Subspace-search variational quantum eigensolver for excited states." Physical Review Research 1.3 (2019): 033062.

About the Author

Huy Binh TRAN
Master 2 Quantum Devices at Institute Paris Polytechnic, France
LinkedIn

Unitary Selective Coupled Cluster

Mon, 01 Jan 0001 00:00:00 +0000

The Unitary Coupled-Cluster with Singles and Doubles (UCCSD) method parameterizes coupled-cluster variational parameters for each fermionic excitation from a reference state, whether single or double excitations. This ansatz has been successfully applied to compute accurate electronic energies for small molecules. However, for large molecules, this approach can introduce many redundant, unimportant excitations, resulting in a large number of parameters to optimize and excessively long circuits

The UsCC method systematically reduces the energy error with an increasing ansatz size for a set of test molecules. A significant advantage of the UsCC method is that expanding the ansatz does not necessitate additional measurements on a quantum computer. The implementation of the UsCC method begins with the reference Hartree–Fock state. One- and two-body excitations (from occupied to unoccupied orbitals) with corresponding Hamiltonian matrix elements above a given threshold $\epsilon$ are included in the ansatz. A Variational Quantum Eigensolver (VQE) is then performed on this ansatz until convergence, completing the first iteration. In subsequent iterations, the threshold is updated such that $\epsilon_i = \frac{\epsilon_{i-1}}{2}$. New, higher-order excitations are generated by applying one- and two-body excitations to those already included in the ansatz. The metric to compare to the threshold for inclusion of these excitations is obtained by multiplying the parameters obtained after optimization at the previous step with the Hamiltonian matrix element corresponding to the single or double excitation added. As in previous iterations, coefficients that are above the threshold are included in the ansatz and then optimized through VQE. The optimization continues until a convergence criterion is met or sufficient excitations have been included.

The ansatz generation starts with the reference Hartree–Fock state, with no initial excitation amplitudes available. First, all possible single- and double-electronic excitations are generated. These excitations are expressed in spin-block notation: the occupied orbitals, from which excitations are performed, are labeled $i$, $j$, $k$, and $l$, while the virtual orbitals, to which electrons are excited, are labeled $p$, $q$, $r$, and $s$. For instance, single and double excitations are denoted as $[i, p]$ and $[i, j, p, q]$, respectively.

UsCCSDTQ-VQE Algorithm

Generate single and double excitations for a given molecule.

For all single (S) and double (D) excitations $[i, p]$ and $[i, j, p, q]$ in UCCSD:

If $h_1[i, p]$ and $h_2[i, j, p, q]$ are larger than $\epsilon_1$ then:
- Add to ansatz.
- end if

end for

Repeat.

Run VQE with the current ansatz to compute energy, update amplitudes for each excitation present in ansatz.
For each single $[i, p]$ or double $[i, j, p, q]$ excitation present in ansatz using $t_1$ and $t_2$ values from the previous iteration and additional excitations $[k, r]$ or $[k, l, r, s]$, generate triple and quadruple excitations with the following coefficients:
- $t_1[i, p] \cdot h_2[j, k, q, r]$
- $h_1[i, p] \cdot t_2[j, k, q, r]$
- $t_2[i, j, p, q] \cdot h_1[k, r]$
- $h_2[i, j, p, q] \cdot t_1[k, r]$
- $t_2[i, j, p, q] \cdot h_2[k, l, r, s]$
For each excitation, if the absolute value of the largest coefficient computed in step 3 is larger than $\epsilon_n$ on iteration $n$, add this excitation to ansatz.

Code Source Implementation

Step 1

Import necessary library and define the fucntions

 1from openvqe.common_files.qubit_pool import QubitPool
 2from openvqe.common_files.molecule_factory import MoleculeFactory
 3from openvqe.ucc_family.get_energy_ucc import EnergyUCC
 4from qat.fermion.transforms import (get_jw_code, recode_integer)
 5from qat.fermion.chemistry.pyscf_tools import perform_pyscf_computation
 6from qat.fermion.chemistry.pyscf_tools import perform_pyscf_computation
 7from qat.fermion.chemistry import MolecularHamiltonian, MoleculeInfo
 8from qat.fermion.chemistry.ucc import guess_init_params, get_hf_ket, get_cluster_ops
 9from qat.fermion.transforms import transform_to_jw_basis # , transform_to_bk_basis, transform_to_parity_basis
 10from qat.fermion.transforms import recode_integer, get_jw_code # , get_bk_code, get_parity_code
 11from qat.lang.AQASM import Program, X
 12from qat.fermion.trotterisation import make_trotterisation_routine
 13from qat.fermion import ElectronicStructureHamiltonian
 14import scipy.optimize
 15from qat.fermion.chemistry.ucc_deprecated import build_ucc_ansatz
 16from qat.lang.AQASM import Program
 17from qat.qpus import get_default_qpu
 18from openvqe.common_files.circuit import count
 19import numpy as np
 20
 21class EnergyUCC:
 22 def ucc_action(self, theta_current, hamiltonian_sp, cluster_ops_sp, hf_init_sp, theta_thresh=1e-7):
 23 """
 24 It maps the exponential of cluster operators ("cluster_ops_sp") associated by their parameters ("theta_current")
 25 using the CNOTS-staircase method, which is done by "build_ucc_ansatz" which creates the circuit on the top of
 26 the HF-state ("hf_init_sp"). Then, this function also calculates the expected value of the hamiltonian ("hamiltonian_sp").
 27
 28 Parameters
 29 ----------
 30 theta_current: List<float>
 31 the Parameters of the cluster operators
 32
 33 hamiltonian_sp: Hamiltonian
 34 Hamiltonian in the spin representation
 35
 36 cluster_ops_sp: list[Hamiltonian]
 37 list of spin cluster operators
 38
 39 hf_init_sp: int
 40 the integer corresponds to the hf_init (The Hartree-Fock state in integer representation) obtained by using
 41 "qat.fermion.transforms.record_integer".
 42
 43 Returns
 44 --------
 45 res.value: float
 46 the resulted energy
 47
 48 """
 49 qpu = 0
 50 prog = 0
 51 reg = 0
 52 qpu = get_default_qpu()
 53 prog = Program()
 54 reg = prog.qalloc(hamiltonian_sp.nbqbits)
 55 qrout = 0
 56 for n_term, (term, theta_term) in enumerate(zip(cluster_ops_sp, theta_current)):
 57 init = hf_init_sp if n_term == 0 else 0
 58 qprog = build_ucc_ansatz([term], init, n_steps=1)
 59 if abs(theta_term) > theta_thresh:
 60 prog.apply(qprog([theta_term]), reg)
 61 circ = prog.to_circ()
 62
 63 return circ
 64
 65 def get_optimization_func(self, circ, qpu, hamiltonian_sp, method, nqbits, psi0, energy_list, fid_list):
 66 # below, I show an example of minimization of the energy where I store the energy and fidelity for each parameter
 67 # I use a gradient-free procedure.
 68 def my_func(x):
 69 """returns energy given parameter x, and stores it + the fidelity of state"""
 70 circ1 = circ.bind_variables(
 71 {k: v for k, v in zip(sorted(circ.get_variables()), x)}
 72 )
 73 res0 = qpu.submit(circ1.to_job(observable=hamiltonian_sp))
 74 energy = res0.value
 75 energy_list[method].append(energy)
 76
 77 # additional computation to compute fidelity (just for my own information)
 78 res = qpu.submit(circ1.to_job())
 79 psi = np.zeros((2**nqbits,), complex)
 80 for sample in res:
 81 psi[sample.state.int] = sample.amplitude
 82 fid = abs(psi.conj().dot(psi0)) ** 2
 83 fid_list[method].append(fid)
 84
 85 return energy
 86
 87 return my_func
 88
 89
 90 def get_grad_func(self, circ, qpu, hamiltonian_sp):
 91 # here I show a gradient-based minimization strategy
 92 def my_grad(x):
 93 grads = circ.to_job(observable=hamiltonian_sp).gradient()
 94 grad_list = []
 95 for var_name in sorted(circ.get_variables()):
 96 list_jobs = grads[var_name]
 97 # list_jobs contains jobs to compute E(theta+pi/2) and E(theta-pi/2)
 98 # the gradient w.r.t theta is then 0.5 (E(theta+pi/2) - E(theta-pi/2))
 99 grad = 0.0
100 for ind in range(len(list_jobs)):
101 circ1 = list_jobs[ind].circuit.bind_variables(
102 {k: v for k, v in zip(circ.get_variables(), x)}
103 )
104 job = circ1.to_job(observable=list_jobs[ind].observable)
105 res = qpu.submit(job)
106 grad += 0.5 * res.value
107 grad_list.append(grad)
108 return grad_list
109
110
111 def prepare_state_ansatz(
112 self, hamiltonian_sp, cluster_ops_sp, hf_init_sp, parameters
113 ):
114 """
115 It constructs the trial wave function (ansatz)
116
117 Parameters
118 ----------
119 hamiltonian_sp: Hamiltonian
120 Hamiltonian in the spin representation
121
122 cluster_ops_sp: list[Hamiltonian]
123 list of spin cluster operators
124
125 hf_init_sp: int
126 the integer corresponds to the hf_init (The Hartree-Fock state in integer representation) obtained by using
127 "qat.fermion.transforms.record_integer".
128
129 parameters: List<float>
130 the Parameters for the trial wave function to be constructed
131
132
133
134 Returns
135 --------
136 curr_state: qat.core.Circuit
137 the circuit that represent the trial wave function
138
139 """
140 qpu = get_default_qpu()
141 prog = Program()
142 reg = prog.qalloc(hamiltonian_sp.nbqbits)
143 for n_term, (term, theta_term) in enumerate(zip(cluster_ops_sp, parameters)):
144 init = hf_init_sp if n_term == 0 else 0
145 qprog = build_ucc_ansatz([term], init, n_steps=1)
146 prog.apply(qprog([theta_term]), reg)
147 circ = prog.to_circ()
148 curr_state = circ
149 return curr_state
150
151 def get_energies(
152 self,
153 hamiltonian_sp,
154 cluster_ops_sp,
155 hf_init_sp,
156 theta_current,
157 fci,
158 method="BFGS"
159 ):
160 """
161 It calls internally the functions "ucc_action" and "prepare_state_ansatz", and uses scipy.optimize to
162 return the properties of the ucc energy and wave function.
163
164 Parameters
165 ----------
166 hamiltonian_sp: Hamiltonian
167 Hamiltonian in the spin representation
168
169 cluster_ops_sp: list[Hamiltonian]
170 list of spin cluster operators
171
172 hf_init_sp: int
173 the integer corresponds to the hf_init (The Hartree-Fock state in integer representation) obtained by using
174 "qat.fermion.transforms.record_integer".
175
176 theta_current: List<float>
177 the Parameters of the cluster operators of "cluster_ops_sp"
178
179
180 theta_current2: List<float>
181 the Parameters of the cluster operators of "pool_generator"
182
183
184 theta_current2: List<float>
185 the Parameters of the cluster operators of "pool_generator"
186
187 fci: float
188 the full configuration interaction energy (for any basis set)
189
190
191 Returns
192 --------
193 iterations: Dict
194 the minimum energy and the optimized parameters
195
196 result: Dict
197 the number of CNOT gates, the number of operators/parameters, and the substraction of the optimized energy from fci.
198
199 """
200
201 iterations = {
202 "minimum_energy_result_guess": [],
203 "theta_optimized_result": [],
204 }
205 result = {}
206 tolerance = 10 ** (-4)
207 print("tolerance= ", tolerance)
208 print("method= ", method)
209
210 theta_optimized_result = []
211
212
213
214 opt_result = scipy.optimize.minimize(
215 lambda theta: self.ucc_action(
216 theta, hamiltonian_sp, cluster_ops_sp, hf_init_sp
217 ),
218 x0=theta_current,
219 method=method,
220 tol=tolerance,
221 options={"maxiter": 50000, "disp": True},
222 )
223
224 xlist = opt_result.x
225
226 for si in range(len(theta_current)):
227 theta_optimized_result.append(xlist[si])
228
229 curr_state_result = self.prepare_state_ansatz(
230 hamiltonian_sp, cluster_ops_sp, hf_init_sp, theta_optimized_result
231 )
232
233 gates = curr_state_result.ops
234 cnot = count("CNOT", gates)
235 iterations["minimum_energy_result_guess"].append(opt_result.fun)
236 iterations["theta_optimized_result"].append(theta_optimized_result)
237 result["CNOT"] = cnot
238 result["len_op"] = len(theta_optimized_result)
239 result["energies_substracted_from_FCI"] = abs(opt_result.fun - fci)
240 return iterations, result

Step 2

Callout the function and excecute the program

 1from openvqe.common_files.molecule_factory import MoleculeFactory
 2#from openvqe.ucc_family.get_energy_ucc import EnergyUCC
 3from openvqe.common_files.generator_excitations import _apply_transforms
 4from qat.fermion.transforms import get_jw_code, recode_integer
 5from qat.core import Term
 6from qat.fermion import FermionHamiltonian
 7
 8
 9def get_h(hamiltonian, exc):
 10 hamiltonian_string = str(hamiltonian)
 11 lines = hamiltonian_string.strip().split("\n")
 12 if len(exc) == 2:
 13 id_str = f"(Cc|[{exc[0]}, {exc[1]}])"
 14 else:
 15 id_str = f"(CCcc|[{exc[0]}, {exc[1]}, {exc[2]}, {exc[3]}])"
 16
 17 lines = [line for line in lines if id_str in line]
 18 if len(lines) == 0:
 19 print("zero h:", exc)
 20 return complex(0.0)
 21 assert len(lines) == 1
 22
 23 line = lines[0]
 24 start_ind = line.find("(") + 1
 25 end_ind = line.find(")")
 26 value = line[start_ind:end_ind]
 27 return complex(value)
 28
 29
 30def init(molecule_symbol):
 31 (
 32 hamiltonian,
 33 hamiltonian_sp,
 34 _,
 35 active_noons,
 36 _,
 37 info,
 38 ) = MoleculeFactory().generate_hamiltonian(
 39 molecule_symbol, active=False, transform="JW"
 40 )
 41
 42 (
 43 _,
 44 cluster_ops,
 45 _,
 46 theta_MP2,
 47 hf_init,
 48 ) = MoleculeFactory().generate_cluster_ops(
 49 molecule_symbol, type_of_generator="UCCSD", transform="JW", active=False
 50 )
 51
 52 hf_init_sp = recode_integer(hf_init, get_jw_code(hamiltonian_sp.nbqbits))
 53 fci = info["FCI"]
 54 print("FCI", fci)
 55 nqbits = len(active_noons)
 56
 57 excitations = [tuple(op.terms[0].qbits) for op in cluster_ops]
 58 current_coeffs = {}
 59
 60 # TODO:
 61 # theta_MP2 = [x if x != 0 else 0.01 for x in theta_MP2]
 62 theta_MP2 = [0.01 for x in theta_MP2]
 63 for i, exc in enumerate(excitations):
 64 current_coeffs[exc] = {"h": get_h(hamiltonian, exc)}
 65
 66 return hamiltonian_sp, hf_init_sp, fci, current_coeffs, nqbits
 67
 68
 69def build_cluster_ops(exc_list, nqbits: int):
 70 """Adapted from myqlm"""
 71 t_opti = []
 72
 73 for op_index in exc_list:
 74 current_excitation_op = []
 75
 76 op_description, indices, indices_conj = None, None, None
 77 if len(op_index) == 2:
 78 op_description = "Cc"
 79 indices, indices_conj = list(op_index), [op_index[1], op_index[0]]
 80
 81 elif len(op_index) == 4:
 82 op_description = "CCcc"
 83 indices, indices_conj = list(op_index), [
 84 op_index[2],
 85 op_index[3],
 86 op_index[0],
 87 op_index[1],
 88 ]
 89 elif len(op_index) == 6:
 90 op_description = "CCCccc"
 91 indices, indices_conj = list(op_index), [
 92 op_index[3],
 93 op_index[4],
 94 op_index[5],
 95 op_index[0],
 96 op_index[1],
 97 op_index[2],
 98 ]
 99
100 elif len(op_index) == 8:
101 op_description = "CCCCcccc"
102 indices, indices_conj = list(op_index), [
103 op_index[4],
104 op_index[5],
105 op_index[6],
106 op_index[7],
107 op_index[0],
108 op_index[1],
109 op_index[2],
110 op_index[3],
111 ]
112
113 current_excitation_op.append(Term(1j, op_description, indices))
114 current_excitation_op.append(Term(-1j, op_description, indices_conj))
115 t_opti.append(FermionHamiltonian(nqbits=nqbits, terms=current_excitation_op))
116
117 return t_opti
118
119
120def update_ansatz(current_excitations, current_coeffs, thresh, nqbits):
121 all_excitations = list(current_coeffs.keys())
122
123 for optimized_exc in current_excitations:
124 for exc in all_excitations:
125 exc_len = len(exc)
126 opt_exc_len = len(optimized_exc)
127
128 # single-single
129 if exc_len == 2 and opt_exc_len == 2:
130 new_exc = sorted([exc[0], optimized_exc[0]]) + sorted(
131 [exc[1], optimized_exc[1]]
132 )
133 elif exc_len == 2 and opt_exc_len == 4:
134 new_exc = sorted([exc[0], optimized_exc[0], optimized_exc[1]]) + sorted(
135 [exc[1], optimized_exc[2], optimized_exc[3]]
136 )
137 elif exc_len == 4 and opt_exc_len == 2:
138 new_exc = sorted([exc[0], exc[1], optimized_exc[0]]) + sorted(
139 [exc[2], exc[3], optimized_exc[1]]
140 )
141 elif exc_len == 4 and opt_exc_len == 4:
142 new_exc = sorted(
143 [exc[0], exc[1], optimized_exc[0], optimized_exc[1]]
144 ) + sorted([exc[2], exc[3], optimized_exc[2], optimized_exc[3]])
145 else:
146 continue
147
148 if len(set(new_exc)) != len(new_exc):
149 continue
150 th = 0
151 ht = 0
152 if "t" in current_coeffs[optimized_exc] and "h" in current_coeffs[exc]:
153 # print(
154 # thresh,
155 # f"t{opt_exc_len//2}",
156 # f"h{exc_len//2}",
157 # len(new_exc) // 2,
158 # current_coeffs[optimized_exc]["t"],
159 # current_coeffs[exc]["h"],
160 # )
161 th = current_coeffs[optimized_exc]["t"] * current_coeffs[exc]["h"]
162 if "t" in current_coeffs[exc] and "h" in current_coeffs[optimized_exc]:
163 # print(
164 # thresh,
165 # f"h{opt_exc_len//2}",
166 # f"t{exc_len//2}",
167 # len(new_exc) // 2,
168 # current_coeffs[optimized_exc]["h"],
169 # current_coeffs[exc]["t"],
170 # )
171 ht = current_coeffs[optimized_exc]["h"] * current_coeffs[exc]["t"]
172
173 new_exc = tuple(new_exc)
174 if new_exc not in current_coeffs:
175 current_coeffs[new_exc] = {}
176
177 current_coeffs[new_exc]["th"] = max(
178 current_coeffs[new_exc].get("th", 0), abs(th)
179 )
180 current_coeffs[new_exc]["ht"] = max(
181 current_coeffs[new_exc].get("ht", 0), abs(ht)
182 )
183
184 for exc in current_coeffs.keys():
185 if exc in current_excitations:
186 continue
187
188 coeffs = list(map(abs, current_coeffs[exc].values()))
189 max_coeff = max(coeffs)
190 if max_coeff > thresh:
191 print("ADDED", exc)
192 current_excitations.append(exc)
193
194 current_theta = [
195 current_coeffs[exc]["t"] if "t" in current_coeffs[exc] else 0.01
196 for exc in current_excitations
197 ]
198
199 cluster_ops = build_cluster_ops(current_excitations, nqbits)
200 _, _, cluster_ops_sp = _apply_transforms(cluster_ops, "JW")
201
202 return current_excitations, current_theta, cluster_ops_sp
203
204
205def iterate(hamiltonian_sp, ansatz_ops, hf_init_sp, theta_current, fci):
206 iterations, result = EnergyUCC().get_energies(
207 hamiltonian_sp, ansatz_ops, hf_init_sp, theta_current, fci, "BFGS"
208 )
209 new_theta = iterations["theta_optimized_result"][0]
210 energy = result["energies_substracted_from_FCI"]
211 print("ENERGY ERROR", energy)
212
213 return new_theta, energy
214
215
216def energy_stop_condition(energy):
217 return False
218
219
220thresholds = iter(
221 [0.04, 0.02, 0.01, 0.005, 0.002, 0.001, 0.0005, 0.0002, 1e-4, 1e-5, 1e-6, 1e-7]
222)
223hamiltonian_sp, hf_init_sp, fci, current_coeffs, nqbits = init("LIH")
224current_excitations = []
225thresh = next(thresholds)
226
227just_count = 0
228while True:
229 prev_num_excitations = len(current_excitations)
230 current_excitations, current_theta, cluster_ops_sp = update_ansatz(
231 current_excitations, current_coeffs, thresh, nqbits
232 )
233 if len(current_excitations) == prev_num_excitations:
234 try:
235 thresh = next(thresholds)
236 except StopIteration:
237 break
238 continue
239 print("Optimization:", just_count)
240 just_count += 1
241
242
243
244 new_theta, energy = iterate(
245 hamiltonian_sp, cluster_ops_sp, hf_init_sp, current_theta, fci
246 )
247 if energy_stop_condition(energy):
248 break
249
250 for i, exc in enumerate(current_excitations):
251 current_coeffs[exc]["t"] = new_theta[i]
252
253
254for exc in current_excitations:
255 print(exc)

Analytical Results

We test UsCCSDTQ-VQE on H$_4$ and LiH molecules using PMRS method (described in the previous section). We emulate 8 qubits in STO-3G basis set. Numerical results are shown in Figure 1 for H$_4$ and 2 LiH for as below:

Figure 1: PMRS application on UsCCSDTQ-VQE algorithm using H₄ molecule (8 qubits) at 0.85Å, using BFGS optimizer: (left figure) shows the energy obtained from UsCC simulations with respect to the number of selective parameters. (Right figure) shows the number of function evaluations per each iteration. Error is the difference between UsCCDTQ energies and FCI. STO-3G basis set is used.

Figure 2: PMRS application on UsCCSDTQ-VQE algorithm using LiH molecule (12 qubits) at 1.45Å, using BFGS optimizer: (left figure) shows the energy obtained from UsCC simulations with respect to the number of selective parameters. (Right figure) shows the number of function evaluations per each iteration. Error is the difference between UsCCDTQ energies and FCI. STO-3G basis set is used.

We observe that only three iterations are needed to reach $10^{-9}$ Hartee for H$_4$ (with overall 19 parameters to optimize, with function evaluations 225 (first iteration), 198 (second iteration) and 180( third iteration)) and 13 iterations are needed for LiH reach to 1.06 $\times 10^{-5}$ Hartree, with about 45 function evaluations. We observe that PMRS helps reduce the number of function evaluations in both systems, which would exceed 1000 if PMRS were not used. This is demonstrated in the below table

$\bm{r_{\text{Li} - \text{H}}}$	Selective Parameters	Functions Evaluation	Gradient Evaluation	Error (Ha)
$0.5\mathring{\text{A}}$	54	10938	226	$3.7\times 10^{-13}$
$1.0\mathring{\text{A}}$	68	10795	247	$4.4\times 10^{-13}$
$1.5\mathring{\text{A}}$	72	10640	242	$7.84\times 10^{-13}$
$2.0\mathring{\text{A}}$	68	11406	263	$1.96\times 10^{-12}$

Table 1: Test UsCCSDTQ-VQE on LiH 12 qubits. BFGS optimizer, tolerance $10^{-6}$ (Hartree), STO-3G basis set is used. (Molecule LiH at $r_{\text{Li} -\text{H}} = \left[0.5 - 2.0 \right] \mathring{\text{A}}$)

References

Fedorov, Dmitry A., et al. "Unitary selective coupled-cluster method." Quantum 6 (2022): 703.
Haidar, Mohammad, et al. "Open source variational quantum eigensolver extension of the quantum learning machine for quantum chemistry." Wiley Interdisciplinary Reviews: Computational Molecular Science 13.5 (2023): e1664.

About the author

Huy Binh TRAN
Master 2 Quantum Devices at Institute Paris Polytechnic, France
LinkedIn