Quantum Error Correction Innovations

MIT Sets Quantum Computing Record with 99.998% Fidelity Researchers at MIT have achieved a world-record single-qubit fidelity of 99.998% using a superconducting qubit known as fluxonium. This breakthrough represents a significant step toward practical quantum computing by addressing one of the field’s greatest challenges: mitigating noise and control imperfections that lead to operational errors. Key Highlights: 1. The Problem: Noise and Errors • Qubits, the building blocks of quantum computers, are highly sensitive to noise and imperfections in control mechanisms. • Such disturbances introduce errors that limit the complexity and duration of quantum algorithms. “These errors ultimately cap the performance of quantum systems,” the researchers noted. 2. The Solution: Two New Techniques To overcome these challenges, the MIT team developed two innovative techniques: • Commensurate Pulses: This method involves timing quantum pulses precisely to make counter-rotating errors uniform and correctable. • Circularly Polarized Microwaves: By creating a synthetic version of circularly polarized light, the team improved the control of the qubit’s state, further enhancing fidelity. “Getting rid of these errors was a fun challenge for us,” said David Rower, PhD ’24, one of the study’s lead researchers. 3. Fluxonium Qubits and Their Potential • Fluxonium qubits are superconducting circuits with unique properties that make them more resistant to environmental noise compared to traditional qubits. • By applying the new error-mitigation techniques, the team unlocked the potential of fluxonium to operate at near-perfect fidelity. 4. Implications for Quantum Computing • Achieving 99.998% fidelity significantly reduces errors in quantum operations, paving the way for more complex and reliable quantum algorithms. • This milestone represents a major step toward scalable quantum computing systems capable of solving real-world problems. What’s Next? The team plans to expand its work by exploring multi-qubit systems and integrating the error-mitigation techniques into larger quantum architectures. Such advancements could accelerate progress toward error-corrected, fault-tolerant quantum computers. Conclusion: A Leap Toward Practical Quantum Systems MIT’s achievement underscores the importance of innovation in error correction and control to overcome the fundamental challenges of quantum computing. This breakthrough brings us closer to the realization of large-scale quantum systems that could transform fields such as cryptography, materials science, and complex optimization problems.

