Will Quantum Computing Fall into the Adatran Trap?

It is very tempting to clamor for shortcuts to transition from classical computing to quantum computing. After all, how many technical professionals have the motivation, energy, and patience to learn quantum mechanics and linear algebra (linear combinations of eigenvectors with eigenvalues of complex numbers!), let alone esoteric concepts such as Hadamard transforms and Fourier transforms? Shortcuts are indeed tempting, but quite risky as well. This informal paper will explore a particular technological pitfall, a shortcut called the Adatran trap — misusing a new technology by imagining that you can use it the same way as an older technology.

Gee, isn’t there a subset of quantum computing and some tricks and shortcuts so that we can trivially map most of our classical algorithms so that they run on a quantum computer? And possibly even employ automated tools, possibly powered by AI to make the leap? Maybe. Possibly. To some degree. Sort of. But, even if such shortcuts can in fact bear some short-term fruit, the cost is likely that such efforts won’t be able to take full advantage of the real power of quantum computing — especially the key advantage, quantum parallelism. I refer to this as falling into the Adatran trap.

Adatran (also written as AdaTran or AdaTRAN) is the name given to attempts to use a subset of a new, advanced technology as if it were some older, more limited technology. The term originated when FORTRAN programmers tried to code in the Ada programming language without fully grasping the nuance and power of the new and advanced features and newer software engineering and object-oriented methodology of Ada. The result was neither pretty nor particularly effective. Quantum computing needs to try to avoid falling into the same trap, the Adatran trap.

The key issue is the degree to which the algorithms of the application use quantum parallelism on a quantum computer, a feature which does not exist in classical computing.

Raw performance is the key indicator of whether the developer has managed to avoid the Adatran trap on a quantum computer. The Adatran trap has been avoided if and only If the quantum solution runs a thousand, a million, or a billion or more times faster than a comparable algorithm on a classical computer. The Adatran trap has not been avoided If the quantum solution take the same amount of time or is merely “a little faster”, “moderately faster”, or even only two to ten times faster.

The ultimate indicator that the Adatran trap has been avoided is that a quantum solution achieves an acceptable result when no acceptable result is even achievable using classical computation in some reasonable amount of time.

The good news (if you consider it good at all) is that it likely isn’t technically possible to mechanically translate most classical algorithms to quantum algorithms at this time or even in the near future, if for no other reason than lack of a sufficient number of qubits and/or lack of sufficient coherence time in the hardware. Still, people will be tempted to try.

The bad news is that the truly massive level of hype around quantum computing will lead to vast hordes of insufficiently trained and resourced teams pushing forward without adequate plans for how to avoid the Adatran trap.

Two alternative approaches which may help to avoid the Adatran trap are also discussed in this paper:

1. Switch to pure quantum solutions early even on classical computers by using quantum simulators running on classical computers. The Adatran trap still exists, but you could buy more time to evolve away from it with more experience.
2. Quantum-inspired classical algorithms. Get into the swing of proper use of quantum algorithms even when still running on classical computers. A hybrid mix that is much closer to pure quantum. Again, the Adatran trap still exists, but you could buy more time to evolve away from it with more experience.

What could cause quantum computing to fall into the Adatran trap?

There are a number of missteps which can result in falling into the Adatran trap, as detailed in the Adatran paper. The raw list is presented here, but substitute “quantum computing” for Ada or “the new technology” and “classical computing” for “the old/older technology”:

1. Minimal or weak training in the new technology.
2. Training using analogy, showing how features of the existing, older technology can be very easily mapped directly into features of the new technology, but without thinking through whether this is really exploiting the advanced features of the new technology.
3. Insufficient training in the philosophy and benefits of the new and advanced features of the new technology.
4. Insufficient time and staff to become more thoroughly acquainted with the new and advanced features and benefits of the new technology. Raw schedule pressure.
5. Too much attention on features rather than on modern methodology.
6. Insufficient examples of how to upgrade existing metaphors in for the older technology to more appropriate metaphors in the new technology.
7. Individuals are still “thinking in (the mindset of) the old technology” rather than “thinking in (the mindset of) the new technology.” A change of mindset is definitely needed, but difficult to arrange. It takes both commitment and time. And management and social support as well.
8. An explicit goal to use the Adatran approach as a teaching tool, despite its limitations. Sure, it gets more people onboard more rapidly, but at the longer-term cost of not taking advantage of the new and advanced features and benefits of the new technology.
9. Lack of methodical code reviews with explicit technical criteria for proper exploitation of the full features of the new technology.
10. Desire to rapidly bulk migrate large and complex applications over to the new technology with no real attention to restructuring to take advantage of the advanced features and modern methodologies of the new technology.
11. Use of automated tools to rapidly bulk migrate large and complex applications over to the new technology with minimal human intervention. No provision for evolving the application to exploit the advanced features and modern methodologies of the new technology.
12. Lack of any deep institutional support for the advanced methodology and features of the new technology. Including and especially inadequate funding by management, including non-technical management.
13. Lack of sufficient experience by technical management with the advanced methodology features of the new technology, or with the requirements for staffing a project with emphasis on modern methodologies.
14. “We don’t have time to do it right.” Ignorance or incompetence on the part of management — or the simple reality that external factors preclude proper scheduling.

How to avoid falling into the Adatran trap?

