Exploring quantum chemistry applications with Tangelo and QEMIST Cloud using Amazon Braket

This post was contributed by Alexandre Fleury, Erika Lloyd, James Brown, Krzysztof Bieniasz, and Valentin Senicourt at Good Chemistry and Perminder Singh at AWS.

The simulation of electronic structure at the atomic level is an essential tool for understanding the chemical properties of molecules. It is a basis for contemporary materials design and drug discovery. Performing accurate electronic structure simulations on classical computers requires computational resources that scale exponentially with system size. This means that only relatively simple molecules can ever be perfectly simulated on classical computers, of any size. However, quantum computers might offer the possibility to create perfect simulations, digital twins, of almost any molecule.

However, while quantum computers are already available in the cloud, they have limited capabilities. Successfully applying this nascent technology to meaningful use cases is an open research topic, and often requires the implementation of complex workflows including classical pre- and post-processing steps. To address this, Good Chemistry has developed QEMIST Cloud, a high-throughput, high-accuracy chemistry platform on AWS. In order to both extend the capabilities of QEMIST Cloud to integrate with quantum computers and accelerate research in the field, Good Chemistry has developed and open-sourced Tangelo, a python package for chemistry workflows on quantum computers.

In this blog post, we illustrate how these tools allow the community to further explore the potential of quantum computing for non-trivial molecular systems, and streamline the design of experiments that you can run on Amazon Braket, the quantum computing service of AWS.

Our companion notebook provides access to the code necessary to recreate the results shown in this blog, and contains additional technical details.

A use case related to umbrella inversion

Amines are a varied class of chemical compounds characterized by the presence of one or many nitrogen centers, with which three bonds can be formed, according to the octet rule. Their chemical and industrial relevance cannot be overstated, as amines are some of the most prevalent biologically active molecules, including amino acids and neurotransmitters. As much as 42% of all pharmaceutical drugs contain amine functional groups, making them one of the most relevant targets for novel drug discovery. Their use in the production of dyes and epoxy resins makes them a focal point for many industrial chemical companies. Finally, their use in gas refineries for the removal of and suggests a potential for application to greenhouse gas sequestration.

An interesting effect which can be observed in these compounds is the amine inversion, commonly referred to as the umbrella (or pyramidal) inversion. In this phenomenon, an amine spontaneously alternates between two opposite forms. This effect is caused by the free electron pair tunneling between one side of the stereocenter nitrogen to the other, each time squeezing the functional groups through the plane to the opposite side. In this process, the bond structure resembles an umbrella being flipped inside-out in a strong wind. It is one of the most readily observable instances of quantum tunneling, which can be easily observed in infra-red spectroscopy.

This phenomenon has a significant role in chemical mechanisms behind the proton diffusion in water, which involves the hydronium cation H₃O⁺, featuring one oxygen center. Fundamental knowledge about this has implications in the materials industry, with one example being the design of proton-exchange membranes(PEM) for fuel cells. At Good Chemistry, we are focused on materials science research, so in this blog we consider the hydronium cation to explore the umbrella inversion (illustrated in figure 1). The energy barrier associated with this geometry change is relatively short and narrow – on the order of 2 kcal/mol which results in a large tunneling rate.

Figure 1: Simple depiction of the umbrella inversion with the hydronium cation. In the cc-pVDZ basis, we represent the H3O+molecular problem with 29 molecular orbitals (MOs) and 10 electrons.

However, computing the ground state energy of even this simple system is beyond the capabilities of current quantum devices. For instance, a straightforward approach using the Variational Quantum Eigensolver (VQE) algorithm with the UCCSD ansatz would yield circuits requiring over 50 qubits, millions of gates, and hundreds of thousands of variational parameters. In order to explore this problem with current quantum computing hardware, a more sophisticated workflow is necessary.

Tangelo provides pre-built algorithms and toolboxes to express complex workflows, including classical pre- and post-processing of quantum computation. It supports you in designing quantum hardware experiments and facilitates advances in quantum algorithm development. Figure 2 illustrates the main steps that occur in a quantum computing workflow for electronic structure calculations. Tangelo provides a flexible and extensible framework to explore quantum workflows with a collection of reusable building blocks that can be combined with user-defined code. We illustrate this approach in the rest of this blog post and the companion notebook.

Figure 2: Simplified representation of a quantum computing workflow for quantum chemistry problems, highlighting the main steps of the process. Dotted arrows represent optional steps. a. Problem decomposition methods (MI-FNO, etc.) can be paired with quantum algorithms, in order to lower computational resource requirements of a molecular system. b. Optional pre-processing steps aiming at designing efficient measurement protocols, or maximizing accuracy of results (circuit compilation, optimizations, etc.)