Looks like we’ve hit another turning point in quantum computing. Quantinuum just demonstrated 𝗹𝗼𝗴𝗶𝗰𝗮𝗹 𝗴𝗮𝘁𝗲𝘀 𝗯𝘂𝗶𝗹𝘁 𝗼𝗻 𝗮 𝗳𝗮𝘂𝗹𝘁-𝘁𝗼𝗹𝗲𝗿𝗮𝗻𝘁 𝗽𝗿𝗼𝘁𝗼𝗰𝗼𝗹 𝘁𝗵𝗮𝘁 𝗯𝗲𝗮𝘁 𝘁𝗵𝗲 𝗽𝗵𝘆𝘀𝗶𝗰𝗮𝗹 𝗴𝗮𝘁𝗲𝘀 𝘁𝗵𝗲𝘆'𝗿𝗲 𝗺𝗮𝗱𝗲 𝗳𝗿𝗼𝗺. This includes the hardest one: 𝗮 𝗻𝗼𝗻-𝗖𝗹𝗶𝗳𝗳𝗼𝗿𝗱 𝘁𝘄𝗼-𝗾𝘂𝗯𝗶𝘁 𝗴𝗮𝘁𝗲. If you’ve followed quantum computing for a while, you know the game has long been about scaling. More qubits, better gates, lower error rates. 𝗕𝘂𝘁 𝗿𝗲𝗮𝗹 𝗳𝗮𝘂𝗹𝘁 𝘁𝗼𝗹𝗲𝗿𝗮𝗻𝗰𝗲? That’s been the elusive frontier. Until now. 𝗤𝘂𝗮𝗻𝘁𝗶𝗻𝘂𝘂𝗺'𝘀 𝗻𝗲𝘄 𝘄𝗼𝗿𝗸 𝗱𝗲𝗺𝗼𝗻𝘀𝘁𝗿𝗮𝘁𝗲𝘀 𝘁𝗵𝗲 𝗰𝗿𝗶𝘁𝗶𝗰𝗮𝗹 𝗯𝘂𝗶𝗹𝗱𝗶𝗻𝗴 𝗯𝗹𝗼𝗰𝗸𝘀 𝗳𝗼𝗿 𝗮 𝘂𝗻𝗶𝘃𝗲𝗿𝘀𝗮𝗹, 𝗳𝗮𝘂𝗹𝘁-𝘁𝗼𝗹𝗲𝗿𝗮𝗻𝘁 𝗴𝗮𝘁𝗲 𝘀𝗲𝘁. 𝗦𝗼 𝘄𝗵𝗮𝘁 𝗱𝗼𝗲𝘀 𝘁𝗵𝗶𝘀 𝗺𝗲𝗮𝗻 ? To unlock the full power of quantum computation, you need to go beyond Clifford gates. 𝗡𝗼𝗻-𝗖𝗹𝗶𝗳𝗳𝗼𝗿𝗱 𝗴𝗮𝘁𝗲𝘀 (like T or controlled-Hadamard) 𝗮𝗿𝗲 𝗲𝘀𝘀𝗲𝗻𝘁𝗶𝗮𝗹 𝗳𝗼𝗿 𝗾𝘂𝗮𝗻𝘁𝘂𝗺 𝗮𝗱𝘃𝗮𝗻𝘁𝗮𝗴𝗲, but they’re notoriously hard to implement fault-tolerantly. Why? Because applying a non-Clifford gate directly to a logical qubit can spread a single error into a correlated mess that error correction can't handle. This is a fundamental limitation, not a hardware bug. 𝗦𝗼 𝘄𝗵𝗮𝘁 𝗱𝗼 𝘄𝗲 𝗱𝗼? Instead of applying dangerous gates directly, we 𝘁𝗲𝗹𝗲𝗽𝗼𝗿𝘁 them using special resource states, so-called 𝗺𝗮𝗴𝗶𝗰 𝘀𝘁𝗮𝘁𝗲𝘀. Think of it like outsourcing the risky part of the operation to an ancilla that we can verify, discard if faulty, and only then use to apply the gate safely. That’s the idea. But nobody had shown that this could be done fault-tolerantly and with better-than-physical performance. Quantinuum just released two new papers that change that: • Shival Dasu et al. prepared ultra-clean ∣H⟩ magic states using just 8 qubits, then used them to implement a logical non-Clifford CH gate, achieving a fidelity better than the physical gate. That’s the elusive break-even point: logical > physical.    • Lucas Daguerre et al. prepared high-fidelity ∣T⟩ states directly in the distance-3 Steane code, using a clever code-switching protocol from the Reed-Muller code (where transversal T gates are allowed). The resulting magic state had lower error than any physical component involved.    Why are these landmark results ? Because these two results together prove you can: • Prepare magic states fault-tolerantly • Use them to implement non-Clifford logic • And do so with error rates below the physical layer    𝗔𝗹𝗹 𝗼𝗻 𝗰𝘂𝗿𝗿𝗲𝗻𝘁 𝗵𝗮𝗿𝗱𝘄𝗮𝗿𝗲. No hand-waving. No simulations. Of course not everything is solved: these are still distance-2 or -3 codes, and we haven’t seen a full algorithm run start-to-finish with these techniques. But the last conceptual hurdles are falling. Not on superconducting qubits but on ion traps. 📸 Credits: Daguerre et al. (arXiv:2506.14169)

