Open in app

Sign in

Write

Sign in

Quantum Algorithm Designers, Application Developers, and Users Shouldn’t Need to Know Anything About Qubits

Jack Krupansky
31 min readApr 12, 2023

--

Very few people who program or use a classical computer need to know anything about classical bits. The same should be true for quantum computers, eventually, although we aren’t even close, yet. A high-level quantum programming model, high-level quantum algorithmic building blocks, rich data types, and high-level quantum programming languages are needed for quantum computing so that quantum algorithm designers, quantum application developers, and users of quantum applications will no longer need to know anything at all about qubits to work with a quantum computer, quantum algorithm, or quantum application. This informal paper explores the current state of affairs and what it might take to get to a place where very few people need to know anything about qubits. I must concede in advance that this is an aspirational proposal rather than a current or near-term reality or even a prospect.

Caveat: My comments here are all focused only on general-purpose quantum computers. Some may also apply to special-purpose quantum computing devices, but that would be beyond the scope of this informal paper. For more on this caveat, see my informal paper:

Topics discussed in this informal paper:

  1. In a nutshell
  2. Motivation
  3. Background
  4. What is a qubit?
  5. What is quantum state?
  6. What is a quantum logic gate?
  7. What is quantum information?
  8. Unlike a classical bit, a qubit is a hardware device rather than abstract logical information
  9. Today: We’re stuck with a low-level programming model, lack of rich data types, lack of high-level quantum algorithmic building blocks, and no high-level quantum programming language
  10. The future: A high-level quantum programming model, high-level quantum algorithmic building blocks, rich data types, and high-level quantum programming languages
  11. Quantum computing deserves the quantum equivalent of data, data types, and information
  12. High-level abstractions would eliminate the need to know about qubits
  13. Shouldn’t need to know about classical bits either
  14. Shouldn’t need to know about classical bit strings either
  15. Same goes for qutrits and other qudits, few need to know about them
  16. Aspirational proposal rather than a current or near-term reality or even a prospect
  17. How do we get there?
  18. Today, even users need to be aware of qubits and their limitations
  19. Nobody has a choice today, an intimate awareness of qubits is needed by anybody wishing to do anything in quantum computing at this juncture
  20. Three categories of personas: quantum algorithm designers, quantum application developers, and users of quantum applications
  21. Three different postures on qubits for the three categories of personas
  22. A higher-level programming model is needed
  23. High-level quantum algorithmic building blocks are needed
  24. Exposure to qubits will vary with three levels of algorithmic building blocks
  25. Exposure to qubits will vary with three stages of adoption of quantum computing
  26. So, how do we start teaching about quantum computers if we don’t start with qubits and by comparing qubits with the 0’s and 1’s of classical bits?
  27. Comparing qubits with classical bits is a very bad way to start off education for quantum computing
  28. Superposition, entanglement, and interference are a poor way to start off education for quantum computing
  29. Quantum parallelism is the best way to start off education for quantum computing, plus algorithmic building blocks and the quantum equivalents to data, data types, and information
  30. Qubit capacity requirements still need to be known, but by the application deployment team, not the actual users
  31. Determination of qubit requirements from automated analysis of the algorithm and input data
  32. Lower level technical professionals still needing direct access to qubits
  33. How long will it take to get to quantum computing without the qubits?
  34. We’re still in the pre-commercialization stage of quantum computing with plenty of research, prototyping, and experimentation ahead of us
  35. Quantum Ready? Why learn a technology that will be obsolete when its practical replacement is introduced?
  36. Focus on the use of classical quantum simulators can help to avoid excessive exposure to details of qubits
  37. Alternative titles I considered
  38. Conclusions

