How a Munich Research Team Boosted a Small Quantum Chip’s Performance by 86% with Dynamic Lattice Surgery

The Moment a Tiny Chip Outran a Giant Quantum Computer: The New Bottleneck in Quantum Computing

What if the number of executable quantum benchmarks increased by 86% without adding a single qubit? This is more than a simple performance improvement. It signals that the competitiveness of Quantum Computing is no longer determined solely by “who can build the largest chip.”

A research team in Munich, Germany, has presented a way to run more advanced quantum benchmarks on a small quantum chip with limited physical resources by using Dynamic Lattice Surgery. Instead of expanding the chip, the key is to continuously rearrange and reuse the error-correction lattice space on the chip to match the computational process.

They did not make a small chip bigger. They made the rules governing the space used by that small chip smarter.

Because quantum computers are vulnerable to noise and decoherence, practical computations require multiple physical qubits to be combined into a single logical qubit. In particular, within surface-code-based error correction, logical-qubit patches occupy a substantial amount of physical space. As a result, even if a chip contains many qubits, the scale of error-corrected circuits it can actually run may still be limited.

In conventional static lattice surgery, patch layouts remain relatively fixed, making it easy for some space to sit unused. Dynamic Lattice Surgery, by contrast, shrinks or dismantles patches according to the order of operations and reconstructs them when needed. Areas that have completed operations between logical qubits are immediately repurposed for other computations.

By analogy with classical computers, this is similar to dynamically allocating and reclaiming memory during program execution according to the tasks at hand, rather than assigning memory once and keeping it fixed until the end. In Quantum Computing, however, this process is not merely a matter of memory management. It becomes a core compilation technology that determines both the stability of error-correcting codes and whether logical operations can be performed.

The significance of this result is clear. The bottleneck in quantum computing depends not only on the number of hardware resources, but also on factors such as:

How efficiently limited physical qubits can be organized into logical qubits
In what order the merging, splitting, and movement of patches are scheduled
How quickly completed error-correction space can be reassigned to the next operation
How precisely circuits can be compiled while accounting for hardware connectivity and error rates

In other words, the future of quantum competition will not belong only to hardware companies that produce ever-greater numbers of qubits. An era is emerging in which quantum compilers, error correction, and architecture technologies—all focused on optimizing space and time on the chip—can deliver real performance gains.

That is why the figure of 86% is so symbolic. It means that, rather than simply waiting for massive quantum computers, we can perform more experiments and benchmarks even on the small chips available today. The next leap in Quantum Computing may not come solely from “bigger chips.” The decisive advantage may arrive sooner than expected—and come down to how intelligently we use the chips we already have.

Quantum Computing: The Lattice That Defeats Errors—How Surface Code Works

Why can’t a quantum computer simply trust a single qubit? Because invisible noise can bring down a quantum state at any moment.

Qubits are highly sensitive to external heat, electromagnetic interference, minute errors in control signals, and interactions with their surrounding environment. During this process, a qubit’s state may change unintentionally, or the entanglement between multiple qubits may disappear. This is known as decoherence.

A bit in a classical computer is either 0 or 1, so it is relatively easy to copy and verify. A quantum state, on the other hand, cannot be copied arbitrarily, and directly measuring it can change the state itself. Therefore, in Quantum Computing, the simple approach of “checking for errors by directly reading the qubit” does not work.

One logical qubit is built from multiple physical qubits

To solve this problem, researchers developed Quantum Error Correction. The central idea is to distribute and store one important computational unit—a logical qubit—across multiple real qubits, known as physical qubits.

Put simply, instead of entrusting all the information to a single qubit, multiple qubits work together to protect the same information. Even if some physical qubits experience errors, analyzing the relationships among neighboring qubits makes it possible to estimate the location and type of the errors and restore the logical computation result.

However, there is one crucial condition:

The traces of errors must be detected without directly looking into the quantum information.

Surface Code is one of the leading error-correction methods designed to satisfy precisely this condition.

Surface Code: Finding the traces of errors on a two-dimensional lattice

Surface Code arranges physical qubits in a two-dimensional lattice. This structure contains two main types of qubits:

