We've upgraded! Visit our new site at www.undermind.ai. The new deep search tool covers all of science, not just ArXiv, and is 10x faster. Your previous data is still available at app.undermind.ai.

Search Topic:

Quantum error correction with surface codes in modular architectures, with higher error rates in communication between modules

Additional Context Provided:

Building a quantum computer in a modular fashion is a good idea so that identical sub-units can be mass produced and then linked together. However, these links between modules are then usually the noisiest part of the system. I'm curious about how to realize error corrected quantum computing with surface codes when these connections between modules are subject to extra noise, for example more noise than is present within each module.

Results

Deep search found 7 relevant papers. This is ~94% of all relevant papers that exist on the arXiv database (see comprehensiveness analysis for details).

Highly Relevant References
 🟢 [1]
Hierarchical surface code for network quantum computing with modules of arbitrary size Ying Li, ..., Simon C. Benjamin (2015)
arXiv:1509.07796v1

The network paradigm for quantum computing involves interconnecting many modules to form a scalable machine. Typically it is assumed that the links between modules are prone to noise while operations within modules have significantly higher fidelity. To optimise fault tolerance in such architectures we introduce a hierarchical generalisation of the surface code: a small `patch' of the code exists within each module, and constitutes a single effective qubit of the logic-level surface code. Errors primarily occur in a two-dimensional subspace, i.e. patch perimeters extruded over time, and the resulting noise threshold for inter-module links can exceed ~ 10% even in the absence of purification. Increasing the number of qubits within each module decreases the number of qubits necessary for encoding a logical qubit. But this advantage is relatively modest, and broadly speaking a `fine grained' network of small modules containing only ~ 8 qubits is competitive in total qubit count versus a `course' network with modules containing many hundreds of qubits.

The paper directly aligns with the specific research interest as it explores error correction in modular quantum computing architectures, using a hierarchical variant of the surface codes. It addresses the situation of higher error rates in the inter-module links and proposes methodologies to manage these errors. The key point of interest is that it not only focuses on surface codes but a hierarchical variant of them, extending their functionality in a modular setup. This hierarchical approach is designed to operate effectively in conditions where inter-module noise is prevalent.

 🟢 [2]
Fault-Tolerant Connection of Error-Corrected Qubits with Noisy Links Joshua Ramette, ..., Vladan Vuletić (2023)
arXiv:2302.01296v1

One of the most promising routes towards scalable quantum computing is a modular approach. We show that distinct surface code patches can be connected in a fault-tolerant manner even in the presence of substantial noise along their connecting interface. We quantify analytically and numerically the combined effect of errors across the interface and bulk. We show that the system can tolerate 14 times higher noise at the interface compared to the bulk, with only a small effect on the code's threshold and sub-threshold behavior, reaching threshold with $\sim 1 \%$ bulk errors and $\sim 10 \%$ interface errors. This implies that fault-tolerant scaling of error-corrected modular devices is within reach using existing technology.

The paper titled 'Fault-Tolerant Connection of Error-Corrected Qubits with Noisy Links' directly correlates with the researcher's topic. The authors discuss the connection of distinct surface code patches in a modular approach even under high noise conditions. They quantitatively analyze the combined effect of errors on both the interface and the bulk. The paper demonstrates that the system can withstand significantly higher noise rate at the inter-module interfaces compared to within the modules, and these findings are directly in line with the researcher's topic. The paper claims that despite higher noise levels, it only slightly affects the code's threshold and sub-threshold behavior, which supports the researcher's interest in finding strategies to address these higher error rates.

Closely Related References
 🟡 [3]
Long-range data transmission in a fault-tolerant quantum bus architecture Shin Ho Choe, ..., Robert Koenig (2022)
arXiv:2209.09774v1

We propose a scheme for fault-tolerant long-range entanglement generation at the ends of a rectangular array of qubits of length $R$ and a square cross section of size $d\times d$ with $d=O(\log R)$. Up to an efficiently computable Pauli correction, the scheme generates a maximally entangled state of two qubits using a depth-$6$ circuit consisting of nearest-neighbor Clifford gates and local measurements only. Compared with existing fault-tolerance schemes for quantum communication, the protocol is distinguished by its low latency: starting from a product state, the entangled state is prepared in a time $O(t_{\textrm{local}})$ determined only by the local gate and measurement operation time $t_{\textrm{local}}$. Furthermore, the requirements on local repeater stations are minimal: Each repeater uses only $\Theta(\log^2 R)$ qubits with a lifetime of order $O(t_{\textrm{local}})$. We prove a converse bound $\Omega(\log R)$ on the number of qubits per repeater among all low-latency schemes for fault-tolerant quantum communication over distance $R$. Furthermore, all operations within a repeater are local when the qubits are arranged in a square lattice. The noise-resilience of our scheme relies on the fault-tolerance properties of the underlying cluster state. We give a full error analysis, establishing a fault-tolerance threshold against general (circuit-level) local stochastic noise affecting preparation, entangling operations and measurements. This includes, in particular, errors correlated in time and space. Our conservative analytical estimates are surprisingly optimistic, suggesting that the scheme is suited for long-range entanglement generation both in and between near-term quantum computing devices.

