Quantum Computing & Machine Learning — Complete Course

Course Material · Part A

Introduction to Quantum Computing

A step-by-step, picture-first course — from the very first idea of quantum computing all the way to how it joins hands with machine learning.

Who this is for This material is written so that anybody can follow it — a 100-level student meeting the idea for the first time, a 400-level student preparing for the practical classes, and the lecturer preparing to teach. No engineering background is needed. If you can use a phone and a laptop, you can follow this course.

How to use this material

📖 Read in order

The pages on the left-hand menu are arranged like a story. Each page builds on the one before it. Start from Page 1 and move down. Use the Next page button at the bottom of each page.

🖐️ Touch the pictures

Many of the pictures in this course are alive — you can click buttons, drag sliders, and toss coins. Please play with them! You will understand ten times faster by doing than by reading.

✍️ Answer the quizzes

Every page ends with short Check Yourself questions. Click an answer and it tells you immediately if you are correct, and why. Nothing is hidden; nothing needs the internet.

🖨️ Print if you like

This whole material can be printed (Ctrl+P / Cmd+P). The interactive parts become still pictures, but all the text and tables print well as handouts for students.

The journey ahead

A promise By the end of Part A you will be able to explain quantum computing to someone else in plain English — which is the real test of understanding, and exactly what a teacher needs.

Topic 1

Basic Concepts of Quantum Computing

Before any big grammar, let us build the picture in our heads with things we already know.

Start from the computer you already know

Every computer you have ever used — your phone, your laptop, the ATM — thinks using bits. A bit is the smallest piece of information, and it can only ever be one of two things:

Interactive · The light switch (a classical bit)

A classical bit is like a light switch. It is either OFF (0) or ON (1) — never both, never in between. Click the switch.

The bit is 0 (OFF). A classical computer is millions of these switches flipping very fast.

Now the quantum idea — in one sentence

The big idea A quantum computer uses special switches (called qubits) that, while they are working, can be 0 and 1 at the same time — and only "settle" into one answer when you look at them.

That sounds strange, so here is the everyday picture that carries the whole course:

Interactive · The spinning coin (a quantum bit)

A coin lying on the table is Heads OR Tails — like a classical bit. But a coin spinning on the table is, in a real sense, both at once. It only becomes one of them when you slap your hand on it (that is a measurement). Press "Spin" first, then "Slap" — and repeat several times:

Lying flat: Heads (1) — not yet spun

Why should anybody care?

Because of a simple mathematics of counting. One spinning coin holds 2 possibilities at once. Two spinning coins hold 4 possibilities at once (HH, HT, TH, TT). Ten coins hold 1,024. The number doubles every time you add one coin.

Interactive · The doubling machine

Drag the slider to add qubits and watch how many possibilities the machine can hold at the same time.

3 qubits → 8 possibilities at once

At 50 qubits, the machine is holding over a quadrillion possibilities at once — that is a 1 followed by 15 zeros, more than a million times a thousand million. No ordinary computer can line up that many options simultaneously — it would have to check them one after the other. This is the source of quantum computing's power: for certain problems, it explores a huge space of answers in parallel, then uses clever tricks to make the right answer the one you see when you "slap the coin".

Honest truth (important for teaching) A quantum computer is not simply "a faster computer". It will not open Microsoft Word faster. It is a different kind of computer that is dramatically better at a specific family of problems — searching, simulating molecules, optimisation, and some mathematics behind cryptography. For everything else, your laptop remains champion.

The three words to carry forward

Qubit

The quantum version of a bit. The spinning coin. Covered fully on Page 5.

Superposition

Being in a blend of 0 and 1 at once — the spin itself. Page 6.

Measurement

Slapping the coin. The act of looking, which forces one definite answer out.

☕ Pause & Think · Class discussion

"Who is better — the computer, or the human being?"

When Dr. Ophori — the lecturer of this very course — asked a class this question, every single hand said "the computer — it is faster!" Her reply: "How can you say it is better, when YOU are the one that developed it? You wrote the algorithm. If you remove the human, the computer cannot process anything again. You are the author — it is only the pen." Before we build these powerful quantum machines together, settle this question in your own heart. Turn to the person beside you and argue it out for two minutes.

Alan Turing (1950) opened his famous paper with the question "Can machines think?" — and then argued the question itself was too vague to answer directly. Seventy years later, we still debate it.

Garry Kasparov, world chess champion, lost to IBM's Deep Blue in 1997 — then spent the following decades arguing that human + machine together beat either one alone. He calls it "augmented intelligence", not artificial.

Ada Lovelace (1843), the first programmer, wrote that the machine "can do whatever we know how to order it to perform" — it originates nothing. Turing named this "Lady Lovelace's objection" and took it seriously.

There is no "correct" answer to collect marks on — the thinking itself is the lesson. A student who can defend either side with reasons has already learned more than one who memorises a definition.

Check yourself · 1

Q1. A classical bit can be 0 or 1. While a quantum computer is working, what can a qubit be?

Only 0 Only 1, but it changes faster A blend of 0 and 1 at the same time, until it is measured Neither 0 nor 1 — it holds letters instead

✔ Correct answer: a qubit can be in a superposition — a blend of 0 and 1 at once, like a spinning coin — and only gives one definite answer when measured.

Check yourself · 2

Q2. If 3 qubits can hold 8 possibilities at once, how many can 4 qubits hold?

10 16 — it doubles each time you add one qubit 12 8 — adding qubits does not change it

✔ Each new qubit doubles the possibilities: 2 → 4 → 8 → 16. The pattern is 2ⁿ for n qubits. This doubling is called exponential growth, and it is why quantum computers excite scientists.

Topic 2

Definitions of Quantum Computing

One idea, defined at four levels — from the market square to the examination hall. All four are correct; they differ only in formality.

The definitions, written out fully

🗣️ Level 1 — The everyday definition

"A quantum computer is a new kind of computer that can consider very many possible answers at the same time, instead of checking them one by one."

🎓 Level 2 — The student definition (recommended for class)

"Quantum computing is a type of computing that uses qubits instead of ordinary bits. Because a qubit can exist as a mixture of 0 and 1 at the same time (superposition), a quantum computer can process many possibilities in parallel, which makes it far more powerful than a classical computer for certain kinds of problems."

🔬 Level 3 — The technical definition

"Quantum computing is the use of quantum-mechanical phenomena — superposition, entanglement, and interference — to perform computation. Devices that perform such computation are called quantum computers."

