Every conversation about quantum computing from hardware vendors seems to center on their qubits, a shortening of the term “quantum bits.” In this analyst insight discussion, I give a high-level overview of what qubits are, the different varieties of them, and who is working with which. This is not a physics or computer science article but rather a brief introduction to or reminder of some of the quantum computing terminology we use. For a more detailed discussion of this “digital,” gate-and-circuit model for quantum computing, see my book, *Dancing with Qubits, Second Edition*.

**Terms Defined:** bit flip, circuit, entanglement, error correction, error detection, error-correcting code, fidelity, gate, ket, logical qubit, measurement, modality, No-Cloning Theorem, perfect qubit, phase flip, physical qubit, Practical Quantum Advantage, qubit, superposition

## Not 0 and 1 at the Same Time

In classical computing, the basic unit of information is the bit. Each bit can hold one value at a time, 0 or 1. We can perform only one interesting operation on a bit, and we call it **not: not**(0) = 1 and **not**(1) = 0. The other operation is the identity **id: id**(0) = 0 and **id**(1) = 1. Eight bits constitute a byte. One million bytes is a megabyte, one billion bytes is a gigabyte, and so on. We represent classical data using bits and bytes, including numbers, text, music, images, and videos.

For quantum computing, we use a qubit instead of a bit. Each qubit holds two numeric pieces of information, and a mathematical rule must hold between the numbers. Together, these values represent what we call a quantum state. Let me give an analogy, briefly introducing some math.

Suppose I want to give you a location in coordinates from some specific starting point. We might use longitude for the east-west coordinate and latitude for the north-south coordinate, but I’ll do something simpler. We designate the starting point as (0, 0) and the endpoint as (*a, b*) for numbers *a* and *b*. If *a* is positive, you move east. If it is 0, you don’t move east or west; if it is negative, you move west. If *b* is positive, you move north. If it is 0, you don’t move north or south; if it is negative, you move south. For this example, we’ll use km for the distances *a* and *b*.

Instead of (*a, b*), I’ll use notation that involves some symbols but is more quantum-like:

*a* |east⟩ + *b* |north⟩ .

We read this as “*a* ket east plus *b* ket north.” The *ket* is the part between and including the vertical bar and the angle bracket. British mathematician and physicist Paul Dirac invented the use of these symbols. It is half of what he called “bra-ket” notation.

However we write it, the expression means we move *a* km east and* b* km north from the starting point. I’ll leave it to you to adjust the directions if *a* or *b* is negative! If I want you to move three km east and four km north, I write the destination as

3 |east⟩ + 4 |north⟩ .

The notation may look odd, but it is descriptive. You don’t remark with amazement that you are east and north simultaneously; you simply recognize that you are at a location whose coordinates are a combination of being east and north.

The mathematical rule I mentioned that must hold for qubits is that if you take the squares of the absolute values of *a* and *b* and add them, you must get 1. This is not the case with the current *a* and *b*, but it does hold if we substitute 3/5 for a and 4/5 for b. All such *a* and* b* that satisfy this rule are on a circle of radius 1 centered at the starting point.

For those of you who may be thinking about the math, there are two important situations where we have two numbers adding up to 1:

- trigonometry and the unit circle, as in sin2(x) + cos2(x) = 1, and
- probability, where the sum of the probabilities of one thing or another happening is 1.

Both ideas are part of quantum computing, as are complex numbers, which you can learn about in my book or elsewhere.

This analogy is the setup for this: we represent the quantum state of a single qubit as

*a* |0⟩ + *b* |1⟩

where* a* and *b* are complex numbers (that is, can include the square root of -1), and the sum of the squares of the absolute values of *a* and *b* is 1. This expression is called a *superposition* of |0⟩ and |1⟩, pronounced as “ket 0” and “ket 1.”

Though it is a popular cliché for quantum computing, we don’t say, “we are 0 and 1 at the same time!” A quantum state for one qubit is a combination of the |0⟩ and |1⟩ states. These have mathematical definitions but treat them like east and north: two perpendicular expressions.

Suppose something disturbs the value of a quantum state. Two possibilities are *bit flips*, where *a* and *b* get interchanged, and *phase flips*, where *b* is replaced by –*b*. Quantum Error Correction (QEC) detects and then fixes errors like these if there are not too many. We call such an error a *fault*, so QEC makes qubits *fault-tolerant*. Note that a bit flip interchanges |0⟩ and |1⟩.

