**The News:** Quantinuum announced that it demonstrated 99.9% fidelity in its 2-qubit quantum operations on its 20-qubit H1-1 quantum computing system, which puts it within range of using quantum error-correcting codes. See the announcement.

## Quantum in Context: Quantinuum and the Quest for More 9s

**Analyst Take:** As I have discussed elsewhere (here and here), quantum computers are not perfect, and we will need error correction to decrease the number of mistakes introduced into computations during qubit initialization, gate operations, measurement, and qubit decoherence. These errors creep in because we work with physical devices affected by their operating environment, manufacturing imperfections, and how we control the qubits. If there is a chance of an error occurring, the mathematics of probability enters our discussion and considerations. Quantinuum’s recent result demonstrated that the company crossed a critical error correction threshold.

## The Repetition Code, Yet Again

To understand the Quantinuum result, let’s see what this means in a simple classical case. It seems that every discussion of error correction begins with a repetition code. In summary:

- I wish to send you a single bit of information, either a
**0**or**1.**Alternatively, I might want to store that bit for later retrieval as part of some text, image, video, or other data, but we will stick with the transmission example. - It’s possible that an error could occur in the process, interchanging
**0**or**1**. We call this a*bit flip*error. - I send you an odd number of copies of the bit to increase your chance of receiving the correct value. This is the repetition.
- When you receive the bits, you count the number of
**0**s and**1**s. You take whichever value has the larger count as the value you think I sent. This is why I sent an odd number of copies, so the majority can win. - The chance of your being able to choose correctly depends on the probability of an error occurring and the number of bit copies I sent.

The repetition code is inefficient because of all the bit copies. The higher the error rate, to a point, the more copies I must send.

## Error Rate and Fidelity

Suppose I perform some operation, and an error occurs once every 100 times I do it, on average. The error rate is 1/100 = 0.01 = 1%. I get the wrong answer 1% of the time, on average. I will stop saying “on average,” but realize that it does not mean there is always an error 1 out of 100 times. Instead, it means that if I do the operation hundreds or thousands of times, I will see errors occurring at approximately that rate. The larger the number of times, the closer to the average I get.

We can turn this around and discuss the *fidelity*, which is 1 minus the error rate. For this same example, the fidelity is 99/100 = 0.99 = 99%. We see the correct answer 99% of the time. We will call this the *physical fidelity*.

If you are a “glass half empty” person, you may like to use the error rate. If you are a “glass half full” person, perhaps fidelity better suits you.

We use the phrase “two 9s” to mean that we have a 99% fidelity. “Three nines” means we have 99.9% fidelity. This fidelity is what Quantinuum claimed for 2-qubit gates. These gates are essential for quantum computing because they can create entanglement, a necessary component of quantum mechanics and the quantum computing gate-and-circuit programming model.

## Some Probability Math

Let’s do some math for our repetition code to understand the idea of a threshold for error correction. The simplest non-trivial code uses three bit copies. This is a typical example; you will encounter it frequently if you do a web search. I cover it in greater detail in Section 6.4, “Probability and error detection,” in my book *Dancing with Qubits, Second Edition*.

Let *p* be the error rate. In our example above, *p* = 0.01. The fidelity is 1 – *p*. Suppose I want to send you a **1** bit. I will make three copies and send **111** to you. You could receive one of the following eight triplets of bits:

**111 110 101 011**

**000 001 010 100**

The four triplets in the top row have at least two **1**s each. You will correctly conclude that I sent a** 1** if you receive one of these. If you receive any triplet on the bottom row, you will incorrectly decide I sent a **0**. What is the probability of getting one on the top row?

The probability of getting a **0** is the error rate *p*. The probability of getting a **1** is the fidelity 1 – *p*. We write this information as Pr(**0**) = p and Pr(**1**) = 1 – *p*. Since these are the only two possibilities, the probabilities must add to 1.0, and they do.

In each triplet, we* multiply* the bit probabilities together to get the probability of getting that triplet.

Pr(**111**) = (1 – *p*) (1 – *p*) (1 – *p*)

Pr(**110**) = (1 – *p*) (1 – *p*)* p*

Pr(**101**) = (1 – *p*) p (1 – *p*)

Pr(**011**) = *p* (1 – *p*) (1 –* p*)

As any of these will work to decode and get the correct answer, we add their probabilities to give us the overall probability of getting a good enough triplet:

(1 – p) (1 – p) (1 – p) + 3 p (1 – p) (1 – p) = (1 – p)^{2} (1 – p + 3 p) = (1 – p)^{2} (2 p + 1)

We can call this the *logical fidelity*. It’s a slightly messy expression, but let’s check it. If an error never occurs,* p* = 0.0, and the chance of getting **111** is 100%. If *p* = 1.0, an error always happens, and the probability of getting a usable triplet is 0%.

Something interesting happens when *p* = 0.5, when the probability of getting an error is 50%. In that case, *p* = 1 –* p* = 0.5. The probability of getting any particular triplet is (0.5)^{3} = 0.125 = 1/8. The probability of getting a good triplet is 4 times 1/8 = ½ = 0.5. This is the same as sending a single bit correctly. The physical fidelity is the same as the logical fidelity. Why did we even bother with the repetition code?

If we have *p* = 0.75, where we might see an error three out of four times, the physical fidelity is 0.25, and the logical fidelity is 0.15625. We went to the trouble of introducing a scheme that worsened the error situation. This is a terrible error rate, so something else needs to be greatly improved.