In a nutshell

  1. Dramatically minimize the knowledge needed to get started with quantum computing. Whether you are a quantum algorithm designer, a quantum application developer, or simply a user of a quantum application.
  2. Dramatically minimize the knowledge needed to design quantum algorithms and to develop quantum applications. Or to use quantum applications.
  3. Focus on raw qubits is both an unnecessary distraction and counterproductive.
  4. Today we’re stuck with a low-level programming model, lack of rich data types, lack of high-level quantum algorithmic building blocks, and no high-level quantum programming language. For now, this is where we are. For the indefinite future. Unclear when this might change.
  5. For the future we need to get to a high-level quantum programming model, high-level quantum algorithmic building blocks, rich data types, and high-level quantum programming languages. Unclear when this future might come about, when the transition might start, or how long the transition might take.
  6. Quantum computing deserves the quantum equivalent of data, data types, and information.
  7. High-level abstractions would eliminate the need to know about qubits.
  8. Shouldn’t need to know about classical bits either. Stick with high-level application-oriented data types. No different from classical developers not needing to know about classical bits.
  9. Shouldn’t need to know about classical bit strings either. Stick with high-level application-oriented data types. No different from classical developers not needing to know about classical bits and bit strings.
  10. Same goes for qutrits and other qudits, few need to know about them.
  11. This is an aspirational proposal rather than a current or near-term reality or even a prospect.
  12. How do we get there? It may not be known until after much research is completed. And much of that research has not even started. And much of that research has not even been proposed. Yes, we have a long way to go. A very long way to go.
  13. Today, even users need to be aware of qubits and their limitations.
  14. Nobody has a choice today, an intimate awareness of qubits is needed by anybody wishing to do anything in quantum computing at this juncture. One exception is the generation of true random numbers, which can be accessed by users or application developers (as a cloud-based service) without any knowledge of qubits.
  15. Three categories of personas: quantum algorithm designers, quantum application developers, and users of quantum applications.
  16. Three different postures on qubits for the three categories of personas.
  17. A higher-level programming model is needed.
  18. High-level quantum algorithmic building blocks are needed.
  19. Exposure to qubits will vary with three levels of algorithmic building blocks.
  20. Exposure to qubits will vary with three stages of adoption of quantum computing.
  21. So, how do we start teaching about quantum computers if we don’t start with qubits and by comparing qubits with the 0’s and 1’s of classical bits? We need to start an education for quantum computing with the really important concepts — quantum parallelism, the quantum equivalent to data, data types, and information, and quantum algorithmic building blocks. In short, it’s the data that’s important, not the underlying qubits.
  22. Comparing qubits with classical bits is a very bad way to start off education for quantum computing.
  23. Superposition, entanglement, and interference are a poor way to start off education for quantum computing.
  24. Quantum parallelism is the best way to start off education for quantum computing, plus algorithmic building blocks and the quantum equivalents to data, data types, and information.
  25. Qubit capacity requirements still need to be known, but by the application deployment team, not the actual users.
  26. Determination of qubit requirements from automated analysis of the algorithm and input data. Nobody should have to guess or manually determine the qubit requirements for a quantum algorithm. There should be an automated analysis method to determine the qubits requirements based on the actual algorithm and particular input data and input parameters.
  27. Lower level technical professionals still need direct access to qubits.
  28. How long will it take to get to quantum computing without the qubits? Unclear how long it will be until most quantum algorithm designers, application developers, and users will no longer need to know or care about qubits. Much research, prototyping, and experimentation will be required to achieve a new high-level approach to quantum computing which is based on quantum parallelism, high-level algorithmic building blocks, and the quantum equivalent of data, data types, and information, rather than detailed familiarity with qubits, quantum state, and quantum logic gates. How long? Unclear. Maybe it might be five years or so. Or maybe seven years. Or maybe we could have the basics in place in three years.
  29. We’re still in the pre-commercialization stage of quantum computing with plenty of research, prototyping, and experimentation ahead of us. There’s plenty of room for pursuing a higher-level approach to quantum computing, one which eliminates the need for quantum algorithm designers, quantum application developers, and users of quantum applications to know or care about low-level raw qubits. The big caveat is that with all of this research, prototyping, and experimentation ahead of us, it can be tempting to find a shortcut and prematurely attempt to leap to commercialization — what I call premature commercialization. We have to diligently attempt to avoid that temptation.
  30. Quantum Ready? Why learn a technology that will be obsolete when its practical replacement is introduced? Learning so much about qubits now seems like a grand waste of effort when no practical applications are likely to occur until a practical replacement technology can be researched, developed, and deployed.
  31. Focus on the use of classical quantum simulators can help to avoid excessive exposure to details of qubits. Especially when combined with high-level algorithmic building blocks.

Motivation

My motivation is twofold:

  1. Dramatically minimize the knowledge needed to get started with quantum computing. Whether you are a quantum algorithm designer, a quantum application developer, or simply a user of a quantum application.
  2. Dramatically minimize the knowledge needed to design quantum algorithms and to develop quantum applications.

Background

Not too many years ago it finally dawned on me that despite all of the talk about bits, very few people, including those designing and developing computer software, needed to know anything at all about bits in even the slightest way, but yet the culture of even the most modern and advanced computers and software was steeped in knowledge of bits.

It occurred to me that knowledge and discussion of bits was both a distraction and counterproductive.

So, I decided to contemplate the matter further and gradually decided that it was worthy of attention — and correction.

As I started getting into quantum computing, it struck me even harder that a bit-level focus — now with qubits — was also indeed both an unnecessary distraction and similarly counterproductive.

In fact, when I was preparing to write my informal paper on an introduction to quantum computing, I seriously considered completely refraining from even mentioning qubits at all, but eventually I decided that we’re not there yet and a relatively deep knowledge and appreciation of qubits is currently needed to exploit quantum computing. Even so, a lot of that informal paper does not rely on knowing anything at all about qubits themselves.

My introduction to quantum computing:

But when I stepped back to write a brief elevator pitch on quantum computing, I was able to almost completely avoid even mentioning qubits, with only a brief mention in a secondary section, not the main sections.