## Measurement

One problem with having quantum states is that you cannot look at them. In classical coding, I might do something with a variable *x* and then check on its value or print it out. If you look at a quantum state, it immediately collapses to 0 or 1. You cannot reverse the process. It makes debugging very difficult.

When we intentionally force this collapse, we call it *measurement*. Why would we want to do it? As I mentioned above, classical data is comprised of bits with 0s and 1s. We might do a quantum computation with qubits, but we eventually need an answer in bits that means something to us, such as a number or some text.

What determines whether we get a 0 or a 1 when we measure a quantum state? The *a* and the *b* are related to the probabilities of getting 0 or 1. In particular, if *a* is 0, we always get 1 when we measure. If *b* is 0, we always get 0. When neither *a* nor *b* is 0, we may get different answers when we repeatedly measure the same quantum state. A quantum algorithm manipulates multiple qubits so that the set of 0s and 1s we get after we measure has a very high probability of being the correct answer.

A *measurement error* happens when quantum hardware mistakenly reads a 0 for a 1 or vice-versa after we force the collapse.

## Gates

Whereas there are two operations we can perform on a single bit, there are an infinite number of 1-qubit quantum operations called gates. The **X** gate behaves as a bit flip, interchanging *a* and *b*, and generalizes the classical **not** gate. The **Z** gate acts like a phase flip, replacing *b* with –*b*. Infinitely many gates behave like partial actions of **X** or **Z**.

The **H** gate moves |0⟩ and |1⟩ into states that have equal probabilities of collapsing to 0 or 1 when measured. Some people describe this as the “coin flip” gate.

If you don’t peek at the value between the two uses, the **X**, **Z**, and **H** gates each undo themselves when applied twice. For example, start with any quantum state, apply **H**, don’t peek, apply **H** again, and you get back to the original state. All quantum gates are reversible, but they don’t all reverse themselves. There are more 1-qubit gates than I have mentioned.

Gates on quantum computers can introduce errors. Instead of an **X** gate changing a |0⟩ state into a |1⟩, it might produce 0.01 |0⟩ + 0.99995 |1⟩ instead. If this happens once every thousand times, the error rate is 1/1000 = 0.001 = 10–3 = 0.1%. The *fidelity* is 1 minus the error rate: 1 – 0.001 = 0.999 = 99.9%. I think of fidelity as a way of saying, “Look how good my qubits are (happy face),” while stating the error rate means, “Look how bad my qubits are (sad face).”

## Entanglement

We also use gates that involve two or more qubits. Perhaps the best-known and most widely used 2-qubit gate is the controlled-**X**. In its simplest form, it applies a bit flip **X** gate to the second qubit if the first qubit is |1⟩. If the first qubit is |0⟩, it leaves the second qubit alone. It generalizes the classical 2-bit** xor** “exclusive or” operation.

Honestly, that seems pretty boring. However, if you start with the qubits in the state |0⟩, apply an **H** gate to the first qubit and then a controlled-**X** to the first and second, you get a 2-qubit entangled state. If I measure the first qubit and get 0, I know that the second will also be 0 when I measure. If the first is a 1 when I measure, so will the second. Once entangled, the qubits lose their ability to act independently until something breaks the entanglement. This behavior is what Einstein called “spooky action at a distance.”

There is no classical analog to entanglement, and you are not doing quantum computing unless you can entangle qubits. I recommend the article “The World-Changing Race to Develop the Quantum Computer” in the *New Yorker *magazine for an excellent explanation of entanglement for the non-scientist.

We get a *quantum circuit* when we combine gates and measurements working on one or more qubits.

## Perfect Qubits

If qubits hold their quantum states forever, preserve entanglement, and gates never introduce errors, we have perfect qubits and gates. This is often the assumption when you read books about qubits, gates, and the quantum circuits built from them. Instead, errors introduced from the operating environment or manufacturing defects in real quantum computers are the reality. We aspire to have perfect qubits, which is probably too much to obtain. Instead, we build quantum computers from *physical qubits* and combine them with hardware control and software to make *logical qubits*.

## Physical Qubits and Modalities

There are many ways to manufacture or control qubits, most involving doing something with photons or electrons, or both. Photons and electrons are quantum particles and exhibit quantum states through spin and polarization. We call the different kinds of physical qubits *modalities*.