Data qubits: Qubits that hold the actual quantum information
Measurement qubits (ancilla qubits): Qubits that check for signs of errors in the data qubits

Ancilla qubits interact with neighboring data qubits according to a predefined procedure and are then measured. What is measured here is not the exact quantum state held by the data qubits. Instead, the measurement reveals whether the relationships between multiple qubits have changed, producing an error signal known as a syndrome.

For example, if the relationships among qubits in a particular area are normal, the same measurement pattern will repeat. But if a bit-flip or phase-flip error occurs at one location, the measurement results around it will change. The system collects these changing patterns and probabilistically estimates where the error occurred.

This approach is similar to a network of sensors installed across a wide floor. The sensors cannot see the object itself, but when they detect vibrations or pressure changes in a particular area, they can narrow down the location of the anomaly.

Errors appear in two forms

Errors in Quantum Computing are more complex than a simple inversion between 0 and 1 in a classical computer. Two representative types must be handled together:

Bit-flip error: An error in which 0 changes to 1, or 1 changes to 0
Phase-flip error: An error in which the phase relationship of a quantum state is reversed, even though the value may appear unchanged

Phase-flip errors are particularly devastating in quantum computation. Quantum algorithms rely on superposition, entanglement, and phase interference between states. Even if the visible value remains the same, an incorrect phase can alter the final measurement probabilities and cause the algorithm’s answer itself to be wrong.

Surface Code repeatedly applies different measurement patterns across the lattice to monitor signs of both bit-flip and phase-flip errors. By analyzing these repeated measurement records along the time axis as well, the system can identify errors more accurately—even errors that are difficult to distinguish through a single measurement.

Code distance: The larger the lattice, the stronger the protection

The protective capability of Surface Code is commonly explained using the concept of code distance. As the code distance increases, more physical errors must occur simultaneously or consecutively in order to destroy the logical qubit.

For example, a lattice with a small code distance can have its logical information damaged by only a small number of errors. By contrast, when a larger lattice with more physical qubits is used, the error-correction system has more room to detect and recover from errors.

However, increasing the level of protection comes at a cost:

More physical qubits are required
More measurement and control procedures are needed
More space is required for operations between logical qubits

In other words, the harder we try to reduce errors, the faster we run out of space on the chip. This is why it is difficult to execute complex error-correction computations on small quantum chips.

Why Surface Code leads to Dynamic Lattice Surgery

In Surface Code, a single logical qubit is represented as a patch on the lattice. To perform operations between logical qubits, these patches must be connected or separated in carefully controlled ways. This approach is known as Lattice Surgery.

The problem is that a static layout requires patches to be positioned with ample space at all times. On a small chip, it is difficult to reserve even unused space in advance, which limits the size and complexity of circuits that can actually be executed.

That is why Dynamic Lattice Surgery has recently attracted attention. Rather than treating the Surface Code lattice as a fixed structure, it views it as a computational space that can be reconfigured to match the situation. Unnecessary patches can be reduced or dismantled, while new patches can be created or connected when needed, allowing a limited number of physical qubits to be used more efficiently.

Ultimately, Surface Code is not merely a technology for preventing errors. It is the foundational language for building reliable logical operations in a Quantum Computing environment where noise is an everyday reality—and the starting point for next-generation architectural technologies such as dynamic lattice surgery.

A Core Technique in Quantum Computing: Merge, Measure, and Split Again with Lattice Surgery

What if gates could be performed without directly connecting logical qubits with physical lines? Lattice Surgery makes this possible by merging, measuring, and then separating lattice patches again—just as its name suggests, like performing surgery on a grid.

In quantum error correction, a single logical qubit is not the same as one physical qubit. Multiple physical qubits form a patch arranged in a two-dimensional lattice, and the entire patch functions as one logical qubit. In particular, in surface-code-based Quantum Computing architectures, how efficiently these patches are arranged and manipulated determines the performance of the overall computation.

Performing Logical Operations by Merging Patches

The basic operation of Lattice Surgery is relatively intuitive:

