Latest Research on Quantum Computing: A Thematic Literature Review of Algorithms, Error Correction, Mitigation, Benchmarks, and Emerging Hardware

Abstract

Recent quantum-computing research shows a clear shift from purely noisy, proof-of-principle demonstrations toward early practical utility and increasingly realistic routes to fault tolerance. Across the available evidence, the strongest advances cluster around quantum error correction and low-overhead architectures, including a 0.7% threshold for fault-tolerant quantum memory with low-density parity-check codes and constant-overhead schemes that outperform the surface code at realistic error rates of 10⁻³, while experimental platforms have already demonstrated fault-tolerant logical-qubit operation in diamond and three-qubit Grover search reaching approximately 95% of the ideal success probability on silicon. In parallel, near-term work continues to extract value from noisy devices through error mitigation, with methods achieving error suppression below 10⁻⁶ in simulation and improved readout correction on superconducting processors, although theory now also shows that mitigation faces superpolynomial sampling overhead and exponentially earlier noise scrambling in larger systems. This review synthesizes recent progress across algorithms, hardware, noise management, benchmarking, and manufacturability to clarify which directions are maturing fastest and where the bottlenecks remain. The evidence indicates that QAOA is becoming more implementation-aware and that photonic and neutral-atom platforms are rapidly advancing toward practical integration, but scalability, calibration, and connectivity constraints continue to delimit near-term impact. Overall, the field is converging on two complementary trajectories: incremental utility on noisy intermediate-scale devices and more credible fault-tolerant pathways through improved codes, decoding, and hardware-native architectures.

Keywords: quantum computing, quantum algorithms, quantum hardware, error correction, error mitigation, fault tolerance, benchmarking

1. Introduction

Quantum computing has moved from a largely speculative promise to an increasingly diversified research program spanning algorithms, hardware engineering, and noise management. Its central challenge remains unchanged: quantum states are intrinsically fragile, and physical errors accumulate faster than the idealized computations required for advantage. As a result, much of the most consequential recent work has focused not only on improving qubit quality, but also on redefining what is achievable before full fault tolerance is available. In this landscape, quantum error correction provides the formal route to scalable computation by encoding logical information into larger physical systems, while quantum error mitigation seeks to recover useful results from noisy processors without the full overhead of correction. At the same time, the algorithmic literature has continued to refine near-term methods such as the quantum approximate optimization algorithm (QAOA), and hardware research has expanded across superconducting circuits, silicon spin qubits, neutral atoms, photonics, diamond defects, and reconfigurable atom arrays.

What is notable in the recent literature is the growing alignment between theory and implementation. Several studies now report hardware-aware protocols with explicit resource estimates, while experimental papers increasingly demonstrate logical operations, calibrated interconnects, and benchmarked fidelities rather than isolated qubit control. Yet the field remains fragmented: progress in one platform does not necessarily transfer to another, and improvements in one layer of the stack may be offset by limitations elsewhere, such as decoding speed, connectivity, loss, or sample complexity. The key question, therefore, is not simply whether quantum computing is advancing, but how the latest evidence reorganizes expectations about where meaningful progress is occurring, which approaches are most credible, and what remains unresolved as the field transitions from noisy demonstrations toward usable quantum information processing.

2. Methods

2.1 Search Strategy

We performed a comprehensive search across over 220 million academic papers from the Semantic Scholar and OpenAlex databases. The search strategy employed hybrid semantic and keyword-based retrieval to maximize coverage.

Search queries included:

• "Quantum computing latest research algorithms hardware and error correction"
• "Quantum computation advances in qubits fault tolerance and scalable architectures"
• "Recent quantum computing applications optimization simulation and machine learning"
• "Quantum error correction and noise mitigation in near-term quantum devices"
• "Survey review of emerging quantum computing methods and experimental platforms"

2.2 Study Selection

Initial database searching identified 200 records. After duplicate removal and relevance-based filtering, 100 records were screened against eligibility criteria. Of these, 80 papers were excluded, resulting in 20 papers included in the final synthesis.