My elevator pitch for quantum computing:

For more on my thinking about this aspect of classical bits, see my informal paper:

I do believe that the same logic holds for qubits as for bits, except that the infrastructure and tools needed to hide the complexity and distraction of bits in classical computing is already in place and has proven to be quite effective, while none of that is true for quantum computing and qubits, yet.

It may not be available yet, but it is a laudable goal and it would yield similar tangible benefits if it did come to fruition, someday.

What is a qubit?

Most people working in the quantum computing sector know this, but for completeness…

Qubit is short for quantum bit. But that’s somewhat of a misnomer. Unlike classical computing where a bit is a unit of information, a qubit is a hardware device comparable to a classical flip flop. It is used to store and manipulate a unit of quantum information represented as a unit of quantum state.

The quantum state stored in a single isolated qubit can simultaneously represent both a 0 and a 1, but with a probability amplitude so that the probability of being a 0 or a 1 can be manipulated anywhere in the range of 0.0 to 1.0, and also represents a phase between 0.0 and two pi.

Isolated qubits alone are not terribly useful. Any number of qubits can have their quantum states entangled, forming product states. For an ensemble of n entangled qubits, there are up to 2^n product states, each associated with an integer value between 0 and n minus 1, usually treated as a bit string, such as 0000 to 1111 for four entangled qubits, for example. Each individual product state has an associated probability amplitude, such that the probabilities of all of the product states (the probability being the square of the probability amplitude) sum to exactly 1.0.

Product states are what enable quantum parallelism — the n qubits are simultaneously in all 2^n product states, but with varying probabilities, which can be manipulated to perform quantum computations on all 2^n discrete values simultaneously.

For more detail on the concept of a qubit, see my informal paper:

What is quantum state?

Without going into detail here, quantum state is how information — quantum information — is represented in a qubit.

Unfortunately, today, quantum algorithm designers need to know a fair amount about quantum state to do even the simplest quantum algorithms.

That needs to change.

But quantum state is an inherent aspect of qubits, so eliminating the need for quantum algorithm designers to know about qubits will simultaneously eliminate their need to know about quantum state.

For more detail on the concept of quantum state, see my informal paper:

What is a quantum logic gate?

Without going into detail here, quantum logic gates are how the information (quantum information) stored in a qubit is manipulated. More specifically, quantum logic gates manipulate the quantum state of a qubit.

Unfortunately, today, quantum logic gates are the only method quantum algorithm designers have to implement quantum algorithms, so they need to know a fair amount about both quantum state and quantum logic gates to do even the simplest quantum algorithms.

That needs to change.

But similar to quantum state, quantum logic gates are closely associated with the quantum state of qubits, so eliminating the need for quantum algorithm designers to know about qubits will simultaneously eliminate their need to know about both quantum state and quantum logic gates.

For more detail on the concept of quantum logic gates, see my informal paper:

What is quantum information?

The good news is that we already have a working concept of quantum information.

The bad news is that the current conception of quantum information is very primitive and too closely associated with quantum state, and hence too closely associated with raw qubits.

That needs to change.

Quantum algorithm designers and quantum application developers need a higher-level abstraction for quantum information, one that is more closely aligned with high-level quantum data and high-level quantum data types rather than with raw low-level quantum state.

For more detail on the concept of quantum information, see my informal paper:

Or you can go directly to my informal paper focused on quantum information for the deepest detail:

Unlike a classical bit, a qubit is a hardware device rather than abstract logical information

Classical bits are simply information — abstract logical information. A variety of classical hardware technologies are capable of storing and manipulating classical bits, such as flip flops, memory chips, disk drives, tape drives, flash drives, punched cards, paper tape, copper wire, and fiber optic cables, but the classical bits are simply the logical information, not the hardware that stores that information.

But with a quantum computer, the situation is reversed — qubits are the hardware devices which store quantum information in the form of quantum state.

And with entangled qubits, n physical qubits can represent 2^n distinct product states, even though there are only n physical devices.

Each of the 2^n product states is a bit string representing a single piece of abstract logical information.

Today: We’re stuck with a low-level programming model, lack of rich data types, lack of high-level quantum algorithmic building blocks, and no high-level quantum programming language

Today, designers of quantum algorithms and developers of quantum applications have no choice and are stuck with working directly with qubits as their primary programming model. The realities of today:

  1. Relatively few qubits.
  2. Even when there are more than a few qubits, their low fidelity and limited connectivity render them relatively useless for most applications.
  3. Very limited coherence time and maximum quantum circuit size.
  4. A low-level programming model.
  5. No rich data types. Not even the integers, real numbers, characters, strings, structures, or basic structured data types as are common for classical software development.
  6. No high-level quantum algorithmic building blocks.
  7. No high-level quantum programming language.

Today, it’s 100% all about the qubits.

The future: A high-level quantum programming model, high-level quantum algorithmic building blocks, rich data types, and high-level quantum programming languages