To avoid the Adatran trap, follow the advice detailed in the Adatran paper, essentially reverse each of the causes of Adatran — substituting “quantum computing” for Ada or “the new technology” and “classical computing” for “the old/older technology”:

1. Provide thorough and deep training in the new technology.
2. Refrain from training using analogy — showing how features of the existing, older technology can be very easily mapped directly into features of the new technology. Instead look more broadly how larger portions of the application can be restructured to exploit the advanced features of the new technology, rather than a too-simplistic one-for-one feature mapping.
3. Provide sufficient training in the philosophy and benefits of the new and advanced features of the new technology.
4. Allow sufficient time and staff to become more thoroughly acquainted with the new and advanced features and benefits of the new technology. Make room in the schedule to reduce time and staff pressure.
5. Focus more attention on modern methodology rather than features of the new technology.
6. Develop a comprehensive set of examples of how to migrate existing metaphors in the older technology to more appropriate metaphors in the new technology.
7. Make the commitment and time to getting people to “think in (the mindset of) the new technology.” A change of mindset is definitely needed. Get commitment and time from management and social support as well.
8. An explicit goal to refrain from using the Adatran approach as a teaching tool. Sure, it has the short-term cost of taking longer to get more people onboard, but at the longer-term benefit of taking advantage of the new and advanced features and benefits of the new technology.
9. Methodical code reviews with explicit technical criteria for proper exploitation of the full features of the new technology.
10. Avoid bulk migration of large and complex applications over to the new technology with no real attention to restructuring to take advantage of the advanced features and modern methodologies of the new technology.
11. Avoid use of automated tools to rapidly bulk migrate large and complex applications over to the new technology with minimal human intervention — and without attempting to fully exploit the benefits of the new technology.
12. Achieve deep institutional support for the advanced methodology and features of the new technology. Including and especially adequate funding by management, including non-technical management.
13. Achieve sufficient experience by technical management with the advanced methodology features of the new technology, and with the requirements for staffing a project with emphasis on modern methodologies.
14. Make time to do it right. Train or replace management, technical and non-technical, to adequately schedule project resources for the new technology. Work with external actors to gain sufficient schedule flexibility.

Quantum simulators and quantum-inspired classical algorithms

An alternative to having a hard split between the two worlds of computing (classical and quantum) might be to transition to quantum computing even on classical computers by using either quantum simulators running on classical computers or to come up with a software framework for developing quantum-inspired algorithms on a classical computer so that developers could write quantum-like code which is then translated by the framework into optimized classical code, providing at least a subset of the benefits of quantum computing with the convenience of continuing to develop and run the full application on a classical computer — at full classical speed, not the speed of a simulator.

A quantum simulator — the simulation of a quantum algorithm on a classical computer, not to be confused with quantum simulation which is the use of quantum algorithms to simulate quantum physics — is feasible but only for a relatively small numbers of qubits, but that may be fine for the near future since it may be another couple of years before quantum computers with more than a handful of qubits — and algorithms which can exploit those qubits — are widely available.

A quantum-inspired classical algorithm is a relatively new and unexplored concept but seems as if it has some significant potential. The potential will hinge on the sophistication of the framework and translator. And also the sophistication of the hardware architecture — how many classical processors can effectively be used in parallel without the communication overhead negating the benefits of additional parallelism. It’s too soon to be more definitive about this approach. Still, it’s an option which seems quite promising.

A key goal of the quantum-inspired classical algorithm framework is that there should be a real effort to assure that a quantum-inspired classical algorithm can also be trivially translated to a raw and pure quantum algorithm which can then be run natively on an actual quantum computer, provided that sufficient qubits, connectivity, and coherence time are available.

The net goal here with quantum simulators and quantum-inspired classical algorithms is to fully escape the Adatran trap. The potential seems plausible. But it’s still not a slam dunk.

Tall order?

Yes, all of that is a very tall order.

Yes, there is a very real risk that many quantum computing efforts will indeed fall into the Adatran trap. The net result will be that many efforts will be seen as failures, as they indeed are, but the real risk will be that quantum computing will be seen as a failure rather than the misguided efforts to use quantum computing in an inadequate manner.

Conclusion

Management and technical experts need to stay on top of the issue and try to avoid half-hearted, underfunded, and understaffed efforts that seem to suffer from an Adatran mentality — trying to brute-force shoehorn classical algorithms into a quantum computer.

It may simply be that it is still too soon with this new technology to be making major commitments for major projects. Research projects? Yes. Experimentation? Yes. Prototyping? Yes. Mainstream projects? No.

And we probably do need to see both the ENIAC moment and the FORTRAN moment for quantum computing:

1. Sufficient hardware — enough qubits, enough connectivity, and enough coherence time.
2. A real and substantial application that really does prove the merit of quantum computing. Probably a few such applications are needed, but certainly at least one which illustrates many of the relevant issues and solutions. This implicitly proves a quantum advantage, at least for this one application.
3. A high-level programming model and associated high-level programming language which obviate much of the tedious and error-prone efforts that the early application developers were forced to tolerate and slog through at very great effort — too great an effort for most mainstream projects.

And serious effort and resources should be put into research for more advanced quantum simulators and frameworks for quantum-inspired classical algorithms, both of which have the prospect of completely skirting the Adatran trap.