You Don't Need To Be A Physicist Or Mathematician To Learn Quantum Computing
Make the Villains of Quantum Computing Education Work for You!
My talk at the RGUT Srikakulam Qiskit Fall Fest'25
Get the slides of my talk here:
When you start learning about quantum computing, you'll face many claims about the potential of this technology.
Just have a look at what McKinsey says:
The emerging technology of quantum computing could revolutionize the fight against climate change, transforming the economics of decarbonization and becoming a major factor in limiting global warming to the target temperature of 1.5°C.
And Forbes seems to agree:
The application of quantum technologies could transform the energy industry and lead to cleaner energy with fewer emissions.
Both sources are completely reputable, and the articles also suggest that they have been thoroughly researched. But they are not selling research results. They are selling hype.
Big consulting firms. Global magazines. Major tech companies.
They all repeat the same prophecy. Quantum computing will change everything for the better
But basically, their claims are worthless. Both fantasize about what quantum computing and quantum machine learning could enable us to do in the future.
They're clever. They always use the word could. So technically, they're not making false claims. Without a doubt, new technology could lead to all sorts of things. But of course, these hypesters know the power of words and that could will be interpreted as will.
They do not even explain or prove why quantum computers will solve these problems.
Their main argument goes something like this: We know that quantum computers are capable of solving difficult problems. Here is a list of problems that we have no idea how to solve. That's why a quantum computer is the right tool.
If you listen closely, there is no how. Just big words and shiny predictions.
These hypesters thrive on your curiosity. They want you to be excited, not informed.
And that's exactly where most beginners fall into the trap: between wonder and confusion.
When you start exploring quantum computing, you enter a world of strange truths. A world where the line between fact and fiction is barely discernible. The simple reason for this is because quantum computing is still so poorly understood.
But quantum computing will only change the world if people like you—programmers, engineers, data scientists, and students—learn how to use it properly. When we stop treating it like sorcery and start treating it like technology. Not through mysticism. But through clarity, practice, and reason.
That’s what this talk is about.
How can we programmers, engineers, data scientists, and students learn quantum computing at all?
If any one unwarily draws into close and hears the singing of the Sirens, his wife and children will never welcome him home again, for they sit in a green field and warble him to death with the sweetness of their song.
So, you really want to learn quantum computing? It's time you turned to more serious sources. The introductory courses.
At first, the beautiful explanations of quantum mechanical concepts will cast a spell over you.
A qubit can be both zero and one at the same time.
You think: That's beautiful. That's elegant. That all makes sense. Finally, someone explains it understandably. They speak softly, clearly, and sound trustworthy. Just like the sirens in Homer's Odyssey. But as soon as you go into detail, they reveal their gruesome face.
The superposition of a two-dimensional quantum system (usually denoted as the quantum state , such as a qubit) is a complex linear combination of its mutually orthogonal basis state vectors and : where is the complex scalar amplitude of measuring , and the amplitude of measuring the value
The sirens don't lie. They just leave out the important part. They replace understanding with metaphors and then abandon you in the middle of it all.
They don't say that a qubit isn't really both zero and one. It isn't in two states. It is in a particular quantum state that we just can't observe directly. They just leave you with Greek letters, vertical lines, strange symbols, and no explanation of their meaning. They skip right over the part where intuition fails.
The Sirens thrive on incomplete understanding. On that satisfying illusion that you almost understand. They make you feel smart, just long enough until you feel stupid again. And then you start to wonder:
- Maybe you do need a degree in physics after all.
- Maybe you should go back to the textbooks.
This thought, that you're not ready yet, is the next trap.
You have survived the siren song of half-truths.
And so you start stacking books.
Quantum physics, linear algebra, tensor calculus. Volumes full of theory that are stacked higher than your motivation.
- Before you can understand quantum computing, you need a solid foundation in linear algebra.
- You'll have to study quantum mechanics first.
- Tensor calculus will help — it’s essential.
But when you open these textbooks, you find no bridge between your own world and theirs. You find an impenetrable wall. You find only a alien landscape of symbols and assumptions.
You calm down and accept it: I'll study a little physics first.
But the deeper you get into the subject, the more alien it becomes to you.
You have entered a world where intuition no longer works.
- Reality is no longer real. It is complex.
- Particles are no longer particles. They suddenly behave like wave functions.
- And this wave function apparently collapses when you look at it.
With every page you turn, you move further away from the computer screen where you started, further away from the problems you actually want to solve.
You wanted to learn how to use a quantum computer. And somehow you ended up trying to understand the universe. An alien universe.
Okay, you think, maybe quantum computing is meant for someone else. For someone smarter, someone with a degree in physics.
But the truth is simpler and much more liberating.
The problem isn't you. Nor is the problem that quantum computing is inherently difficult.
It's only difficult because of how it is explained. Quantum computing is taught the wrong way. It is full of physics jargon and unexplained equations.
What you need is not another degree.
What You need is a translation. You need a bridge between mathematics, physics, and the way you already think as a developer, engineer, data scientist, or student.
But when you look for that bridge, you'll find that it's guarded by a group of gatekeepers. Those who tell you that you can't cross it until you've earned your stripes in quantum mechanics, linear algebra, and tensor calculus.
If you keep going and hope that the next explanation will finally tie everything together, you'll find that the landscape starts to split.
On one side, there are the physics-heavy resources. The textbooks, the lectures, the professors who patiently explain the nature of the universe.
On the other side are the mathematics-heavy resources: the proofs, the equations, the derivations that promise clarity through formalism.
And both sides are convinced that they are perfectly clear.
And, yes. They are. But neither of them speaks your language.
The physics-oriented material explains everything based on the behavior of matter and energy. It deals with particles, spin, and wave functions. Every statement refers to how the world is, not how it can be used.
- If you ask how a qubit stores information, you will get an answer about Hilbert spaces.
- If you ask what measurement means, you learn about Born's rule.
- If you ask why an algorithm works, you learn about interference patterns and unitary evolution.
It's beautiful. It's rigorous. And it's completely impractical for someone who wants to understand something.
The mathematical resources are not more forgiving.
They remove the physical metaphors and replace them with symbols. Where the physicist draws a diagram, the mathematician writes a definition.
Where the physicist says, A qubit interferes with itself, the mathematician says:
and then spends ten pages proving why the normalization condition must hold.
Everything is correct. But almost nothing is understandable unless you already know what it means.
The explanations become recursive: you have to understand the symbols in order to understand the explanation that conveys the meaning of the symbols.
It's like being handed a dictionary in a foreign language.
The Ghoul of unexplained equations hides meaning behind elegance. It speaks in proofs rather than explanations.
These are not extremes. These are the normal teachers you encounter in quantum computing.
They insist on rigor, but they exclude intuition. They describe, but they do not translate.
You feel like an intruder in a foreign country: You recognize some of the words, but you cannot participate in a conversation.
The knowledge is not hidden in the equations, but in the silence between them. The part that no one wants to translate for the eager learner.
It took me a long time to realize this.
I stopped waiting for the right book or the right course.
I stopped trying to understand the universe.
Instead, I started to use it.
I opened a Jupyter notebook, wrote my first quantum circuit, and executed it.
And suddenly, the fog cleared. That was the turning point.
That was it. A few lines.
I pressed Run and for the first time, I wasn't reading about superposition and entanglement. I was creating it.
No metaphors. No equation. Just code.
The results weren't dramatic. Two measured bits, seemingly random at first glance.
But they had meaning. I could see the change in probability distribution when I added a gate or changed the circuit.
For the first time, I could observe the abstract behavior of a qubit and didn't just have to imagine it.
That's when I realized what was missing from all the textbooks: Understanding doesn't come from memorizing equations. It comes from interacting with them.
When superposition and entanglement were discovered, they didn't have computers to do the math. Not even classic computers.
But today, we don't need to multiply matrices by hand. We have computers. They do it well. They do it fast.
So let's let them do what they do best so that we can focus on what we do best. And that means making sense of things.
The more circuits I built, the more the concepts began to make sense. Superposition was no longer magic. It became the result of a Hadamard gate. Entanglement was not a philosophical conundrum. It became simply what happened when you connected a CNOT behind the Hadamard gate.
Measurement collapse? That was the part where I clicked Run and saw one result trump the others.
Physics hadn't changed. What had changed was my relationship to it.
That was when I understood how to learn this subject properly.
Most people approach quantum computing in the traditional way: Theory → Equations → Code → Concept.
They start with the most difficult part and end with the most intuitive. No wonder most of them give up.
But when you reverse this order, something remarkable happens.
You start with practice. You start with code and conceptual thinking. You develop intuition first. The math becomes an explanation rather than an obstacle.
The correct order is: Concept → Code → Equations → Theory.
Learn what a system does, not why it does it. Use it, explore it, observe when it behaves unexpectedly. Only then do you go back and let the theory explain what you have already seen.
This simple reversal turned confusion into understanding.
For me, programming quantum circuits replaced the noise of technical jargon with the clarity of cause and effect. And in doing so, I discovered something else: Quantum computing wasn't as strange as it seemed.
It was simply a different system. A system governed by logic, structure, input, and output.
You don't have to understand quantum mechanics to use it. You just have to understand how it behaves.
This realization became the basis for how I teach and write about quantum machine learning today: not as abstract physics, not as a mathematical exercise, but as technology. Quantum computing is something you work with, not something you worship.
When I started building things, something unexpected happened. The voices that had previously confused me, the physics sorcerer, the ghoul, the sirens, not even the hypester, they suddenly sounded different.
Once I began to understand through practice, I realize that none of them were completely wrong. They were all just incomplete.
The physics sorcerer is right about one thing: Without rigor, everything degenerates into buzzwords. His language always sounded like an incantation: unitary operators, decoherence, Hilbert spaces. But when I started programming, I realized why he insists on this precision. A single false assumption can render an entire algorithm meaningless.
I am not yet fluent enough to think in this language. I do not understand particles or wave functions.
But I have learned to be interested in the truth behind a concept. The obsession with accuracy prevents us from getting lost in ambiguous metaphors.
The ghoul has its own kind of truth. Its symbols should not exclude anyone. They are meant to protect meaning.
Every equation is a safeguard against misinterpretation.
At first, the equations looked like barriers. Now I see them as contracts: clear, unambiguous statements about what must be true.
Once deciphered, they do not obscure understanding. They stabilize it.
They force you to question your own beliefs.
They prevent wishful thinking.
I still don't read equations like text. But I treat them like a code. I only check them when something doesn't work.
The sirens who tell half-truths have something to teach us, too.
Their metaphors were never the problem. They were the starting point. Their mistake was that they stopped there.
Intuition is the starting point for all understanding. It is only dangerous when it is confused with the goal. Used correctly, it is a bridge between curiosity and understanding. They taught me that metaphors are not lies, but scaffolding.
And even the hypesters with their exaggerated headlines and wild promises served a purpose. They remind me why the topic was important to me in the first place.
Quantum computers have great potential. They could revolutionize optimization, simulation, logistics, and research. Their exaggerations are clumsy, but their instincts are right: This technology is important.
Ultimately, none of these characters are purely villains.
The Sinister Villains Of Quantum Computing Education
They are specialists, each preserving one aspect of understanding.
Rigour. Precision. Intuition. Motivation.
You need all four. The challenge is not to silence them. It's about translating between them.
Weaving their strengths into a learning method that feels human. That's what I've built my teaching approach on. It borrows the rigor of the physicist, the precision of the mathematician, the intuition of the siren, and the motivation of the hypester.But I rearrange them into a path you can actually walk.
Just when I thought I had found balance. When I had learned to navigate between math, code, and practice, a new villain appeared on the horizon.
Not a Sorcerer.
Not a Ghoul.
Not even a Siren.
Something far more mischievous.
The Qiskit Squirrel.
It didn't come quietly. It was announced with trumpets and fanfare. The Squirrel updated Qiskit to 1.0. Then 2.0. Every tutorial, every blog post, every GitHub notebook. They all stopped working.
Dozens of examples I had used to teach myself quantum circuits no longer worked. Import errors. Outdated functions. Missing parameters.
My entire approach seemed to collapse. If the code doesn't run, you can't see what it does. And if you can't see what it does, you can't understand how it works. I found myself back in complete darkness.
The new API is, of course, documented. In pages of concise technical details that read like internal notes written by software engineers for other software engineers.
It almost seems as if you need to be a computer scientist to understand it.
Of course, that can't be true. And it isn't. But it teaches us that there is another trait we need to embrace rather than suppress.
Practical quantum computing is still in its infancy. It is still in the process of laying its foundations. Every new version, every API change is a symptom of an emerging field.
To the learner, however, it feels like sabotage. But in truth, the squirrel doesn't care about you. It only cares about progress. It gnaws at tutorials, scatters notebooks, and breaks code not for its own sake, but because it needs to survive the winter. If it doesn't grow, it dies.
So there's another truth hidden in this frustration: when you're learning quantum computing, you can't rely on stability. You have to rely onunderstanding.
If you know why the code worked before, you can fix it when it stops working. If you know what a circuit does, you can rebuild it in any syntax. That's when I stopped worrying about which library or API I was using and focused on mastering the underlying concepts.
Concepts survive version changes. Understanding outlasts syntax.
After the chaos with the squirrel, I understood something simple but crucial:
- You can't control how quantum computers develop.
- You can't control how research papers are written.
- You can't control when the next version will destroy your code.
But you can control how you learn.
- You don't have to learn quantum mechanics.
- You don't have to get a degree in physics.
- You don't have to memorize every matrix identity
You need a learning framework that adapts as quickly as the field itself. This framework is simple: Concept → Code → Equations → Theory.
Start with the concepts: What does the system do, how does information flow, what do superposition and entanglement mean as operations?
Then move on to the code: Test it, run it, observe its behavior.
Only then return to the equations. Not as obstacles, but as confirmation of what you already know.
This order reverses the traditional order. It does not trivialize theory, but grounds it.
That's how I developed PyQML. My approach to teaching quantum machine learning. No more series of lectures or derivations, but a modular, practice-oriented structure that lets you learn by doing.
You explore the field yourself: experimentally, iteratively, practically. And the theory comes naturally when you actually need it.
You don't learn quantum computing by staring at the universe. You learn it by building one.
So, when someone asks me today, do I have to be a physicist or mathematician to learn quantum computing?, I answer, No. You only have to be a learner who refuses to wait for permission.
Quantum computing does not belong to physicists or mathematicians. It belongs to anyone who is willing to think differently.