PRISMA Flow Diagram

Eligibility criteria included:

• Quantum Scope: Does the study focus on quantum computing, quantum computation, or quantum information processing rather than unrelated classical computing topics?
• Recent Publication: Was the study published in 2020 or later?
• Primary Research: Does the paper present original research, a survey, benchmark, experiment, theory, or simulation rather than a non-research editorial or opinion piece?
• Hardware or Algorithms: Does the study address quantum hardware, quantum algorithms, error correction, noise mitigation, benchmarking, or applications?
• Novelty: Does the paper report a new method, platform, result, benchmark, or comparative analysis?
• Scalability: Does the study discuss scalability, performance limits, error rates, fidelity, or resource overheads?
• Practical Relevance: Does the paper include an experimental platform, application use case, or implementation-oriented contribution?

All included studies met the stated eligibility criteria.

2.3 Data Extraction and Synthesis

Data extraction focused on the following variables:

• Research Focus: The main quantum computing topic addressed, such as algorithms, hardware, error correction, benchmarking, applications, or theory.
• Approach: The specific method, model, experimental platform, or theoretical approach used.
• Quantum Platform: The quantum hardware or platform studied, such as superconducting qubits, trapped ions, photonics, neutral atoms, or annealers; if none, theoretical or software-only.
• Key Result: The central finding or contribution reported by the paper, emphasizing what is new or improved.
• Use Case: The application domain or benchmark task studied, if any, such as optimization, chemistry, materials, machine learning, cryptography, or simulation.
• Limitations: Any limitations, scalability constraints, noise issues, or open challenges explicitly stated by the paper.
• Evidence Type: The study type, such as experiment, review, benchmark, theory, or simulation.

Thematic analysis was employed to identify patterns and synthesize findings across studies. Evidence strength was assessed based on consistency of findings and number of supporting studies.

3. Results

3.1 Characteristics of Included Studies

The evidence base is dominated by theoretical and review work, but it is anchored by a growing set of experimental and simulation studies across superconducting, silicon, diamond, neutral-atom, and photonic platforms. A notable feature of the landscape is the convergence on fault tolerance and noise management, even in studies that otherwise differ sharply in platform and methodology.

3.2 Thematic Findings

3.2.1 Fault Tolerance Is Moving from Abstract Threshold Theory Toward Hardware-Native Architectures and Early Demonstrations

Recent research converges on the conclusion that fault tolerance is becoming more practical because the field is no longer relying on a single code family or a single hardware route. Low-density parity-check approaches now achieve a 0.7% threshold for the standard circuit-based noise model and can preserve 12 logical qubits for nearly 1 million syndrome cycles using 288 physical qubits at 0.1% physical error (Bravyi et al., 2024). Complementing this, reconfigurable atom-array architectures with qLDPC codes are reported to outperform the surface code at as few as several hundred physical qubits at 10⁻³ error and to provide more than an order of magnitude qubit savings below 3000 physical qubits (Xu et al., 2024). In parallel, constant-space-overhead protocols based on concatenated small codes reduce the space burden while bringing time overhead down to quasi-polylogarithmic levels (Yamasaki & Koashi, 2024). Experimental work aligns with these theoretical trajectories: a diamond processor demonstrated fault-tolerant logical-qubit encoding and a complete set of single-qubit logical Clifford gates using the five-qubit code and flag protocol (Abobeih et al., 2022), while a silicon processor executed Grover's search with all control fidelities above the fault-tolerant threshold and approximately 95% of the ideal success probability (Thorvaldson et al., 2025). The common pattern is that fault tolerance is no longer framed solely as a distant asymptote; instead, it is being instantiated in platform-specific ways that trade off qubit count, connectivity, and decoder complexity. Confidence is strong because theory, simulation, and experiment point in the same direction, even though the exact resource advantage depends on architecture.

3.2.2 Error Mitigation Remains Useful, but Its Theoretical Limits Are Now Sharper Than Its Practical Successes