The paper proposes a scheme for fault-tolerant long-range entanglement generation, although there seems to be less of a focus on specifically using surface codes. While surface codes are used in some of the cited works and surface code concepts seem to feature in the architecture, the authors clarify that their protocol does not involve intermediate encoding/recovery operations associated with these surface codes, which suggests it might not be an exact fit for the research interest. However, the paper does address inter-module communication and its associated noise/errors and discusses various generations of protocols to deal with operation errors and qubit loss, which are directly related to understanding error correction in modular architectures. Given these aspects, this paper could provide useful context and comparison for surface code-based solutions.

 🟡 [4]
Topological quantum computing with a very noisy network and local error rates approaching one percent Naomi H. Nickerson, ..., Simon C. Benjamin (2012)
arXiv:1211.2217v3

A scalable quantum computer could be built by networking together many simple processor cells, thus avoiding the need to create a single complex structure. The difficulty is that realistic quantum links are very error prone. A solution is for cells to repeatedly communicate with each other and so 'purify' any imperfections; however prior studies suggest that the cells themselves must then have prohibitively low internal error rates. Here we describe a method by which even error-prone cells can perform purification: groups of cells generate shared resource states, which then enable stabilization of topologically encoded data. Given a realistically noisy network (>=10% error rate) we find that our protocol can succeed provided that intra-cell error rates for initialisation, state manipulation and measurement are below 0.82%. This level of fidelity is already achievable in several laboratory systems.

The paper is focused on a modular architecture for quantum computing and discusses error-prone links between such modules. The protocol they propose, based on 'purifying' errors and stabilization of topologically encoded data, could be potentially pertinent to dealing with higher error rates in inter-module communication. The paper specifically mentions achieving a higher tolerance for internal error rates, which aligns with the topic at hand. However, the paper does not specify that they used surface codes for the error correction, and while inferences might be made from references to other papers focused on surface codes, it is not directly clear from the abstract and selected parts of the paper.

 🟡 [5]
Fault-tolerant interface between quantum memories and quantum processors Hendrik Poulsen Nautrup, ..., Hans J. Briegel (2016)
arXiv:1609.08062v3

Topological error correction codes are promising candidates to protect quantum computations from the deteriorating effects of noise. While some codes provide high noise thresholds suitable for robust quantum memories, others allow straightforward gate implementation needed for data processing. To exploit the particular advantages of different topological codes for fault-tolerant quantum computation, it is necessary to be able to switch between them. Here we propose a practical solution, subsystem lattice surgery, which requires only two-body nearest neighbor interactions in a fixed layout in addition to the indispensable error correction. This method can be used for the fault-tolerant transfer of quantum information between arbitrary topological subsystem codes in two dimensions and beyond. In particular, it can be employed to create a simple interface, a quantum bus, between noise resilient surface code memories and flexible color code processors.

The paper indeed discusses the need for and methods of error correction in quantum computation, with considerable focus on topological stabilization codes, and surface codes in particular. The authors propose subsystem lattice surgery as a way to transfer information fault-tolerantly between different topological codes, essentially bridging communication between modules. The paper thus addresses the noise resilience of these codes in 'noisy' scenarios, although it may lack a more explicit exploration of the case where inter-modular communication has higher error rates (the noise is only indirectly alluded to). Additionally, the authors primarily explore interactions with two different kinds of topological codes (surface and color codes), and not only surface codes as requested by the researcher. That being said, the mechanism proposed in this paper for switching between codes and the experimental investigations encouraged might have implications for the very scenario where communication faces additional noise and where surface codes are utilized exclusively.

 🟡 [6]
Quantum error correction in crossbar architectures Jonas Helsen, ..., Stephanie Wehner (2017)
arXiv:1712.07571v1