A physical qubit has a *coherence time*, the time you have to work with it before the stored quantum state becomes chaotic. More bluntly, the qubit’s value is garbage after the coherence time. It might seem like a long coherence time is good, but such systems seem to be paired with slow gate speeds. *Gate parallelism* is the degree to which you can simultaneously perform operations on multiple qubits. If I have a short coherence time and fast gates, I might get more done than you can with a long coherence time and slow gates. Gate parallelism complicates the formula, and several other factors can also.

When we eventually have quantum computers large and powerful enough to tackle significant problems, we will trade off factors like these together with cost and energy use.

In the following table, I list the modalities and some of the vendors that provide quantum computers using them. I include modalities for analog quantum computers, not just digital, gate-and-circuit ones. I do not include quantum annealing, a third approach using superconducting qubits. D-Wave is the foremost vendor taking that approach.

Each vendor strives to reduce the errors that the environment and hardware introduce into their system during operation. For example, a control technique with lasers or microwaves on one qubit might disturb the quantum states of nearby qubits. Improving the control precision helps mitigate these errors. Using machine learning for error mitigation also seems promising, possibly more than quantum computing for AI in the short term.

Once the error rates get low enough, meaning the fidelities are large enough, vendors can consider error correction to bring us closer to the ideal set of perfect qubits.

## Logical Qubits and Error Correction

If a physical qubit can’t be perfect, can we get closer to the ideal behavior by making several physical qubits work together to detect and correct errors?

This would create what we might consider a “virtual qubit” exhibiting high-fidelity quantum behavior and built from low-level software and physical multi-qubit hardware.

An error correction code can detect and fix some errors. Imagine using your phone in an area with a lot of RF static that introduces noise into your conversation. Can we clean up the transmission to an acceptable level? In the 1950s and 1960s, we might have talked about noise on telephone lines. Those classical codes introduced extra data and redundancies into the original messages. We rate a particular code by how many errors it can detect and how many it can correct. We can’t fix anything if the noise turns the information into garbage. Therefore, we need a low enough error rate to use a given code.

A classical repetition code makes copies of information and then sends the copies to the receiver. If I want to send you a 1, I could make 8 copies and send you

111111111 .

If the error rate is low and you receive

111111011 ,

you can say that the majority wins, and I sent you a 1. Based on the specific probability of a transmission error, we can compute how many copies I should send you to guarantee you get the correct answer a given percentage of the time. You can see how we added redundancy and dramatically increased the amount of information sent.

Even with this simple scheme, there is a problem using it for qubits. The No-Cloning Theorem is central to quantum mechanics and quantum computing. It states that I cannot copy or clone a quantum state. This is a severe restriction, and it is impossible to fix it. It’s the way nature works.

Instead, researchers have invented quantum error-correcting codes requiring dozens up to about a thousand physical qubits to create one logical qubit, depending on whom you want to believe. The fidelity rates for 1- and 2-qubit gate operations must be sufficiently high and past a computed threshold to use the codes.

Logical qubits are not perfect, but they must have significantly lower rates than the physical qubits from which we construct them. We must have implementations of logical quantum gates with very low error rates along with the logical qubits.

If someone claims they have logical qubits, ask them the following:

- How many physical qubits do you need to make one logical qubit?
- Can you do error detection and correction?
- What are the error rates of your logical qubits and gates?
- What quantum error-correcting code do you use?

“Logical qubit” should not be a marketing term; it is a technical term. Without the information above, you can’t tell if someone will ultimately be able to create the thousands of near-perfect qubits we will need for practical use cases. That point is P*ractical Quantum Advantage*, when quantum and classical systems work together and perform significantly better than classical systems alone. I use “practical” to clarify that these quantum systems must show the advantage for the currently intractable problems most important to society and business.

## Key Takeaway

Quantum computing is confusing and complex, and it doesn’t help when discussions are filled with scientific jargon. A high-level understanding of the key concepts of qubits is the foundation for understanding this important emerging technology.

**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 equity positions in each company.**

**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: Pasqal Is the Latest to Publish a Roadmap

Quantum in Context: Extreme Software Optimization with Superstaq

Quantinuum Announces Breakthroughs for Quantum Computing Scale-Up

### 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 scheduled for release in April 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.