If we have a 99% physical fidelity, the logical fidelity with the three-bit repetition code is 0.999702 = 99.9702%. This is three 9s and almost four.

For a 99.9% physical fidelity, the logical fidelity is approximately 0.999997 = 99.9997%. A 1-in-1000 physical error rate yields almost a 1-in-1 million logical error rate. This is quite an improvement. Said another way, a three 9s physical fidelity is the approximate *threshold* for a six 9s logical fidelity.

## Quantum Error Correction

Many other classical error detection and correction schemes are more space-efficient than repetition codes, but the math is simpler with the latter.

None of them work without modification for quantum computing.

The No-Cloning Theorem states that we cannot copy quantum information. We can’t use repetition codes or anything that requires us to duplicate information. Instead, we use extra qubits, quantum operations, and entanglement as in the 9-qubit Shor code (*Dancing with Qubits, Second Edition*, Section 11.5). To correct one qubit, we need eight other qubits. There is also the 7-qubit Steane code. Even better, there is a quantum error correcting code that uses five extra qubits, and this is the best we can do.

These extra qubits and operations to fix a qubit may have errors themselves. How do we fix them?

We adopt more sophisticated schemes to spread quantum information among many other qubits. These have names like stabilizer codes, including surface and color codes, and quantum low-density parity check (qLDPC) codes, including the *gross code* recently introduced by IBM.

## What Quantinuum Did

Quantum error-correcting codes use gates on one and two qubits. As a rule of thumb, error rates on 2-qubit gates are ten times worse than for 1-qubit gates. Therefore, the 2-qubit gate error rate or fidelity is the one to watch as vendors publish their results.

Quantinuum achieved a 99.914(3)% physical 2-qubit gate fidelity across all pairs of trapped ions in its H1-1 Quantum computing system using its quantum charge-coupled device (QCCD) architecture. In its announcement, Quantinuum states this is a reproducible result, not a one-time, best-performance hero result.

The company further states that this physical fidelity is above the threshold for adopting modern quantum error-correcting codes. Remember, if you are below the threshold, trying to fix errors actually makes things worse.

## Key Takeaway: Quantinuum’s strong result continues its cadence of very positive progress in quantum computing. Trapped ion systems have been known for their low error rates, and this result is a landmark on the journey to fault-tolerant quantum computing systems.

You cannot look at one metric to claim overall quantum computing leadership. If I have far fewer qubits than you do but a terrific physical fidelity, is my system superior to yours even if I don’t have enough scale for practical applications? Over time, I may significantly increase my number of great qubits, and you may dramatically improve your gate fidelity. Leadership can be short-lived in the quantum computing business and always comes with several caveats and footnotes. Newer quantum technologies may have lower fidelities, but very good velocities for improvement. This appears to be the case with Infleqtion’s recent announcement of a 98.8%±0.2% neutral atom 2-qubit gate fidelity. In any case, Quantinnum is now the one to beat in the fidelity competition.

**Disclosure: The Futurum Group is a research and advisory firm that engages or has engaged in research, analysis, and advisory services with many technology companies, including those mentioned in this article. The author is a former employee of IBM and Infleqtion and holds an equity position in each company. The author does not hold any equity positions with any other company mentioned in this article.**

**Analysis and opinions expressed herein are specific to the analyst individually and data and other information that might have been provided for validation, not those of The Futurum Group as a whole.**

### Other Insights from The Futurum Group:

Quantum in Context: A Qubit Primer

Quantinuum Announces Breakthroughs for Quantum Computing Scale-Up

Quantum in Context: Microsoft & Quantinuum Create Real Logical Qubits

### Author Information

Dr. Bob Sutor has been a technical leader and executive in the IT industry for over 40 years. Bob’s industry role is to advance quantum and AI technologies by building strong business, partner, technical, and educational ecosystems. The singular goal is to evolve quantum and AI to help solve some of the critical computational problems facing society today. Bob is widely quoted in the press, delivers conference keynotes, and works with industry analysts and investors to accelerate understanding and adoption of quantum technologies. Bob is the Vice President and Practice Lead for Emerging Technologies at The Futurum Group. He helps clients understand sophisticated technologies in order to make the best use of them for success in their organizations and industries. He is also an Adjunct Professor in the Department of Computer Science and Engineering at the University at Buffalo, New York, USA. More than two decades of Bob’s career were spent in IBM Research in New York. During his time there, he worked on or led efforts in symbolic mathematical computation, optimization, AI, blockchain, and quantum computing. He was also an executive on the software side of the IBM business in areas including middleware, software on Linux, mobile, open source, and emerging industry standards. He was the Vice President of Corporate Development and, later, Chief Quantum Advocate, at Infleqtion, a quantum computing and quantum sensing company based in Boulder, Colorado USA. Bob is a theoretical mathematician by training, has a Ph.D. from Princeton University, and an undergraduate degree from Harvard College.

He’s the author of a book about quantum computing called *Dancing with Qubits,* which was published in 2019, with the Second Edition released in March 2024. He is also the author of the 2021 book *Dancing with Python*, an introduction to Python coding for classical and quantum computing. Areas in which he’s worked: quantum computing, AI, blockchain, mathematics and mathematical software, Linux, open source, standards management, product management and marketing, computer algebra, and web standards.