A central challenge for the scaling of quantum computing systems is the need to control all qubits in the system without a large overhead. A solution for this problem in classical computing comes in the form of so called crossbar architectures. Recently we made a proposal for a large scale quantum processor~[Li et al. arXiv:1711.03807 (2017)] to be implemented in silicon quantum dots. This system features a crossbar control architecture which limits parallel single qubit control, but allows the scheme to overcome control scaling issues that form a major hurdle to large scale quantum computing systems. In this work, we develop a language that makes it possible to easily map quantum circuits to crossbar systems, taking into account their architecture and control limitations. Using this language we show how to map well known quantum error correction codes such as the planar surface and color codes in this limited control setting with only a small overhead in time. We analyze the logical error behavior of this surface code mapping for estimated experimental parameters of the crossbar system and conclude that logical error suppression to a level useful for real quantum computation is feasible.

The paper presents about quantum error correction in crossbar architectures with a focus on surface and color codes, which aligns well with the researcher's interest. Although the specific mention of higher error-rates in inter-module communication isn't explicitly addressed, the paper acknowledges that noise - a source of errors - is a problem in quantum computing environments, and that it has developed a language for mapping quantum circuits which takes into account these limitations. Additionally, it describes how the surface codes will behave under estimated parameters of the described system. The paper offers insights into some components of the desired topic such as mapping quantum circuits and error behaviors, and provides a context for considering how to address errors and limitations but may not directly tackle the specific points about higher error rates between modules.

 🟡 [7]
Learning correlated noise in a 39-qubit quantum processor Robin Harper, ..., Steven T. Flammia (2023)
arXiv:2303.00780v1

Building error-corrected quantum computers relies crucially on measuring and modeling noise on candidate devices. In particular, optimal error correction requires knowing the noise that occurs in the device as it executes the circuits required for error correction. As devices increase in size we will become more reliant on efficient models of this noise. However, such models must still retain the information required to optimize the algorithms used for error correction. Here we propose a method of extracting detailed information of the noise in a device running syndrome extraction circuits. We introduce and execute an experiment on a superconducting device using 39 of its qubits in a surface code doing repeated rounds of syndrome extraction, but omitting the mid-circuit measurement and reset. We show how to extract from the 20 data qubits the information needed to build noise models of various sophistication in the form of graphical models. These models give efficient descriptions of noise in large-scale devices and are designed to illuminate the effectiveness of error correction against correlated noise. Our estimates are furthermore precise: we learn a consistent global distribution where all one- and two-qubit error rates are known to a relative error of 0.1%. By extrapolating our experimentally learned noise models towards lower error rates, we demonstrate that accurate correlated noise models are increasingly important for successfully predicting sub-threshold behavior in quantum error correction experiments.

The paper closely addresses several major components of the specified topic. It demonstrates a robust understanding of how error correction functions in a practice by using an actual superconducting device for experimentation, this leans towards a practical approach rather than a purely theoretical one. The noise being explored is directly derived from the device executing the necessary circuits for error correction, indicating their efforts to simulate real-world usage. The authors discuss the significance of tailored codes and decoders to accommodate the noise specific to the device, which is a clear acknowledgment of the problem of elevated noise rates between modules. Diagrams provided in the selected sections point to an examination of noise propagation and mitigation strategies, such as the pattern of ancilla-data qubit connections, which is relevant to the primary concern of the research topic. However, the paper does not make explicit mention of the communication between modules, suggesting that this aspect may not be the main focus.

Distantly Related References (missing key criteria)
 🔴 [8]
Surface Code Design for Asymmetric Error Channels Utkarsh Azad, ..., Ritajit Majumdar (2021)
arXiv:2111.01486v2

Surface codes are quantum error correcting codes normally defined on 2D arrays of qubits. In this paper, we introduce a surface code design based on the fact that the severity of bit flip and phase flip errors in the physical quantum systems is asymmetric. For our proposed surface code design for asymmetric error channels, we present pseudo-threshold and threshold values in the presence of various degrees of asymmetry of Pauli $\hat{X}$, $\hat{Y}$, and $\hat{Z}$ errors in a depolarization channel. We show that, compared to symmetric surface codes, our asymmetric surface codes can provide almost double the pseudo-threshold rates while requiring less than half the number of physical qubits in the presence of increasing asymmetry in the error channel. We also demonstrate that as the asymmetry of the surface code increases, the advantage in the pseudo-threshold rates begins to saturate for any degree of asymmetry in the channel.