The great hope for the future would be that quantum algorithm designers and quantum application developers and users alike would be dealing primarily with high-level abstractions rather than qubit-level data.

The goal is to eventually have:

  1. A reasonable number of qubits.
  2. Qubits with relatively high fidelity and full connectivity, enabling many applications.
  3. Significantly greater coherence time and maximum quantum circuit size.
  4. A high-level quantum programming model.
  5. High-level quantum algorithmic building blocks. No longer stuck at the primitive gate level.
  6. Rich data types. Not quite the same as classical data types, but quantum equivalents.
  7. High-level quantum programming languages which offer rich data types and control structures.

At that point, there would be no reason for most quantum algorithm designers, quantum application developers, or users to care about or even know about qubits.

Quantum computing deserves the quantum equivalent of data, data types, and information

Quantum computing deserves the quantum equivalent of the concepts of data, data types, and information rather than dealing with raw qubits and quantum states.

With just raw qubits, we are forced to rely on the classical concept of bits.

By shifting from raw qubits and quantum states to the higher level abstract concepts of data, data types, and information, classical bits would no longer be relevant to quantum computing.

What would the quantum equivalent of the concepts of data, data types, and information look like? That’s unclear. Much research is needed.

In some cases the data and data types might be fairly similar to the data and data types of classical computers, but in some cases they could be fairly or even very different, or even radically different and not even roughly comparable to classical data types. I’ll stop there — I don’t want to prejudge the research.

High-level abstractions would eliminate the need to know about qubits

Summarizing the points of the preceding sections a little more abstractly and conceptually:

  • The availability of high-level abstractions would eliminate the need for most people to know anything at all about qubits.

Clearly we are not at that state of affairs at this juncture, but it is indeed the goal.

Shouldn’t need to know about classical bits either

It should go without saying that quantum algorithm designers, quantum application developers, and users of quantum applications shouldn’t have any need to know about classical bits either, such as results from reading or measuring qubits.

They should be able to stick with high-level application-oriented data types.

This is no different from classical developers not needing to know about classical bits. For more on my thinking about this aspect of classical bits, see my informal paper:

Sure, some quantum algorithm designers at the lowest level, closest to the raw hardware will have some need to worry about directly using classical bit values for state preparation and for measurement of qubits (so-called SPAM), but that should be the rare exception rather than the rule.

Shouldn’t need to know about classical bit strings either

It should go without saying that quantum algorithm designers, quantum application developers, and users of quantum applications shouldn’t have any need to know about classical bit strings either, such as results from reading or measuring a sequence or register of qubits, or when considering the bit string values for product states of entangled qubits.

They should be able to stick with high-level application-oriented data types. The bit string values for product states of entangled qubits should have high-level application-oriented data values rather than the raw bit strings of the raw product states. In the simplest cases these might be simple integers or symbolic values associated with the integer values.

This is no different from classical developers not needing to know about classical bit strings. For more on my thinking about this aspect of classical bits and bit strings, see my informal paper:

Sure, some quantum algorithm designers at the lowest level, closest to the raw hardware will have some need to worry about directly using classical bit and bit string values for state preparation and for measurement of qubit sequences or registers (so-called SPAM), but that should be the rare exception rather than the rule.

Same goes for qutrits and other qudits, few need to know about them

Qutrits are similar to qubits but have three states — 0, 1, and 2.

Qudits are similar to qubits but have d states, where d can be any integer greater than or equal to 2. A qutrit is a qudit with d = 3. A qubit is a qudit with d = 2.

Working with qutrits and qudits for d greater than 3 can be challenging. That’s all the more reason that knowledge of the details and ins and outs of qutrits and qudits should be hidden behind a high-level quantum programming model, high-level quantum algorithmic building blocks, rich data types, and high-level quantum programming languages.

In any case, the aspirational goal should be that quantum algorithm designers, quantum application developers, and users of quantum applications will not need to know anything at all about qutrits or qudits to work with a quantum computer, quantum algorithm, or quantum application.

And, yes, some quantum algorithm designers at the lowest level, closest to the raw hardware will have some need to worry about directly using qutrits and qudits for state preparation and for measurement of qutrit or qudit sequences or registers (so-called SPAM), but that should be the rare exception rather than the rule.

Aspirational proposal rather than a current or near-term reality or even a prospect

The proposal of this informal paper is aspirational rather than descriptive of any existing and near-term prospect.

Whether the high-level model proposed by this informal paper comes to pass within two years, or five years, or maybe not even for seven or ten years, is unknown.

How do we get there?

Unfortunately, we currently have no conception of what path will get us to the fruition of the proposal of this informal paper. I have some ideas, but it’s a wide open space with plenty of room for innovation. And lots of research is needed.

It may not be known until after much research is completed. And much of that research has not even started. And much of that research has not even been proposed.

Yes, we have a long way to go. A very long way to go.

Today, even users need to be aware of qubits and their limitations