The next sections describe how tools such as QEMIST Cloud, Tangelo and Amazon Braket can be combined to push the limits of what is possible on current quantum devices. Using these tools, we define a workflow that brings the computational requirements within reach of current quantum devices, and run an experiment on the trapped-ion IonQ device with Amazon Braket. We also describe how other algorithms in Tangelo can be used to simulate the tunneling inversion process.

Combining QEMIST Cloud, Tangelo and Amazon Braket

QEMIST Cloud, Good Chemistry’s platform that enables high-accuracy quantum chemistry simulations in the cloud, features state-of-the-art quantum chemistry algorithms, including implementations of fragmentation techniques such as the Method of Increments (MI-FNO) and incremental Full Configuration Interaction (iFCI). These approaches reduce the need for computational resources by decomposing the initial problem into a collection of independent sub-problems of lower complexity. Those sub-problems can then be solved classically on a large number of compute instances, asynchronously and in parallel. You can learn more about how Good Chemistry scaled this approach to provide the first near-exact accuracy simulation for bond-breaking in PFAS molecules, also known as “forever chemicals”, using up to 1.1 million vCPU cores in this AWS HPC blog post.

This same problem decomposition process can also be used to reduce the compute requirements when using quantum computers. Good Chemistry takes advantage of this capability in Tangelo, our open-source Python package, by importing the sub-problems from QEMIST Cloud and orchestrating efficient workflows to perform experiments on actual quantum hardware, using services such as Amazon Braket. Figure 3 illustrates how Tangelo and QEMIST Cloud rely on several AWS services to run these hybrid workloads. Note that while MI-FNO is only available through QEMIST Cloud, Tangelo offers other built-in problem decomposition techniques.

Figure 3: a. Tangelo users with an existing Braket account can use the Braket API or the Tangelo wrappers to interact with the service and run their experiments. b. QEMIST Cloud uses Tangelo as a plug-in to provide additional features and services to its users, which are fully integrated through its client library and dashboard. On the one hand, users can perform problem decomposition on the cloud, retrieve the results from S3 and import them into Tangelo to explore new use cases. On the other hand, Tangelo users can take their QEMIST Cloud credentials and make calls to the QEMIST Cloud client library to run quantum experiments on Braket on their behalf, using QEMIST Cloud credits.

Tackling larger systems with QEMIST Cloud

The experiments in this study rely on MI-FNO for reducing problem size, and facilitating the ground-state energy calculations present in our study. The full molecular computational space is defined in terms of occupied orbitals (i, j, k,...) and virtual orbitals (a, b, c,...). The Method of Increments decomposes the occupied space into smaller 1-, 2-, 3- and higher n-body increments which consists of one, two, three and up to n active electron pairs, respectively for an n-body expansion. The virtual space of a given n-body increment can be reduced by using the FNO procedure. These subproblems can then be solved independently, using classical or quantum algorithms.

Next, we’ll illustrate how you can use quantum computers on larger systems by solving one of the 1-body fragments with the ADAPT-VQE algorithm, while solving the other fragments with a classical solver, the Heat-Bath Configuration Interaction (HBCI) method. Figure 4 depicts this approach for the hydronium cation H₃O⁺.

Figure 4: Illustration of MI-FNO applied to the optimal geometry of H3O+. All the fragments are solved with HBCI (classical solver) to obtain reference results. Our quantum experiment aims to recompute the energy for one of these fragments using the ADAPT-VQE quantum algorithm in Tangelo.

For our illustration, we focus on the optimal geometry of H₃O⁺, characterized by a H-O distance of 0.986Å and an angle between that bond and the C₃ rotational axis of around 70 degrees, in the cc-pVDZ chemical basis. The code snippet in section 3 of the companion notebook shows how the QEMIST Cloud client library builds the corresponding molecule object, employs the MI-FNO approach to decompose this molecule into 1-, 2- and 3-body fragments, and performs the energy calculations classically using a HBCI solver. It returns a problem handle that can be used to monitor the status of the job and retrieve the results through the API or using the QEMIST Cloud dashboard. These results include the MI-FNO energy computed for H₃O⁺, as well as a per-fragment breakdown detailing the correlation energy contributed by each sub-problem. As further shown in the companion notebook, we obtained a total MI-FNO energy of -76.52019 Ha for this system and the simulation resulted in four 1-body fragments, six 2-body fragments, and four 3-body fragments.

