Geometry-optimized hyperbolic codes for modular fault-tolerant quantum architectures

arXiv:2610.10948 · quant-ph, math-ph, math.MP · Submitted 2026-10-07 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Quantum Radio. Generated commentary on the latest quantum physics and condensed matter papers.

Kai: Today's paper: "Geometry-optimized hyperbolic codes for modular fault-tolerant quantum architectures".

Mira: The gist: This work presents finite families of hyperbolic surface codes that leverage optimal efficiency scaling kd2/n = C(log k)2 attainable by surface codes with bounded local geometry,

Kai: First, who's behind it and why it matters.

Title and authors: Kai: So we’re looking at this paper today, "Geometry-optimized hyperbolic codes for modular fault-tolerant quantum architectures," and the authors are Ahmed Adel Mahmoud and Steven Rayan. I mean, it sounds really technical, but they're tackling something fundamental about how we actually build these systems. It’s not just about the abstract math; it’s about making sure the physical layout works out in practice for fault tolerance, which is what we need to get real quantum computers running reliably.

Mira: I agree, Kai. The title suggests they're moving beyond standard surface codes by using hyperbolic geometry to optimize something crucial: how the code actually maps onto a physical processor. It’s not just about finding *a* code; it’s about finding the right shape for that code so it fits the hardware constraints better, which is where this work gets interesting.

Lev: From a researcher standpoint, when you hear "modular fault-tolerant quantum architectures," you immediately think about scaling up. The challenge isn't just making one qubit robust; it's managing all those local connections and communication links when you have thousands of them across different modules. This paper seems to be providing a geometric framework to handle that complexity better.

Kai: Exactly. They’re using these hyperbolic codes, which have this specific structure, to see if we can double the code distance without having to increase the physical number of qubits or the check weight too much. It’s about improving efficiency while maintaining—or even boosting—the error-correction capability itself.

Mira: And they are leveraging a scaling law that they found applies specifically to surface codes with bounded local geometry, which is a key assumption here. If those assumptions hold up when you introduce this hyperbolic structure, it opens up new possibilities for how we design these large systems.

The paper's summary: Kai: So what are they actually showing? Basically, the paper shows that by optimizing the way they perform periodic identifications on a regular hyperbolic tiling, they can achieve an efficiency scaling of kd2/n = C(log k)two <ref:2610.10948#pg1,kd2/n = C(log k)2>. That’s a specific mathematical relationship describing how good the code gets as you add more logical qubits.

Mira: That is a significant finding because it relates directly to Delfosse’s bound, which says that for surface codes with bounded local geometry, this scaling limit is at most O((log k)two) <ref:2610.10948#pg1,surface codes with bounded local geometry>. By showing they can hit this optimal scaling, they prove that periodic identifications actually help us reach the best possible efficiency we thought was achievable for these types of codes.

Lev: But there’s a catch. They show that optimizing these periodic boundary conditions can actually double the code distance while keeping the qubit count and check weight fixed, which is a big deal because it means you get more protection for the same physical resource footprint.

Kai: Right, so if we take that doubling of distance, what does that translate to in terms of how much better they are than just using a standard surface code setup? It’s not just a small bump; it’s a factor of four increase in efficiency for some cases they found.

Mira: That factor of four increase is what they highlight as the main result concerning efficiency. They also show that for specific families, like the (five five) and (seven seven) codes, their finite-size scaling matches this optimal scaling derived from Delfosse’s bound.

The paper's improvements: Kai: Now we move to the practical stuff—how they make this work on real hardware. They introduce something called a topology-aware compiler that partitions these closed hyperbolic surface codes into smaller, bounded planar modules. That’s where they start moving from pure theory to actual engineering.

Mira: The goal of that compiler is very specific: minimize the communication overhead between those modules. They measure this overhead using metrics like R, which is the total number of remote interactions per syndrome extraction round, and K, which tracks how checks are distributed across those modules.

Lev: From a hardware perspective, that modular approach has to respect physical constraints. They enforce a strict limit: every module must contain between Bmin and eighty qubits. It’s about making sure the division of work makes sense for what you can actually put on a chip today.

Kai: They’re essentially doing three things in that compiler: first, partitioning the faces; second, assigning the physical qubits to those modules; and third, validating everything to make sure it fits all those geometric and hardware capacity constraints they just talked about.

