As we explained earlier this year, operating a quantum computer requires a significant investment in classical computing resources given the amount of measurements and control operations that need to be performed and interpreted. This means that for a quantum computer to work, it also requires a software stack to control and interpret the flow of information from the quantum side.
But long before anything is executed, software is also involved. Although it is possible to run algorithms on quantum hardware by defining the complete set of commands sent to the hardware, most users are not interested in the control details of a single piece of quantum hardware. I would like to focus on algorithm development. “If we all had to go down and figure out what that sound was. [use] Developing performance management tools requires knowing how to compile quantum circuits through hardware, and doing algorithmic discovery requires a lot of expertise,” said IBM’s Jay. Gambetta said. The software stacks that companies are developing to control quantum hardware include software that translates abstract representations of quantum algorithms into the set of commands needed to run them.
IBM’s version of this software It’s called Qiskit (However, it was open sourced and subsequently adopted by other companies). Recently, IBM made several announcements regarding Qiskit, benchmarking it against other software stacks and opening it up to third-party modules. Before we get into the details of the new features, let’s take a look at what the software stack does.
What does the software stack do?
It’s tempting to equate IBM’s Qiskit with a compiler. At the most basic level, this is a reasonable analogy in that it takes a human-defined algorithm and translates it into something that can be executed on hardware. But there are big differences in the details. Traditional computer compilers generate code that a computer’s processor translates into internal instructions that are used to configure the processor’s hardware and perform operations.
Even when using so-called “machine language”, programmers do not directly control the hardware. Programmers have no control over where things are executed on the hardware (i.e., which processor or execution unit within that processor) or even the order in which instructions are executed.
The situation is very different with quantum computers, at least for now. First, everything that happens on the processor is controlled by external hardware, which typically works by generating a series of laser or microwave pulses. So software like IBM’s Qiskit and Microsoft’s Q# work by converting code given to them into commands that are sent to hardware external to the processor.
These “compilers” also need to track exactly which part of the processor is having problems. Quantum computers work by performing specific operations (called gates) on individual qubits or pairs of qubits. To do that, we need to know exactly which qubit we are addressing. Additionally, in the case of superconducting qubits, etc., there may be variations between devices, so which hardware qubit is ultimately used can have a significant impact on the results of calculations.
As a result, most, such as Qiskit, offer the option of addressing the hardware directly. However, if the programmer chooses not to do so, the software can translate the general instructions into a precise sequence of actions that execute the encoded algorithm. This involves the software stack making choices about which physical qubits to use, which gates and measurements to perform, and in what order to perform them.
However, the role of the software stack is likely to expand significantly in the coming years. Many companies are experimenting with hardware qubit designs that can flag when certain types of common errors occur, and progress is also being made in developing logical qubits that enable error correction. . Ultimately, companies providing access to quantum computers will want to modify their software stacks to enable these capabilities without requiring any effort on the part of those designing the algorithms.
