Important Milestone achieved
After more than a year of hard work, eleQtron and Fraunhofer Fokus are pleased to announce the completion of an important milestone in the development of our quantum software stack. This milestone required the successful integration of the firmware for a single register eleQtron quantum computer and the next higher software layer of the hardware specific compiler. This critical development step is essential for the overall success of our joint project and marks a significant achievement in our journey. In addition to the milestone requirement, we also demonstrated the compilation and execution of a Qrisp program by the quantum software stack.
The connected software layers:
MAGIC OS - eleQtron Firmware
The eleQtron firmware, also called MAGIC OS, controls, calibrates, and monitors all hardware components of the eleQtron quantum computer. This software layer must deterministically execute the requested quantum circuits on the hardware. The firmware runs on a control computer. The real-time critical instructions of a quantum circuit are additionally compiled on the control computer and then executed on a separate real-time computer. In MAGIC technology, qubits are mainly manipulated by microwave pulses. Laser sources and optical sensors are only needed for the preparation and evaluation of a quantum program.
Thrift Interface
The interface is implemented using a client-server architecture. A server is hosted on the control computer of the quantum computer and provides an API. Another computer can connect to the control computer as a client and exchange data. The control computer receives the quantum circuits as a sequence of gates.
CoMAGIC - Compiler for MAGIC based ion trapped quantum computers
The CoMAGIC compiler for ion trap-based quantum computers is needed to translate the circuits that describe the operations of a quantum computer into the native instructions that can be executed by the hardware. The compiler is currently limited to single registers but will be extended to multiple registers and constrained topologies in the future.
Qrisp – Higher programming language
Qrisp is a high-level programming language for quantum computing. Qrisp is designed to allow programmers to write highly complex quantum algorithms with the ease of a modern programming language, while compiling down to the circuit level. By automating many of the low-level coding tasks, we aim to make this field of research accessible to a wide range of developers. Qrisp will soon be available as open-source software package. The documentation can already be found under qrisp.eu
Demonstration of the quantum software stack
Since in the first quarter of 2023 there was not yet a functional quantum computer, the firmware was tested on a simulation model. This allowed a partial real testing of hardware components, while qubits and measurement processes remained simulated. The microwave source for qubit manipulation and the real-time computer were tested on real hardware. The client ran the hardware-specific compiler, compiled a Qrisp program into a quantum circuit, and sent it to the firmware. The control computer returned measurement results for all circuit runs. The following example shows a compact Qrisp program that defines two single-qubit QuantumFloat variables and adds them in place. Although limited to the values 0 and 1, its simplicity demonstrates the interconnections of the software layers. The easy-to-understand Qrisp high-level programming language is compiled into an assembler-like quantum circuit and translated for eleQtron hardware compatibility. The microwave pulses shown in the figure, which implement the “0 + 1” operation on a quantum computer, serve as proof of concept.
from qrisp import QuantumFloat, transpile
from CoMAGIC.GZZ_synthesis import transpile_zyz
from qrisp.interface import BackendClient
qf_0 = QuantumFloat(1, 0)
qf_1 = QuantumFloat(1, 0)
qf_0[:] = 0
qf_1[:] = 1
qf_0 += qf_1
qc = transpile_zyz(qf_0.qs)
magic_backend = BackendClient(socket_ip = "192.168.100.27", port = 8081)
result = magic_backend.run(transpile(qc, 1), shots = 2, token = "lorem ipsum")
print(result)