Designing a quantum experiment with Tangelo

Section 3 and 4 of the notebook illustrate how Tangelo can compute the fermionic and qubit Hamiltonians of the target fragment. These objects are used to implement an approach based on the ADAPT-VQE algorithm, combined with a Qubit Coupled Cluster (QCC) ansatz and a DIS operator pool, to generate a shallow quantum circuit with optimized variational parameters. Here, the operator pool is provided as a user-defined function called qcc_pool, and takes as input a set of arguments referred to as pool_args (section 4 of the notebook illustrates how simple it is).

Algorithms in Tangelo can be run using various quantum circuit simulators, including the simulators and gate-model quantum devices available in Amazon Braket, and even user-defined backends. In the code snippet below, we run it on a local exact simulator.

from tangelo.algorithms import ADAPTSolver

pool_args = {"mol": mol, "mapping": "scbk", "up_then_down": True, "qubit_hamiltonian": qu_op}
opt_dict = {"molecule": mol, "qubit_mapping": "scbk", "pool": qcc_pool, "pool_args": pool_args,
            "up_then_down": True}

adapt_solver = ADAPTSolver(opt_dict)
adapt_solver.build()
opt_energy = adapt_solver.simulate()

adapt_circ = adapt_solver.vqe_solver.optimal_circuit

Figure 5: The resulting quantum circuit. The optimal value found for θ is approximately 0.053 π .

The simulator converged to an optimized energy of -76.32902 Ha, very close to the exact fragment energy returned by QEMIST Cloud, which was 76.32905 Ha (a difference of 3 x 10^-5 Ha, well below 0.0016 Ha, referred to as chemical accuracy). This level of agreement between the HBCI and ADAPT-VQE results suggests that this quantum approach is accurate, and that it could be interesting to see how close the numerical results of a hardware experiment are to the reference values.

Algorithms in Tangelo keep track of quantum resource requirements, which are important to determine the feasibility of an experiment on quantum hardware, or compare different approaches on a given use case. The output of the get_resources method shows a shallow optimized circuit that can run on current devices, requiring only a handful of gates.

adapt_solver.get_resources()

{'qubit_hamiltonian_terms': 9, 'circuit_width': 2, 'circuit_gates': 8, 'circuit_2qubit_gates': 2, 'circuit_var_gates': 1, 'vqe_variational_parameters': 1}

Our simple quantum experiment focuses on recomputing the corresponding optimized energy, as performing successive energy evaluations would introduce classical optimization convergence challenges, and quickly become prohibitive in terms of time and cost.

Running the quantum experiment on Amazon Braket

Tangelo assisted us in designing a reasonable approach for this use case, both in terms of resource requirements and computational accuracy. The use of error-mitigation techniques can be crucial to obtain meaningful numerical results with early quantum computers, and learning about how well an algorithm or a device deals with various sources of error. Section 4.2 of the companion notebook shows how we put together a simple noise model based on the one- and two-qubit gate error rates for the trapped-ion device from IonQ “Harmony”, available through Braket, to get a sense of what raw results may look like.

The error observed suggested that applying chemistry-inspired noise-mitigation techniques may improve the accuracy of results. With the help of Amazon Braket, we execute the ADAPT circuit generated above on Harmony, and use it to perform classical shadow tomography, which is an efficient way to classically represent a quantum state. We then use the toolboxes in Tangelo to apply a combination of several additional error-mitigation techniques to the raw results, such as symmetry post-selection and McWeeny’s purification, to recompute the energy of the system. The number of measurements taken for each circuit run has been set to 10,000, which sets the cost of our experiment to $900. The code used in this experiment is detailed in section 5 of the companion notebook.

The first error-mitigation technique consists of state symmetry post-selection to mitigate some of the SPAM errors occurring on the device, based on Bonet et. al. This approach entangles the system with an ancilla qubit, which acts as an indicator of the state symmetry with respect to a symmetry operator, e.g. a Pauli word which commutes with the Hamiltonian. In our case, the symmetry operator is ZZ, which corresponds to the standard measurement basis on the device. We implement this approach in Tangelo by adding an ancilla qubit and appending the gates below to our ADAPT circuit. Post-selection is then accomplished through renormalization of the histograms, by filtering out measurements exhibiting an ancilla value that is not in agreement with the targeted symmetry subspace. Comparing the results of energy calculations with and without this additional step informs us about the impact of noise in the experiment.

Figure 6: State-symmetry verification circuit.