Mira: The real improvement here is showing how this modularization helps with routing. They describe a topology-aware algorithm that partitions the hyperbolic code into these bounded planar modules while actively trying to reduce long-range communications demand. This leads to reduced performance across all five communication metrics relative to what you get from just using spectral partitioning assignments.

Conclusion: Kai: So, wrapping up on this paper, the main point is that hyperbolic surface codes aren't just mathematically neat; they offer a structure that organizes both the logical information and the physical interactions in a way that’s very useful for building scalable architectures. They operationalized all this theory through an exhaustive search for finite codes and then designing hardware-aware layouts.

Mira: They showed how optimizing periodic identifications can double the code distance, which directly leads to increasing efficiency by a factor of four in specific scenarios, while also confirming that their scaling matches the theoretical limit for bounded local geometry. It connects the high-level theory to concrete performance gains in terms of resource efficiency.

Lev: And from an error correction view, it’s important because they ran circuit-level Monte Carlo simulations comparing monolithic versus modular architectures under noisy long-range gates. They found that even when you triple the error probability on those nonlocal gates, the estimated thresholds for both setups only drop to around zero point one seven percent and zero point one eight percent, respectively. That shows that modularity helps preserve those thresholds better than a purely monolithic approach under long-range noise conditions.

Kai: So, in short, this work provides a blueprint: use hyperbolic geometry to design codes that scale better efficiently, and then use topology-aware compilers to map those codes onto hardware modules while keeping the communication overhead manageable. It’s all about making fault tolerance practical at scale.

Mira: It’s a solid piece of work because it connects the geometric structure directly to efficiency scaling, which is something we need to predict when designing these massive systems. The paper, "Geometry-optimized hyperbolic codes for modular fault-tolerant quantum architectures," shows how these complex structures can be harnessed effectively for physical implementation.

Lev: I just want to add that while they show the benefits of modularity, they do acknowledge a limitation: the simulations focus on long-range gates and don't fully account for all the lower-level overheads like routing buses or entanglement generation protocols. So, we’re seeing excellent estimates under those specific conditions, but we still need to figure out how that translates when you add every other physical layer.

Kai: Exactly. It gives us a very strong starting point for what’s possible, showing the theoretical potential and the hardware-aware mapping needed to actually build it. That’s what this paper is about today.

Ahmed Adel Mahmoud, *, Steven Rayan†

Centre for Quantum Topology and Its Applications (quanTA) · Department of Mathematics and Statistics, University of Saskatchewan

quant-ph, math-ph, math.MP

Submitted: 2026-10-07

Updated: 2026-10-07

Comments: 14 pages, 6 figures, 4 tables

License: http://creativecommons.org/licenses/by-nc-nd/4.0/

Importance score: 87/100

The gist: The gist: This work presents finite families of hyperbolic surface codes that leverage optimal efficiency scaling kd2/n = C(log k)2 attainable by surface codes with bounded local geometry, showing

Key concepts

Hyperbolic Surface Codes
These are quantum error correction codes built on the geometry of hyperbolic surfaces, which have a unique structure. Data qubits sit on edges, Z checks are placed on faces, and X checks are at vertices. This geometric arrangement allows for high encoding rates and favorable scaling properties.
Optimal Efficiency Scaling
This refers to the theoretical best way for surface codes with bounded local geometry to scale their code distance relative to the number of qubits (k). The paper shows that by optimizing periodic identifications, this scaling can reach kd2/n = C(log k)2, which is crucial for maximizing code efficiency.
Topology-Aware Modular Compilation
This is a compiler designed to physically implement the abstract hyperbolic surface codes onto hardware. It partitions the large surface into smaller, manageable planar modules to minimize communication overhead between them while respecting physical constraints like qubit limits per module.
Circuit-Level Memory Performance
These simulations quantify how noisy gates, especially long-range ones, degrade the performance of quantum circuits on both monolithic and modular hardware. The study shows that tripling the error probability of a nonlocal gate can reduce estimated fault tolerance thresholds to approximately 0.17% or 0.18%.

Terminology

Summary

The gist: This work presents finite families of hyperbolic surface codes that leverage optimal efficiency scaling kd2/n = C(log k)2 attainable by surface codes with bounded local geometry, showing that optimizing periodic identifications can double the code distance and thereby increase the code’s efficiency by a factor of four

Code Construction and Search