The literature presents a clear duality: mitigation is immediately valuable on noisy devices, yet its scalability is fundamentally constrained. On the practical side, classical post-processing based on detector tomography improved readout correction on IBM and Rigetti superconducting transmons and enhanced outcomes for quantum state tomography, quantum process tomography, non-projective measurements, Grover's search, and the Bernstein–Vazirani algorithm (Maciejewski et al., 2020). Likewise, methods using up to four circuit copies achieved error suppression below 10⁻⁶ in numerical simulations for circuits with several hundred noisy gates and a two-qubit gate error of 0.5% (Koczor, 2021). However, analytical work substantially narrows the optimistic interpretation of these gains. One study shows that, for many general mitigation protocols, sampling overhead scales exponentially with circuit depth and that probabilistic error cancellation is optimal in a broad class of local dephasing settings (Takagi et al., 2022). Another finds superpolynomial sample requirements even at shallow circuit depths and identifies noise scrambling at exponentially smaller depths than previously thought, with implications for variational algorithms, kernel estimation, and expectation-value estimation (Quek et al., 2024). Taken together, the field supports mitigation as a short-term enabling tool but not a substitute for correction at scale. Confidence is strong for the existence of practical benefits and equally strong for the presence of scalability barriers, because experimental improvements and formal lower bounds jointly support that conclusion.

3.2.3 Near-Term Algorithm Research Is Shifting from Abstract Performance Claims to Resource-Aware Implementation

The algorithmic literature is becoming more operationally realistic. For QAOA, one line of work shows that carefully designed parameter initialization can find quasioptimal p-level solutions in polynomial time and that the algorithm can exploit nonadiabatic behavior to circumvent small spectral gaps (Zhou et al., 2020). A later review consolidates this view by emphasizing that QAOA's relevance now depends on both performance across problem instances and resilience to hardware noise (Blekos et al., 2024). At the same time, experimental evidence suggests that useful output can be extracted before fault tolerance for strong-entanglement settings on a 127-qubit superconducting processor, where measured expectation values exceeded the brute-force classical computation regime (Kim et al., 2023). These results do not establish broad quantum advantage, but they do indicate that algorithmic value is increasingly framed as a resource-sensitive, hardware-conditional question rather than a binary claim. The evidence is moderate to strong: algorithmic feasibility is better supported than algorithmic superiority, and the latter remains context dependent.

3.2.4 Hardware Diversity Is Broadening, but Each Platform Advances Through Different Bottlenecks

Across platforms, the field is no longer centered on one dominant hardware story. Photonic work demonstrates a manufacturable silicon-photonics platform with 99.98% ± 0.01% state preparation and measurement fidelity, 99.50% ± 0.25% Hong–Ou–Mandel visibility, 99.22% ± 0.12% two-qubit fusion fidelity, and 99.72% ± 0.04% chip-to-chip interconnect fidelity, conditional on detection and excluding loss (Alexander et al., 2025). Another photonic study realized a GKP state in propagating light at telecommunication wavelength, verified by homodyne measurements without loss corrections (Konno et al., 2024). In neutral atoms, hardware-efficient fault-tolerant schemes directly address Rydberg-related decay and correlated errors (Cong et al., 2022), and reconfigurable atom arrays are presented as a plausible route for qLDPC-based computation (Xu et al., 2024). Silicon spin qubits likewise show increasingly credible multi-qubit control, and diamond spin qubits have already supported fault-tolerant logical operations (Abobeih et al., 2022; Thorvaldson et al., 2025). The limiting factor is no longer just qubit coherence in the abstract; rather, it is the interaction between platform-specific error channels and the structure of the code or algorithm. Confidence is moderate, because the platforms are heterogeneous and the metrics are not directly comparable, but the cross-platform direction of travel is consistent.

3.2.5 Benchmarking and Reviews Are Becoming Infrastructure for the Field Rather Than Peripheral Synthesis