Place two logical-qubit patches next to each other.
Temporarily connect the boundaries between the two patches, turning them into one larger lattice.
Repeatedly perform specific error-correction measurements—namely, stabilizer measurements—in the boundary region.
Use the measurement results to obtain the correlation between the two logical qubits and implement the required logical gate.
Once the operation is complete, separate the boundary again and restore the two independent patches.

This process differs from physically moving qubits or adding direct connections between distant qubits. Instead, it uses the structure of measurements and error-correction codes to create logical interactions.

For example, essential two-qubit logical gates such as CNOT can be implemented using an ancillary patch and parity measurements. The key point is that the two logical qubits are not simply “connected.” Rather, the measurement information obtained during the patch-merging process becomes part of the gate operation itself.

Why Is It More Advantageous Than Direct Connections?

In a large-scale quantum computer, directly connecting every logical qubit to every other one is practically difficult. As the number of connections grows, chip design becomes more complex, while the risk of control-signal interference and errors also increases.

Lattice Surgery offers an alternative that avoids these problems.

It fits naturally into a two-dimensional lattice structure.
Logical operations can be constructed without direct long-distance connections.
Error-correction procedures and gate operations can be combined into a single workflow.
Logical-qubit patches can be operated efficiently within a limited chip area.

In other words, the performance of Quantum Computing does not come solely from increasing the number of physical qubits. It also depends on calculating which patches should be merged and when, when they should be separated again, and how empty space can be reused within the limited available area.

The Limitations of Static Lattice Surgery

In conventional approaches, the positions of logical-qubit patches and ancillary patches are generally fixed. Although this simplifies design and control, it creates a problem on small chips: even when empty space becomes available, it is difficult to use that space immediately for another operation.

For instance, if an ancillary patch prepared for a particular operation has to wait until the next operation, that space is effectively sitting idle. The more complex the circuit, the more these idle areas and waiting times accumulate, ultimately limiting the range of benchmarks the chip can process.

This is precisely where Dynamic Lattice Surgery enters the picture. Rather than relying on a fixed operating-room layout, it takes an approach in which patches are shrunk, expanded, moved, and reconfigured according to the order of operations. Unnecessary patches can be dismantled to return their space, while new patches can be created and put to work when needed.

The Core of the “Surgery” Lies in Interpreting Measurement Results

In Lattice Surgery, merging and separation are not merely physical wiring operations. The measurements performed at each stage provide critical information that determines both the outcome of error correction and the result of the logical operation.

Measurement results may contain changes caused by physical errors. The system must therefore analyze measurements taken repeatedly to distinguish genuine errors from normal changes in the logical state. Through this process, it tracks and corrects errors while also determining whether the desired logical gate was performed correctly.

Ultimately, Lattice Surgery works when the following three elements are precisely coordinated:

The spatial arrangement of patches
The timing and sequence of merging and separation
Measurement-based error interpretation and correction

This is also why the achievements of the Munich research team have drawn attention. If patches can be reconfigured more flexibly on a small chip, more logical circuits and benchmarks can be executed using the same physical resources. This shows that Quantum Computing is moving beyond a competition over hardware scale and into a new phase in which the intelligence of layouts and compilers becomes a source of competitive advantage.

Quantum Computing: Abandoning Static Lattices and Using Time Like Space

What if we temporarily dismantled unused logical-qubit patches and created new ones only when they were needed? The physical chip would remain the same size, yet it could handle complex computations as if it had gained a much larger workspace. This is the core idea behind Dynamic Lattice Surgery, proposed by a research team in Munich.

Conventional lattice surgery generally relies on a static layout in which logical-qubit patches continue occupying fixed positions. The problem is that on a small chip, keeping every patch active at all times means that even logical qubits not currently involved in computation consume valuable physical qubits. As circuits become more complex, the space available for new operations rapidly disappears.

Dynamic Lattice Surgery turns this assumption on its head.

Patches that are not immediately needed are shrunk or dismantled.
When a required logical operation arises, a new patch is created at the appropriate moment.
When two logical qubits need to interact, their patches are merged, measured, and then separated again.
Once an operation is complete, the region is reclaimed and reassigned to another operation later on.

