My Quantum Computing Journey: From Qubits to Building a Semantic Search Tool
Planting intuitions about quantum gates, growing understanding of entanglement, and harvesting a real quantized vector search engine along the way.
13 min read
Quantum computing is not the future anymore. It is the present. IBM, Google, and Amazon are building quantum hardware right now, and the engineers who understand both classical and quantum computing will have a massive edge in the next decade.
But most quantum resources are either too academic (pages of Dirac notation with no intuition) or too hand-wavy ("it is like being in two places at once!"). I wanted something in between. Rigorous enough to be correct, but explained simply enough that my past self could have understood it on the first read.
So I started building. I worked through MIT's quantum computing course, wrote Feynman-technique explanations for every concept that tripped me up, and then built a real project: a quantized vector search tool for Ontario government websites. This is where theory met practice, and where my understanding finally solidified.
Why I Built This
I started this quantum garden in February 2026 because I realized the biggest barrier to entry was not the math. It was the explanation style. Every resource I found assumed I already spoke the language of quantum mechanics, or it oversimplified to the point of being misleading.
I wanted to create the resource I wished existed. Each concept gets its own notebook with code, math, and plain-English reasoning. The Deutsch-Jozsa algorithm, the CHSH inequality, quantum information formulation; each one is a self-contained lesson built for genuine understanding.
Core Concepts
Qubits: The Quantum Bit
A classical bit is like a light switch: ON (1) or OFF (0). A qubit is like a dimmer switch that can be anywhere between fully off and fully on, and it stays in that blended state until you actually look at it.
Mathematically, a qubit is |psi> = alpha|0> + beta|1>, where alpha and beta are complex numbers whose squared magnitudes give the probability of measuring 0 or 1. The qubit is not secretly 0 or 1 before measurement. It genuinely exists in a combination of both states. This is superposition, and it is the computational resource that makes quantum algorithms powerful.
The Bloch Sphere
Since a single qubit state is defined by two angles (theta and phi, after factoring out a global phase), you can represent any qubit state as a point on the surface of a sphere. |0> is the north pole. |1> is the south pole. The equator holds superposition states like |+> and |->.
Every quantum gate is a rotation on this sphere. The Bloch sphere turned abstract linear algebra into something I could actually picture, and my understanding accelerated from there.
Quantum Gates
Quantum gates are to quantum computing what logic gates (AND, OR, NOT) are to classical computing. But instead of flipping bits, they rotate the state on the Bloch sphere.
The Hadamard (H) gate creates equal superposition from a definite state. Think of it as the "coin flip" gate. The Z Gate leaves |0> alone but flips the phase of |1>. Phase is invisible when you measure directly, but it becomes visible when you interfere states, and that interference is the engine of quantum algorithms. The S Gate is a 90-degree rotation around Z (the square root of Z). The T Gate is a 45-degree rotation, and it is the key ingredient for universal quantum computing.
Entanglement
Imagine two coins that are magically linked: whenever one lands heads, the other always lands tails, no matter how far apart they are. That is entanglement. Formally, two qubits are entangled when the state of the combined system cannot be written as a product of individual qubit states.
The Bell state (|00> + |11>)/sqrt(2) is the classic example. Measuring the first qubit as 0 instantly tells you the second is 0. This is not communication; it is correlation baked into the quantum state. The CHSH inequality notebook in my repo explores how entanglement produces correlations that are literally impossible in classical physics.
The Deutsch-Jozsa Algorithm
This was the first quantum algorithm that blew my mind. You have a black-box function that takes n bits and outputs 0 or 1. You are promised the function is either constant (same output for every input) or balanced (outputs 0 for exactly half the inputs). Classically, you might need to check 2^(n-1) + 1 inputs. The Deutsch-Jozsa algorithm does it in one query.
It puts all inputs into superposition simultaneously, runs the function once, and uses interference to amplify the answer. Wrong answers destructively interfere and cancel out. The right answer constructively interferes and stands alone.
Quantized Vector Search: The Practical Project
Theory is great, but I also built something real. I created a semantic search engine for Ontario government websites. The pipeline: scrape web pages, chunk the text, create embeddings (dense vector representations of meaning), then search by finding the closest embedding to a query.
The twist: raw embeddings are 32-bit floats, which eat memory. I applied quantization, multiplying by 100 and rounding to integers, which compresses the embeddings to roughly 4x smaller with minimal accuracy loss. This is the same principle behind model quantization in production ML, and it connects beautifully to quantum computing where discrete state representations are fundamental.
How It Works
Here is the learning path I designed, and the one I recommend you follow:
Quantum Information Formulation
(Hilbert spaces, state vectors)
|
v
Z Gate Deep Dive
(Phase manipulation, why it
matters for interference)
|
v
Deutsch-Jozsa Algorithm
(Superposition + interference
= first quantum speedup)
|
v
CHSH Inequality
(Proof that quantum correlations
beat classical physics)
|
v
Quantized Vector Search Tool
(Theory meets deployment:
embeddings, quantization,
semantic search)
Start with the fundamentals notebook that sets up the mathematical framework: Hilbert spaces, state vectors, measurement probabilities. Then move to the Z Gate Feynman explanation, because understanding phase is the gateway to understanding why quantum algorithms work.
Work through Deutsch-Jozsa next. Run each cell, modify the oracle function, and watch the output change. Then explore the CHSH inequality to see proof that quantum mechanics allows correlations that classical physics cannot. Finally, try the quantized vector search tool as the practical capstone.
What I Learned
- Quantum computing is linear algebra with attitude. Once I stopped being intimidated by the notation and saw qubits as vectors and gates as matrices, everything opened up.
- Phase is the secret weapon. Understanding why the Z gate matters, even though it does not change measurement probabilities, was my biggest breakthrough.
- Interference is the engine. Quantum algorithms work by making wrong answers cancel out and right answers add up. Deutsch-Jozsa is the simplest and most elegant example of this pattern.
- Quantization bridges classical and quantum. Working with discrete representations and managing precision-versus-efficiency trade-offs, these skills transfer directly between classical ML deployment and quantum computing.
- Building projects cements understanding. The Ontario government search tool forced me to connect theoretical concepts to real engineering constraints: memory, latency, accuracy.
- Curiosity is a competitive advantage. Most engineers are not exploring quantum computing yet. By starting now, I am building intuitions that will compound as quantum hardware matures.
Why This Matters for Your Career
Quantum computing questions are starting to appear in interviews at top tech companies. Here is how this work prepares you:
Q1: Explain what a qubit is and how it differs from a classical bit.
A classical bit is 0 or 1. A qubit is a linear combination of |0> and |1> with complex amplitudes. Before measurement, it genuinely exists in superposition, enabling parallel exploration of computational paths.
Q2: What is quantum entanglement, and why is it useful?
Entanglement is a correlation between qubits that cannot be described by treating each qubit independently. It enables quantum algorithms to coordinate information across qubits. Teleportation, superdense coding, and error correction all rely on it.
Q3: Walk me through the Deutsch-Jozsa algorithm.
Initialize qubits, apply Hadamard to create superposition, apply the oracle, Hadamard again, then measure. If all zeros, the function is constant; otherwise, balanced. The magic is interference created by the oracle combined with Hadamard transforms.
Q4: What is vector quantization and why would you use it?
It maps continuous values to a discrete set of representatives. I scaled float embeddings by 100 and stored them as integers, achieving 4x memory compression with minimal accuracy loss for nearest-neighbor search tasks.
Q5: How does the Hadamard gate create superposition?
It applies the matrix (1/sqrt(2)) * [[1,1],[1,-1]]. Applied to |0>, it produces equal superposition with 50/50 measurement probability. Applied to |1>, it also gives 50/50, but with a relative phase difference that is crucial for interference-based algorithms.
Try It Yourself
The entire quantum garden is open source. Start planting your own intuitions:
git clone https://github.com/tolani007/Eigentiki-s-Quantum-Garden.git
cd Eigentiki-s-Quantum-Garden
pip install qiskit numpy jupyter
# Start with the quantum information formulation
jupyter notebook General_formulation_of_quantum_information.ipynb
# Then explore Deutsch-Jozsa for your first quantum algorithm
jupyter notebook Deutsch_Jozsa_Algorithm.ipynbFind the full repository here: github.com/tolani007/Eigentiki-s-Quantum-Garden
About the Author
I am Tolani Akinola, also known as Eigentiki. I build at the intersection of machine learning, data engineering, systems programming, and creative tech. I believe the best way to learn anything is to build it, break it, and then explain it to someone else as simply as possible.
Find this project and all my work on GitHub. Let us connect:
