Norway5.jpg.cropped960x442o0,-423s975x972

TundraSystems Quantum Software

Near term, the next generation of quantum technologies will be Noisy Intermediate-Scale Quantum (NISQ) i.e. quantum computers with a number of qubits ranging from 50 to several hundred. Fifty qubits are a significant milestone as it’s beyond what can be simulated using the most powerful existing digital supercomputers. However, the potential of the few specialist NISQ devices is restricted by the relatively large classical computers that control them. One solution is to embed a quantum co-processor within a larger classical architecture. However, simulation of a quantum computer on a classical device presents challenges, in particular the quality of the qubits and error rate. To enhance performance optimising the delicate interface between the classical and quantum halves is crucial.

Design and implementation of the quantum processing unit (QPU) and the quantum instruction set architecture (QISA) at the classical interface to control it, are core parts of the ambitious work at TundraSystems.

The objective is to develop the Classical-Quantum interface; to achieve this we will create novel software tools that form unique ‘middleware’ to intermediate between the higher-level operating system and the classical and quantum hardware. These tools include a cross-compiler and translators targeting different computational hardware platforms offering robust inter-operability across a range of quantum and classical computers. Building on this work, we will develop a more general portable operating system for universal quantum computation to support further translation and expedite adoption near-term. This will materialize in the form of the development of the TundraQOSTM (Quantum Operating System); a universal quantum operating system with classical control. The TundraQOSTM will offer a revolutionary solution to fast-track the exploitation and commercialisation of quantum computing within the next half decade.

Quantum programmers work in high-level quantum programming languages, that afford powerful features such as variables, functions, and recursion. But when these high-level languages are converted into machine instructions for the actual hardware, there are orders of magnitude more boilerplate instructions that a classical controller could handle, than there are instructions that can only be performed on quantum hardware. This translation loses efficiency. How can we best rearrange it, so that the cheap classical controller handles the boilerplate bookkeeping, and the expensive QPU is used optimally? That is the technological challenge we at TundraSystems are addressing. None of the state-of-the-art quantum specification platforms identified above address this second-generation implementation challenge in any way.

High-level quantum programming languages, such as the open-source Quipper, or Microsoft’s Q#, come with compilers. When a high-level quantum program is currently compiled, the resulting machine code is taken up to a very large extent by non-quantum pieces: there are hugely many fewer quantum instructions than there are boilerplate classical instructions around them. The relatively limited NISQ devices are similarly dwarfed by relatively large classical computers that control them. The most obvious near-term quantum computer consists of a tiny quantum co-processor embedded in a much larger classical architecture. How can we make more efficient compiler? We want to let the classical controller handle as much of the bookkeeping as possible, optimising the use of the quantum co-processor for the crucial instructions only it can execute. This is the pain point addressed lies at the interface between the classical and quantum halves. How can we efficiently maximise the utilisation of the two halves, especially the expensive quantum half?

The first generation of quantum computing developments have seen NISQ prototypes such as the IBM-Q, Google’s Bristlecone and Skylake processors, and Rigetti’s platform. TundraSystem’s efforts embark on a second generation, focused on integrating one or more of these first generation NISQ devices with a larger classical controller, and then developing a suitable unified software control and execution environment.

The state of the art in quantum software space consists of

  • High-level programming languages such as the open-source Quipper, Microsoft’s Q#, and Rigetti’s Forest;
  • Low-level machine languages such as OpenQASM;
  • Hybrid experimental languages such as the purely graphical ZX calculus, which are universal but remain theoretical for now.

The problem is translating between these languages in a way that uses the quantum parts of the hardware as efficiently as possible. Current translations assume that the resulting code will be run on massive devices that are exclusively quantum, which is simply not realistic for NISQ hardware.

Our efforts focus on this second-generation quantum software technology. It will map high-level quantum programming languages onto realistic hardware that includes only a small number of NISQ quantum co-processors. Achieving this will expedite the commercial application of quantum computing e.g. in pharmaceutical and financial industries near-term.

The goal of this TundraSystem’s effort is to design a low-level language that can instruct both a classical controller and a QPU in the form of a technology agnostic QISA. Working with quantum software experts at the University of Edinburgh, we are developing an early prototype of three crucial interoperating pieces of the required technology to bridge the gap between layers in a full quantum technology stack:

  1. a low-level language that can instruct both a classical controller and a quantum coprocessor (QISA);
  2. a cross-compiler that converts higher-level languages into this QISA;
  3. a scheduler that can easily balance instructions over the delicate interface of the classical and quantum halves of a possibly distributed NISQ quantum computing network.

Successful outcomes will support a further validation study with the technology integrated into a commercially ready quantum operating system (TundraQOSTM) which can be applied across a range of sectors.

This second-generation quantum software technology will expedite commercial applications near-term. Our solution builds on academic research expertise in AI and data-driven innovation and industry expertise to engineer these foundational tools into fit-for-purpose commercial products. The Quantum Informatics team at the University of Edinburgh has very relevant expertise:

  • Measurement-Based Quantum Computing (MBQC) is a universal framework whereby the entire computation consists entirely of local measurements and classically feeding forward their results.
  • The Andres-Martinez-Heunen algorithm is an automatic and efficient way to distribute a larger quantum computation among several smaller communicating QPUs.

We will adapt the foundational tools provided by MBQC and the AMH algorithm to develop the desired QISA. This phase will input domain-specific knowledge from quantum instruction languages. Existing compilers from higher-level quantum programming languages typically output quantum circuits. While translations from quantum circuits into MBQC exist, they are not optimal. We will adapt an existing compiler to convert not into circuits, but instead into the developed QISA earlier on in the development pipeline. This will produce the desired scheduler as a by-product. We will quantify the results from the compiler and scheduler using metrics that are appropriate in this case, as suggested by the AMH algorithm, namely the load balance between the QPU and the classical controller.

Share this post

Share on facebook
Share on google
Share on twitter
Share on linkedin
Share on pinterest
Share on print
Share on email