A less dramatic but important trend is the maturation of benchmarking, review, and tooling. MQT Bench provides more than 70,000 circuits ranging from 2 to 130 qubits across four abstraction levels, designed to improve comparability, reproducibility, and transparency (Quetschlich et al., 2023). Broad reviews of near-term techniques and error mitigation synthesize the same overarching message: useful quantum computing in the NISQ era depends on better evaluation, mitigation, compilation, and simulation (Cai et al., 2023; Huang et al., 2023). In parallel, the review of recent QEC advances highlights a community shift toward early error-corrected quantum computers while noting unresolved platform-specific challenges (Campbell, 2024). This infrastructure-building trend matters because it makes claims about performance, robustness, and scalability more testable. Confidence is moderate to strong, as the evidence is mainly descriptive but highly convergent.

3.3 Summary of Evidence

4. Discussion

4.1 Principal Findings and Their Interpretation

The synthesis indicates that the most consequential progress in quantum computing is currently concentrated in the interface between error correction and hardware architecture. This is not surprising: once physical errors dominate, algorithmic sophistication alone cannot compensate. The stronger fault-tolerance results are important because they show that overhead is no longer merely a theoretical metric; it is becoming a design variable that can be optimized through code choice, decoder structure, and hardware layout. The low-overhead qLDPC results, the constant-space-overhead concatenation strategy, and the experimental demonstrations in diamond and silicon collectively suggest that the field is moving from "can fault tolerance work?" to "which physical architecture can support it most efficiently?" That shift is analytically meaningful because it implies the dominant bottleneck is no longer conceptual feasibility but engineering coherence between code and device.

The error-mitigation literature adds a second, more cautionary lesson. Practical mitigation continues to yield useful outputs on today's devices, especially for readout correction and expectation-value estimation, but the formal lower bounds show that such gains are inherently limited as circuits deepen or system sizes grow. This creates a bifurcated landscape: mitigation is valuable for extracting short-term utility, yet correction remains necessary for scalable computation. The evidence for this conclusion is strong because theoretical impossibility results and experimental demonstrations point in the same direction. By contrast, the algorithmic literature around QAOA is more tentative. Its recent progress appears to depend less on universal algorithmic superiority and more on better parameter strategies and more realistic implementation models. That interpretive shift matters because it suggests the field is maturing away from headline claims toward operational criteria.

4.2 Comparison with Existing Literature and Resolution of Contradictions

The recent literature is broadly consistent in treating noise as the central determinant of progress, but it diverges sharply on what can be achieved before fault tolerance. Experimental studies and reviews that emphasize near-term utility align in showing that useful outputs can be obtained from noisy devices, especially when coherence, calibration, or tomography-informed post-processing are improved (Kim et al., 2023; Maciejewski et al., 2020; Cai et al., 2023). In contrast, the formal error-mitigation bounds suggest that these successes do not generalize indefinitely. This tension is not a contradiction in the strict sense; rather, it reflects different target regimes. Small- to medium-scale experiments may benefit substantially from mitigation, while asymptotic theory reveals why those same methods cannot scale efficiently to larger problems. The distinction matters because it prevents overgeneralizing short-term empirical wins into long-term architectural solutions.

A similar pattern appears in algorithm research. QAOA is presented as promising and increasingly well understood, but its utility is highly contingent on instance structure, parameter optimization, and noise exposure (Zhou et al., 2020; Blekos et al., 2024). This helps resolve any implicit contradiction between optimistic algorithmic claims and practical caution: the algorithm can exploit nonadiabatic mechanisms and be implemented on near-term hardware, yet its performance advantage is not universal. The same logic applies across hardware platforms. Photonics shows extremely high component fidelities, but loss remains a major issue; neutral atoms promise efficient fault-tolerant schemes, but long-range connectivity is difficult; silicon and diamond have strong control fidelities, but scaling remains unresolved (Alexander et al., 2025; Cong et al., 2022; Thorvaldson et al., 2025; Abobeih et al., 2022). Overall, the literature does not show a single best platform. Instead, it shows platform-specific advances that are strongest where the dominant error channel matches the correction or control strategy. Because many of the most positive reports are demonstration-oriented, publication bias toward successful systems cannot be ruled out, although the presence of rigorous negative or limiting theory on mitigation tempers that concern.