The sad fact is that current quantum computers are relatively unusable, so that most prospective users are SOL — OL means out of luck.

And in the relatively few, relatively rare cases where current quantum computers are at least somewhat useful, users need to know:

  1. That there are enough qubits.
  2. That the qubits have a high enough fidelity.
  3. That the qubits have sufficient connectivity for the particular quantum algorithms and quantum applications.
  4. That the qubits have sufficient coherence time and maximum quantum circuit size.

True, users don’t need to know much at all about how qubits work, other than that they have sufficient fidelity and connectivity, and that there are enough of them.

Generally, users don’t need to know about:

  1. Quantum mechanics.
  2. Quantum physics.
  3. Quantum state.
  4. Wave functions.
  5. Basis states.
  6. Probability amplitudes.
  7. Phase.
  8. State preparation.
  9. Measurement.
  10. Coherence time.
  11. Gate execution time.
  12. Quantum logic gates.
  13. Unitary transformation matrices.

That’s a great saving grace, but doesn’t make up for the details of qubits that current users do need to be aware of and need to care about greatly even if they don’t have any desire to.

Nobody has a choice today, an intimate awareness of qubits is needed by anybody wishing to do anything in quantum computing at this juncture

Just to emphasize the point, whether you are a quantum algorithm designer, a quantum application developer, or even merely a user, you outright have no choice (today), an intimate awareness of qubits is needed by anybody wishing to do anything in quantum computing at this juncture.

It is my full expectation that that will change at a future juncture, but such a change is not imminent.

One exception is the generation of true random numbers, which can be accessed by users or application developers (as a cloud-based service) without any knowledge of qubits.

For more on generation of true random numbers:

And information on an existing commercial service to generate true quantum random numbers:

Three categories of personas: quantum algorithm designers, quantum application developers, and users of quantum applications

There are three distinct categories of personas involved with quantum computing from the perspective of this informal paper:

  1. Quantum algorithm designers. Working at the gate and circuit level.
  2. Quantum application developers. Working at the application level, invoking quantum algorithms and processing their results.
  3. Users of quantum applications. Normal users, who just happen to be using an application which is at least partially implemented on a quantum computer.

Three different postures on qubits for the three categories of personas

There are differences in the postures that each of the three categories of personas has regarding qubits:

  1. Quantum algorithm designers. Difficult to move away from intimate qubit knowledge. High-level algorithmic building blocks will help to minimize dependence on behavior of raw qubits. Need at least rudimentary high-level data types.
  2. Quantum application developers. Careful packaging of quantum algorithms coupled with encapsulated generative interface modules can help to minimize or even eliminate the intimate knowledge of qubit behavior required.
  3. Users. Can move away from qubits with carefully packaged applications. Epitomized by configurable packaged quantum solutions which are fully abstracted away from qubits.

A higher-level programming model is needed

Currently, quantum algorithm designers work at the gate level for constructing quantum circuits. This is comparable to classical programmers working at the machine language or assembly language level.

Most modern classical computer software is now designed and implemented using high-level languages and working with rich data types rather than working at the machine language or assembly language level with raw bits, bytes, and primitive hardware data types.

We need a similar transition for quantum computing.

We need a higher-level programming model.

Details are beyond the scope of this informal paper, and must await the outcome of much more research in this area.

High-level quantum algorithmic building blocks are needed

High-level quantum algorithmic building blocks are a fundamental aspect of a higher-level programming model for quantum computing.

Today, quantum algorithm designers work at the gate level on raw qubits.

We need quantum equivalents to the rich data types of the classical data types of classical computing. Not necessarily a one-for-one correspondence, but something higher-level than raw qubits or raw sequences of qubits.

High-level quantum algorithmic building blocks would work in conjunction with quantum data types. They would be the operations that can be performed on quantum data rather than raw quantum logic gates operating on raw qubits or raw sequences of qubits.

This should lead to one or even two orders of magnitude reduction in the complexity of quantum algorithms. Quantum algorithm designers should be expressing dozens of high-level quantum algorithmic building blocks rather than hundreds or even thousands of gates.

Details are beyond the scope of this informal paper, and must await the outcome of much more research in this area.

Exposure to qubits will vary with three levels of algorithmic building blocks

With very little in the way of algorithmic building blocks today, quantum algorithm designers are directly exposed to qubits. That’s just the way it is.

I see that algorithmic building blocks will progress through three levels, each having a different degree of exposure to qubits:

  1. Low level. Where we are today, and maybe a little higher. Focus on raw qubits, raw quantum effects, and primitive quantum logic gates. Direct exposure to raw qubits.
  2. Medium level. Introduce basic quantum data, data type, and information concepts, using low-level algorithmic building blocks, with some, but minimal, acknowledgement of raw quantum effects. Still some, but minimal, exposure to raw qubits, but no or minimal use of primitive quantum logic gates — the low-level algorithmic building blocks are the primitive operations at this level. Overall, modest to moderate exposure to raw qubits.
  3. High level. Strictly quantum data, data types, and information, emphasizing quantum parallelism. Completely hides raw qubits and quantum effects. No exposure to raw qubits. Nirvana for quantum algorithm designers and quantum application developers.