You will not just memorise this definition — you will run every word of it as code: superposition in Lab 1, entanglement in Lab 2, and interference beating a classical computer in Lab 2.5 (Deutsch's algorithm), all in Part B.

📜 Level 4 — The formal definition

"Quantum computation is a model of computation in which information is stored in quantum states (qubits) and processed by unitary transformations called quantum gates, with results extracted by measurement."

Key terms that live inside the definitions

Term	Plain meaning	Picture to hold
Quantum mechanics	The physics of very small things (atoms, electrons, light particles), where objects behave in surprising ways.	The rulebook nature uses at the smallest scale.
Qubit	Quantum bit — the basic unit of quantum information.	The spinning coin.
Superposition	A qubit being in a blend of 0 and 1 at once.	The spin itself.
Entanglement	Two or more qubits linked so that they behave as one system, even far apart.	Twin coins that always agree.
Interference	Possibilities can add up (louder) or cancel out (silent), like ripples meeting on water. Quantum algorithms use this to cancel wrong answers.	Two ripples meeting on a calm river.
Measurement	Reading the qubit — which forces it to pick 0 or 1.	Slapping the spinning coin flat.
Quantum gate	An operation that changes a qubit's state — the quantum version of AND, OR, NOT.	A hand that flicks or re-spins the coin in a controlled way.

Lock the terms in — play the matching game

Interactive · Match the term to its picture (works offline)

Tap a term on the left, then tap the picture that belongs to it on the right. Correct pairs lock in green. Can you clear the board without a single miss?

Teaching tip When teaching, give students Level 1 first and let them repeat it back in their own words. Only after they own the plain idea should Levels 2 and 3 be introduced. A definition memorised before it is understood is quickly forgotten.

☕ Pause & Think · Class discussion

Can we use something we do not fully understand?

You have just read four definitions of quantum computing. Here is an uncomfortable secret: even the professors who write these definitions admit the deep "why" of quantum mechanics is still mysterious. So — is it honest to build billion-dollar machines on it? Before you answer, think: do you fully understand electricity? Your own brain? Yet you use both every day.

Richard Feynman, Nobel laureate, famously said: "I think I can safely say that nobody understands quantum mechanics." He did not mean the mathematics — that is precise and tested — he meant the deep why underneath it.

The engineers' answer: a working motto in the field was long "shut up and calculate" — the equations predict perfectly, so build with them, and let the philosophy catch up later. Aeroplanes flew before we fully understood turbulence; medicine healed before we understood every cell.

The teachers' answer: a definition is not the end of understanding — it is a handle for carrying an idea while your understanding grows. That is why this course gives you four handles, not one.

Good discussion direction: ask students for other things humanity used before understanding (fire? fermentation? gravity?). Science is not finished knowledge — it is honest work in progress.

Check yourself

Which three quantum phenomena appear in the technical definition of quantum computing?

Electricity, magnetism, and gravity Superposition, entanglement, and interference Binary, hexadecimal, and decimal Speed, memory, and storage

✔ The three pillars are superposition (many states at once), entanglement (linked qubits), and interference (cancelling wrong answers, boosting right ones). We will meet each one with its own visual on Page 6.

Topic 3

Historical Development

Not a history lesson — a short relay race. Each runner passed the baton to the next. 👉 Click any event to open its story.

1900–1930s · The physics era

Planck, Einstein, Bohr, Heisenberg & Schrödinger discover quantum mechanics

Scientists studying heat, light and atoms found that nature at the smallest scale does not follow everyday rules. Energy comes in packets ("quanta"), particles behave like waves, and a particle can be in a mixture of states. This strange rulebook — quantum mechanics — became the most accurate theory in all of physics. No computers yet; just the raw physics.

1981–82 · The spark

Richard Feynman asks the founding question

The famous physicist Richard Feynman observed that ordinary computers struggle badly to simulate molecules and atoms (quantum systems), because the possibilities multiply too fast. His proposal: "Nature isn't classical… if you want to simulate nature, you'd better make it quantum mechanical." In other words — build a computer out of quantum parts. This moment is widely taken as the birth of quantum computing. Paul Benioff had also shown, around 1980, that a quantum-mechanical model of a computer was theoretically possible.

1985 · The blueprint

David Deutsch defines the universal quantum computer

At Oxford, David Deutsch worked out the mathematics of a universal quantum computer — a machine that could, in principle, perform any computation. This gave the field its formal foundation, the quantum version of what Alan Turing did for classical computing.

1994 · The alarm bell

Peter Shor's algorithm threatens world cryptography

Peter Shor (AT&T Bell Labs) discovered a quantum algorithm that could factor huge numbers exponentially faster than any known classical method. Why it mattered: internet security (RSA encryption, used by banks everywhere) depends on factoring being hard. Suddenly governments and companies worldwide started funding quantum computing seriously. This single algorithm turned a physics curiosity into a global race.

1996 · The search trick

Lov Grover's search algorithm

Grover showed a quantum computer can search an unsorted list of N items in roughly √N steps instead of N. Searching 1,000,000 items takes about 1,000 quantum steps. A second major proof that quantum machines beat classical ones on real tasks.

1998–2010s · First baby hardware

From 2 qubits in a lab to working chips

The first tiny quantum computers (2–7 qubits) were demonstrated using molecules and trapped atoms. In 1999–2011, companies entered: D-Wave sold the first commercial quantum annealer in 2011 (a specialist optimisation machine — fully explained on the next page), and superconducting qubit chips (the technology IBM and Google use today) matured rapidly.

2016 · Quantum for everybody

IBM puts a quantum computer on the internet

IBM launched the IBM Quantum Experience — free access to a real quantum computer over the cloud, and later the open-source Qiskit Python library. This is the single most important event for this course: it means our students in Nigeria can run programs on a real quantum computer in America using only a laptop and internet. The practical part of this course (Part B) is built on Qiskit.

2019 · The milestone

Google claims "quantum supremacy"

Google's 53-qubit Sycamore chip performed a (very specialised) sampling task in about 200 seconds that they argued would take the best supercomputer thousands of years. IBM disputed the exact numbers, but the moment stands as the first public claim that a quantum machine did something practically impossible classically. The term for this is quantum supremacy (also called quantum advantage) — defined fully on Page 6.

2020s → today · The engineering era

Bigger chips, fewer errors, early usefulness

IBM crossed 1,000+ physical qubits (Condor, 2023) and shifted focus to error correction — making qubits reliable, which is today's central challenge. Google's Willow chip (2024) showed errors can be driven down as systems scale, a key milestone. China, the EU, and startups (IonQ, Quantinuum, PsiQuantum, Rigetti) are all racing. We are in the NISQ era — "Noisy Intermediate-Scale Quantum" — machines big enough to be interesting, still too noisy to be perfect.

The story in one paragraph (for exams) Quantum mechanics was developed in the early 1900s. In 1981–82, Feynman (building on Benioff) proposed computing with quantum systems. Deutsch formalised the universal quantum computer in 1985. Shor (1994) and Grover (1996) provided killer algorithms that proved quantum computers would matter. Hardware followed: first lab qubits (late 1990s), first commercial machine (D-Wave, 2011), cloud access for everyone (IBM, 2016), Google's supremacy experiment (2019), and today's race toward error-corrected machines.

☕ Pause & Think · Class discussion

Einstein doubted quantum mechanics all his life — and his doubt became a gift. Can being "wrong" be valuable in science?

The greatest scientist of the 20th century never accepted that nature is random at the bottom. He fought Bohr about it for decades. And here is the beautiful twist: Einstein's sharpest attack (the 1935 EPR paper) forced physicists to study entanglement so carefully that it became the experiments that won the 2022 Nobel Prize — and the technology inside quantum computers. His doubt built the field he doubted.

Albert Einstein: "God does not play dice with the universe" — his way of saying a true theory should describe reality itself, not just probabilities of what we will see.

Niels Bohr is said to have replied: "Einstein, stop telling God what to do." (A famous anecdote — historians note the exact words are uncertain, a good lesson in checking sources!) Bohr held that you cannot separate reality from the act of measuring it.

The verdict of experiment: Bell's theorem (1964) turned the philosophy into a measurable test; Aspect, Clauser and Zeilinger ran the tests — nature sided with Bohr. The dice are real. Yet Einstein's questions sharpened the field more than easy agreement ever could.

For the classroom: ask students when a respectful disagreement last taught them something. Science moves forward on good questions, not just right answers — a student who disagrees with the lecturer and gives reasons should be celebrated, not silenced.

Check yourself · 1

Who is generally credited with proposing the idea of a quantum computer in 1981–82?

Peter Shor Richard Feynman (building on Paul Benioff's work) Bill Gates Alan Turing

✔ Feynman proposed simulating nature with quantum machines; Benioff had shown it was theoretically possible. Shor came later (1994) with the factoring algorithm; Turing founded classical computing theory.

Check yourself · 2

Why did Shor's 1994 algorithm cause governments to take quantum computing seriously?

It made computer games run faster It showed a quantum computer could break the encryption that protects banks and the internet It proved quantum computers could never work It won a Nobel Prize that year

✔ Shor's algorithm factors large numbers quickly — and internet security (RSA) depends on factoring being slow. The threat to cryptography unlocked massive funding worldwide.

Topic 4

Examples of Quantum Computers

Real machines exist today. They differ mainly in what they build their qubits out of — and each choice has a trade-off.

The key insight A qubit can be made from anything that obeys quantum rules and has two states we can control: a tiny superconducting circuit, a single trapped atom, a particle of light, an electron's spin. Different companies bet on different materials — like different car makers betting on petrol, diesel, or electric.

🧊 Superconducting qubits — IBM & Google

Machines: IBM Quantum (Eagle 127 qubits, Osprey 433, Condor 1,121; now the Heron series), Google Sycamore (53) and Willow (105).

How: Tiny electric circuits cooled to about −273 °C (colder than outer space) so current flows without resistance and behaves quantum-mechanically.

Fast gatesEasy to manufacture like chipsNeeds giant fridgeShort memory (microseconds)

⚛️ Trapped-ion qubits — IonQ & Quantinuum

Machines: IonQ Forte, Quantinuum H2.

How: Individual charged atoms (ions) held floating in a vacuum by electric fields, controlled with laser beams. Each atom is one qubit.

Very accurateLong memoryIdentical qubits (atoms are perfect)Slower gatesHard to scale to thousands

💡 Photonic qubits — PsiQuantum & Xanadu

Machines: Xanadu Borealis; PsiQuantum (building toward a million qubits).

How: Particles of light (photons) carry the quantum information through optical chips.

Works at room temperatureLight travels — good for quantum networksPhotons are hard to make interact

🧲 Quantum annealers — D-Wave

Machines: D-Wave Advantage (5,000+ qubits — but a different, weaker kind).

How: Not a general-purpose quantum computer. It is a specialist machine that only solves optimisation problems (finding the best arrangement — e.g., cheapest delivery routes, best schedule).

Available commercially since 2011Many qubitsOnly one problem typeCannot run Shor/Grover

Comparing them at a glance

Technology	Who	Qubit made from	Temperature	Main strength	Main weakness
Superconducting	IBM, Google, Rigetti	Tiny cold electric circuit	≈ −273 °C	Fast, chip-like manufacturing	Noisy, giant fridges
Trapped ion	IonQ, Quantinuum	A single floating atom	Room-temp trap (lasers do the work)	Highest accuracy	Slow, hard to scale
Photonic	Xanadu, PsiQuantum	A particle of light	Mostly room temperature	Networking, no fridge	Photons barely interact
Annealer	D-Wave	Superconducting loops	≈ −273 °C	Optimisation problems now	Not general-purpose
Neutral atoms / spin qubits	QuEra, Pasqal, Intel	Uncharged atoms / electrons in silicon	Varies	Promising scaling paths	Younger technology

Test your eye — "Which machine am I?"

Interactive · Guess the technology from its clue (works offline)

Each clue describes one of the four machine families above. Tap your answer — then get a fresh clue.

Which one will our students touch? IBM's superconducting machines — because IBM gives free cloud access and the open-source Qiskit Python library. In Part B (practicals), students will write Python on their laptops in Nigeria and run it on a real IBM quantum computer abroad. No fridge required on our side!

Check yourself · 1

Why do IBM's and Google's quantum chips need to be cooled to about −273 °C?

To stop the chips from catching fire So the circuits superconduct and behave quantum-mechanically, protected from heat noise Because electricity only flows when cold It is only for advertising

✔ Heat is random jiggling — and random jiggling destroys delicate quantum states (we call this decoherence). Near absolute zero, the circuit loses electrical resistance and the qubit's quantum state survives long enough to compute.

Check yourself · 2

D-Wave's machines have over 5,000 qubits — far more than IBM's. Why is D-Wave still not "ahead"?

D-Wave's qubits are imaginary D-Wave machines are too expensive An annealer is a specialist machine for optimisation only — it cannot run general quantum algorithms like Shor's Because IBM advertises more

✔ Qubit count alone doesn't decide power. An annealer's qubits solve one family of problems (optimisation). A universal gate-based machine (IBM, Google, IonQ) can run any quantum algorithm. Lesson for students: always ask what kind of qubits, not just how many.

Topic 5 · The building block

Qubits

Everything in quantum computing stands on this one object. Take this page slowly — once qubits are clear, every other topic becomes easy.

One idea only: the LEAN

A bit is a pole lying flat against a wall — fully on the "0" side or fully on the "1" side. Finished. Certain. Nothing more to say.

A qubit is that pole stood up and spinning — and here is this entire page in one sentence: a qubit is a spin that can LEAN. Lean it toward one side, and when you slap it, it falls to that side more often — in exact proportion to the lean. That is the whole idea. Everything below is just this one picture, practiced with your own hands.

Interactive · The spinning coin that LEANS — your first real qubit

Drag the slider = set the lean. Slap = one toss. The big numbers on the floor are not decoration — they ARE the answer: a 60% lean means 60 out of every 100 slaps land on "1". That is the whole machine. Play:

"But what MAKES it fall 60/40 — where is the machinery?" There is none hidden. The lean IS the whole story — the same way nothing extra "makes" a leaning pole fall the way it leans. That the fall-shares match the lean exactly is the measured law of nature (physicists call it the Born rule) that every quantum computer stands on. The qubit's secret is not machinery; it is geometry.

What you just learned by playing One slap tells you almost nothing. Many slaps, counted, reveal the lean. And that counting is exactly how real quantum computers are used every day: run the same circuit hundreds of times (engineers call the runs "shots"), count the results, read the shares. You will do precisely this, with real code, in Part B.

❓ "It looks like the qubit is learning to match my slider…" — it is not. Read this slowly once

Nothing in this demo learns. Nothing improves. Nothing changes. You set a lean with the slider. Then you slapped the pole, many times, and counted the falls. A leaning pole falls the way it leans — slap it 10 times and the tally is rough, slap it 1,000 times and the tally clearly shows the lean. The lean stayed the same from the first slap to the last. Only your COUNT grew.

Picture a woman selling puff-puff who drops one in ten on a bad day. Watch her for 10 customers and maybe she drops none — you'd wrongly think she never drops any. Watch her for 500 customers and you will count very close to one-in-ten drops. She did not change. You just watched long enough to see the truth. That is ALL the right chart is doing: watching long enough.

So when IS something actually learning? Learning would be if the pole re-leaned itself after every slap to please you. That never happens here — but machines that genuinely re-adjust themselves after every mistake DO exist, and you will build one in Part B (Lab 6). When you get there, remember this page: counting tosses (here) and a machine re-adjusting itself (there) look similar on a chart, but they are completely different things.

The two particles, side by side

Interactive · BIT vs QUBIT — same floor, different physics

Left — the classical bit: a coin lying flat. Certain. Flip it to change it; read it a thousand times — same answer, no damage. Right — the qubit: spinning with a 60% lean. Reading it is an EVENT: one slap, one forced fall, one answer — then it must be re-spun. Try both sides:

stored value: 1 — not read yet

spinning (60% lean) — not slapped yet

❓ A question from Dr. Ophori's reading — answered

"Some materials say a qubit can be in three states: quantum state 0, quantum state 1, and superposition. But if superposition is 0-and-1, what does 'quantum state of 1' even mean — and what would the computer print?"

Beautiful question — and the confusion disappears with one sentence: |0⟩ and |1⟩ are themselves quantum states. They are the two "resting poles" of the qubit — the north and south of the Bloch sphere below. A qubit sitting in quantum state |1⟩ is not spinning at all: measure it 100 times and it prints 1 all 100 times. It is still fully quantum — you can rotate it into superposition any moment — it is simply resting at a pole right now.

In coin language, the "three states" are:

Textbook name	Coin picture	If you measure 100 times, it prints…
Quantum state \|0⟩	Coin lying flat, tails up	0, all 100 times — `{'0': 100}`
Quantum state \|1⟩	Coin lying flat, heads up	1, all 100 times — `{'1': 100}`
Superposition	Coin spinning	A mixture — e.g. `{'0': 48, '1': 52}` for a fair spin

And the full truth is even richer: between the two poles lie infinitely many blends (every tilt of the arrow below) — "three states" is just the beginner's summary of poles + everything-in-between. In Part B, Lab 1, you will run all three on a real simulator and watch each one print exactly this table.

From the coin to the globe — one small step

In the demo above, your coin could only lean left or right. But a real spinning coin can lean in any direction — toward you, away from you, north-east, anywhere around the circle. Now ask: if I drew a dot for every possible lean — every direction, every amount — what shape would all those dots make? A ball. That ball is the famous Bloch sphere: nothing mysterious, just the map of every lean a qubit can have, with an arrow showing the lean it has right now.

How to read the globe in ten seconds:

Top of the ball = no lean toward "1" at all → always falls "0".
Bottom = fully leaned → always falls "1".
How far DOWN the arrow points = the percentage. Equator = exactly 50/50. That is the same slider you have been dragging all along — just drawn on a map.

Interactive · The map of every lean — in 3D

Slider = lean the arrow (watch the percentages follow it, same as the coin). Drag the ball itself = turn the map in your hands.

"But why a whole BALL? A simple dial from 0% to 100% would do…" Sharp question — and here is the honest answer. For the fall-percentages alone, a dial WOULD do: only how far down the arrow points matters for that. But the direction around the ball (toward you, away, sideways) is a real, physical part of the lean too — it just stays invisible until two leans meet. When they meet, leans pointing the same way around add up, and leans pointing opposite ways around cancel — and that adding-and-cancelling is exactly the interference you will watch wipe out randomness on the next page. So: up-down = the percentages (today's lesson), around = the secret handshake between qubits (next page's lesson). The ball holds both.

What is a qubit physically?

Remember Page 4: anything quantum with two controllable states can be a qubit.

Superconducting circuit (IBM/Google): two energy levels of a cold circuit.
Trapped ion (IonQ): two energy levels of a single atom.
Photon (Xanadu): e.g., two polarisations of light.
Electron spin (Intel): spin-up vs spin-down in silicon.

The mathematics is identical for all of them. That is why we can learn qubits once and program any machine.

The two hard truths about qubits

⚠️ Truth 1 — Measurement destroys the blend

The moment you measure, the superposition collapses to plain 0 or 1 and the extra information is gone. You cannot peek and continue. Algorithms must do all their clever work before measuring.

⚠️ Truth 2 — Qubits are fragile (decoherence)

Heat, vibration, stray radio waves — any disturbance acts like an accidental measurement and ruins the state. This is why machines live in extreme cold and why error correction is the biggest challenge in the field today.

No-cloning (bonus fact students love) It is physically impossible to copy an unknown qubit. There is no "copy & paste" in quantum! This sounds like a weakness, but it is the foundation of quantum cryptography: a spy cannot copy the message without destroying it — so eavesdropping is always detected.

☕ Pause & Think · Class discussion

Before you measured the qubit, did it HAVE a value — or did your looking create the answer?

You just played with the blend slider and watched measurements collapse. Now sit with the deeper question. Einstein once asked a colleague, walking under the night sky: does the moon exist only when somebody looks at it? For big things like moons, of course it is there. But for a qubit, experiment says the answer genuinely was not there before the measurement. Where, then, does "reality" begin?

Erwin Schrödinger (1935) pushed the discomfort to its limit with his famous cat: a cat whose fate is tied to a quantum event would be, absurdly, alive-and-dead until observed. He designed the picture to show how strange the theory sounds when scaled up — and it became its most famous teaching tool.

The Copenhagen view (Bohr): physics does not describe what nature is — it describes what we can say about nature. The measurement is part of the story, not an interruption of it.

The many-worlds view (Everett, 1957): nothing collapses — every outcome happens, each in its own branch of reality. Mathematically clean, philosophically breathtaking, and still seriously defended today.

Let students vote on which view they find most believable, then defend their vote. Physicists themselves are split — your students are entering a live debate, not a settled one.

For the exam only: how scientists WRITE the lean Textbooks write the lean as |ψ⟩ = α|0⟩ + β|1⟩. Decode it in ten seconds: |0⟩ = the pole flat on the "0" side, |1⟩ = flat on the "1" side, and α, β are two numbers saying how much the lean points each way. Square them and you get the fall-shares: α² = share of "0" falls, β² = share of "1" falls — together always 100%. Example: β = 0.77 → 0.77² ≈ 60% of slaps fall to "1". Nothing new — your leaning pole, in fancier handwriting.

Check yourself · 1

A qubit is in the state |ψ⟩ = α|0⟩ + β|1⟩ with P(0) = 25%. What is P(1)?

25% 50% 75% — because all probabilities must add up to 100% Cannot be known

✔ Probabilities always total 100%: P(1) = 100% − 25% = 75%. On the Bloch sphere, this arrow points below the equator, closer to |1⟩.

Check yourself · 2

Why do quantum programs run the same circuit many times ("shots") instead of once?

Because the computer is slow Because one measurement gives one random outcome — many runs reveal the probability pattern (histogram) To warm up the processor It is a billing trick by IBM

✔ One shot = one collapsed answer. Hundreds of shots = a histogram showing the real probabilities. You experienced this yourself with the "Measure 100 times" button above.

Topic 6 · The three powers

Superposition, Entanglement & Quantum Supremacy

Three terms, one family: the first two are the powers a quantum computer uses; the third is the finish line that proves those powers beat classical machines.

Power 1 — Superposition (the spinning coin, now official)

You already own this idea from Pages 1 and 5: a qubit can exist in a blend of |0⟩ and |1⟩ until measured. The real-life payoff is parallelism: with n qubits in superposition, a quantum computer manipulates 2ⁿ possibilities in a single operation.

Real-life anchor Checking routes for a delivery van through 10 cities: a classical computer tries routes one-by-one. A quantum computer in superposition holds all routes at once, then uses interference to make the bad routes cancel out and the good one stand tall.

The experiment behind it all — the double slit

❓ A question from Dr. Ophori's reading — answered "The materials talk about electrons and photons behaving one way when observed and another way when not observed. What is that about?" — That is the double-slit experiment, the single most famous experiment in physics. Richard Feynman said it contains "the only mystery" of quantum mechanics. Instead of reading about it — run it yourself, right here.

The setup: a gun fires particles (electrons or photons) one at a time at a wall with two narrow slits. Behind the wall is a screen that records where each particle lands. Common sense says particles are like small stones — they should pile up in two bands, one behind each slit. Watch what actually happens:

Interactive · The double-slit experiment — watch a single particle travel

🎬 Fire ONE and watch: with the detector OFF, the particle leaves the gun as a dot, then spreads into a ripple that passes through BOTH slits at once — the two ripples overlap, and it lands as a single dot placed by their meeting pattern. Switch the detector ON and fire again: now it stays a dot, takes ONE slit (the detector flashes), and lands in a plain band. Then use the fast buttons to build the statistics.

Detector OFF. Fire some particles and watch the stripes appear…

👁‍🗨 Detector OFF — the mystery

The particles land in many alternating stripes (an interference pattern) — the signature of a wave passing through both slits at once and interfering with itself. Yet each particle arrives as a single dot! Each one travelled as a superposition of "through the left slit" AND "through the right slit" — the spinning coin, in flight.

👁 Detector ON — the collapse

Place a detector at the slits to see which path each particle takes, and the stripes vanish — just two plain bands, like stones. Knowing the path IS a measurement, and measurement collapses the superposition. Nature behaves differently when the information exists — whether or not any human is looking.

❓ WHY does it behave like this? — the question every student asks, answered straight

Why stripes when nobody watches? Drop two stones into a calm river and watch the ripples meet: where crest meets crest the water jumps high; where crest meets trough the water cancels flat. An unwatched particle travels exactly like that ripple — one wave of possibilities that passes through both slits and then meets itself on the far side. Where its two halves agree → many landings (a bright stripe). Where they cancel → almost none (a dark gap). The stripes are the meeting-pattern of a particle overlapping itself.

Then why does each particle land as ONE dot? Because travelling and arriving are different acts. It travels as a wave — but the screen is a measurement, a slap: the wave must surrender one definite landing point, chosen with chances set by its own stripes. This is not philosophy — in 1989, physicists in Japan (Tonomura's team) filmed electrons arriving one at a time: each a lone dot, random-looking… and after thousands, the stripes stood there, assembled dot by dot. Travels as a wave. Arrives as a particle. Both, honestly.

And why does watching kill the stripes? Here is the answer to give a student slowly: it is not eyes, not minds — it is INFORMATION. The stripes exist only while "went through the top" and "went through the bottom" remain two indistinguishable halves of one spinning possibility — your coin being both faces at once. A detector at the slit makes a permanent record of which path — and two recorded, distinguishable histories can no longer overlap and cancel. The detector's record is a slap delivered at the slit instead of at the screen: the coin is forced to land early, so it flies the rest of the way as a decided little stone — two slits, two plain piles. The universe never cared that someone looked; it cares that anything kept the record.

Why this experiment matters for OUR course The double slit is superposition + measurement + interference in one picture — the same three ingredients inside every quantum computer. A quantum algorithm is, at heart, a cleverly engineered interference pattern: wrong answers land in the dark stripes, right answers in the bright ones. And one honest correction to popular myth: the "observer" needs no eyes and no consciousness — any physical detector that records the path information collapses the pattern. It is information, not attention, that does it.

Power 2 — Entanglement (the twin coins)

Take two qubits and link them with a special operation. They now form one shared state: measuring one instantly tells you about the other, even if they were separated across the world. Einstein was so uncomfortable with this that he called it "spooky action at a distance" — but experiments (Nobel Prize 2022: Aspect, Clauser, Zeilinger) confirm it is real.

Interactive · Entangled twin coins

These two coins are entangled so they always land the same way. Both are spinning (superposition). Measure either one — and watch its distant twin collapse instantly to match.

Coin A — Lagos

∞

Coin B — London

Careful — common misconception Entanglement does not let us send messages faster than light. The outcome of each measurement is still random — only the correlation is guaranteed. What entanglement does give us: qubits that work as one team, which is what makes multi-qubit algorithms, quantum error correction, and quantum cryptography possible.

How the two powers work together

The finish line — Quantum Supremacy

Definition Quantum supremacy (politely: quantum advantage) is the demonstrated moment when a quantum computer performs a task that no classical computer could complete in any practical amount of time.

2019 — Google Sycamore: 53 qubits performed a sampling task in ~200 seconds; Google estimated ~10,000 years for the top supercomputer. IBM argued it could be done in days — but even "days vs 200 seconds" made the point.
Important honesty: the task was artificial, chosen because it suits quantum machines. Supremacy ≠ "quantum computers are now better at everything." The current race is for useful quantum advantage — a real-world problem (chemistry, materials, finance) solved better. That milestone is still being contested today.

☕ Pause & Think · Class discussion

If two particles can stay connected across the whole world, what does "distance" even mean to nature?

You just measured the Lagos coin and watched the London coin obey instantly. Everything in your daily experience says influence needs travel — a letter, a signal, a journey. Entanglement says: not always. Some physicists believe this hints that space itself is not fundamental — that connection is deeper than distance. Others say the correlation is simply how shared quantum states work, nothing mystical. In your own life, you already know relationships that distance cannot weaken. Is nature telling us something similar — or is that reading too much poetry into physics?

Einstein dismissed it as "spooky action at a distance" — surely, he argued, the particles carried hidden instructions all along, like twins who agreed before parting.

John Bell (1964) found the genius test: if hidden instructions existed, measurement statistics must obey a certain limit. Experiments broke the limit. No hidden instructions — the connection is real.

A caution from the physicists: entanglement carries correlation, never messages — so it does not break Einstein's speed limit for information. Nature is spooky, but it is also disciplined.

A lovely class exercise: let two students act out the twin coins at opposite ends of the room, then ask the class to design a way to send a message using only the coins — and discover together why it cannot work.

Check yourself · 1

Two entangled qubits are separated — one in Lagos, one in London. The Lagos qubit is measured and gives 1. What do we instantly know?

Nothing — they are too far apart The London qubit's outcome is now determined (correlated with Lagos's result) The London qubit is destroyed A message has been sent faster than light

✔ Entangled qubits form one shared state — measuring one determines the other's correlated outcome instantly. But note: no usable message travels, because the Lagos result itself was random.

Check yourself · 2

Which statement about quantum supremacy is most accurate?

It means quantum computers are now better than classical computers at all tasks It means a quantum computer has done at least one task no classical computer could practically do It means classical computers will be thrown away soon It is the name of IBM's biggest chip

✔ Supremacy is a one-task milestone (Google claimed it in 2019 with an artificial sampling task). Your laptop is still champion of everyday computing — the race now is for advantage on useful problems.

Topic 7

Difference Between Classical and Quantum Computers

Everything from the previous pages, now arranged side by side — the page to revise from the night before a test.

The full comparison table

Feature	Classical computer	Quantum computer
Basic unit	Bit (0 or 1)	Qubit (blend of 0 and 1)
Information in n units	One pattern out of 2ⁿ	All 2ⁿ patterns in superposition
Physical basis	Transistors on silicon chips	Superconducting circuits, trapped ions, photons…
Operating condition	Room temperature	Often near −273 °C, heavily shielded
Logic operations	AND, OR, NOT gates	Quantum gates (H, X, CNOT…) — all reversible
Reading data	Harmless, repeatable	Measurement collapses the state — one chance
Copying data	Trivial (copy–paste)	Impossible (no-cloning theorem)
Errors	Extremely rare	Frequent — error correction is the central challenge
Results	Deterministic — same input, same output	Probabilistic — run many shots, read the histogram
Best at	Everyday tasks: documents, web, databases, video	Simulation of molecules, optimisation, factoring, (quantum) machine learning
Today's maturity	Decades of refinement, billions of devices	Early era (NISQ) — powerful but noisy prototypes

Watch them race

Interactive · The search race (works offline)

A prize is hidden in one of 16 boxes. The classical computer must open boxes one at a time. The quantum computer holds all 16 in superposition, then uses interference waves (≈√16 = 4 of them) to make the prize box stand out. Race them!

The prize has been hidden. Choose a computer.

The partnership, not a war The future is hybrid: a classical computer handles the everyday work and sends only the hard quantum-friendly piece to a quantum processor — exactly as your laptop today sends heavy graphics work to a GPU. Remember this; it returns on Page 10, because quantum machine learning is built exactly this way.

Check yourself · 1

Which task should remain on a classical computer even when quantum computers mature?

Simulating a new drug molecule Typing documents and browsing the web Factoring enormous numbers Optimising a nationwide delivery network

✔ Everyday tasks (documents, web, video) are already handled perfectly and cheaply by classical machines. Quantum computers are specialists for simulation, optimisation and certain mathematics — not replacements.

Check yourself · 2

Same quantum circuit, run twice, gives different outputs. Is the computer faulty?

Yes — a computer must always give the same answer Not necessarily — quantum results are probabilistic; we run many shots and study the histogram Yes — someone should reboot it Quantum computers never give outputs

✔ Probabilistic output is normal quantum behaviour (each measurement collapses the superposition randomly according to the blend). The information lives in the distribution over many shots — the histogram practical in Part B.

Topic 8

Application Areas of Quantum Computing

Where will all this power actually be used? Six big areas — each with a picture you can hold, and a Nigerian angle where it fits naturally.

💊 1. Drug discovery & chemistry

Molecules are quantum systems — simulating them is exactly what Feynman said quantum computers were born for. Instead of years of trial-and-error in the lab, researchers could test candidate drugs inside the computer first.

Picture: designing a new malaria or sickle-cell drug by simulating how the molecule binds — before a single test tube is opened.

🔐 2. Cryptography & security

Two sides of one coin: Shor's algorithm will one day break today's RSA encryption — so banks and governments are already migrating to post-quantum cryptography. Meanwhile, quantum physics itself gives quantum key distribution: communication where eavesdropping is physically detectable (thanks to no-cloning, Page 5).

Picture: every bank's security team, including Nigerian banks, planning their "quantum-safe" migration.

🚚 3. Optimisation & logistics

Best routes for hundreds of delivery vans in Lagos traffic; optimal scheduling of flights; smartest arrangement of a national power grid. These problems explode combinatorially — perfect targets for quantum optimisation (and today, for D-Wave-style annealers).

💰 4. Finance

Portfolio optimisation (best mix of investments under risk limits), fraud detection, and option pricing via quantum-accelerated simulations. Banks like JPMorgan and Goldman Sachs run active quantum research teams today.

🤖 5. Machine learning & AI

Quantum computers may speed up the heavy linear algebra inside machine learning, and quantum models can explore patterns in data differently from classical ones. This is our destination topic — fully opened on Page 10.

🧪 6. Materials & energy

Designing better batteries, superconductors, and fertilizers. One famous target: nitrogen fixation — nature makes fertilizer at room temperature while our factories (Haber process) burn ~1–2% of the world's energy. Simulating the responsible enzyme could transform agriculture — a direct African food-security interest.

Make it yours — match the problem to its quantum answer

Interactive · Nigerian problems, quantum application areas (works offline)

Tap a real problem on the left, then the application area that would attack it on the right.

How close is each application?

Application	Status today	Rough horizon
Optimisation (annealers, hybrid)	Pilot projects running now	Now → near term
Quantum machine learning	Active research, small demos (Qiskit!)	Near → mid term
Chemistry & drug simulation	Small molecules demonstrated	Mid term
Finance models	Bank research teams, prototypes	Mid term
Breaking RSA (Shor at scale)	Needs millions of error-corrected qubits	Long term — but defences must start now

Why Nigerian students should care now The hardware race may be abroad, but the software, algorithms, and applications are open to everyone with a laptop — Qiskit is free, and IBM's machines are on the cloud. The nations that benefited most from classical computing were not only those who built chips, but those who built software and solutions. Quantum is at that same early doorway today, and this classroom is standing in it.

☕ Pause & Think · Class discussion

Shor's algorithm can one day break the encryption protecting every bank. Should such research have been published at all?

The same discovery funds cancer-drug simulation and threatens your account balance. This is the dual-use dilemma, and it is as old as fire — the knife that cooks dinner can also wound. Peter Shor published openly in 1994. Because he did, the world got a thirty-year head start on building quantum-proof locks. Would secrecy have been safer — or more dangerous?

The case for openness: cryptographers argue security through secrecy always fails — someone else discovers the weakness quietly and exploits it. Publishing Shor's algorithm is why post-quantum cryptography standards already exist before the machines that threaten us do.

The sobering precedent: the physicists of the 1940s watched their beautiful equations become weapons, and many spent the rest of their lives on the ethics of it. Science does not get to choose how it is used — but scientists get to speak about it.

The African angle: nations that understand a technology shape its rules; nations that ignore it receive the rules. A Nigerian computer scientist fluent in post-quantum security is not a luxury — she is national infrastructure.

Debate format for class: split into two benches — "publish openly" vs "restrict" — then swap sides halfway. Arguing the side you disagree with is where the deepest learning happens.

Check yourself · 1

Which application was quantum computing literally invented for (Feynman, 1981)?

Playing chess Simulating nature — molecules and quantum systems Sending emails securely Mining cryptocurrency

✔ Feynman's founding argument: quantum systems (like molecules) are impossibly expensive for classical computers to simulate — so simulate them with a quantum machine. Chemistry and materials remain the most natural application.

Check yourself · 2

Breaking RSA encryption with Shor's algorithm needs machines far bigger than today's. Why are banks acting already?

Data stolen today can be stored and decrypted years later when machines mature ("harvest now, decrypt later") Banks simply enjoy spending money Quantum computers already broke RSA in 2019 There is no real reason

✔ Encrypted data intercepted today can sit in storage until quantum machines can crack it. Anything that must stay secret for 10+ years needs quantum-safe protection now — which is why post-quantum cryptography migration has already begun worldwide.

Topic 9

The Architecture of a Quantum Computer

What is actually inside those golden "chandelier" machines you see in photos? Let us open one up, layer by layer — from a computer-science point of view.

The golden chandelier, explained

That famous golden structure is not the computer — it is mostly the fridge (a dilution refrigerator). Each layer downward is colder, and the actual quantum chip — about the size of a thumbnail — sits at the very bottom at ≈ 0.015 K, colder than outer space. 👉 Click each layer below.

Interactive · Inside the machine (click the layers)

The five layers every computer scientist should name

Just as a classical computer has layers (transistor → logic gate → CPU → operating system → application), a quantum computer has a clean layered architecture:

#	Layer	What it is	Classical cousin
1	Physical layer	The qubits themselves + the fridge, lasers, shielding keeping them alive	Transistors on silicon
2	Control layer	Classical electronics firing precise microwave/laser pulses — each pulse is a quantum gate	Clock + control circuitry
3	Gate / circuit layer	Sequences of quantum gates (H, X, CNOT…) arranged into circuits — the quantum "program"	Logic gates → machine code
4	Software layer	Languages & compilers: Qiskit (IBM, Python), Cirq (Google), Q# (Microsoft). Translates your code into pulse schedules	OS, compilers, Python
5	Application layer	The actual algorithms: Shor, Grover, chemistry simulation, quantum machine learning	Apps: Word, browsers, ML models

Where our course lives Our practicals (Part B) live in layers 3, 4 and 5: we design circuits, write them in Qiskit (Python), and build quantum machine learning applications. Layers 1 and 2 belong to physicists and hardware engineers — we only need to understand them, not build them. Exactly as a web developer understands but does not manufacture CPUs.

One job's journey through the machine

Check yourself · 1

In the famous photos, the golden "chandelier" structure is mostly…

The quantum processor itself The cooling system (dilution refrigerator) — the chip is a thumbnail-sized device at the very bottom Decoration for visitors The power generator

✔ The chandelier is the fridge. Each golden plate is a colder stage, ending near 0.015 K where the small chip lives. Great exam distinction: the computer is tiny; the life-support is enormous.

Check yourself · 2

A student writes Qiskit code in Python. Which architecture layers will she work in during our practicals?

Layer 1 — she must build qubits in the lab first Layers 3–5: circuits, software, and applications — the hardware is reached via the cloud Layer 2 only — wiring microwave electronics None — Python cannot talk to quantum computers

✔ Our work is circuits (layer 3), Qiskit software (layer 4), and QML applications (layer 5). The cloud carries our circuits to IBM's physical machine and returns the histogram — the exact workflow of Part B.

Topic 10 · The destination

Quantum and Machine Learning

The two biggest ideas in modern computing, joined. This page bridges everything you have learned into the first topic of the practical course.

First, machine learning in one minute

Machine learning (ML) is teaching a computer by examples instead of by rules. You do not write "if the fruit is yellow and curved, it is a banana" — you show the computer 1,000 photos of bananas and oranges, and it works out the pattern by itself.

1 · Data

Examples with answers: photos labelled "banana"/"orange", past house prices, past exam scores.

2 · Model

A flexible mathematical machine with adjustable knobs (parameters/weights). A neural network is the most famous model.

3 · Training

Show the data, measure the mistakes (loss), nudge the knobs to reduce mistakes, repeat thousands of times. The nudging recipe is backpropagation + gradient descent.

Interactive · Watch a machine "learn"

This tiny model must learn to separate ■ oranges from ■ bananas by moving a dividing line. Press Train and watch the mistakes (loss) fall step by step — this is the heart of all machine learning.

Now — why bring quantum into it?

Machine learning is, under the bonnet, mountains of linear algebra — multiplying huge grids of numbers (vectors and matrices). And here is the beautiful coincidence:

The deep connection A quantum computer's natural language is linear algebra. The state of n qubits is a vector in a 2ⁿ-dimensional space, and every quantum gate is a matrix multiplying it. So a quantum computer performs certain enormous linear-algebra operations natively, in physics, in one step — operations a classical computer must grind through number by number.

Quantum Machine Learning (QML) — the idea

QML uses quantum computers to do part of the machine-learning work. Today's standard recipe is the hybrid loop — remember the classical–quantum partnership from Page 7:

The dictionary: every ML idea has a quantum twin

Classical ML concept	Quantum twin	Where you'll meet it in Part B
Input features (numbers)	Data encoding — rotating qubits by angles that represent the data	Quantum circuits practical
Neural network layers	Parameterised quantum circuit — gates with adjustable rotation angles θ	Quantum neural network in Python
Weights / parameters	The rotation angles θ	QNN practical
Prediction (output)	Measurement statistics (the histogram!)	Plotting histogram practical
Backpropagation	Parameter-shift rule — run the circuit at shifted angles to find the gradient	Backpropagation practical
Training loop	The hybrid loop in the diagram above	ML algorithms for QC practical
Randomness in data	Quantum probability — e.g., a Hadamard gate = a perfect coin toss	Qiskit coin-tossing practical

Look at that table again Every practical topic in the course outline — quantum neural networks, backpropagation, quantum circuits, ML algorithms, histograms, Qiskit coin tossing — appears in the right-hand columns. Part A has quietly prepared you for every single one. The coin you spun on Page 1 is the Hadamard gate you will program in Part B.

Honest expectations (important for a teacher)

QML is young. Today's quantum computers are small and noisy; QML has not yet beaten classical ML on big real-world problems. We teach it because the field is being built right now — and our students can be builders, not just users.
The skills transfer. Learning QML forces mastery of linear algebra, probability, Python and ML fundamentals — valuable even outside quantum.
Everything we need is free: Python, Qiskit, and IBM's cloud machines.
One quiet trend to keep in your pocket: the field is drifting toward teams of small models working together — like a committee of wise elders — rather than one giant brain. Hold that picture loosely; it will grow on its own as the course continues.

☕ Pause & Think · Class discussion

When a machine "learns", is it really learning — or only calculating? And is there a difference?

Machine learning borrowed a human word — learning — for a mathematical process of adjusting numbers. The model that recognises a banana has never tasted one, never peeled one, never shared one with a friend. Does it know what a banana is? Now be careful before you laugh — someone may ask the same of a student who memorises definitions for an exam without ever using them. What, truly, is the difference between knowing and performing?

Alan Turing (1950) proposed a practical test: if a machine's answers are indistinguishable from a human's, what grounds remain for denying it thinks? Judge the behaviour, he suggested, since we cannot open the mind.

John Searle (1980) answered with the famous Chinese Room: a man in a room follows rule-books to answer notes in perfect Chinese — without understanding one word. Flawless performance, zero understanding. Searle says all programs are that man.

The teacher's mirror: this ancient debate is also a theory of education. If performance without understanding is not learning for machines, it is not learning for students either — which is exactly why this course makes you build, predict and argue, not just memorise.

Ask the class: how would you PROVE to someone that you understand something, beyond passing a test on it? Their answers will quietly describe good science.

Check yourself · 1

In hybrid quantum machine learning, what job does the QUANTUM computer do?

It stores the whole dataset forever It runs the parameterised circuit (the model) and returns measurement results It replaces the classical computer completely It draws the graphs

✔ The quantum processor is the model: encode data → run circuit U(θ) → measure. The classical computer keeps the data, computes the loss and updates θ. Partnership, not replacement.

Check yourself · 2

Why is a quantum computer naturally suited to machine learning mathematics?

Because it is newer, and newer is always better Because ML is built on linear algebra, and quantum states/gates ARE vectors and matrices — the operations happen natively in physics Because qubits are cheaper than GPUs Because quantum computers have more RAM

✔ The deep connection: n qubits live in a 2ⁿ-dimensional vector space and every gate is a matrix operation. The heavy linear algebra of ML is the quantum computer's mother tongue.

Check yourself · 3

The "Qiskit probability — tossing of a coin" practical connects to which Part A idea?

Superposition — a Hadamard gate puts a qubit in a 50/50 blend, a perfect quantum coin toss The cooling system of the fridge The history of D-Wave Nothing — it is unrelated

✔ The spinning coin from Page 1 becomes real code: one Hadamard gate + one measurement = a true quantum coin toss, and 1,000 shots give the histogram. Theory and practice meet exactly here.

Revision

Final Revision Quiz

Ten questions covering the whole of Part A. Answer all, then check your score at the bottom. Suitable as a class test template.

Question 1

The basic unit of quantum information is the…

BitQubitBytePhoton only

✔ The qubit — which can be made from many physical things (circuits, ions, photons), but mathematically is always the same object.

Question 2

Superposition means a qubit…

Is brokenExists in a blend of |0⟩ and |1⟩ until measuredIs stacked on top of another qubitStores two full numbers permanently

✔ The spinning coin: a weighted blend of both states at once, collapsing to one answer on measurement.

Question 3

n qubits in superposition can represent how many possibilities simultaneously?

n2n2ⁿn²

✔ 2ⁿ — doubling with every qubit. 10 qubits → 1,024; 50 qubits → over a quadrillion.

Question 4

Who proposed quantum computing in 1981–82, and whose 1994 algorithm made the world take notice?

Feynman proposed it; Shor's factoring algorithm raised the alarmShor proposed it; Feynman factored numbersTuring proposed it; Gates commercialised itDeutsch proposed it; Grover built IBM

✔ Feynman (1981–82, after Benioff) → Deutsch (1985, formal model) → Shor (1994, factoring threatens RSA) → Grover (1996, fast search).

Question 5

IBM's and Google's qubits are built from…

Trapped ions controlled by lasersSuperconducting circuits cooled near absolute zeroParticles of light at room temperatureOrdinary silicon transistors

✔ Superconducting circuits at ≈ −273 °C. Trapped ions = IonQ/Quantinuum; photons = Xanadu/PsiQuantum; annealers = D-Wave.

Question 6

Entanglement is best described as…

Two qubits physically tied with wireQubits sharing one state, so measuring one instantly determines its partner's correlated resultA way to send WhatsApp messages faster than lightA software bug

✔ A shared state with guaranteed correlation — "spooky action at a distance" — but no faster-than-light messaging, since each individual outcome is random.

Question 7

Reading (measuring) a qubit…

Can be repeated harmlessly like reading RAMCollapses the superposition to a definite 0 or 1 — you get one chanceDoubles the qubitCools the chip

✔ Measurement collapses the state — hence many "shots" and histograms, and hence no-cloning makes quantum cryptography possible.

Question 8

Which is NOT a leading application area of quantum computing?

Simulating molecules for drug discoveryOptimising delivery routes and schedulesMaking Microsoft Word open fasterPost-quantum cryptography and security

✔ Quantum computers are specialists — everyday tasks like opening Word stay with classical machines forever (and that's fine).

Question 9

In the five-layer architecture, Qiskit (Python) lives in the…

Physical layer (the fridge)Control layer (microwave electronics)Software layer — translating circuits into instructions for the machineNowhere; Qiskit is hardware

✔ Physical → Control → Circuit → Software (Qiskit) → Application. Our course works in layers 3–5 via the cloud.

Question 10

In hybrid quantum machine learning, the quantum computer plays the role of the…

Dataset storageModel — a parameterised circuit whose measured outputs are the predictionsGraph plotterInternet connection

✔ Quantum = the model (encode → circuit U(θ) → measure). Classical = data, loss, and knob-updating. The loop between them is the whole of Part B.

Your score

0 / 10

Answer the questions above — your score updates automatically.

☕ Pause & Think · The closing question

The computing revolution made some nations rich twice — once for building chips, once for building software. Quantum is at that same doorway. Where should Africa stand?

The fridges and chips may be built abroad — but Qiskit is free, the cloud is open, and the algorithms are unwritten. The nations that won the internet era were not only the chip-makers: they were the ones whose young people built solutions. You, reading this in Nigeria, have the same access to IBM's quantum computers as a student in New York — this very material proves it. So the honest question is not "can we participate?" It is: what will you build?

The leapfrog lesson: Africa largely skipped landlines and jumped straight to mobile — and built M-Pesa, mobile banking the West later copied. Technologies in their early days reward newcomers who solve their own problems with them.

Feynman's blackboard (1988): at his death, his blackboard read "What I cannot create, I do not understand." Creation is the deepest test of knowledge — and the invitation of this entire course.

Dr. Ophori's classroom principle: the human is the author; the computer is the pen. Quantum computers will be the most powerful pens ever made — and pens do not choose what gets written.

Close the class with this: each student writes one sentence — "If I had a quantum computer, the Nigerian problem I would point it at is ______." Collect them. That page is a research agenda.

What comes next — Part B With Part A complete, the class is ready for the practical series: 1. Quantum & machine learning (deepened) · 2. Implementing a quantum neural network in Python · 3. Backpropagation · 4. Quantum circuits · 5. ML algorithms for quantum computing · 6. Plotting histograms · 7. Qiskit probability — tossing of a coin. Every one of them plugs directly into a concept from this material.

Part B · Practical Course

Practical Quantum Computing & Machine Learning

Nine hands-on labs. Everything you need is inside this one page — the Python engine, the quantum simulator, the exercises. No VS Code. No Jupyter. A phone with Chrome is enough to follow along.

Before you start Part A (the introduction material) explained what qubits, superposition, entanglement and the hybrid quantum–ML loop are. Part B is where we touch them with our hands. If any concept feels foggy, revisit its Part A page — every lab tells you which one.

Step 1 — Install the Python engine (one click)

This page carries a complete Python scientific engine that runs inside your browser. Click the button once; it downloads the engine (about 10 MB, one time only — afterwards your browser remembers it). Then every lab's code runs live, right here.

⚙️ Quantum Lab Engine

Engine not installed yet. The visual demos in every lab work WITHOUT it — the engine is for running real Python code. If you are on a slow connection, you can do the whole course with the visual demos first and install the engine later.

No internet? No problem Every single lab also contains visual simulators built directly into this page (no download needed at all). The Python engine is the icing — the cake works offline.

Step 2 — Know the toolbox (names you will hear in industry)

Tool	What it is	In this course
Python	The programming language of science and ML	Embedded in this page — runs live
Qiskit	IBM's open-source quantum library for Python	We use a built-in mini version with the same commands; full Qiskit code is given for the real machine
Simulator	Classical software that imitates a small quantum computer perfectly	Built into this page (up to 8 qubits)
IBM Quantum cloud	Free access to real quantum hardware	Optional final step — the same code runs there
Jupyter / VS Code	Traditional tools for writing Python	Not required — but your skills transfer there directly

Step 3 — The syllabus map

The official course outline, and the lab where each topic is treated:

Official outline topic	Covered in
Simple quantum program · quantum vs classical environment	Lab 1 (orientation, as taught by Dr. Ophori)
Quantum circuits	Lab 2
Qiskit probability — tossing of a coin	Lab 3
Plotting histogram	Lab 4
Quantum and machine learning	Lab 5
Backpropagation	Lab 6 (with toggleable techniques)
Implement quantum neural network in Python	Lab 7
Machine learning algorithms for quantum computing	Lab 8
Machine learning example with Python	Labs 5–7 + Capstone

The order is slightly rearranged from the outline so each lab stands on the one before it — the standard sequence used by IBM's own Qiskit textbook: circuits before histograms, histograms before ML, ML before quantum neural networks.

Warm-up check

What do you need installed on your computer or phone before starting these labs?

VS Code, Jupyter, Anaconda and Qiskit Nothing — everything is embedded in this page; the Python engine installs itself with one click A quantum computer Windows 11 only

✔ The whole lab lives in this page. Visual simulators need nothing; live Python needs one click. (And nobody needs their own quantum computer — even IBM's engineers use simulators daily.)

Lab 1 · Orientation

Your First Quantum Program

Exactly as done on the first day in a real laboratory: meet the environment, run one classical program, run one quantum program, and see the difference with your own eyes.

1.1 — The classical program (the world you know)

In classical Python, a bit is just a variable. It is 0 or 1 — decided the moment you write it, the same every time you run it.

🐍 classical_bit.py

Press ▶ Run (install the engine on Page 0 first).

1.2 — The quantum program (the new world)

Now the same idea, written for a quantum computer. We take one qubit, apply a Hadamard gate (h) — the instruction that "spins the coin" into superposition — and measure it. Watch what happens when we run it several times:

⚛️ quantum_bit.py — uses Qiskit-style commands

Press ▶ Run — then press it AGAIN and compare. The results change!

Stop and look at what just happened The classical program prints the same answer forever. The quantum program gives a different random answer each run — because until measurement, the qubit was genuinely 0-and-1 at once (the spinning coin from Part A, Page 1). You have just witnessed superposition and collapse in code.

1.2b — The three faces of one qubit (a lecturer's question, answered in code)

❓ The question "Materials say a qubit has three states — quantum state 0, quantum state 1, and superposition. If the qubit is in 'quantum state 1', what exactly will the computer print?" — Let the machine itself answer. The program below prepares a qubit in each of the three textbook states and measures each one 100 times.

⚛️ three_states.py — |0⟩, |1⟩ and superposition, measured

Press ▶ Run — the three textbook states, each answering for itself.

The sentence to keep "Quantum state |1⟩" does not mean the qubit is spinning — it means the coin is lying flat, heads up. Measured, it prints 1 every single time: {'1': 100}. It remains a quantum object (one H gate would set it spinning again), but at this moment it is resting at a pole. The "three states" of the textbooks = two resting poles + the spin between them.

1.3 — The two programs, side by side

	Classical program	Quantum program
The unit	`bit = 0` — a definite value	`QuantumCircuit(1)` — a qubit starting at \|0⟩
The operation	Assignments, arithmetic (`bit = 1`)	Gates (`qc.h(0)`, `qc.x(0)`…) that rotate the state
Reading it	`print(bit)` — harmless, repeatable	`measure` — collapses superposition; one chance
Result	Deterministic — same every run	Probabilistic — a distribution over many runs
Where it runs	Your CPU directly	A simulator here; a real IBM machine via the cloud

1.4 — Watch the two programs RUN (animated, no engine needed)

Here is the same comparison as a moving picture. Watch the dot travel through each program. In the classical lane it follows one road. In the quantum lane, the H gate splits it into two ghost-paths at once — and the measure box forces one ghost to become real.

Interactive · The program journey

Press a button — run each program several times and compare the endings.

The same experiment, as a still picture

Press each button several times. The classical bit never changes. The quantum bit is re-spun and re-measured each time.

classical bit

quantum qubit

1.5 — Running on the REAL IBM quantum computer (the full industry path)

Everything in this course runs on simulators — perfect for learning. But the same code can run on IBM's actual quantum hardware, free, from Nigeria. This follows IBM's own official course flow. Three stages:

Stage 1 — One-time setup (10 minutes, needs internet)

Create a free account at quantum.ibm.com (IBM Quantum Platform).
Copy your API token from the dashboard (your personal key — keep it private like a password).
On any computer with Python: pip install qiskit qiskit-aer qiskit-ibm-runtime

Stage 2 — The simulator version (what you learned, in full Qiskit)

# Same logic as our labs — industry Qiskit, perfect noiseless simulator
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

qc = QuantumCircuit(1)
qc.h(0)
qc.measure_all()
qc.draw("mpl")   # draws the circuit as a picture — wires and gates, like Lab 2's builder

result = AerSimulator().run(qc, shots=1000).result()
print(result.get_counts())

Stage 3 — The real machine (the goosebumps moment)

# Runs on actual quantum hardware in IBM's lab — same circuit!
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

service = QiskitRuntimeService(channel="ibm_quantum_platform", token="YOUR_TOKEN")
backend = service.least_busy(operational=True)      # pick the shortest queue
print("Running on:", backend.name)

# TRANSPILE: translate our circuit into the exact gate-language of that chip
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
qc_ready = pm.run(qc)

job = Sampler(backend).run([qc_ready], shots=1000)
print(job.result()[0].data.meas.get_counts())

🈯 What is "transpiling"?

Each real chip only speaks its own small dialect of gates, and its qubits are wired to specific neighbours. The transpiler is a translator: it rewrites your circuit into that chip's dialect and layout — like translating a lesson from English into Yoruba before teaching it in a Yoruba-speaking class. Same meaning, local language.

⏳ What to expect from the real machine

A queue — your job waits in line behind researchers worldwide (seconds to hours; least_busy picks the shortest line). And noise — unlike our perfect simulator, a few percent of shots will land on "impossible" outcomes. Seeing that noise with your own eyes is the lesson: you are touching real, imperfect, genuine quantum hardware.

Lab 1 check · 3

Before a circuit runs on real IBM hardware, it must be "transpiled". What does that mean?

Compressed into a ZIP file to upload faster Translated into the specific gate-dialect and qubit-wiring of that particular chip Converted from Python to English Encrypted so nobody can steal it

✔ Transpiling = translating your ideal circuit into the chip's own gate set and layout, like translating a lesson into the local language before class. The simulator skips this because it speaks every dialect.

Lab 1 check · 4

Your Bell-state histogram from the REAL machine shows 00: 478, 11: 489, 01: 18, 10: 15 — but the simulator gave only 00 and 11. Which statement is right?

The real machine is broken and should be reported to IBM This is normal hardware noise — the entanglement signal (00/11) is clearly visible above the small noise bars Your code has a bug that only appears on Tuesdays Entanglement doesn't exist on real machines

✔ Real qubits are noisy (Part A, Page 5): a few percent of shots misfire. Signal 97%, noise 3% — a successful real-hardware run. Learning to see signal through noise is a professional skill.

☕ Pause & Think · Class discussion

You just watched the dice roll. Einstein insisted "God does not play dice" — your own program suggests otherwise. Who do you side with?

Take a breath and notice what happened on this page: the classical program obeyed you completely; the quantum program kept its own counsel until measured. Einstein believed the randomness must be hiding a deeper, deterministic story we have not found yet. Decades of experiments (Nobel Prize 2022) say no — the randomness is genuine, physics at its very floor. You have now run that randomness with your own hand. Does it change how you see the question?

Einstein's hope: hidden variables — the qubit "knew" its answer all along, like a tossed coin whose landing is already determined by physics too fast to see.

Bell & the experimenters: designed and ran tests that hidden variables could never pass. Nature failed the hidden-variable test — the undecidedness is real.

The question students always raise next: if nature is random at the bottom, what happens to fate and free will? Philosophers genuinely disagree — some say randomness rescues freedom, others say random is no more "free" than determined. There is no examiner's answer; there is only good thinking.

Let the class debate for five minutes, then return to the keyboard. Great scientists hold the philosophy in one hand and the working code in the other.

Lab 1 check · 1

The classical program prints 0 every time. Why does the quantum program's answer keep changing?

The simulator is buggy The Hadamard gate put the qubit in superposition, and each measurement randomly collapses it to 0 or 1 Python generates random numbers for fun The qubit is broken and needs cooling

✔ qc.h(0) creates a 50/50 superposition; measure collapses it. Different runs → independent collapses → different answers. This is physics, not a bug.

Lab 1 check · 2

Which line of the quantum program "spins the coin"?

qc = QuantumCircuit(1) qc.h(0) — the Hadamard gate qc.measure_all() print(...)

✔ QuantumCircuit(1) gives a qubit resting at |0⟩. h(0) rotates it to the equator of the Bloch sphere — the 50/50 blend. measure_all() is the slap that collapses it.

Lab 2

Quantum Circuits

A quantum program is a circuit: qubits drawn as horizontal wires, gates placed along them left to right, measurements at the end. Learn the four gates that carry 90% of this course.

2.1 — The gate vocabulary

H — Hadamard

The coin spinner. Sends |0⟩ to a perfect 50/50 superposition. The starting move of almost every quantum algorithm.

X — NOT gate

The flipper. Swaps |0⟩ ↔ |1⟩. Exactly the classical NOT — proof that quantum computers contain classical computing inside them.

Z — Phase flip

The invisible twist. Leaves |0⟩ alone, puts a minus sign on |1⟩. Invisible to a single measurement but crucial for interference — it is how wrong answers get cancelled.

● CNOT (CX)

The entangler. Two qubits: flips the target only if the control is 1. H + CNOT together create the entangled twin coins of Part A Page 6.

2.2 — Build circuits with your fingers

Interactive circuit builder (works offline)

1) Tap a gate in the palette. 2) Tap a slot on a wire to place it (for CNOT: tap control slot, then target slot in the same column). The chart shows the measurement results of 1,000 shots, updating live.

How to read a result: read each bitstring right-to-left — the rightmost digit is q0, the next is q1, then q2. So 01 means q0 gave 1 and q1 gave 0. (This right-to-left convention is IBM Qiskit's standard too.)

Palette: tap H, then tap a slot on wire q0.

2.3 — Three classic circuits to reproduce

The coin: H on q0 → histogram shows ~50% 0, ~50% 1.
The certain flip: X on q0 → 100% 1. Deterministic — gates are not always random!
The Bell state (entanglement!): H on q0, then CNOT (control q0, target q1) → only 00 and 11 appear, ~50% each. 01 and 10 never occur: the qubits always agree. You have just built the twin coins.

2.4 — The same circuits in code

⚛️ bell_state.py — create entanglement

Press ▶ Run.

Reading a result like a pro {'00': 503, '11': 497} means: out of 1,000 shots, 503 times both qubits gave 0, 497 times both gave 1 — and no shot ever disagreed. On a real machine you would also see a few 01/10 counts: that is noise, today's great engineering battle (Part A, Page 5).

☕ Pause & Think · Class discussion

You just built entanglement with two taps. Einstein wrestled with it for twenty years. Does building something mean you understand it?

Feel the strangeness of this moment: a mystery that troubled the greatest physicist of the 20th century now sits on your phone screen, built by your own fingers in two gates. But be honest with yourself — can you explain why the coins always agree, or did you only follow the recipe? Both are respectable places to stand. The question is which one you are standing in.

Richard Feynman's blackboard, left at his death in 1988: "What I cannot create, I do not understand." For Feynman, building was the royal road to understanding — which is the entire philosophy of these labs.

The counter-view: a child can strike a match without understanding combustion; billions use phones without understanding radio. Creation from a recipe is not yet understanding — understanding begins when you can predict what happens if you change the recipe.

The resolution this course takes: build first, then break. That is why every lab asks you to change a number, re-run, and predict before you look. Prediction is where recipe-following becomes understanding.

Challenge for the class right now: BEFORE trying it, predict what the histogram shows if you put the H gate on q1 instead of q0, keeping CNOT from q0 to q1. Write the prediction down — then build it above and check. That feeling of being right (or wrong!) is understanding being born.

2.5 — The third power, finally in your hands: INTERFERENCE

Part A's technical definition promised three powers: superposition (you ran it — H gate), entanglement (you ran it — the Bell state), and interference… which until now you only read about. Time to close that gap — because interference is where quantum computing's speed actually comes from.

Step 1 — Interference made visible in two gates

Common sense says: spin the coin twice and it is doubly random. Watch what actually happens:

⚛️ interference.py — randomness that cancels itself

Press ▶ Run — and watch randomness annihilate itself.

Step 2 — Your first true quantum ALGORITHM: Deutsch's (1985)

Now use that engine to beat a classical computer, provably, with your own hands. The game: a sealed machine flips coins by a hidden rule. The rule is either CONSTANT (it gives the same answer no matter what you feed it) or BALANCED (its answer depends on the input). Classically you must try both inputs — two questions, no shortcut exists. Quantumly: feed it a superposition of both inputs at once, let interference recombine the two answers, and read the verdict in one question.

⚛️ deutsch.py — one question where classical needs two

from microqiskit import QuantumCircuit, simulate

def deutsch(hidden_rule):
    """Ask the sealed machine ONE quantum question. Return its verdict."""
    qc = QuantumCircuit(2)
    qc.x(1); qc.h(1)          # prepare the 'answer' qubit in the |-> state
    qc.h(0)                   # SUPERPOSITION: ask both inputs at once
    # --- the sealed machine (the 'oracle') ---
    if hidden_rule == "constant_same":
        pass                  # always answers 0: touches nothing
    elif hidden_rule == "constant_flip":
        qc.x(1)               # always answers 1: flips regardless of input
    elif hidden_rule == "balanced":
        qc.cx(0, 1)           # answer DEPENDS on the input
    # ------------------------------------------
    qc.h(0)                   # INTERFERENCE: recombine the two answers
    qc.measure_all()
    counts = simulate(qc, shots=200)
    ones = sum(v for k, v in counts.items() if k[-1] == "1")  # read q0 (rightmost)
    return "BALANCED" if ones > 100 else "CONSTANT"

print("Classical rule: 2 questions ALWAYS needed. Quantum: watch...")
print()
for rule in ["constant_same", "constant_flip", "balanced"]:
    print(f"  hidden rule = {rule:13s} -> 1 question -> verdict: {deutsch(rule)}")
print()
print("Three machines identified, ONE question each - a provable quantum")
print("win, powered by interference. Scale this idea up and you get")
print("Deutsch-Jozsa, Grover's search, and Shor's factoring (Part A, p.3).")

Press ▶ Run — your first algorithm that provably beats classical computing.

The definition, now earned Part A, Page 2, Level 3 defined quantum computing as "computation using superposition, entanglement and interference to solve certain problems faster." As of this moment you have personally executed all three words of that definition — H (superposition, Lab 1), H+CNOT (entanglement, this lab), and Deutsch's algorithm (interference beating a classical bound, just now). You no longer quote the definition. You have run it.

Lab 2 check · 1

You place an X gate on a fresh qubit and measure 1,000 shots. What histogram do you expect?

~50% 0 and ~50% 1 100% of shots give 1 — X deterministically flips |0⟩ to |1⟩ 100% of shots give 0 No result — X gates crash

✔ X is the NOT gate: |0⟩ becomes |1⟩ with certainty. Not everything quantum is random — randomness only enters with superposition (H) and measurement.

Lab 2 check · 2

Which two-gate recipe creates the entangled Bell state?

X then Z on the same qubit H on the first qubit, then CNOT from it to the second Two H gates on the same qubit Measure twice quickly

✔ H creates superposition on the control; CNOT spreads it onto the target so the two qubits share one state. Result: only 00 and 11, perfectly correlated.

Lab 3 · Official outline: "Qiskit probability — tossing of a coin"

Tossing a Coin with Qiskit

The world's simplest quantum program — and secretly the world's only true random coin. Your phone's "random" is a formula pretending; a measured qubit is genuinely undecided until it lands.

3.1 — Why a qubit coin is special

🎲 Classical "random"

Computers use formulas (pseudo-random generators). With the starting seed, every "toss" can be predicted. Good enough for games — not for cryptography.

⚛️ Quantum random

The outcome of measuring a superposed qubit is not hidden anywhere — it does not exist before the measurement. Physics guarantees unpredictability. Companies sell quantum random-number generators for exactly this reason.

3.2 — One toss, then a thousand

⚛️ coin_toss.py

Press ▶ Run — run it a few times and watch the single toss change while the 1000-toss percentages stay near 50%.

3.3 — A biased coin (your first controlled quantum state)

H always gives 50/50. The RY gate rotates the qubit by any angle you choose — letting you build a coin with any bias. This exact skill — controlling probabilities with rotation angles — is the foundation of quantum machine learning in Labs 5–7.

⚛️ biased_coin.py

Press ▶ Run — then edit 0.80 to another probability and run again!

Visual twin · Design-a-coin (works offline)

Drag the angle θ and toss 1,000 times. You are doing exactly what ry(theta, 0) does.

3.4 — Loops: putting the quantum coin to work

Real programs wrap quantum circuits in ordinary Python loops — run, check, decide, repeat. Here is a playful but honest example: keep tossing the quantum coin until it gives 5 heads in a row, and count how long that takes. (On average it should take about 2⁵ = 32 extra tosses after each failure — watch!)

⚛️ streak_hunter.py — a quantum circuit inside a Python loop

Press ▶ Run several times — compare your numbers with your neighbour's.

Exercise for the class (loops + probability) Task: change the loop to hunt for 3 heads in a row, run it 5 times, and write down the counts. Then hunt for 7 in a row. Question to discuss: why does each extra head roughly double the waiting time? (Hint: Page 1 of Part A — the doubling machine — has been here all along.)

Lab 3 check · 1

What makes a quantum coin toss fundamentally different from Python's random.random()?

It is faster The quantum outcome genuinely does not exist until measurement — a formula-based "random" can be predicted from its seed It can only give heads There is no real difference

✔ Classical randomness is pseudo-random (deterministic formula + seed). Quantum randomness is guaranteed by physics — which is why it matters for security.

Lab 3 check · 2

To build a coin that lands heads 25% of the time, you should…

Use two H gates Use an RY rotation with the angle chosen so P(1) = 0.25 Measure only every fourth shot It is impossible — quantum coins are always fair

✔ RY(θ) tilts the Bloch-sphere arrow to any angle → any probability. θ = 2·asin(√0.25) = 60°. Controlling probabilities via rotation angles is the exact mechanism quantum ML models use to learn.

Lab 4 · Official outline: "Plotting histogram"

Plotting Histograms

The histogram is the face of every quantum result. A quantum computer never hands you "the answer" — it hands you counts, and the histogram is how you read them.

4.1 — Anatomy of a quantum histogram

This is a Bell-state run on a real IBM machine: the tall 00/11 bars are the entanglement signal; the tiny 01/10 bars are hardware noise. Reading signal-vs-noise from a histogram is a core professional skill.

4.2 — Plot your own, in code

⚛️ histogram.py — counts → picture

Press ▶ Run.

In full Qiskit, the same picture is one line: plot_histogram(counts). Keep this for the real machine:

from qiskit.visualization import plot_histogram
plot_histogram(counts)   # the official Qiskit chart, same bars you drew above

4.3 — Histogram detective game

Interactive · Guess the circuit from its histogram (works offline)

A mystery circuit was run 1,000 times. Study the histogram and deduce which circuit produced it. Science works exactly this way — evidence first, conclusion after.

Lab 4 check

A histogram from a real quantum machine shows bars 00: 480, 11: 490, 01: 15, 10: 15. The best interpretation is…

The circuit produces all four outcomes equally A Bell state (entanglement) measured on noisy hardware — 00/11 is the signal, 01/10 is noise The machine is completely broken Histograms cannot be interpreted

✔ Perfect entanglement would give ONLY 00 and 11; the small 01/10 bars (~3%) are hardware noise. Distinguishing signal from noise is exactly what quantum engineers do every day.

Lab 5 · Official outline: "Quantum and machine learning" + "ML example with Python"

Quantum & Machine Learning — Hands On

Part A, Page 10 gave you the map. Now we walk the road: train a real machine-learning model in Python, then see precisely where a quantum computer plugs into the loop.

5.1 — Machine learning in 20 lines of real Python

A model that learns to convert Celsius to Fahrenheit from examples only — it is never told the formula. This is the entire soul of ML in one small program:

🐍 learn_temperature.py — a complete ML training loop

# The model: fahrenheit = w * celsius + b
# It must DISCOVER w and b from examples. (True answer: w=1.8, b=32)
celsius    = [0, 10, 20, 30, 40]
fahrenheit = [32, 50, 68, 86, 104]

w, b = 0.0, 0.0                      # start knowing NOTHING
lr = 0.001                           # learning rate (size of each nudge)

for step in range(8000):
    # 1. predict with current knobs
    preds = [w * c + b for c in celsius]
    # 2. measure the mistakes (loss) and the direction to nudge (gradient)
    #    (these formulas come from differentiating the squared error -
    #     take them on trust for now; Lab 6 explains gradients as "the slope")
    grad_w = sum(2 * (p - f) * c for p, f, c in zip(preds, fahrenheit, celsius)) / 5
    grad_b = sum(2 * (p - f)     for p, f    in zip(preds, fahrenheit)) / 5
    # 3. nudge the knobs downhill
    w -= lr * grad_w
    b -= lr * grad_b * 20   # x20 is a scaling trick for THIS problem only,
                            # because b (32) is far bigger than w (1.8) - not a general rule
    if step % 2000 == 0:
        loss = sum((p - f) ** 2 for p, f in zip(preds, fahrenheit)) / 5
        print(f"step {step:5d}  w={w:.3f}  b={b:.2f}  loss={loss:.1f}")

print()
print(f"LEARNED: F = {w:.2f} x C + {b:.1f}   (truth: F = 1.80 x C + 32)")
print("Test: 25 C ->", round(w * 25 + b, 1), "F  (truth: 77 F)")

Press ▶ Run — watch the loss fall and the formula emerge from nothing.

Name what you just saw — the universal ML loop 1. Predict with current parameters → 2. Measure mistakes (loss) → 3. Compute the nudge direction (gradient) → 4. Update parameters → repeat. Every ML system on Earth — from this 20-line script to ChatGPT — runs this identical loop. Memorise it; Labs 6 and 7 reuse it exactly.

5.2 — Where does quantum enter?

Look at the loop again. Steps 2, 3, 4 (loss, gradient, update) are bookkeeping — a classical computer does them happily. Step 1, the model itself, is where we substitute:

Everything else — the loop, the loss, the nudging — stays classical. That is the hybrid architecture, and it is how every serious quantum-ML system is built today (IBM's Qiskit Machine Learning, Google's TensorFlow Quantum, Xanadu's PennyLane).

5.3 — Encoding data into qubits (the bridge skill)

A quantum model needs the data inside the qubits. The standard trick is angle encoding — exactly the biased coin of Lab 3: a data value x becomes a rotation ry(x · π, 0). Big x → arrow near |1⟩; small x → near |0⟩.

One preparation step first: squeeze every data value into the range 0 to 1 before encoding — for example, divide each Celsius value by the largest one (40 °C → 40/40 = 1.0, 25 °C → 0.625). Angle encoding expects x between 0 and 1; this squeezing is called normalisation and you will do it in every quantum ML program, including Lab 7 and Part C.

⚛️ encode_data.py — put a number into a qubit

Press ▶ Run — see the data value smoothly control the qubit's behaviour.

☕ Pause & Think · Class discussion

The program just "discovered" F = 1.8C + 32 from examples alone. So — who is better: the machine that found it in seconds, or the human who wrote the loop?

This is Dr. Ophori's question from Part A, and now you can answer it with evidence from your own screen. Yes, the machine found the formula faster than any student would. But look again at the code: a human chose the examples, designed the loss, picked the learning rate, decided what "better" even means. The machine descended the hill — a human built the hill and pointed at the valley. Faster is not the same as better; the pen is not the author.

Ada Lovelace (1843): the machine does "whatever we know how to order it to perform." Every line of the training loop you just ran is such an order — written by a person.

Garry Kasparov, after losing to Deep Blue, championed "centaur chess" — human + machine teams that beat both grandmasters and supercomputers alone. His conclusion: the future belongs to those who partner with machines, not those who compete with them or surrender to them.

The uncomfortable modern twist: today's large AI models surprise even their builders. When a machine does something nobody explicitly ordered, is Lovelace's answer still enough? This question is genuinely open — your generation will answer it.

Re-run the class vote from Part A, Page 1 — "who is better?" — and count hands again. Minds that have changed (in either direction!) should say what changed them. That is education happening out loud.

Lab 5 check · 1

In the universal ML loop, which step does the quantum computer take over in hybrid QML?

Measuring the loss The model — producing predictions (via a circuit whose measurement statistics are the output) Updating the parameters Downloading the dataset

✔ Quantum replaces the model (step 1). Loss, gradients and updates stay classical. Loop unchanged — engine swapped.

Lab 5 check · 2

Angle encoding puts the data value x into a qubit by…

Typing x into the fridge's keyboard Rotating the qubit by an angle proportional to x, e.g. ry(x·π) Measuring the qubit x times Naming the qubit "x"

✔ ry(x·π, 0) — the data literally becomes geometry: the tilt of the Bloch-sphere arrow. The biased coin of Lab 3 was secretly your first data encoder.

Lab 6 · Official outline: "Backpropagation"

Backpropagation

The algorithm that teaches neural networks — explained as a hill walk in fog, then placed under your fingers with every technique toggleable.

6.1 — The fog-covered hill

Imagine standing on a hillside in thick fog, needing to reach the valley floor. You cannot see the valley — but you can feel the slope under your feet. Strategy: feel the slope, take a step downhill, repeat. In ML language:

Your position on the hill = the model's parameters (the knobs).
The height = the loss (total mistakes).
The slope under your feet = the gradient.
Backpropagation = the efficient bookkeeping method that computes that slope for every knob at once, by passing the error backwards through the network layer by layer (chain rule of calculus).
The step downhill = the parameter update; the step size = the learning rate.

Choose your level

This lab is taught in three depths. Start at Basic; each level stands on the one before. The lecturer can teach any level to any class — Basic suits 100-level, Advanced suits 400-level and research students.

🟢 Level 1 — The ball and the valley (no mathematics)

Forget formulas. Watch a ball released on a hillside: it rolls downhill, settles in the valley, done. That is ALL that training a neural network is — the ball is the model's settings, the height is "how wrong the model is", and the valley floor is the best possible model. Backpropagation is simply the way the ball feels which way is downhill.

Interactive · Release the ball (works offline)

The ball starts high on the hill (a bad, untrained model).

Level 1 vocabulary — just three words Loss = how high the ball is (how wrong the model is). Gradient = the slope under the ball (which way is downhill). Learning rate = the size of each roll. Say these three aloud and Level 1 is complete.

🔴 Level 3 — Under the bonnet: the chain rule, and backprop from scratch

Level 2 used the playground's built-in backpropagation. Level 3 removes the cover. The entire algorithm is one idea from calculus — the chain rule: if the loss depends on the output, and the output depends on a weight, then

The one formula ∂Loss/∂weight = ∂Loss/∂output × ∂output/∂weight
"How much does this weight matter?" = "how much the output matters to the loss" × "how much this weight matters to the output". For deep networks the chain just grows longer, multiplying link by link backwards from the loss — hence the name back-propagation. One backward pass computes the slope for every weight at once, which is why training is affordable at all.

🐍 backprop_from_scratch.py — the full algorithm, no libraries, 30 lines

import math

# A 2-neuron network learning XOR-ish data - every gradient written BY HAND.
# data: two inputs -> label
data = [((0,0),0), ((0,1),1), ((1,0),1), ((1,1),0)]

import random
random.seed(7)
W1 = [[random.uniform(-1,1) for _ in range(2)] for _ in range(2)]  # hidden weights
b1 = [0.0, 0.0]
W2 = [random.uniform(-1,1) for _ in range(2)]                      # output weights
b2 = 0.0
lr = 0.9
sig = lambda z: 1/(1+math.exp(-z))

for step in range(4000):
    total = 0
    for (x1,x2), y in data:
        # ---- FORWARD PASS ----
        h = [sig(W1[j][0]*x1 + W1[j][1]*x2 + b1[j]) for j in range(2)]
        o = sig(W2[0]*h[0] + W2[1]*h[1] + b2)
        total += (o-y)**2
        # ---- BACKWARD PASS (the chain rule, link by link) ----
        d_o = 2*(o-y) * o*(1-o)              # dLoss/d(output pre-activation)
        for j in range(2):
            d_h = d_o * W2[j] * h[j]*(1-h[j])   # chain extends one layer back
            W2[j] -= lr * d_o * h[j]
            W1[j][0] -= lr * d_h * x1
            W1[j][1] -= lr * d_h * x2
            b1[j]  -= lr * d_h
        b2 -= lr * d_o
    if step % 1000 == 0:
        print(f"step {step:4d}  loss = {total/4:.4f}")

print()
for (x1,x2), y in data:
    h = [sig(W1[j][0]*x1 + W1[j][1]*x2 + b1[j]) for j in range(2)]
    o = sig(W2[0]*h[0] + W2[1]*h[1] + b2)
    print(f"input ({x1},{x2}) -> prediction {o:.2f}   (truth {y})")

Press ▶ Run — XOR learned with gradients you can read line by line. This is the same algorithm inside ChatGPT, just 100 billion times smaller.

Level 3 exercise In the code above: (1) change lr to 0.05 and re-run — connect what you see to the playground's "too small" setting; (2) change the hidden layer from 2 neurons to 1 (delete index j=1 everywhere) and watch XOR become unlearnable — the 1986 lesson, reproduced by your own hand.

6.4 — Backpropagation in the quantum world

The quantum twist — parameter-shift rule A quantum circuit's gradient cannot be found by classical backpropagation — you cannot peek inside a superposition without collapsing it! Instead we use the parameter-shift rule: run the circuit twice, once with the knob shifted up (θ + π/2) and once shifted down (θ − π/2); the gradient is (loss at θ+π/2 − loss at θ−π/2) ⁄ 2 — two ordinary numbers, subtracted. Simple, exact, and hardware-friendly. You will use it with your own hands in Lab 7.

☕ Pause & Think · Class discussion

Your network reached 100% accuracy. Does it UNDERSTAND the pattern — or is it a man in a room, following rules it cannot read?

In 1980 the philosopher John Searle imagined a man locked in a room, passing out perfect Chinese answers by following rule-books, while understanding not one word of Chinese. Searle's claim: every program, however impressive, is that man. Your trained network separates the classes flawlessly — but its "knowledge" is just numbers that got nudged downhill. Then again… a sceptic might ask whether your own neurons are doing anything fundamentally different. Careful — this question bites in both directions.

John Searle (1980): perfect performance without understanding is possible — syntax is not semantics; rule-following is not knowing. The room speaks Chinese; nobody in it understands Chinese.

The "systems reply" from Searle's critics: the man doesn't understand Chinese, but perhaps the whole room — man, rule-books and all — does, the way no single neuron in your brain understands English, yet you do.

What the backprop playground adds: you watched learning happen as a purely mechanical process — errors flowing backwards, knobs nudging downhill. Whatever understanding is, you have now seen exactly how much of it can be built from arithmetic alone. Where the arithmetic ends and understanding begins, nobody yet knows.

A gentle classroom move: ask students to describe how THEY knew the XOR pattern needed a curved boundary. Could they write their insight as a rule a machine could follow? The struggle to answer is the lesson.

Lab 6 check · 1

In the hill-in-fog picture, what is backpropagation?

The hill itself The efficient method of feeling the slope for every knob at once, by passing the error backwards through the layers The decision to climb up instead of down The fog

✔ Backprop computes the gradient (the slope) for all parameters in one backward pass using the chain rule. The update that follows (the step) is gradient descent — two partners, often confused.

Lab 6 check · 2

Your loss curve is jumping wildly up and down and never settles. The most likely culprit is…

The dataset is too small The learning rate is too large — each step overshoots the valley The computer is too slow Backpropagation is impossible for this problem

✔ Classic over-large learning rate. You saw it yourself with the "Too large (1.5)" toggle. First reflex of every ML practitioner when loss explodes: reduce the learning rate.

Lab 6 check · 3

Why do quantum circuits need the parameter-shift rule instead of ordinary backpropagation?

Quantum computers cannot do subtraction You cannot inspect intermediate quantum states without collapsing them — so the gradient is found by running the circuit at shifted angles Python forbids it It is a marketing name, the method is identical

✔ Backprop needs to read intermediate values; measurement destroys quantum states. Parameter shift sidesteps this: evaluate at θ+π/2 and θ−π/2, halve the difference — an exact gradient from whole-circuit runs only.

Lab 7 · Official outline: "Implement quantum neural network in Python"

Implement a Quantum Neural Network in Python

The summit of the course. Every lab has placed one stone: encoding (Lab 5) + circuits (Lab 2) + histograms (Lab 4) + training loop (Labs 5–6). Today we stack them into a working quantum neural network — and train it.

7.1 — What a QNN actually is

Encoder + trainable rotations + measurement. In research papers this is called a parameterised (variational) quantum circuit — "quantum neural network" is its friendly name, because the rotation angles θ play exactly the role of weights.

7.2 — The complete QNN, trained live

The task: classify exam scores (scaled 0–1) as fail (0) or pass (1), learning the pass-mark from examples alone. Small — and genuinely complete: every ingredient of published QML research is here.

⚛️ quantum_neural_network.py — the full summit

from microqiskit import QuantumCircuit, simulate
import math

# ---- training data: (score, passed?) -- pass mark is hidden at 0.5 ----
data = [(0.05,0),(0.15,0),(0.25,0),(0.35,0),(0.45,0),
        (0.55,1),(0.65,1),(0.75,1),(0.85,1),(0.95,1)]

def qnn_predict(x, theta, shots=600):
    """The quantum model: encode -> trainable rotation -> measure."""
    qc = QuantumCircuit(1)
    qc.ry(x * math.pi, 0)        # 1. ENCODER   (Lab 5)
    qc.ry(theta, 0)              # 2. TRAINABLE (the knob)
    qc.measure_all()             # 3. MEASURE   (Lab 4)
    counts = simulate(qc, shots=shots)
    return counts.get("1", 0) / shots

def loss(theta):
    return sum((qnn_predict(x, theta) - y) ** 2 for x, y in data) / len(data)

# ---- training with the PARAMETER-SHIFT rule (Lab 6) ----
theta, lr = 0.0, 1.2
print("Training the quantum neural network...")
for step in range(12):
    s = math.pi / 2
    grad = (loss(theta + s) - loss(theta - s)) / 2    # parameter shift!
    theta -= lr * grad
    print(f"  step {step+1:2d}: theta = {theta:+.3f}  loss = {loss(theta):.4f}")

print()
print("--- Testing the trained QNN ---")
for x in [0.2, 0.4, 0.6, 0.9]:
    p = qnn_predict(x, theta, shots=2000)
    verdict = "PASS" if p >= 0.5 else "FAIL"
    print(f"  score {x:.1f} -> P(pass) = {p:.2f} -> {verdict}")

Press ▶ Run — training takes a few seconds (it is simulating hundreds of quantum circuits!).

Read the output like a researcher The loss falls step by step — the circuit is learning. The trained θ shifts the decision point so low scores give P(pass) near 0 and high scores near 1. One trainable knob only — yet the complete architecture of a QNN: this same pattern with 4 qubits and 20 knobs is a publishable variational classifier.

7.3 — Watch the same QNN train, visually

Interactive · QNN trainer (works offline)

The curve is the QNN's output P(1) across all inputs; dots are the training data. Press Train and watch the quantum model bend itself to fit the data.

7.4 — Scaling up: the industry version

The same architecture in production Qiskit Machine Learning — notice it is our three blocks with more qubits:

# pip install qiskit qiskit-machine-learning
from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes
from qiskit_machine_learning.algorithms import VQC

feature_map = ZZFeatureMap(2)          # block 1: the encoder (our ry(x·π), richer)
ansatz      = RealAmplitudes(2, reps=2) # block 2: trainable rotations (our ry(θ), many)
vqc = VQC(feature_map=feature_map, ansatz=ansatz)  # block 3 + training loop built in
vqc.fit(X_train, y_train)               # same fit() style as scikit-learn!

Lab 7 check · 1

In our QNN, what plays the role that weights play in a classical neural network?

The number of shots The trainable rotation angles θ The fridge temperature The histogram colours

✔ θ is the knob the optimiser nudges, exactly as w and b were nudged in Lab 5's temperature model. Weights → angles; everything else in the loop is unchanged.

Lab 7 check · 2

The QNN's prediction for one input is obtained by…

Reading the qubit's wavefunction directly off the chip Running the circuit many shots and using the fraction of 1-outcomes, P(1), as the output Asking the fridge One single measurement is always enough

✔ The prediction is a probability read from the histogram — Lab 4's skill powering Lab 7's model. One shot would give a noisy 0-or-1; hundreds of shots reveal P(1).

Lab 8 · Official outline: "Machine learning algorithms for quantum computing"

Machine Learning Algorithms for Quantum Computing

You have built one QNN. Now meet the whole family — the standard algorithm toolbox of quantum machine learning, each mapped to what you already know.

8.1 — The four families

1 · Variational Quantum Classifier (VQC)

You already built one. Encoder + trainable circuit + measurement, trained by parameter shift. The workhorse of near-term QML. Lab 7's model is a one-qubit VQC.

supervisedruns on today's machines

2 · Quantum Kernel Methods (QSVM)

Instead of training a circuit, use the quantum computer as a similarity meter: encode two data points, measure how much their quantum states overlap, feed those similarities into a classical Support Vector Machine. The quantum part maps data into a huge space where tangled classes may separate cleanly.

supervisedquantum + classical SVM

3 · Quantum Approximate Optimisation (QAOA)

For optimisation problems — best routes, schedules, portfolios. Writes the problem's cost as energy, then uses a trainable circuit to coax the qubits toward the lowest-energy (= best) answer. Cousin: VQE, the same idea used for molecule energies in chemistry.

optimisationlinks to Part A, Page 8

4 · Quantum Sampling & Generative Models

Quantum circuits produce genuinely random samples from very complex distributions (your Lab 3 coin was the simplest case). Used for generative modelling — learning to produce data resembling the training data — and quantum Boltzmann machines.

unsupervisednative quantum strength

8.2 — Taste a quantum kernel (live)

The heart of family 2 in a few lines: a quantum similarity between two numbers — 1.0 for identical points, falling as they separate:

⚛️ quantum_kernel.py — the similarity meter

Press ▶ Run.

8.3 — Choosing the right tool (decision guide)

Your problem	Reach for	Why
Classify labelled data (spam/not, pass/fail)	VQC — or QSVM if the classes are badly tangled	Supervised classifiers; VQC is simplest, kernels handle hard geometry
Find the best arrangement (routes, timetables, portfolios)	QAOA	Optimisation is its native language
Simulate a molecule / material	VQE	Molecules are quantum — the home advantage
Generate realistic samples / model a distribution	Quantum generative models	Sampling is what measurement does naturally
Everyday prediction on big tabular data	Classical ML!	Honesty: today's quantum devices don't beat XGBoost on ordinary data — know when NOT to use the quantum hammer

The honest frontier (teach this!) Quantum ML has not yet demonstrated clear advantage over classical ML on real-world datasets — the field is searching for the problems where quantum geometry genuinely helps (quantum data, chemistry, specific structures). Students who can state this honestly and build a working VQC are exactly the researchers the field needs. And notice one quiet pattern across this whole table: again and again, a team of small specialists beats one giant generalist — the ensemble idea of classical machine learning, returning at every scale. Keep it; it matters later.

☕ Pause & Think · Class discussion

Quantum computing attracts billions in funding — and some of its own leaders spend their careers warning against the hype. Should a scientist ever oversell to keep the funding flowing?

Here is a tension your generation will live inside. Governments and investors fund what sounds revolutionary; careful scientists know revolutions take decades and might even fail. Oversell, and you betray the truth; undersell, and the laboratory closes. Nigerian science faces this squeeze more sharply than most. Where is the honest line?

John Preskill coined the sober term NISQ — "Noisy Intermediate-Scale Quantum" — precisely to set honest expectations: today's machines are promising, limited, and noisy. Naming the limits honestly strengthened the field's credibility.

Scott Aaronson, called "the conscience of quantum computing", has spent years publicly puncturing exaggerated claims — including the claim that quantum will soon revolutionise machine learning — while still believing deeply in the field. He even grants that quantum computing could, in principle, turn out impossible. Honesty and belief, held together.

Feynman's rule for scientists: the first principle is that you must not fool yourself — and you are the easiest person to fool. A scientist's reputation for honesty is her only permanent asset; funding cycles end, credibility compounds.

Class exercise: each student writes a two-sentence grant pitch for a quantum project — one version "fundable", one version brutally honest — then reads both aloud. Discuss: can the honest one be made exciting WITHOUT lying? (It can. That skill is called science communication.)

Lab 8 check · 1

A bank wants the best arrangement of 50 delivery stops. Which quantum algorithm family fits?

QSVM — it classifies the stops QAOA — optimisation problems are written as energy and minimised A histogram No algorithm exists for routing

✔ "Best arrangement" = optimisation = QAOA (or an annealer, Part A Page 4). VQC/QSVM are for classification; VQE for chemistry.

Lab 8 check · 2

What does a quantum kernel method use the quantum computer for?

Training millions of parameters Measuring the similarity (overlap) between data points encoded as quantum states — a classical SVM does the rest Storing the dataset Drawing the final chart

✔ Quantum = similarity meter; classical SVM = decision maker. Your quantum_similarity() function was a genuine quantum kernel.

Capstone

Capstone & Final Quiz

One program that uses every lab at once — then ten questions to certify the journey.

9.1 — The capstone program

Read it first, predict what it will print, then run it. It combines: circuits (L2), the coin (L3), histograms (L4), encoding (L5), parameter-shift training (L6), and a QNN (L7).

⚛️ capstone.py — everything, together

from microqiskit import QuantumCircuit, simulate
import math

print("=" * 52)
print(" CAPSTONE - Quantum Computing Course, Dr. Ophori")
print("=" * 52)

# [Lab 2] Build entanglement, [Lab 4] read its histogram
bell = QuantumCircuit(2); bell.h(0); bell.cx(0, 1); bell.measure_all()
print("\n1) Bell state, 500 shots:", simulate(bell, shots=500))

# [Lab 3] A fair quantum coin
coin = QuantumCircuit(1); coin.h(0); coin.measure_all()
h = simulate(coin, shots=500).get("1", 0)
print(f"2) Fair coin: {h}/500 heads ({h/5:.0f}%)")

# [Labs 5-7] Mini QNN: learn to detect "high" values, 6 quick steps
data = [(0.1,0),(0.3,0),(0.7,1),(0.9,1)]
def pred(x, t):
    qc = QuantumCircuit(1); qc.ry(x*math.pi,0); qc.ry(t,0); qc.measure_all()
    return simulate(qc, shots=400).get("1",0)/400
def L(t): return sum((pred(x,t)-y)**2 for x,y in data)/4

theta = 0.0
for i in range(6):
    g = (L(theta + math.pi/2) - L(theta - math.pi/2)) / 2
    theta -= 1.5 * g
print(f"3) QNN trained: theta={theta:+.2f}, final loss={L(theta):.3f}")
print(f"   test 0.2 -> P(high)={pred(0.2,theta):.2f} | 0.8 -> P(high)={pred(0.8,theta):.2f}")
print("\nCongratulations - you have run the entire course in one program.")

Press ▶ Run.

9.2 — Where to go next (all free)

IBM Quantum Platform — quantum.ibm.com: free account, run your circuits on real hardware.
Qiskit documentation & textbook — the official learning path; your commands here transfer directly.
PennyLane (Xanadu) — the other great QML library, with excellent tutorials.
Class project idea: each student designs a biased coin for a given probability, proves it with a 1,000-shot histogram, and explains the angle mathematics — every skill in one exercise.

☕ Pause & Think · The final discussion

You began this course answering "who is better — computer or human?" You end it having trained a quantum machine with your own hands. Answer it one last time.

Look at what you did in these labs: you commanded superposition, built entanglement, taught a classical network, taught a quantum circuit. At every step, the machine supplied the speed — and you supplied the question, the design, the judgment of right and wrong, the decision of what was worth doing at all. Dr. Ophori's answer stands at the end of the evidence: the human wrote the algorithm. The machine is magnificent — and it is yours. The only remaining question is the one no computer, classical or quantum, can answer for you: what will you point it at?

The whole debate, in one line each: Turing asked if machines can think; Lovelace said they only perform our orders; Searle said performing is not understanding; Kasparov said partner with them; Einstein doubted the dice and his doubt built the field. Every one of them would agree on a single point — the asking of the question is the human part.

Final class ritual: every student states one sentence beginning "With what I now know, I will…" — and the lecturer goes last. Education is complete when the teacher also answers.

9.3 — Final quiz

Question 1

Which gate turns |0⟩ into an equal superposition — the quantum coin spin?

XH (Hadamard)ZCNOT

✔ H is the coin-spinner. X flips deterministically; Z twists the phase; CNOT entangles two qubits.

Question 2

The recipe H on q0 then CNOT(q0→q1) produces a histogram showing…

All four outcomes equallyOnly 00 and 11, about half each — entanglementOnly 01 and 10Always 00

✔ The Bell state: perfectly correlated qubits. 01/10 appearing on real hardware = noise.

Question 3

Why do we run a quantum circuit with many shots?

To warm up the qubitsOne measurement collapses to a single random outcome; many shots reveal the probability distributionBecause Python requires loopsTo use more electricity

✔ The information lives in the distribution — hence shots and histograms.

Question 4

Angle encoding means…

Writing data in degrees CelsiusLoading a data value into a qubit as a rotation, e.g. ry(x·π)Encrypting the datasetNaming variables with Greek letters

✔ Data becomes geometry — the tilt of the Bloch arrow. The doorway from classical data to quantum models.

Question 5

The universal ML training loop is…

Predict → measure loss → compute gradient → update parameters → repeatDownload → install → run → deleteEncode → entangle → forgetGuess once and stop

✔ The loop behind the temperature model, the backprop playground, the QNN — and ChatGPT.

Question 6

A loss curve that explodes upward usually means…

Perfect learningLearning rate too large — steps overshoot the valleyThe data is too cleanMomentum is working

✔ Reduce the learning rate — the first reflex you practised in the Lab 6 playground.

Question 7

The parameter-shift rule computes a quantum gradient by…

Peeking inside the superpositionRunning the circuit at θ+π/2 and θ−π/2 and halving the difference of the resultsAsking IBM supportGuessing randomly

✔ Whole-circuit evaluations only — no forbidden peeking at intermediate states. You used it to train both QNNs.

Question 8

The three blocks of a quantum neural network, in order:

Measure → encode → trainEncoder (data → rotations) → trainable rotations θ → measurement (P(1) = prediction)Fridge → chip → cablesPython → Java → C++

✔ Encode, transform (trainably), measure. More qubits and layers = the industry VQC, same skeleton.

Question 9

Best algorithm family for "find the optimal timetable":

VQCQuantum kernelsQAOAPlotting histograms harder

✔ Timetabling = optimisation = QAOA. VQC/kernels classify; VQE does chemistry.

Question 10

The honest status of quantum machine learning today:

It already beats classical ML at everythingWorking methods exist (VQC, kernels, QAOA) and run on real hardware, but clear real-world advantage over classical ML is still being searched forIt is pure fictionIt was abandoned in 2019

✔ Real algorithms, real hardware, open frontier. Scientists who state limits honestly are the ones trusted to announce the breakthroughs.

Your final score

0 / 10

Answer the questions above — your score updates automatically.

To the student who reached this line You installed nothing but a browser page — yet you ran quantum circuits, created entanglement, built a true random coin, read histograms like an engineer, trained classical and quantum neural networks, and used the parameter-shift rule from current research papers. You are no longer an outsider to quantum computing. Welcome to the field.

Generation	Approach	Example	Limitation
1 · Expert judgment	Experienced people guess, structured or not	Delphi method	Subjective, unrepeatable, optimistic
2 · Algorithmic models	Fixed mathematical formulas from project size	COCOMO (effort = a·KLOC^b·EAF), Function Points	Rigid — calibrated to 1980s projects
3 · Machine learning	Learn the size→effort pattern from past projects	Regression, neural networks, stacking ensembles (Paper 1)	Starved by tiny datasets → Paper 2

Dataset	Projects	Typical features
COCOMO81	63	KLOC + 15 cost drivers
Desharnais	81	Team experience, transactions, entities, language
NASA93	93	COCOMO-style drivers, NASA projects
Maxwell	62	Size, application type, 15+ factors
Albrecht	24	Function-point components
ISBSG	1000s (commercial)	Industry-submitted projects, heterogeneous

Section	Content	You already have…
1 · Introduction	The estimation problem, the small-data pain, the "why quantum fits" argument, RQ1–RQ3	Pages 2–4 of this Part C
2 · Background	Cost estimation models; QML essentials (qubits → kernels → QNN) written for SE readers	The whole course, Parts A–B!
3 · Related work	Classical ML for SEE; augmentation for SEE; QML in SE (defect prediction); the gap statement	Page 3 of this Part C
4 · Method	The pipeline diagram, four arms, encoding choices, tuning protocol	Page 4 of this Part C
5 · Results	Tables + histograms per dataset × condition × arm; statistical tests	Metrics defined (Page 2)
6 · Discussion	RQ answers, the augmentation×quantum interaction, threats to validity	Threats drafted (Page 4)
7 · Conclusion	Contributions + the honest frontier	Lab 8's honesty discipline

Term	Plain meaning	You already know it from…
Token	A word-piece — the unit the model reads and writes (≈ ¾ of a word)	The buttons you just tapped
Inference	Using the trained model to generate — the tapping you just did	Lab 7's "predict" step
Training	Adjusting the model's knobs to make better guesses — the loop of Lab 5/6	Predict → loss → gradient → update
Parameters	The knobs. GPT-class models have billions; your Lab 7 QNN had one (θ)	w and b; the rotation angles

Line of work	The idea	Status
Quantum self-attention (e.g. QASA, 2025)	Replace dot-product attention with a parameterised quantum circuit that scores token pairs in Hilbert space	Small-scale experiments; reported large error reductions on small tasks; unproven at LLM scale
Quixer (Quantinuum, 2024)	A full transformer designed natively for quantum computers	Research prototype on simulators
Hybrid quantum-enhanced NLP	Quantum layers inside otherwise classical language models — exactly the hybrid pattern of Lab 5	Active papers 2025–26; small models only
Quantum-inspired attention	No quantum computer at all — borrow the mathematics (interference, phases) to design cheaper classical attention	Running in classical systems today; a quiet success of quantum thinking
Trainable measurements (2025)	Stop measuring with a fixed lens: make the observable itself a trained parameter, learned jointly with the circuit — the measurement adapts to the task	Active papers reporting clear gains over fixed measurement choices; the full idea is developed in Part E

Modality	What becomes a "token"	The generator	Blocks you already know
Text (LLMs)	Word-pieces	Transformer predicting next token	All of them — Pages 1–4
Images	Patches of the picture	Diffusion: start from pure noise, remove noise step by step until a picture remains — a trained walk downhill, like Lab 6's ball finding the valley	Training loop, attention (patches attend to patches), embeddings
Audio / music / voice	Slices of sound	Same transformers & diffusion over sound-tokens	Identical stack, different data
Video	Patches across space AND time	Diffusion transformers — attention now also looks across frames	Positional encoding grows a time axis; everything else unchanged
3D worlds / spatial	Points, camera rays, or Gaussian splats (millions of tiny coloured blobs that together form a scene you can walk through)	Optimised by — yes — gradient descent on a loss ("does the rendered view match the photos?")	The ball and the valley, one more time

Tool	What it proves	Hardware needed
whisper.cpp	Speech → text (the exact "talking like this, turning to text" dream)	Any laptop CPU, offline
llama.cpp + GGUF models (GGUF = the compressed model file format)	Full chat LLMs (1–8B parameters, 4-bit) conversing locally	An ordinary 8 GB laptop
BitNet.cpp	1.58-bit models, up to 100B parameters, CPU-only	CPU; Raspberry Pi demonstrated
ONNX Runtime	Industry-standard CPU inference of almost any trained model	CPU

Software concept	Its AI twin (real, published)	What it does
A function	LoRA adapter	A tiny trained patch (often <1% of model size) adding one skill to a frozen base model — train the patch, never the model
A library of functions	LoraHub / AdapterSoup	A shelf of ready adapters, combined for a new task without gradient training
Snapping LEGO bricks	LoRA-LEGO (its real name!)	Decomposes adapters into rank-pieces and reassembles them across tasks
if/else dispatch	Mixture of Experts (MoE)	A router sends each token to the right specialist sub-network; most of the model stays asleep — frontier LLMs already ship this way
An operating system	Routing + orchestration	Small specialist models called like programs: the "AI OS" picture

Proof point	What happened	Lesson for the programme
INTELLECT-1 (2024)	A 10-billion-parameter LLM trained across 14 nodes on 3 continents by ~30 independent contributors — with a 400× cut in communication bandwidth (DiLoCo-style low-communication training)	Distributed training over the open internet is no longer theory
Bittensor	A blockchain network (valued in billions) paying independent contributors for inference, training and data via "proof of intelligence" scoring	On-chain incentives can sustain a real AI economy — and also show the failure modes to avoid
DePIN compute markets (Akash, Render, io.net)	Open marketplaces renting out idle GPUs/CPUs at 60–75% below big-cloud prices	Spare capacity is enormous and willing — the missing piece is trustworthy coordination
Swarm inference (Petals)	Large models served BitTorrent-style, each volunteer hosting a few layers	Even running one model can be a community act — modules (Pillar 3!) are the natural unit to host

Linux kernel principle	Its Sankofa-kernel twin
A tiny trusted core, everything else outside it	A tiny trusted core holding only: the ledger invariants, the module loader, the scheduler. Everything else — even intelligence — lives outside, replaceable
Loadable modules (drivers added at runtime, no reboot)	Skill modules & knowledge packs installed at runtime — the medicine pack loads like a driver loads
The scheduler (who gets the CPU, when)	The conductor (Page 6): routes each job to CPU, GPU, NPU — or out to the swarm fabric — by its nature
"Everything is a file" — one interface for all resources	"Everything is a verifiable, content-addressed resource" — models, packs, media chunks, credit receipts: one interface, hash-checked
System calls — the small, stable contract apps rely on	New native syscalls: `infer()`, `fetch_pack()`, `q_sim()` (quantum-inspired math), `settle()` (credit, evidence-first). AI, quantum math and honest credit as primitives, not add-ons
Package manager (apt/opkg) with signed packages	The pack manager: signed, verified knowledge and skill packs served by the fabric
Portability — the same kernel IS Android, the Raspberry Pi, the data centre	The same Sankofa kernel on a market trader's phone, a student's laptop, a university server — one codebase, every device a full citizen

Open model (Hugging Face)	Size	4-bit footprint	Role in the proof
whisper-small / whisper.cpp	244M	<0.5 GB	Offline speech → text (the ears)
SmolLM2 / Qwen-class small	135M–1.7B	0.1–1.0 GB	The conversational base (the voice)
Llama-3.2-class / Gemma-2-class small	1B–3B	0.7–1.8 GB	Stronger base if quality demands
BitNet b1.58 (2B, 4T tokens)	2B ternary	≈0.4 GB	The Pillar-1 flagbearer — natively CPU
Phi-3-mini-class	3.8B	≈2.3 GB	Upper bound still comfortable in 32 GB
+ LoRA adapters (ours)	<1% of base each	MBs	The trained skills — the coins in the pot