4.3 Practical Implications

For practitioners, the clearest implication is that quantum computing strategy must be use-case specific. On superconducting processors, readout mitigation and benchmark-driven calibration can improve the reliability of tomography and small algorithmic tasks, but these methods should be viewed as tactical rather than definitive solutions (Maciejewski et al., 2020). For developers of near-term applications, QAOA and expectation-value-based methods are most credible when paired with resource-aware parameter initialization, careful benchmarking, and explicit noise modeling (Zhou et al., 2020; Quetschlich et al., 2023). For hardware teams, the most actionable message is that fault tolerance is increasingly achievable when the code, decoder, and platform are co-designed: qLDPC codes appear especially promising for reconfigurable atom arrays, while concatenated codes offer a different route where decoder latency is manageable (Xu et al., 2024; Yamasaki & Koashi, 2024).

Regulatory and strategic implications are also emerging. The mitigation literature indicates that there is no general "free" correction layer that can indefinitely compensate for noise; therefore, system-level progress requires population-wide improvements in fidelity and architecture rather than reliance on post hoc fixes (Takagi et al., 2022; Quek et al., 2024). For photonic systems, the manufacturable-platform work suggests that loss reduction and scalable integration are the critical prerequisites for broader deployment (Alexander et al., 2025). For silicon, diamond, and neutral atoms, the challenge is to preserve high control fidelity while increasing qubit count and managing platform-specific error channels (Abobeih et al., 2022; Thorvaldson et al., 2025; Cong et al., 2022). In short, the practical horizon for quantum computing is real but differentiated: near-term value is most plausible in carefully benchmarked, noise-aware settings, while scalable utility will depend on whether fault tolerance can be realized with low enough overhead.

4.4 Strengths and Limitations

This review benefits from a broad thematic coverage spanning algorithms, error correction, error mitigation, benchmarking, and multiple hardware platforms, which allows comparison across otherwise siloed subfields. The inclusion of both theoretical and experimental work strengthens the synthesis because it captures not only what has been demonstrated, but also what is considered feasible or impossible under current models. However, the included studies vary widely in design quality, platform, and outcome metrics, which limits direct comparability. Many results are architecture-specific and cannot be generalized without caution. Several papers are reviews rather than primary data, and some experimental demonstrations report conditional fidelities or simulation-based validation rather than end-to-end scalable performance. Within this review, the use of abstract-level and extracted-data synthesis also limits the granularity of methodological appraisal, and no formal risk-of-bias assessment was conducted.

5. Gaps and Future Directions

The synthesis reveals several concrete gaps. First, the field still lacks head-to-head comparisons of fault-tolerant strategies on the same hardware under matched noise conditions; qLDPC, concatenated-code, and flag-protocol approaches are promising, but their tradeoffs remain fragmented across platforms (Bravyi et al., 2024; Xu et al., 2024; Yamasaki & Koashi, 2024; Abobeih et al., 2022). Second, error-mitigation research needs more direct experimental validation of the theoretical limits identified for larger systems, because most current positive results are small-scale or simulation-based (Koczor, 2021; Quek et al., 2024; Takagi et al., 2022). Third, benchmark standardization remains incomplete: more cross-platform, cross-level benchmarks are needed to make claims about performance comparable across devices and software stacks (Quetschlich et al., 2023). Finally, several platforms remain underrepresented in directly scalable demonstrations, especially photonics and neutral atoms at the level of full logical computation rather than component or error-source characterization (Alexander et al., 2025; Cong et al., 2022; Konno et al., 2024). Future work would be strongest if it paired fault-tolerant protocols with realistic decoder latency, noise-aware compilation, and end-to-end benchmarks on the exact target hardware.

