Technical Munich Team Enables 86% More Quantum Benchmarks on Small Chips

Achieving practical fault-tolerant quantum computing has been limited by inflexible architectures for managing qubits on constrained chips. Technical University of Munich researchers have developed RushHour, a dynamically reconfigurable lattice surgery system which allows algorithms to run efficiently on smaller hardware. This approach enabled 86% of benchmarks to execute successfully where previous methods required sharply larger processors. RushHour is a new system improving how quantum computers manage their resources during calculations.

The team’s approach allows complex algorithms to run on smaller computer chips; this represents progress towards building practical quantum systems capable of tolerating errors. In tests against existing methods, the new system successfully completed computations where others failed entirely, demonstrating its potential for advancing the field. Technical University of Munich researchers unveiled RushHour, a system designed to improve resource management in quantum computers and bring practical fault-tolerant computing closer to reality.

Current methods for managing qubits are often inflexible, requiring pre-allocation of resources which limits performance on smaller chips. The team’s approach dynamically rearranges these resources, akin to rearranging tiles in a mosaic to correct errors and complete the picture, allowing algorithms to run more efficiently. This dynamic reconfiguration also includes an ‘ancilla space’, best understood as extra workspace around a puzzle being assembled, providing temporary auxiliary qubits without impacting core data storage. In tests, 86% of benchmarks ran successfully using RushHour where existing systems failed.

Dynamic lattice surgery enables substantial gains in qubit utilisation and computational speed

Technical University of Munich scientists have successfully demonstrated their new ‘RushHour’ system runs 86% of quantum computing benchmarks where established methods fail completely. Previously, computations demanded chips 1.2 to 3.5 times larger than those now required. This breakthrough originates from dynamic lattice surgery, a technique manipulating qubits by rearranging them during calculations, achieved through a co-design between hardware and compiler software. Close collaboration between hardware design and compiler development at Technical University of Munich drives the performance gain.

The Lattice Management Unit efficiently manages these qubit rearrangements, streamlining operation while allocating resources when needed. Despite real-world limitations, the system operates 4.8 times beyond an idealised machine configuration’s capabilities; this holistic strategy enabled direct evaluation against six state-of-the-art compilers using two distinct resource models to provide comparative data on its effectiveness.

Dynamic qubit reallocation enhances quantum benchmark completion on reduced architectures

‘RushHour’, a demonstrably capable architecture executing 86% of tested benchmarks on smaller physical chips than currently possible with established methods, has been developed. It overcomes inherent limitations in static qubit allocation by enabling reconfiguration during computation, previous systems pre-allocate qubits and routing pathways regardless of immediate need. Substantial gains in resource efficiency are apparent for constrained hardware configurations.

This new design achieves median speedups ranging from 2.0 to 7.2 times compared to the best performing alternative compilers when operating within space constraints; this suggests considerable reductions in execution time are achievable. Performance remains below theoretical limits at 4.8 times slower than an “idealised machine”, indicating ongoing optimisation opportunities exist before reaching peak potential. While acknowledging these limitations, operation against variations in chip quality or noise beyond those tested isn’t addressed.

Dynamic Resource Allocation Optimises Fault Tolerant Quantum Computation

The researchers have developed RushHour, a dynamically reconfigurable architecture for lattice surgery used in fault-tolerant quantum computing that allows complex algorithms to operate with limited hardware resources. Existing methods rigidly allocate qubits and routing space prior to execution, hindering performance and scalability. RushHour addresses this through dynamic allocation of resource states and reconfiguration of ancilla space; an ‘ancilla’ is a temporary qubit assisting the main computation.

This approach optimises both chip size and computational speed across the entire “space-time trade-off” using a single system. The team realised this capability via co-design involving a new instruction set architecture (ISA), Lattice Management Unit, and RushHour Compiler. Evaluations against six state-of-the-art compilers revealed that it enables 86% of benchmarks to run on chips where existing methods fail, requiring hardware between 1.2 and 3.5 times larger.

On early fault-tolerant quantum computing chips limited by space, median speedups range from 2.0 to 7.2 compared to alternative approaches while matching performance levels seen in much larger systems. Future work should explore durability against variations in chip quality or noise beyond those tested during these benchmark evaluations. The team’s development of RushHour represents an advance in managing quantum resources. Unlike rigid pre-allocation methods, it dynamically reconfigures them as needed allowing complex algorithms to execute on smaller processors and overcome limitations imposed by constrained chip sizes. This enabled successful completion of benchmarks where existing systems failed entirely, demonstrating its potential for unlocking more efficient fault-tolerant quantum computing.

The research demonstrates that dynamic lattice surgery allows quantum computations to run efficiently on chips with limited space and processing power. By dynamically allocating ancilla qubits and resource states, the new system, named RushHour, overcomes restrictions present in earlier approaches which required fixed hardware configurations. Results showed that 86% of tested programs ran successfully using RushHour when they could not be executed via other methods, while also achieving speedups between 2.0 and 7.2 times faster on smaller chips. The authors suggest future work will focus on improving performance under varying chip conditions and noise levels.