The construction utilizes a regular hyperbolic tiling specified by the orientation-preserving triangle group ∆p = ⟨x, y x p = y p = (xy) squared = 1⟩ to define the underlying hyperbolic tiling Data qubits occupy the edges, while each face defines a Z check on its boundary edges, and each vertex defines an X check on its incident edges. For a closed, connected, orientable surface of genus g, the code encodes k = 2g logical qubits. Euler’s relation then yields k/n = p − 4/p + 2n. The search involved an exhaustive enumeration over selfdual prime-field (p, p) tessellations for p ∈ 5, 6, 7, and 8 across all primes q < 60. The global optimum within this parameter space is achieved by the (6, 6) code [[51330, 17112, 10]], which exhibits a remarkable encoding efficiency of η ≈ 33.34.

Finite-Size Efficiency Scaling

The paper examines how code efficiency grows with the number of logical qubits by comparing computed efficiencies with Delfosse’s bound, kd2/n = O((log k)2) for surface codes with bounded local geometry. The results show that optimizing periodic boundary conditions can double the code distance at fixed qubit count, encoding rate, and check weight, increasing code efficiency by a factor of four. For selected (5, 5) and (7, 7) code families exhibit finite-size scaling consistent with the optimal code-efficiency scaling allowed by Delfosse’s bound. The fitting of distance as a linear function of ln k and efficiency as a linear function of (ln k)2 yields results such as d ≈ 1.265 ln k + 0.543 for the (5, 5) sequence.

Topology-Aware Modular Compilation

To address physical implementation, a topology-aware compiler is introduced to partition closed hyperbolic surface codes into planar modules of bounded size. The algorithm performs three sequential phases: face partitioning, physical qubit assignment, and validation. The primary objective is to minimize inter-module communication overhead while satisfying explicit geometric and hardware-capacity constraints. Communication overhead is quantified by metrics R (total number of remote interactions per complete syndrome extraction round) and K (aggregate distribution of checks across multiple modules). The algorithm enforces a strict upper bound of Bmax = 80 qubits per module, ensuring every module encapsulates between Bmin and 80 qubits.

Circuit-Level Memory Performance

Circuit-level Monte Carlo simulations quantify threshold degradation under noisier long-range gates across both monolithic and modular architectures The effective error model isolates the operational impact of remote gate infidelity under a fixed schedule, abstracting away physical link lengths and the lower-level overheads of routing buses, communication ports, or entanglement-generation protocols. For the selected logical Z-memory circuits, both architectures exhibit ≈ 0.22% estimated thresholds at α = 1. Tripling the nonlocal-gate error probability reduces these estimated thresholds to ≈ 0.17% and ≈ 0.18% for the modular and monolithic architectures, respectively.

Conclusion

Hyperbolic surface codes offer a compelling combination of high encoding rates, growing code distances, low check weights, and a geometric structure that organizes both logical information and physical interactions. The work operationalizes this theoretical potential through an exhaustive finite code search, hardware-aware layout design, and circuit-level memory simulations that quantify the cost of noisy long-range interactions. The central result of this section is a circuit-level comparison of finite-size threshold estimates for two explicit hardware assignments: both exhibit ≈ 0.22% estimated thresholds at α = 1. Tripling the nonlocal-gate error probability reduces the estimated thresholds to ≈ 0.17% and ≈ 0.18% for the modular and monolithic architectures, respectively. Both implementations retain finite-size threshold behavior under this increased long-range noise >

--- Page 1 ---

The gist: This work presents finite families of hyperbolic surface codes that leverage optimal efficiency scaling kd2/n = C(log k)2 attainable by surface codes with bounded local geometry, showing that optimizing periodic identifications can double the code distance and thereby increase the code’s efficiency by a factor of four

Code Construction and Search

The construction utilizes a regular hyperbolic tiling specified by the orientation-preserving triangle group ∆p = ⟨x, y x p = y p = (xy) squared = 1⟩ to define the underlying hyperbolic tiling. Data qubits occupy the edges, while each face defines a Z check on its boundary edges, and each vertex defines an X check on its incident edges. For a closed, connected, orientable surface of genus g, the code encodes k = 2g logical qubits. Euler’s relation then yields k/n = p − 4/p + 2n. The search involved an exhaustive enumeration over selfdual prime-field (p, p) tessellations for p ∈ 5, 6, 7, and 8 across all primes q < 60. The global optimum within this parameter space is achieved by the (6, 6) code [[51330, 17112, 10]], which exhibits a remarkable encoding efficiency of η ≈ 33.34.