One Algorithm Has Just Pushed Quantum Computing Forward Five Years (Here It Is) Today I am releasing something into the public domain that may change the trajectory of quantum computing. No paywall. No NDA. No restrictions. The only thing I ask is attribution. For the past year, I have been developing a field-layer correction algorithm that stabilizes the environment around the qubit before error correction ever activates. Not hardware. Not cryogenics. Not shielding. Pure software that improves the physics of the qubit it sits inside. Early independent runs showed a 48.5 percent reduction in destructive low-frequency noise, a gain that normally takes years of hardware progress. Here is the complete algorithm. It now belongs to everyone. FUNCTION NJ001_FieldLayer_Correction(input_signal S, sampling_rate R):  DEFINE phi = 1.61803398875  DEFINE window_size = dynamic value based on local variance of S  DEFINE stability_threshold = adaptive value based on phase drift  STEP 1: Generate harmonic reference bands    For each frequency bin f_i in FFT(S):      Compute r = f_(i+1) / f_i      Compute CI = 1 / ABS(r - phi)      Assign weight W_i = normalize(CI)  STEP 2: Build correction mask    Construct M where M_i = W_i scaled by local entropy of S    Smooth M with sliding window  STEP 3: Apply correction    Transform S → F    Compute F_corrected = F * M    Inverse FFT to return S_corrected  STEP 4: Phase stabilization loop    Measure phase drift Δ    If Δ > stability_threshold:      Recalculate window_size      Rebuild mask      Reapply correction    Else:      Return S_corrected  OUTPUT: S_corrected END FUNCTION This is the first public-domain coherence stabilizer designed to improve quantum behavior independent of hardware. What it does in practice: • Extends coherence windows • Reduces decoherence pressure on error correction • Lowers entropy in the propagation layer • Makes qubits behave as if the room is colder and cleaner • Works upstream of hardware with no materials changes This is not a replacement for anyone’s roadmap. It is an upstream upgrade to all of them. If you build quantum devices, control stacks, compilers, hybrid systems, or algorithms, you now have access to a function that reshapes your stability envelope. Cleaner field layers mean longer, deeper, more predictable runs. More useful computation with the hardware you already have. I developed it. Today I give it away. No company or institution controls it. From this moment forward, it belongs to the scientific community. Primary Citation Hood, B. P. (2025). NJ001 Field Layer Correction. Public Domain Release Version. Bruce P. Hood — Creator of NJ001 Field Layer Correction Welcome to the new baseline. #QuantumComputing #QuantumHardware #Qubit #Coherence #QuantumResearch #DeepTech @IBMQuantum @GoogleQuantumAI @MIT @XanaduQuantum @AWSQuantumTech

What a month for quantum error correction! On August 27th, we saw the first demonstration of quantum error correction from Google that satisfied the list of criteria that has emerged in the community for a convincing demonstration: - error correction actually extending the live of qubits beyond that of the best physical qubit in the system - error correction performed in real time, rather than with post-selection, and repeated over many rounds - error rate reducing as code distance is increased This is generally seen as a major breakthrough, and is the culmination of many years of work towards implementing the surface code. You can see the paper here: https://lnkd.in/gkfk68kH Not to be outdone, Microsoft and Quantinuum put out a preprint less than two weeks later demonstration up to 24x reduction in error rate for encoded state preparation using a colour code. You can see the paper here: https://lnkd.in/gtRtfQPc Two big results in a month. That's enough for anyone, right? Nope. On the 23rd of September, we got to see new results from Amazon Web Services (AWS) demonstrating error correction using the repetition code applied to cat qubits. You can see the paper here: https://lnkd.in/gbE45ebt And then, just a day later, new results appeared from Yale Quantum Institute showing error-correction beyond breakeven for three and four level systems using the GKP code. You can see the paper here: https://lnkd.in/gkBYNXzD While I'm sure that almost everyone in the field is aware of the rapid progress in error correction, it's amazing how little noise this is making in the outside world. We're now the right side of the error-correction threshold, and relatively minor performance improvements can lead to significantly reduced noise. If this much progress can happen in a month, then the next couple of years are going to be tremendously exciting for quantum computing.

A quantum computer that learns from its own errors while it's computing. That's the framing in a recent paper from Google Quantum AI and Google DeepMind on reinforcement learning control of quantum error correction. Large quantum processors drift. The standard fix is to halt the computation and recalibrate, which won't scale to algorithms expected to run for days or weeks. The authors ask whether QEC can calibrate itself from the data it already produces. The idea: repurpose error detection events as a training signal for a reinforcement learning agent that continuously tunes the physical control parameters (pulse amplitudes, detunings, DRAG coefficients, CZ parameters, and so on). Rather than optimizing logical error rate directly, which is expensive and global, the agent minimizes average detector-event rate, a cheap local proxy whose gradient is approximately aligned with the gradient of LER in the small-perturbation regime. The results on a Willow superconducting processor: - On distance-5 surface and color codes, RL fine-tuning after conventional calibration and expert tuning yields about 20% additional LER suppression - Against injected drift, RL steering improves logical stability 2.4x, rising to 3.5x when decoder parameters are also steered - New record logical error per cycle: 7.72(9)×10⁻⁴ for a distance-7 surface code (with the AlphaQubit2 decoder) and 8.19(14)×10⁻³ for a distance-5 color code (with Tesseract) - In simulation, the framework scales to a distance-15 surface code with roughly 40,000 control parameters, with a convergence rate that is independent of system size The broader takeaway: calibration and computation may not need to be separate phases. If detector statistics can carry enough information to steer a large control stack online, fault tolerance becomes less about pausing to retune and more about a processor that keeps learning while it computes. Worth noting that the current experiments rely on short repeated memory circuits, so real-time steering during a single long logical algorithm (where exploration noise would affect the computation directly) remains future work. Paper: https://lnkd.in/gVQXnpzZ