This paper introduces a design for surface codes specifically for asymmetric error channels, positing that the severity of bit flip and phase flip errors can be uneven. While the paper does delve deeply into surface codes and error correction, it does not specifically mention or discuss modular architectures nor increased error rates in intermodule communication. Its focus is on asymmetric errors within an error channel, rather than on the positioning of these errors in a modular system.

 🔴 [9]
Ultrahigh Error Threshold for Surface Codes with Biased Noise David K. Tuckett, ..., Steven T. Flammia (2017)
arXiv:1708.08474v3

We show that a simple modification of the surface code can exhibit an enormous gain in the error correction threshold for a noise model in which Pauli Z errors occur more frequently than X or Y errors. Such biased noise, where dephasing dominates, is ubiquitous in many quantum architectures. In the limit of pure dephasing noise we find a threshold of 43.7(1)% using a tensor network decoder proposed by Bravyi, Suchara and Vargo. The threshold remains surprisingly large in the regime of realistic noise bias ratios, for example 28.2(2)% at a bias of 10. The performance is in fact at or near the hashing bound for all values of the bias. The modified surface code still uses only weight-4 stabilizers on a square lattice, but merely requires measuring products of Y instead of Z around the faces, as this doubles the number of useful syndrome bits associated with the dominant Z errors. Our results demonstrate that large efficiency gains can be found by appropriately tailoring codes and decoders to realistic noise models, even under the locality constraints of topological codes.

The paper examines a modified version of the surface code that displays significantly increased error correction thresholds in the presence of biased noise, which is pertinent to the researcher's interest in situations of increased noise. The paper discusses a tailored surface code that improves error thresholds for a biased noise model, where Pauli Z errors occur more often than X or Y errors. This tailored surface code could indeed be relevant for quantum architecture modules with higher noise levels. However, the paper does not explicitly address the application in modular architectures nor it specifically discusses increased noise on the lines of communication between modules.

 🔴 [10]
Correcting non-independent and non-identically distributed errors with surface codes Konstantin Tiurev, ..., Jan-Michael Reiner (2022)
arXiv:2208.02191v3

A common approach to studying the performance of quantum error correcting codes is to assume independent and identically distributed single-qubit errors. However, the available experimental data shows that realistic errors in modern multi-qubit devices are typically neither independent nor identical across qubits. In this work, we develop and investigate the properties of topological surface codes adapted to a known noise structure by Clifford conjugations. We show that the surface code locally tailored to non-uniform single-qubit noise in conjunction with a scalable matching decoder yields an increase in error thresholds and exponential suppression of sub-threshold failure rates when compared to the standard surface code. Furthermore, we study the behaviour of the tailored surface code under local two-qubit noise and show the role that code degeneracy plays in correcting such noise. The proposed methods do not require additional overhead in terms of the number of qubits or gates and use a standard matching decoder, hence come at no extra cost compared to the standard surface-code error correction.

The paper primarily focuses on the implementation and analysis of topological surface codes adapted to non-uniform single-qubit noise, increasing the error thresholds and suppressing sub-threshold failure rates compared to the standard surface code error correction. It does discuss the nature of noise in quantum systems and suggests tailored strategies for error correction. However, the discussion seems to focus on errors across individual qubits and their non-identical nature, rather than explicitly looking into issues related to communication between multiple sub-units or modules. While the study of error correction within the module is relevant, the paper does not address the specific topic of higher error rates in the communication links between different modules in a modular architecture.

 🔴 [11]
Realizing Repeated Quantum Error Correction in a Distance-Three Surface Code Sebastian Krinner, ..., Andreas Wallraff (2021)
arXiv:2112.03708v1

Quantum computers hold the promise of solving computational problems which are intractable using conventional methods. For fault-tolerant operation quantum computers must correct errors occurring due to unavoidable decoherence and limited control accuracy. Here, we demonstrate quantum error correction using the surface code, which is known for its exceptionally high tolerance to errors. Using 17 physical qubits in a superconducting circuit we encode quantum information in a distance-three logical qubit building up on recent distance-two error detection experiments. In an error correction cycle taking only $1.1\,\mu$s, we demonstrate the preservation of four cardinal states of the logical qubit. Repeatedly executing the cycle, we measure and decode both bit- and phase-flip error syndromes using a minimum-weight perfect-matching algorithm in an error-model-free approach and apply corrections in postprocessing. We find a low error probability of $3\,\%$ per cycle when rejecting experimental runs in which leakage is detected. The measured characteristics of our device agree well with a numerical model. Our demonstration of repeated, fast and high-performance quantum error correction cycles, together with recent advances in ion traps, support our understanding that fault-tolerant quantum computation will be practically realizable.