Classical shadow tomography yields a “snapshot” of the quantum state. Tangelo currently provides convenience functions for the construction of randomized, derandomized or adaptive shadows based on tensor products of Pauli operators; we here construct a randomized shadow. The code listing below generates circuits in the nine measurement bases required, by first appending the symmetry verification circuit to the ADAPT circuit, and then appending the gates that transform the system into the eigenbasis of the operator.

Below, we streamline the execution through QEMIST Cloud by using the QEMISTCloudConnection class, and its job_submit and job_result methods. As a result, the jobs can be managed through the QEMIST Cloud dashboard. Note that Tangelo users do not need to have access to QEMIST Cloud to run experiments on Braket, and can simply use our wrappers (upcoming BraketConnection class) or convert their circuit to the Braket format if they’d rather use their own AWS Account. The experiment in the code snippet below can be run on other devices, such as the superconducting devices from Rigetti or OQC, by simply changing the Amazon Resource Name (ARN) to that of the desired processor.

from tangelo.linq.qpu_connection import QEMISTCloudConnection
from tangelo.toolboxes.measurements import RandomizedClassicalShadow

cs_basis_list = ["ZZ", "XZ", "ZX", "XX", "YZ", "ZY", "YY", "XY", "YX"]
job_ids = {}
parity_circ = Circuit([Gate("CNOT", target=2, control=0), Gate("CNOT", target=2, control=1)])

# Create QEMIST Cloud connection object to streamline experiment through QEMIST Cloud
# Users can also use the upcoming BraketConnection class with their Braket account directly
qemcl = QEMISTCloudConnection()

# Create circuit in each measurement basis and submit job to target quantum device
for basis in cs_basis_list:
    meas_circ = Circuit(measurement_basis_gates(pauli_string_to_of(basis)))
    circ_exp = adapt_circ + parity_circ + meas_circ
    job_ids[basis] = qemcl.job_submit(circ_exp, n_shots=10000, 
                                      backend='arn:aws:braket:::device/qpu/ionq/ionQdevice')

# Apply post-selection to raw hardware results, using the ancilla qubit
res = {basis: qemcl.job_result(job_id)[0] for basis, job_id in job_ids.items()}
res_post = {base: post_select(hist, 2, "0") for base, hist in res.items()}

# Construct classical shadow
bitstrings, unitaries = [], []
for b in cs_basis_list:
    for s, f in res_post[b].items():
        factor = round(f*10000)
        bitstrings.extend([s]*factor)
        unitaries.extend([b]*factor)

res_post_cs = RandomizedClassicalShadow(unitaries=unitaries, bitstrings=bitstrings)

The code snippet shows how the symmetry-verified quantum circuits can be submitted to Amazon Braket, before applying post-selection on the data and building the classical shadow. From there, purified RDMs and fragment energy can be reconstructed.

Tangelo facilitates the recomputation of the one- and two-electron reduced density matrices, commonly abbreviated as 1-RDM and 2-RDM. As the fragment consists of a two-electron system, the McWeeny purification technique can be used to further mitigate the errors from decoherence effects, which cause our quantum state to end up in a mixed state. Purification allows us to recover the dominant pure state that we seek. Functions from Tangelo toolboxes allow us to recompute the energy of the fragment, and then the total system (section 5.2 and 5.3 of the companion notebook).

We used bootstrapping to estimate the error of the calculated fragment energy: we generate more data sets by resampling from the experimental histogram, effectively using the experimental data as a statistical distribution to sample from. We repeated this 1000 times to produce an averaged energy, along with its standard deviation. The data presented in table 1 below demonstrates that the symmetry post-selection and state purification not only significantly improved the calculated energy, but also reduced the calculation error by removing noise from the data. Applying the exact same approach to ammonia (NH₃), also in the cc-pVDZ basis, led to similar observations.

Table 1: The quantum results obtained for the H₃O⁺ and NH₃ molecules. The standard deviation was estimated using bootstrapping with 1000 resampled data sets.

To put things into perspective, Figure 7 displays the different corrected total energy values, overlaid on the umbrella curve computed classically with MI-FNO + HBCI for H₃O⁺. The error mitigation techniques improved the accuracy by more than an order of magnitude, reducing the error from 0.05 Ha to 0.002 Ha and approaching chemical accuracy of 1 kcal/mol (~0.0016 Ha).

Figure 7: The experimental results compared to the MI-FNO classical calculation umbrella curve for H₃O⁺, with a zoom region inset. RHF refers to the restricted Hartree-Fock computation.

Simulating the umbrella inversion process