Conclusion

Hyperbolic surface codes offer a compelling combination of high encoding rates, growing code distances, low check weights, and a geometric structure that organizes both logical information and physical interactions. The work operationalizes this theoretical potential through an exhaustive finite code search, hardware-aware layout design, and circuit-level memory simulations that quantify the cost of noisy long-range interactions. The central result of this section is a circuit-level comparison of finite-size threshold estimates for two explicit hardware assignments: both exhibit ≈ 0.22% estimated thresholds at α = 1. Tripling the nonlocal-gate error probability reduces the estimated thresholds to ≈ 0.17% and ≈ 0.

Improvements for AI systems

  1. Continuous optimization of code distance through periodic identification: optimizing the periodic identifications can double the code distance at fixed qubit count, encoding rate, and parity-check weight. This allows AI systems to design quantum error correction codes that are more robust against noise without increasing physical resource overheads.

  2. Topology-aware modular partitioning for hardware mapping: The system can use a topology-aware compiler to modularize hyperbolic codes into bounded planar modules to minimize inter-module communication overhead, quantified by metrics like R measures the total number of remote (inter-module) interactions. This enables the design of scalable quantum processors that satisfy physical capacity constraints (Bmin ≤ Bj ≤ Bmax).

  3. Circuit-level threshold estimation under noise: The AI can use circuit-level Monte Carlo simulations to quantify threshold degradation, showing that tripling the long-range gate error probability mildly lowers, but does not eliminate, the estimated error-correction thresholds. This provides concrete performance metrics for fault-tolerant architectures based on hyperbolic surface codes.

  4. Adaptive routing protocols: The system can implement a topology-aware algorithm that partitions a hyperbolic code into bounded planar modules while reducing long-range communications demand to address the routing problem, leading to reduced all five communication metrics relative to the tested load-feasible spectral-partitioning assignments. This allows for efficient physical connectivity mapping in superconducting architectures.

  5. Finite-size efficiency scaling prediction: The system can utilize the derived growth functions, such as d ≃ 1.265 ln k + 0.543 for the weight-five sequence, to predict how code efficiency scales with increasing logical qubits based on finite-size growth of the selected codes. This informs the selection of optimal code parameters for target qubit counts in large-scale systems.

  6. Resource allocation optimization: The AI can use metrics like K quantifies the aggregate distribution of checks across multiple modules and max remote-interaction count to perform iteratively optimize data-qubit assignments by minimizing the cost function Ce in Eq. (14). This ensures that data qubits are distributed optimally within hardware constraints.

  7. Architecture comparison for memory preservation: The system can compare an effective-modular implementation based on our topologyaware partitioning algorithm against a monolithic implementation with native long-range connections to determine the impact of routing on logical error probabilities, showing that modular architectures can yield lower threshold estimates under noise (tripling the nonlocal-gate error probability reduces the estimated thresholds to ≈ 0.17% and ≈ 0.18%).

Abstract

Quantum fault tolerance is a prerequisite to harness the full potential of quantum computers. However, achieving fault tolerance remains a major challenge since it requires optimizing tradeoffs between several intertwined theoretical and experimental parameters, including the encoding rate, code distance, parity-check weights, code planarity, and routing. Surface codes remain strong candidates for fault tolerance due to their simple geometric structure, established decoding methods, locality, and experimental attainability. In this work, we present finite families of hyperbolic surface codes that leverage the optimal efficiency scaling kd 2/n = C squared attainable by surface codes with bounded local geometry. We show that optimizing the periodic identifications can double the code distance and thereby increase the code's efficiency by a factor of four, at fixed qubit count, encoding rate, and parity-check weight. We also address the routing problem of hyperbolic surface codes by introducing a topology-aware algorithm that partitions a hyperbolic code into bounded planar modules while reducing long-range communications demand. Circuit-level Monte Carlo simulations yield finite-size threshold estimates for both modular and monolithic layouts, showing that tripling the long-range gate error probability mildly lowers, but does not eliminate, the estimated error-correction thresholds. Together, these results strengthen the case for hyperbolic surface codes as structured and highly efficient large-scale quantum error correction codes for future fault-tolerant architectures.

Sources

Related papers