6. Conclusion

The latest research on quantum computing supports a clear but qualified conclusion: the field is advancing most convincingly through fault-tolerance-oriented engineering and noise-aware implementation rather than through universal algorithmic breakthroughs. The strongest evidence comes from studies showing a 0.7% threshold and a 288-physical-qubit route to preserving 12 logical qubits for nearly 1 million syndrome cycles at 0.1% error (Bravyi et al., 2024), along with qLDPC architectures that outperform the surface code at 10⁻³ and require less than 3000 physical qubits for substantial savings (Xu et al., 2024). Experimental demonstrations in diamond and silicon further show that fault-tolerant logical operation and Grover's search at approximately 95% of the ideal success probability are now within reach on specific platforms (Abobeih et al., 2022; Thorvaldson et al., 2025). At the same time, near-term utility remains real but bounded: readout mitigation, expectation-value estimation, and QAOA optimization can deliver useful performance, yet formal work shows that mitigation faces exponential or superpolynomial scaling barriers (Maciejewski et al., 2020; Koczor, 2021; Takagi et al., 2022; Quek et al., 2024).

Because much of the evidence is platform-specific, the most defensible conclusion is that quantum computing is entering a phase of differentiated progress rather than uniform maturity. The unresolved question with the greatest significance is which hardware–error-code–decoder combinations can scale to practical quantum advantage with acceptable overhead. Answering that will determine whether the current wave of advances becomes a transitional milestone or a durable foundation for large-scale quantum computation.

References

