What is InQuanto?

InQuanto is Quantinuum’s state-of-the-art Python-based quantum computational chemistry platform. It is designed to facilitate quantum computational chemistry for researchers in industry and academia, and to provide an ecosystem for quantum researchers to develop and implement novel algorithms for chemical problems.

Why use InQuanto?

Computational chemistry aims to accurately model the behavior of electrons and nuclei in molecules and materials. Modeling these electrons and nuclei allows one to evaluate, from first principles, chemically meaningful properties such as bond energies or reaction rates. These particles are intrinsically quantum, and have properties that are challenging to compute accurately on classical computers. The most accurate classical methods have only been applied to tens of atoms, even on the largest computing resources, but chemically meaningful molecules often have thousands of electrons. Quantum computers are predicted to be better at storing and manipulating highly entangled states, such as systems of interacting electrons, than classical computers. Consequently, chemistry is generally considered to be among the first fields in which quantum computing can outperform classical computing, unlocking accurate modeling of larger, more complex systems. This would be an example of quantum advantage.

Whilst InQuanto contains a broad set of tools for quantum computational chemistry, it has also been developed and deployed to support collaborations with industry partners to ensure that there are robust, practical algorithms for calculating chemical quantities on Noisy Intermediate-Scale Quantum (NISQ) devices. For example, we have shown how InQuanto can be applied to carbon capture in metal-organic frameworks, utilizing NISQ experiments and an efficient fragmentation scheme to model dissociation. [1] A more complete list of example publications is available online.

Looking beyond the NISQ era, InQuanto is scoped for the regime of fault-tolerant quantum computation in a number of ways. Firstly, current algorithms will become easier to evaluate and give more precise answers. Secondly, specifically fault-tolerant algorithms are currently in development in the context of chemistry, such as quantum phase estimation. InQuanto is also coupled to, and will take advantage of, other research work in Quantinuum on fault-tolerant methods, such as quantum signal processing, [2, 3] to improve the capabilities and performance of chemical calculations. Additionally, building on top of TKET ^TM means users can easily switch between, and experiment with, different quantum hardware and quantum simulator, allowing easier pivoting to the best devices.

How it works

InQuanto is designed to support the complete quantum computational chemistry pipeline, therefore it has tools to process several steps. A simplified version of these steps is presented in Fig. 1, and we relate this to the codebase in the manual introduction.

Fig. 1 Schematic overview of the InQuanto platform.

Chemical problem

Firstly, the user defines the chemical problem, which is given by the physical quantity of interest and the atomic structure of the system. For example, one could be interested in modeling protein binding strengths or chromophore excitation.

InQuantize

Next, the chemical problem must be InQuantized, or interpreted as an appropriate quantum computational problem. For example, excitation calculations can be performed by representing the electronic states using X and the Hamiltonian using Y, solving the problem using the quantum algorithm Z. This is where InQuanto excels: in creating efficient representations of chemical problems and offering a range of quantum algorithms and methods.

Circuit construction and experimentation

Thirdly, the quantum problem is compiled into quantum circuits. InQuanto utilizes TKET, Quantinuum’s quantum SDK, to a) further optimize the constructed circuits (reducing depth, and complexity), and b) to deploy the circuits to a wide range of quantum hardware and simulator options.

Analysis

When an experiment/simulation is complete, measurements are collected. These measurements need to be analyzed to be related back to the chemical problem. This may include error mitigation steps. Often there is a loop between analysis and further experimentation/simulation, for example in variational quantum algorithms.

Results

When the algorithm and analysis is complete, post-processing yields results, such as binding energies or spectra.

Throughout the whole pipeline, InQuanto has tools for analyzing and limiting the amount of error that occurs in Noisy Intermediate-Scale Quantum devices. Whilst InQuanto includes streamlined routines, it is a modular Python toolbox which allows scientists to easily mix and match components and build their own research scripts.

Powered by TKET ^TM

Current quantum computers have limited capabilities. In order to exploit them efficiently, several considerations have to be made. First, in general it is desirable to reduce the circuit depth and complexity to reduce the amount of noise that is accumulated during circuit processing. However, this must be done without changing the accuracy of the circuit. There are also unique intricacies to each quantum architecture. For example, different operations may have more or less noise, or the device may have restricted connectivity between qubits.

To adapt the quantum circuits to difference devices we use TKET . Among other tools, TKET has routines for: efficient qubit routing for device architecture, mapping circuits to different gate sets, and finding shortcuts in circuit structures. Utilizing TKET underneath InQuanto allows one to focus on the chemistry and deploy effectively to a variety of backends without thinking too much about technical details.

InQuanto utilizes pytket, a python interface to TKET. Users can also take control of many InQuanto objects (e.g. circuits) using native pytket methods. pytket’s documentation can be found here, and the list of devices and backends that InQuanto can interface with through pytket-extensions can be found here. In the hardware tutorials we present examples of using pytket-extensions to interface with difference devices, such as through using pytket-qiskit.