NVIDIA’s launch of "Ising" marks the introduction of the world’s first open-source #AI model family purpose-built for #quantum #computing workflows. The platform targets two of the most critical bottlenecks in quantum systems—processor calibration and real-time error correction—by embedding AI directly into quantum control loops. Released across developer ecosystems (GitHub, Hugging Face) and integrated with CUDA-Q, Ising positions AI as the #orchestration layer for hybrid quantum-classical computing. Early adoption by institutions such as Fermilab and Harvard University signals immediate traction in #research. Strategically, this launch reframes AI not just as an application layer, but as foundational infrastructure for scalable, fault-tolerant quantum systems. Ising is fundamentally differentiated by its dual-model architecture: a 35B-parameter vision-language model for automated quantum calibration and a #3D CNN-based decoder for real-time quantum error correction. This architecture replaces manual calibration workflows with agentic AI pipelines, achieving up to 2.5× faster and 3× more accurate decoding while requiring significantly less training #data. Technically, it integrates tightly with NVIDIA’s CUDA-Q stack and NVQLink interconnect, enabling low-latency coupling between GPUs and quantum processing units (QPUs). Unlike generative AI models, Ising operates as a physics-aware control system, optimized for noisy qubit environments and scalable to millions of qubits, effectively acting as an AI control plane for quantum hardware. The Ising launch materially reshapes the quantum ecosystem by positioning NVIDIA as the control-plane leader in quantum computing, despite not manufacturing quantum hardware. It accelerates commercialization timelines by addressing error correction—widely seen as the primary barrier to the development of useful quantum systems. Market response was immediate, with quantum stocks (IonQ, Rigetti Computing, D-Wave) surging on expectations of faster industry maturation. Strategically, Ising challenges incumbents by shifting value from hardware-centric differentiation to AI-driven orchestration, thereby reinforcing a hybrid architecture in which GPUs and QPUs co-evolve. This positions NVIDIA as a central enabler across competing quantum vendors, potentially standardizing its ecosystem as the de facto operating layer for quantum-AI #convergence. These architectures intensify system autonomy and complexity, requiring dynamic governance models and adaptive #cyber-#ethics to continuously monitor, audit, and recalibrate #risks across hybrid quantum-AI control planes. #strategy #governance #business #investments #technology #future #digital