Exposure to qubits will vary with three stages of adoption of quantum computing

I see that there will be three stages of adoption of quantum computing, each having its own degree of exposure to qubits:

  1. The ENIAC Moment. Hand-crafted applications. Very limited deployments. Relying on super-elite technical teams at only the most elite of organizations. Full or at least significant exposure to qubits.
  2. Configurable packaged quantum solutions. Quantum applications which can easily be configured and customized in application terms, without any need to know about qubits. Widespread deployments of a relatively few applications. Requires no quantum expertise. Full or at least significant exposure to qubits for the quantum algorithm designers and application developers within the packaged solution, but no exposure to qubits for the users.
  3. The FORTRAN Moment. Higher-level programming model coupled with a high-level quantum programming language. Full support for the quantum equivalent of data, data types, and information, fully separate from the underlying qubits. Widespread development of custom applications. No longer requires super-elite technical teams and is no longer limited to only the most elite of organizations. No exposure to qubits.

So, until we get past The ENIAC Moment, full or at least significant exposure to qubits will be the norm.

The configurable packaged quantum solutions stage has the advantage that the user need not worry about the internals of the packaged solution, so they have no exposure to qubits.

And The FORTRAN Moment stage is the best of all, with no exposure to qubits for either the quantum algorithm designers, the quantum application developers, or the users of those applications.

For more detail on this model of stages of adoption for quantum computing, see my informal paper:

So, how do we start teaching about quantum computers if we don’t start with qubits and by comparing qubits with the 0’s and 1’s of classical bits?

Alas, as I’ve already conceded, today and for the foreseeable future we are stuck with needing to start with qubits.

And maybe even stuck with the worn out cliche of comparing qubits with the 0’s and 1’s of classical bits.

Actually, with my elevator pitch informal paper, I start with quantum parallelism and leave out qubits:

Although I do bring in qubits — but only briefly — to elaborate how quantum parallelism works:

  • Forget about individual qubits — little of value can be computed with individual, isolated qubits (other than a random bit value.)
  • The real power of quantum computing comes from quantum parallelism — n entangled and superimposed qubits (no longer isolated) can represent and operate on 2^n distinct values simultaneously while n classical bits can only represent and operate on one of those 2^n distinct values at a time.
  • That’s the real power of quantum computing — quantum parallelism.

That is an interesting challenge, how to characterize, quantify, and teach about quantum parallelism, the exponential speedup, without referring to the 2^n speedup which is based on the qubit count.

In any case, we need to start an education for quantum computing with the really important concepts — quantum parallelism, the quantum equivalent to data, data types, and information, and quantum algorithmic building blocks.

I’m sure there’s some reasonable way to work with quantum parallelism without delving into the underlying raw qubits.

In short, it’s the data and quantum parallelism that are important, not the underlying qubits.

Comparing qubits with classical bits is a very bad way to start off education for quantum computing

At a very minimum, starting off education for quantum computing by comparing qubits with classical bits — as virtually every introduction to quantum computing does — is a very bad start. It’s simply a distraction, adding no real value.

Raw qubits tell the student or reader nothing about quantum parallelism, algorithmic building blocks, or the quantum equivalent to data, data types, and information.

And raw qubits tell the student or reader nothing about how quantum advantage will be achieved or what it can achieve.

Superposition, entanglement, and interference are a poor way to start off education for quantum computing

Quantum effects, superposition, entanglement, and interference are certainly core concepts for quantum computing, but they are not a useful way to start off education for quantum computing.

They are certainly essential for quantum parallelism and achieving quantum advantage, but focusing on them early in the process of educating people for quantum computing adds no real value.

Again, they focus too much attention on raw qubits and quantum state rather than focusing on the quantum equivalent of data, data types, and information. And they do a poor job of introducing quantum parallelism and quantum advantage.

Quantum parallelism is the best way to start off education for quantum computing, plus algorithmic building blocks and the quantum equivalents to data, data types, and information

Quantum parallelism is the heart and foundation of quantum computing. That’s the best place to start off an education for quantum computing.

A focus on high-level algorithmic building blocks builds on quantum parallelism.

And the quantum equivalents of data, data types, and information provide the heart and foundation for algorithmic building blocks.

These concepts will be a much better start of an education for quantum computing than focusing on raw qubits.

Qubit capacity requirements still need to be known, but by the application deployment team, not the actual users

Even if the specific details of how qubits are used can be fully hidden from quantum algorithm designers, quantum application developers, and users of quantum applications, the number of qubits required to execute the quantum algorithm must be known to properly select hardware that supports that qubit count.

And qubit requirements can vary dynamically based on input data size and input parameters.