The end-to-end process above can be repeated for many points on the surface, and yield a full potential energy curve which can then be utilized to perform a simulation of the umbrella inversion process. Future quantum computers, capable of handling deeper circuits, will be able to simulate the umbrella inversion. This process would however require simulating circuits made of tens of thousands of gates, while current devices can only handle a few dozens. Tangelo provides a growing collection of fault-tolerant primitives and algorithms, such as multiproduct simulation, linear combination of unitaries and qubitization. We can use the grid-based method to simulate the umbrella inversion on H₃O⁺, as illustrated in the code snippet below (for full details, please consult section 6 of the companion notebook). We approximate the motion by defining a fictitious particle with mass that is defined by:

The length along the inversion process is defined as the distance the nuclei move in mass-weighted coordinates with units

where m_u is the atomic mass unit and a₀ is the Bohr radius. We choose a grid spacing of

with 256 points such that the wave packet propagation is well localized in the simulation box at all times. The mass is defined as the reduced mass of a two-particle system where the three hydrogen nuclei represent one particle and the oxygen nucleus represents the other. This is a reasonable (albeit incomplete) approximation to the inversion process.  In order to perform the simulation, we converted the potential energy curve into a qubit operator (named qu_op_v below) and defined a state-preparation circuit. Here, init_circuit performs the state preparation of the initial wave function defined as:

from tangelo.linq import get_backend
from tangelo.toolboxes.circuits.grid_circuits import get_psquared_circuit
from tangelo.toolboxes.ansatz_generator.ansatz_utils import trotterize

# Define reduced mass of fictitious particle
m = 3*mH*mO/(3*mH+mO)

# Split operator with n_trotter_steps
def trotter_func(n_trotter_steps, time):
    p2_circ = get_psquared_circuit(time/n_trotter_steps/2, dx=dx, mass=m, qubit_list=qubit_list)
    vcirc = trotterize(operator=qu_op_v, time=time/n_trotter_steps, n_trotter_steps=1)
    return (p2_circ + vcirc + p2_circ) * n_trotter_steps

# Instantiate a simulator backend, evolve the system for 50000 a.u
sim = get_backend()
time = 50000
f, _ = sim.simulate(init_circuit + trotter_func(10, time))

The state is evolved for 50,000 atomic units (approximately 1.2  picoseconds) using the split operator method. In the figure below, we see the initial density is localized in the left well signifying that the orientation of the molecule has the three hydrogen atoms below the oxygen nucleus (as depicted on the left side of the inset inversion process figure). The final density on the other hand shows peaks in the right well, which means that there is significant probability that the hydrogen atoms are localized above the oxygen atom. Even though the initial wave packet was localized below the barrier height, the wave packet tunneled through, such that we have successfully witnessed the umbrella inversion!

Figure 8: Illustration of the tunneling process in the H₃O⁺ molecule. A wave packet is initialized in the left well, with an initial energy below the classical barrier at the origin of the x-axis. After evolving the time for 1.2 ps, a non-zero density is visible in the right well, indicating that the classically forbidden region can be crossed (via quantum tunneling).

Conclusion

Investigating more industrially-relevant phenomena and chemical systems with quantum computers will require equipping the research community with the right tools. Meaningful studies on current quantum devices need to account for their limited capabilities, and the presence of noise. We must empower researchers to express complex workflows and design experiments within their budget. Tangelo is an open-source library under an Apache 2.0 license developed to facilitate this exploration and propel advances in the field, supporting researchers in quickly prototyping their ideas and putting them to the test. Although Tangelo users can directly use Braket within their AWS account, QEMIST Cloud users can benefit from problem decomposition at scale and use their QEMIST Cloud credits to submit quantum experiments to Braket, among other services.

Tangelo features a growing collection of algorithms and toolboxes that can also be used to explore open-shell systems and excited states, among other applications,  and was designed to be easily extended by the community to encompass more features in the future. The Tangelo community is growing: whether you are a beginner or a seasoned expert, you can follow or contribute to the developments on the main Github repository or have your work featured in the tutorial / examples repository.

QEMIST Cloud is currently in closed beta. It is possible to sign up to request access to the platform to run experiments. Check out Good Chemistry’s website and their academic grant program to potentially benefit from free QEMIST Cloud credits to use in your research.

For more information regarding the range of quantum devices on Amazon Braket, and to learn more about Amazon Braket see here. Academic researchers interested in running experiments on quantum computers available via Amazon Braket should apply for research credits through the AWS Cloud Credits for Research program.