1. Abobeih, M. H., Wang, Y., Randall, J., Loenen, S. J. H., Bradley, C. E., Markham, M., Twitchen, D. J., Terhal, B. M., & Taminiau, T. H. (2022). Fault-tolerant operation of a logical qubit in a diamond quantum processor. Nature, 606(7916), 884–889. https://doi.org/10.1038/s41586-022-04819-6
2. Alexander, K., Bahgat, A., Benyamini, A., Black, D., Bonneau, D., Burgos, S., Burridge, B., Campbell, G., Catalano, G., Ceballos, A., … PsiQuantum Team. (2025). A manufacturable platform for photonic quantum computing. Nature, 641(8064), 876–883. https://doi.org/10.1038/s41586-025-08820-7
3. Blekos, K., Brand, D., Ceschini, A., Chou, C.-H., Li, R.-H., Pandya, K., & Summer, A. (2024). A review on quantum approximate optimization algorithm and its variants. Physics Reports, 1068, 1–66. https://doi.org/10.1016/j.physrep.2024.03.002
4. Bravyi, S., Cross, A. W., Gambetta, J. M., Maslov, D., Rall, P., & Yoder, T. J. (2024). High-threshold and low-overhead fault-tolerant quantum memory. Nature, 627(8005), 778–782. https://doi.org/10.1038/s41586-024-07107-7
5. Cai, Z., Babbush, R., Benjamin, S. C., Endo, S., Huggins, W. J., Li, Y., McClean, J. R., & O'Brien, T. E. (2023). Quantum error mitigation. Reviews of Modern Physics, 95(4), 045005. https://doi.org/10.1103/RevModPhys.95.045005
6. Campbell, E. (2024). A series of fast-paced advances in quantum error correction. Nature Reviews Physics, 6(3), 160–161. https://doi.org/10.1038/s42254-024-00706-3
7. Cong, I., Levine, H., Keesling, A., Bluvstein, D., Wang, S.-T., & Lukin, M. D. (2022). Hardware-efficient, fault-tolerant quantum computation with Rydberg atoms. Physical Review X, 12(2), 021049. https://doi.org/10.1103/PhysRevX.12.021049
8. Huang, H.-L., Xu, X.-Y., Guo, C., Tian, G., Wei, S.-J., Sun, X., Bao, W.-S., & Long, G.-L. (2023). Near-term quantum computing techniques: Variational quantum algorithms, error mitigation, circuit compilation, benchmarking and classical simulation. Science China Physics, Mechanics & Astronomy, 66(5), 250302. https://doi.org/10.1007/s11433-022-2057-y
9. Kim, Y., Eddins, A., Anand, S., Wei, K. X., van den Berg, E., Rosenblatt, S., Nayfeh, H., Wu, Y., Zaletel, M., Temme, K., & Kandala, A. (2023). Evidence for the utility of quantum computing before fault tolerance. Nature, 618(7965), 500–505. https://doi.org/10.1038/s41586-023-06096-3
10. Koczor, B. (2021). Exponential error suppression for near-term quantum devices. Physical Review X, 11(3), 031057. https://doi.org/10.1103/PhysRevX.11.031057
11. Konno, S., Asavanant, W., Hanamura, F., Nagayoshi, H., Fukui, K., Sakaguchi, A., Ide, R., China, F., Yabuno, M., Miki, S., Terai, H., Takase, K., Endo, M., Marek, P., Filip, R., van Loock, P., & Furusawa, A. (2024). Logical states for fault-tolerant quantum computation with propagating light. Science, 383(6680), 289–293. https://doi.org/10.1126/science.adk7560
12. Maciejewski, F. B., Zimborás, Z., & Oszmaniec, M. (2020). Mitigation of readout noise in near-term quantum devices by classical post-processing based on detector tomography. Quantum, 4, 257. https://doi.org/10.22331/q-2020-04-24-257
13. Quek, Y., Stilck França, D., Khatri, S., Meyer, J. J., & Eisert, J. (2024). Exponentially tighter bounds on limitations of quantum error mitigation. Nature Physics, 20(10), 1648–1658. https://doi.org/10.1038/s41567-024-02536-7
14. Quetschlich, N., Burgholzer, L., & Wille, R. (2023). MQT Bench: Benchmarking software and design automation tools for quantum computing. Quantum, 7, 1062. https://doi.org/10.22331/q-2023-07-20-1062
15. Skoric, L., Browne, D. E., Barnes, K. M., Gillespie, N. I., & Campbell, E. T. (2023). Parallel window decoding enables scalable fault tolerant quantum computation. Nature Communications, 14, 7040. https://doi.org/10.1038/s41467-023-42482-1
16. Takagi, R., Endo, S., Minagawa, S., & Gu, M. (2022). Fundamental limits of quantum error mitigation. npj Quantum Information, 8, 114. https://doi.org/10.1038/s41534-022-00618-z
17. Thorvaldson, I., Poulos, D., Moehle, C. M., Misha, S. H., Edlbauer, H., Reiner, J., Geng, H., Voisin, B., Jones, M. T., Donnelly, M. B., Peña, L. F., Hill, C. D., Myers, C. R., Keizer, J. G., Chung, Y., Gorman, S. K., Kranz, L., & Simmons, M. Y. (2025). Grover's algorithm in a four-qubit silicon processor above the fault-tolerant threshold. Nature Nanotechnology, 20(4), 472–477. https://doi.org/10.1038/s41565-024-01853-5
18. Xu, Q., Bonilla Ataides, J. P., Pattison, C. A., Raveendran, N., Bluvstein, D., Wurtz, J., Vasić, B., Lukin, M. D., Jiang, L., & Zhou, H. (2024). Constant-overhead fault-tolerant quantum computation with reconfigurable atom arrays. Nature Physics, 20(7), 1084–1090. https://doi.org/10.1038/s41567-024-02479-z
19. Yamasaki, H., & Koashi, M. (2024). Time-efficient constant-space-overhead fault-tolerant quantum computation. Nature Physics, 20(2), 247–253. https://doi.org/10.1038/s41567-023-02325-8
20. Zhou, L., Wang, S.-T., Choi, S., Pichler, H., & Lukin, M. D. (2020). Quantum approximate optimization algorithm: Performance, mechanism, and implementation on near-term devices. Physical Review X, 10(2), 021067. https://doi.org/10.1103/PhysRevX.10.021067