In other words, rather than allocating space once and leaving it there, this approach continuously rearranges it in step with the flow of time. It resembles dynamic memory allocation or register reuse in classical computing, but is far more challenging here because the error-correction code must be preserved. Every process of moving, merging, and splitting patches must account for the logical error rate, measurement order, and physical-qubit connectivity.

The strategy is not to hold on to the same physical resources for longer, but to use them precisely—and only when they are needed.

This approach does not view the limitations of small chips simply as a “shortage of qubits.” Instead, it suggests that the key bottleneck may lie in failing to properly manage when each logical patch is needed and how much space it occupies. The research team’s result—an 86% increase in the number of quantum benchmarks that could be executed on the same constrained chip—shows that this resource-management strategy is more than a purely theoretical idea.

This shift is highly significant in quantum computing. The performance of a fault-tolerant quantum computer is not determined solely by the number of physical qubits. How logical qubits are arranged, how the order of operations is coordinated, and how quickly idle patches can be reclaimed all have a major impact on the range of computations that can actually be performed.

Ultimately, Dynamic Lattice Surgery can be described as a technology that expands space by leveraging time before physically expanding the chip. Going forward, competition may extend beyond the hardware race to build more qubits, becoming a race among compilers and architectures to extract more logical operations from a limited number of qubits.

The Next Competitor in Quantum Computing Isn’t the Qubit—It’s the Compiler

The winners and losers in the quantum industry may be decided even before the era of millions of qubits arrives. The companies that take the lead are more likely to be those that extract more logical operations from the same chip, rather than those that simply possess more chips.

A research team in Munich demonstrated this with Dynamic Lattice Surgery. Without increasing the number of physical qubits, the team increased the number of quantum benchmarks that could be executed on a limited chip by 86%. The key was not replacing the hardware, but designing a more intelligent way to place, merge, split, and reuse error-correction patches.

Even the Same Chip Can Deliver Different “Logical Throughput”

In Quantum Computing, the number of physical qubits is an important metric. However, in an environment that requires error correction, the number of physical qubits does not directly translate into practical computing power.

Actual performance is determined by a combination of the following factors:

The number of physical qubits required to maintain a single logical qubit
How patches are arranged for operations between logical qubits
How quickly completed regions can be reclaimed and reused
The ability to map circuits while accounting for chip connectivity and error-correction constraints
The quality of scheduling that reduces idle time and unnecessary operations

In other words, even with the same quantum chip, the size, depth, and throughput of executable circuits can vary significantly depending on the compiler and layout strategy. Dynamic Lattice Surgery is not bound to a static lattice arrangement. Instead, it reconstructs patches as the computation progresses. Unused space is reclaimed, while computational patches are configured only when needed.

This resembles dynamic memory allocation, efficient register assignment, and instruction-order optimization in classical computing. In quantum environments, however, the process is far more complex because it must also account for error-correction codes, measurement procedures, and physical connectivity.

From Hardware Competition to Architecture Competition

In the future, it will be difficult to assess the competitiveness of quantum companies solely by asking, “How many qubits does their chip have?” A more important question will be:

How many error-corrected logical operations can this company perform with a given set of physical resources?

By this standard, the value of companies developing quantum compilers, error-correction codes, and control software will rise alongside that of hardware companies. In particular, for cloud-based Quantum Computing services, resource utilization directly translates into operational efficiency. If a company can process more benchmarks and customer workloads on the same equipment, it can gain an advantage in both cost structure and service competitiveness.

Dynamic Lattice Surgery marks the starting point of this shift. Technologies that expand chip capacity will remain important, but compiler technologies that make the most of limited hardware are becoming an equally decisive competitive factor.

The Next Battleground Is “Dynamic Optimization”

Future quantum compilers will go beyond simply translating algorithms into a set of gates. They are likely to evolve into quantum resource management systems that design, in near real time, when error-correction patches should be created, where they should be placed, and when they should be merged or split.

Challenges, of course, remain. As patch reconstruction becomes more frequent, compilation time and control complexity may increase. The impact of dynamic operations on noise and error budgets must also be validated in large-scale environments.

Even so, the direction is clear. Rather than waiting for millions of qubits to arrive, the companies that realize more logical operations on today’s limited chips may seize the early lead in Quantum Computing.

The Trend Blender

Search This Blog