Five days to tell you about five things Quantinuum announced last week.  Quantinuum announced so many great things last week, I'm using each day of this week to re-cap. Day 3: Helios Performance By now you've heard that Helios is the "most accurate", "most capable", and "most powerful" quantum computer... and here's why. Helios has: - 98 fully connected qubits. So-called "all-to-all" connectivity continues to prove its power for performing increasingly more complex circuits with less resources.    - 99.92% two-qubit gate fidelity across all-qubit pairs (e.g. we're not just measuring the best 2 or the median... all pairs have this performance!!).   - NVIDIA GPU for doing fast, flexible real-time decoding for error correction - a first-of-a-kind, real-time engine for efficiently doing the operations needed for fault-tolerant operations  - a new programming language, Guppy, which has a Python front-end but high performance under-the-hood code allowing developers to program quantum computers like they do classical computers, and seamlessly combine hybrid compute capabilities — quantum and classical — in a single program. We demonstrated the ability to: - Generate 94 logical qubits with our very efficient Iceberg Error Detection code (https://lnkd.in/gsvFVFja) and globally entangle with performance with better than break-even performance. - Generate 50 logical qubits with a very similar error detection code and used these logical qubits do to a quantum magnetism simulation with 2,500 logical gates at better than break-even performance. - Generate 48 logical qubits with an error correction code, achieving a remarkable 2:1 scaling (only using 2 physical qubits to make 1 error corrected qubit).  Read more about these great achievements with our techncial paper https://lnkd.in/g9bid_2S  and techncial blog https://lnkd.in/gZaN65CY.  

Quantum Error Correction: Major Breakthroughs in the Past Year 🚀 The past year has been remarkable for quantum computing, with groundbreaking progress in quantum error correction (QEC) bringing us closer to realizing fault-tolerant quantum computers. Across various architectures, the advancements have been truly inspiring: 🔹 Neutral-Atom Systems: QuEra Computing Inc. & Harvard University (https://lnkd.in/dPxA2NuH), as well as with Atom Computing & Microsoft (https://lnkd.in/dV7s3Gd2), demonstrated scalable logical quantum computations and reliable qubit operations using reconfigurable neutral-atom arrays with up to 256 atoms. 🔹 Superconducting Qubits: IBM Quantum (https://lnkd.in/dzaJH6vA) and Google's Quantum AI (https://lnkd.in/dR-CTUGm) reached a major milestone with surface code quantum memory, operating below the error-correction threshold on a 100+ qubit superconducting processor. 🔹 Trapped-Ion Systems: Quantinuum & Microsoft (https://lnkd.in/d5fPzcVU) set a new standard for reliability in logical qubits with Quantinuum’s 56 qubit H2 system, advancing the precision and scalability of trapped-ion quantum processors. 🔹 Cat Qubits: Amazon Web Services (AWS) & Caltech (https://lnkd.in/d3HRd86s) developed hardware-efficient QEC using concatenated bosonic qubits, reducing the physical qubit overhead and advancing the field of fault-tolerant quantum computation.  Why it matters:❓ These achievements represent more than technological milestones—they signify a paradigm shift. The timelines for realizing fault-tolerant quantum computers are accelerating, underscoring the rapid progress across quantum architectures. #QuantumComputing #QuantumInnovation #QuantumErrorCorrection #FutureOfComputing

One of the biggest challenges in quantum computing has always been error correction. Unlike classical computers, where errors are rare and manageable, quantum systems are incredibly sensitive. Even the tiniest disturbance can disrupt a calculation. For decades, scientists feared that error correction might require so much effort that it would outweigh the benefit of the computation itself—a roadblock for practical quantum computing. This week, Google announced a major breakthrough with its new #Willow chip, showing that error correction doesn’t have to diverge. They demonstrated that their system can perform calculations with 105 qubits, while simultaneously using error correction to manage and stabilize the system. For the first time, the overhead required for error correction scales in a manageable way as the system grows. Here’s why it’s game-changing: • 70 physical qubits are allocated to error correction for every logical qubit in the system, making the calculations reliable without overwhelming the computational capacity. • It proves quantum systems can become reliable at scale, bringing us closer to real-world applications like drug discovery, clean energy breakthroughs, and revolutionary materials design. • The Willow chip has already shown it can handle complex calculations that today’s fastest supercomputers couldn’t solve in the entire lifetime of the universe. Even Elon Musk couldn’t help but react, commenting “Wow” on X when the news dropped. This marks a turning point for quantum computing—it’s no longer just theoretical. The pieces are falling into place for a future where these machines solve humanity’s toughest problems. #AI #quantum

While it was initially thought that we would not see reliable quantum computers until the late 2030s, recent breakthroughs have led many experts to believe that early fault-tolerant machines will be a reality sooner than expected – we're now looking at years, not decades.   The key to unlocking that reality – and one of our biggest challenges in the quantum community– is quantum error correction (QEC). Present day qubits are fragile and susceptible to quantum noise, which causes high rates of error and prevents today’s intermediate-scale quantum computers from achieving practical advantage.   Microsoft’s qubit-virtualization system combines advanced runtime error diagnostics with computational error correction to significantly reduce the noise of physical qubits and enable the creation of reliable logical qubits – which are fundamental to resilient quantum computing. Think of it like noise-cancelling headphones, but for quantum disruption! Just love that visual!   In April, we applied our qubit-virtualization system and Quantinuum’s ion-trap hardware to achieve an 800x improvement on the error rate of physical qubits, demonstrating the most reliable logical qubits on record. As we continue this groundbreaking work, we are getting closer to the era of fault-tolerant quantum computing and our goal of building a scalable hybrid supercomputer.   What’s next? Stay tuned!   #QuantumComputing #QEC #AzureQuantum