On the flip side, once we get to the point where typical quantum computers have far more qubits than the typical quantum algorithm can effectively use, then there will be no technical need to know or care exactly how many qubits are needed or actually used by a given quantum application.

Determination of qubit requirements from automated analysis of the algorithm and input data

Nobody should have to guess or manually determine the qubit requirements for a quantum algorithm. There should be an automated analysis method to determine the qubits requirements based on the actual algorithm and particular input data and input parameters.

Qubit requirements that need to be determined automatically include:

  1. Qubit count.
  2. Qubit connectivity.
  3. Probability amplitude and phase granularity.
  4. Circuit depth and total circuit size.
  5. Coherence time. Based on total circuit size.

Selection of the specific quantum computer (AKA backend) to run a particular quantum algorithm can then be automated, based on the qubit requirements which are automatically determined by analyzing the quantum algorithm and input data and input parameters.

The net effect is to eliminate yet another reason that anyone should need to know anything about qubits.

Lower level technical professionals still needing direct access to qubits

Even if and when we transition to a higher-level programming model for quantum computing, there will still be niches of technical professionals who still need deep knowledge and access to raw qubits and quantum logic gates:

  1. Performance and capacity-sensitive quantum algorithm designers.
  2. Physicists. Designing qubit technologies.
  3. Quantum hardware engineers. Implementing qubit and gate technologies.
  4. Quantum computer engineers. Implementing qubit and gate technologies.
  5. Low-level quantum software engineers. Implementing quantum circuits and various levels of quantum algorithmic building blocks.

How long will it take to get to quantum computing without the qubits?

At this stage, it is completely unclear how long it might take to advance quantum computing to the stage where most quantum algorithm designers, most quantum application developers, and most users of quantum applications will no longer have to know anything about or care in any way about raw qubits.

Much research, prototyping, and experimentation will be required until we know even the basics of a new high-level approach to quantum computing which is based on quantum parallelism, high-level algorithmic building blocks, and the quantum equivalent of data, data types, and information, rather than detailed familiarity with qubits, quantum state, and quantum logic gates.

All of that said, maybe it might be five years or so. Or maybe seven years. Or maybe we could have the basics in place in three years.

We’re still in the pre-commercialization stage of quantum computing with plenty of research, prototyping, and experimentation ahead of us

Despite all of the progress in recent years, quantum computing is still far from being ready for commercialization.

As I like to put it, quantum computing remains in the pre-commercialization stage, where lots of research, lots of prototyping, and lots of experimentation are needed before actual commercialization can begin.

So, there’s plenty of room for pursuing a higher-level approach to quantum computing, one which eliminates the need for quantum algorithm designers, quantum application developers, and users of quantum applications to know or care about low-level raw qubits.

For more on the pre-commercialization stage of quantum computing, see my informal paper:

The big caveat is that with all of this research, prototyping, and experimentation ahead of us, it can be tempting to find a shortcut and prematurely attempt to leap to commercialization — what I call premature commercialization. We have to diligently attempt to avoid that temptation.

For more on the risks of premature commercialization, see my informal paper:

Quantum Ready? Why learn a technology that will be obsolete when its practical replacement is introduced?

Learning so much about qubits now seems like a grand waste of effort when no practical applications are likely to occur until a practical replacement technology can be researched, developed, and deployed.

There are plenty of concepts that can be learned now, such as focusing on quantum parallelism, that will continue to have great value whenever we do manage to introduce replacement technologies, such as a superior high-level programming model, high-level algorithmic building blocks, high-level quantum data types, and even high-level quantum programming languages.

Focus on the use of classical quantum simulators can help to avoid excessive exposure to details of qubits

Trying to run a quantum algorithm on current quantum computing hardware can be a real challenge. It tends to force the user to know a fair amount about the raw qubits.

But running the quantum algorithm on a classical quantum simulator can sidestep those details of qubits.

Especially when combined with high-level algorithmic building blocks.

Alternative titles I considered

For my own future reference, here are alternative titles which I considered for this informal paper:

  1. No, Quantum Algorithm Designers and Quantum Application Developers and Users Should Not Need to Know Anything About Qubits
  2. Quantum Algorithm Designers, Application Developers, and Users Shouldn’t Need to Know Anything About Qubits
  3. Algorithm Designers, Application Developers, and Users Shouldn’t Need to Know Anything About Qubits
  4. Quantum Algorithm Designers, Application Developers, and Users Shouldn’t Need to Know about Qubits
  5. Quantum programmers and users shouldn’t Need to Know about Qubits. Lump quantum algorithm designers and quantum application developers together. What about quantum software infrastructure developers? Or quantum software development kit developers?
  6. Qubits considered harmful