While the paper discusses quantum error correction with surface codes, it does not address the unique challenges posed by modular architectures or noise between modules. It's more focused on improving the error correction within a single module and doesn't delve into strategies to handle higher error rates in the inter-module communication. Therefore, though relevant in the broader field of quantum error correction, the paper does not delve into the researcher's specific focus.

 🔴 [12]
Design of Quantum error correcting code for biased error on heavy-hexagon structure Younghun Kim, ..., Younghun Kwon (2022)
arXiv:2211.14038v1

Surface code is an error-correcting method that can be applied to the implementation of a usable quantum computer. At present, a promising candidate for a usable quantum computer is based on superconductor-specifically transmon. Because errors in transmon-based quantum computers appear biasedly as Z type errors, tailored surface and XZZX codes have been developed to deal with the type errors. Even though these surface codes have been suggested for lattice structures, since transmons-based quantum computers, developed by IBM, have a heavy-hexagon structure, it is natural to ask how tailored surface code and XZZX code can be implemented on the heavy-hexagon structure. In this study, we provide a method for implementing tailored surface code and XZZX code on a heavy-hexagon structure. Even when there is no bias, we obtain $ 0.231779 \%$ as the threshold of the tailored surface code, which is much better than $ 0.210064 \%$ and $ 0.209214 \%$ as the thresholds of the surface code and XZZX code, respectively. Furthermore, we can see that even though a decoder, which is not the best of the syndromes, is used, the thresholds of the tailored surface code and XZZX code increase as the bias of the Z error increases. Finally, we show that in the case of infinite bias, the threshold of the surface code is $ 0.264852\%$, but the thresholds of the tailored surface code and XZZX code are $ 0.296157 \% $ and $ 0.328127 \%$ respectively.

The paper focuses on the implementation of tailored surface codes and XZZX codes on a heavy-hexagon structure specific for transmon-based superconducting quantum computers. It presents improved thresholds for error correction in the presence of biased Z errors, which are common in transmon qubits. There is no specific mention of modular architectures or the issue of inter-modular communication noise, rather the focus is on overcoming biased errors within a specific type of qubit architecture. The subject of the study is relevant to quantum error correction and surface codes, but it falls short of addressing the challenge of higher error rates during communication between modular components of a quantum computing system.

 🔴 [13]
The Impact of Hardware Specifications on Reaching Quantum Advantage in the Fault Tolerant Regime Mark Webber, ..., Winfried K. Hensinger (2021)
arXiv:2108.12371v3

We investigate how hardware specifications can impact the final run time and the required number of physical qubits to achieve a quantum advantage in the fault tolerant regime. Within a particular time frame, both the code cycle time and the number of achievable physical qubits may vary by orders of magnitude between different quantum hardware designs. We start with logical resource requirements corresponding to a quantum advantage for a particular chemistry application, simulating the FeMoco molecule, and explore to what extent slower code cycle times can be mitigated by using additional qubits. We show that in certain situations architectures with considerably slower code cycle times will still be able to reach desirable run times, provided enough physical qubits are available. We utilize various space and time optimization strategies that have been previously considered within the field of error-correcting surface codes. In particular, we compare two distinct methods of parallelization, Game of Surface Code's Units, and AutoCCZ factories, both of which enable one to incrementally speed up the computation until the reaction limited rate is reached. Finally we calculate the number of physical qubits which would be required to break the 256 bit elliptic curve encryption of keys in the Bitcoin network, within the small available time frame in which it would actually pose a threat to do so. It would require approximately 317 million physical qubits to break the encryption within one hour using the surface code, a code cycle time of 1 $ \mu s$, a reaction time of 10 $ \mu s$, and physical gate error of $10^{-3}$. To break the encryption instead within one day it would require 13 million physical qubits.

The paper extensively discusses the impact of hardware design factors on the fault-tolerant regime and the potential for achieving quantum advantage. Specifically, it focuses on resource estimation for different error correction techniques and the factors affecting scalability and run-time. From the highlighted portions, it is clear that the surface code and its properties are central to the evaluation process. The paper also briefly touches on issues of interconnectivity, and acknowledges the potential of higher-dimensional error correction codes in enhancing system performance. However, it does not delve deeply into the specific topic of interest - managing high error rates during inter-module communication using surface codes in modular architectures. The subtopics of tailoring surface codes, noise resilience of quantum gates, or specifically altering error correction strategies to address high inter-module error rates are not addressed.

 🔴 [14]