Conclusions

  1. Dramatically minimize the knowledge needed to get started with quantum computing. Whether you are a quantum algorithm designer, a quantum application developer, or simply a user of a quantum application.
  2. Dramatically minimize the knowledge needed to design quantum algorithms and to develop quantum applications. Or to use quantum applications.
  3. Focus on raw qubits is both an unnecessary distraction and counterproductive.
  4. Today we’re stuck with a low-level programming model, lack of rich data types, lack of high-level quantum algorithmic building blocks, and no high-level quantum programming language. For now, this is where we are. For the indefinite future. Unclear when this might change.
  5. For the future we need to get to a high-level quantum programming model, high-level quantum algorithmic building blocks, rich data types, and high-level quantum programming languages. Unclear when this future might come about, when the transition might start, or how long the transition might take.
  6. Quantum computing deserves the quantum equivalent of data, data types, and information.
  7. High-level abstractions would eliminate the need to know about qubits.
  8. Shouldn’t need to know about classical bits either. Stick with high-level application-oriented data types. No different from classical developers not needing to know about classical bits.
  9. Shouldn’t need to know about classical bit strings either. Stick with high-level application-oriented data types. No different from classical developers not needing to know about classical bits and bit strings.
  10. Same goes for qutrits and other qudits, few need to know about them.
  11. This is an aspirational proposal rather than a current or near-term reality or even a prospect.
  12. How do we get there? It may not be known until after much research is completed. And much of that research has not even started. And much of that research has not even been proposed. Yes, we have a long way to go. A very long way to go.
  13. Today, even users need to be aware of qubits and their limitations.
  14. Nobody has a choice today, an intimate awareness of qubits is needed by anybody wishing to do anything in quantum computing at this juncture. One exception is the generation of true random numbers, which can be accessed by users or application developers (as a cloud-based service) without any knowledge of qubits.
  15. Three categories of personas: quantum algorithm designers, quantum application developers, and users of quantum applications.
  16. Three different postures on qubits for the three categories of personas.
  17. A higher-level programming model is needed.
  18. High-level quantum algorithmic building blocks are needed.
  19. Exposure to qubits will vary with three levels of algorithmic building blocks.
  20. Exposure to qubits will vary with three stages of adoption of quantum computing.
  21. So, how do we start teaching about quantum computers if we don’t start with qubits and by comparing qubits with the 0’s and 1’s of classical bits? We need to start an education for quantum computing with the really important concepts — quantum parallelism, the quantum equivalent to data, data types, and information, and quantum algorithmic building blocks. In short, it’s the data that’s important, not the underlying qubits.
  22. Comparing qubits with classical bits is a very bad way to start off education for quantum computing.
  23. Superposition, entanglement, and interference are a poor way to start off education for quantum computing.
  24. Quantum parallelism is the best way to start off education for quantum computing, plus algorithmic building blocks and the quantum equivalents to data, data types, and information.
  25. Qubit capacity requirements still need to be known, but by the application deployment team, not the actual users.
  26. Determination of qubit requirements from automated analysis of the algorithm and input data. Nobody should have to guess or manually determine the qubit requirements for a quantum algorithm. There should be an automated analysis method to determine the qubits requirements based on the actual algorithm and particular input data and input parameters.
  27. Lower level technical professionals still need direct access to qubits.
  28. How long will it take to get to quantum computing without the qubits? Unclear how long it will be until most quantum algorithm designers, application developers, and users will no longer need to know or care about qubits. Much research, prototyping, and experimentation will be required to achieve a new high-level approach to quantum computing which is based on quantum parallelism, high-level algorithmic building blocks, and the quantum equivalent of data, data types, and information, rather than detailed familiarity with qubits, quantum state, and quantum logic gates. How long? Unclear. Maybe it might be five years or so. Or maybe seven years. Or maybe we could have the basics in place in three years.
  29. We’re still in the pre-commercialization stage of quantum computing with plenty of research, prototyping, and experimentation ahead of us. There’s plenty of room for pursuing a higher-level approach to quantum computing, one which eliminates the need for quantum algorithm designers, quantum application developers, and users of quantum applications to know or care about low-level raw qubits. The big caveat is that with all of this research, prototyping, and experimentation ahead of us, it can be tempting to find a shortcut and prematurely attempt to leap to commercialization — what I call premature commercialization. We have to diligently attempt to avoid that temptation.
  30. Quantum Ready? Why learn a technology that will be obsolete when its practical replacement is introduced? Learning so much about qubits now seems like a grand waste of effort when no practical applications are likely to occur until a practical replacement technology can be researched, developed, and deployed.
  31. Focus on the use of classical quantum simulators can help to avoid excessive exposure to details of qubits. Especially when combined with high-level algorithmic building blocks.

For more of my writing: List of My Papers on Quantum Computing.

Quantum Computing
Quantum Algorithms
Quantum Applications
Computing

--

--

Jack Krupansky
Jack Krupansky

Written by Jack Krupansky

730 Followers
1 Following

Freelance Consultant

Help

Status

About

Careers

Press

Blog

Privacy

Terms

Text to speech

Teams