Concatenation of the Gottesman-Kitaev-Preskill code with the XZZX surface code Jiaxuan Zhang, ..., Guo-Ping Guo (2022)
arXiv:2207.04383v3

Bosonic codes provide an alternative option for quantum error correction. An important category of bosonic codes called the Gottesman-Kitaev-Preskill (GKP) code has aroused much interest recently. Theoretically, the error correction ability of GKP code is limited since it can only correct small shift errors in position and momentum quadratures. A natural approach to promote the GKP error correction for large-scale, fault-tolerant quantum computation is concatenating encoded GKP states with a stabilizer code. The performance of the XZZX surface-GKP code, i.e., the single-mode GKP code concatenated with the XZZX surface code is investigated in this paper under two different noise models. Firstly, in the code-capacity noise model, the asymmetric rectangular GKP code with parameter $\lambda$ is introduced. Using the minimum weight perfect matching decoder combined with the continuous-variable GKP information, the optimal threshold of the XZZX-surface GKP code reaches $\sigma\approx0.67$ when $\lambda=2.1$, compared with the threshold $\sigma\approx0.60$ of the standard surface-GKP code. Secondly, we analyze the shift errors of two-qubit gates in the actual implementation and build the full circuit-level noise model. By setting the appropriate bias parameters, the logical error rate is reduced by several times in some cases. These results indicate the XZZX surface-GKP codes are more suitable for asymmetric concatenation under the general noise models. We also estimate the overhead of the XZZX-surface GKP code which uses about 291 GKP states with the noise parameter 18.5 dB ($\kappa/g \approx 0.71\%$) to encode a logical qubit with the error rate $2.53\times10^{-7}$, compared with the qubit-based surface code using 3041 qubits to achieve almost the same logical error rate.

The title and abstract of this paper suggest the focus is on a theoretical study of a concatenated code involving GKP states with the XZZX surface code. While these topics are closely related to quantum error correction and surface codes, there is no mention in the abstract or the selected parts of the paper regarding modular architectures or the specific issue of higher error rates during communication between modules. Instead, the paper seems to focus on a specific approach to strengthening error correction abilities within a single noisy model (not necessarily modular). Moreover, there is an emphasis on the asymmetric noise model and improving logical error rates, which, while valuable, may not directly address the issues of modularity and inter-module communication noise.

 🔴 [15]
Demystifying Noise Resilience of Quantum Error Correction: Insights for Code Optimization Avimita Chatterjee, ..., Swaroop Ghosh (2023)
arXiv:2308.02769v1

Quantum error correction codes (QECCs) are critical for realizing reliable quantum computing by protecting fragile quantum states against noise and errors. However, limited research has analyzed the noise resilience of QECCs to help select optimal codes. This paper conducts a comprehensive study analyzing two QECCs - repetition codes and surface codes - under different error types and noise models using simulations. Surface codes emerge robust to both bit and phase flip errors. Among them, rotated surface codes perform best with higher thresholds attributed to simplicity and lower qubit overhead. The noise threshold, or the point at which QECCs become ineffective, surpasses the error rate found in contemporary quantum processors. When confronting quantum hardware where a specific error or noise model is dominant, a discernible hierarchy emerges for surface code implementation in terms of resource demand. This ordering is consistently observed across repetition, unrotated, and rotated surface codes. Our noise model analysis ranks the code-capacity model as the most pessimistic and circuit-level model as the most realistic. The study maps error thresholds, revealing surface code's advantage over modern quantum processors. It also shows higher code distances and rounds consistently improve performance. However, excessive distances needlessly increase qubit overhead. By matching target logical error rates and feasible number of qubits to optimal surface code parameters, our study demonstrates the necessity of tailoring these codes to balance reliability and qubit resources.

This paper presents an in-depth study of quantum error correction codes, specifically looking at repetition codes and surface codes, and how they perform with different error types and noise models. It does emphasize the strength of surface codes in their handling of both bit-flip and phase-flip errors, and advocates for the use of rotated surface codes due to their higher thresholds and lower qubit needs. It also highlights the importance of tailoring surface code parameters to match the target logical error rate and hardware capabilities, reducing unnecessary overhead. However, the paper does not distinctly discuss a modular architecture or specifically address the issue of increased noise in inter-module communication, which is central to the specific research interest identified.