Q Quantum Learning Hub
Quantum computing, in plain language
हिंदी
Module 1A · The Big Picture

Quantum Machine Learning: Four Flavors

In simple words

"Quantum machine learning" sounds like one subject, but it is really four — and mixing them up causes most of the confusion in the field. The clean way to sort them is a 2×2 table: the rows are the data-generating system (classical C, or quantum Q), the columns are the data-processing device (classical C, or quantum Q). That gives four boxes: CC, CQ, QC, QQ.

CC — quantum-inspired algorithms. Classical computer, classical data — but the algorithm borrows ideas from quantum computing. The famous story: in 2016, Kerenidis and Prakash proposed a quantum recommendation algorithm proved exponentially faster than known classical methods. In 2018, undergraduate Ewin Tang found a classical algorithm that matched it, using quantum-inspired principles — and in her PhD she "dequantized" several more quantum ML algorithms. The lesson: not every quantum speedup survives contact with a clever classical idea.

QC — machine learning for quantum. Classical computer, but now the data comes from a quantum system: using ML to calibrate qubits, fight noise, and assist quantum error correction — even using neural networks to mimic quantum systems we cannot simulate directly. This flavor works today and needs no quantum computer at all.

CQ — quantum for machine learning. Classical data, quantum processor. This is the most interesting box for the course — and the most delicate. The poster child is the HHL algorithm for solving linear systems: exponentially faster in theory — O(log n) versus classical O(n). The catch is the input-output problem: just loading classical data into the quantum computer and reading the answer out already costs O(n), which can erase the speedup. Quantum RAMs would fix this in theory — but they don't exist, and may never.

QQ — quantum in, quantum out. Both the data and the processor are quantum: analyzing the output of a particle collider (CERN's LHC), or the output of another quantum computer. Here there is no loading problem — the data is already quantum — and the ML principles carry straight over from the CQ box. Four boxes, one honest summary: QC works now, CC keeps everyone humble, CQ is the great hope with a loading-shaped hole in it, and QQ waits for quantum data to become abundant. (See also: HHL algorithm.)

Go deeper — the math & the rigor

Why did dequantization sting? Because the Kerenidis–Prakash recommendation algorithm was a flagship: an exponential speedup for a genuinely practical problem, built on the same linear-algebra machinery as HHL. Tang's insight was that the speedup's fine print — the assumption that data arrives in a special quantum-friendly format — could be matched classically by an analogous classical data structure (sampling access). Once she showed the classical algorithm inherits the same advantage under comparable assumptions, the "exponential speedup" evaporated into a polynomial one. The reality check: a quantum ML speedup claim must specify its input model, or it is comparing a quantum athlete to a classical athlete with tied shoes.

The loading bottleneck deserves its full weight, because it is the central caveat of the entire CQ program. HHL solves \(Ax = b\) in time \(O(\log n)\) — but only if the vector \(b\) is already loaded as a quantum state \(|b\rangle\), and only if you are satisfied with a quantum state \(|x\rangle\) as the answer rather than all \(n\) classical numbers. Preparing \(|b\rangle\) from classical data costs \(O(n)\) in general; reading out all of \(x\) costs \(O(n)\) too. So the exponential speedup survives only for problems where the input is cheap to prepare and the output you need is some global property — an expectation value, not the full vector.

Quantum RAM (QRAM) is the theoretical escape hatch: a device that loads classical data into superposition in \(O(\log n)\) time. But no QRAM exists, and building one requires maintaining coherence across an enormous routing network — arguably as hard as building the quantum computer itself, with error-correction overhead on top. Most researchers treat QRAM as a placeholder for "someday, maybe," not a plan. Until the input problem is solved, CQ algorithms are speedups waiting for a data pipeline.

That is why QQ is conceptually the cleanest box: when the data-generating system is itself quantum — a collider, a quantum sensor network, a quantum simulation — there is nothing to load. The state arrives as a state. The ML principles (function approximation plus optimization, from the last lesson) carry over unchanged; only the substrate changes. The field's bet is that as quantum devices proliferate, quantum-native data will too — and QQ will inherit the earth. Honest summary for the whole 2×2: the physics is real, the speedups are conditional, and the conditions are the interesting part.

Key takeaways

  • Quantum ML splits into four boxes by data source (C/Q) × processing device (C/Q): CC, CQ, QC, QQ.
  • CC (dequantized algorithms): Ewin Tang's 2018 classical match to the 2016 Kerenidis–Prakash quantum recommender showed some 'quantum speedups' were really about better input assumptions.
  • QC (ML for quantum): classical ML improving real quantum systems — calibration, error correction — works today.
  • CQ (quantum for ML): HHL promises O(log n) vs O(n), but the input-output loading problem can erase the speedup; QRAM doesn't exist.
  • QQ (quantum in, quantum out): no loading problem — the cleanest box, waiting for quantum-native data to become abundant.

Check your understanding

Q1.In the 2×2 table, what does 'CQ' mean?

Q2.What was the significance of Ewin Tang's 2018 result?

Q3.Why is the input-output problem the central caveat of CQ algorithms like HHL?

References

The books, papers, and articles this lesson drew on — with a note on what each one was used for.

  1. Kerenidis & Prakash, "Quantum recommendation systems", arXiv:1603.08675 (2016). · source ↗
    Used for: the 2016 quantum recommendation algorithm behind the dequantization story.
  2. Tang, "A quantum-inspired classical algorithm for recommendation systems", STOC 2019 (arXiv:1807.04271). · source ↗
    Used for: the 2018 dequantization result and the CC flavor.
  3. Harrow, Hassidim & Lloyd, "Quantum algorithm for linear systems of equations", Phys. Rev. Lett. 103, 150502 (2009). · source ↗
    Used for: the HHL algorithm and its O(log n) claim in the CQ flavor.
  4. Aaronson, "Read the fine print", Nature Physics 11, 291–293 (2015). · source ↗
    Used for: the caveats around HHL-style speedups, including the input problem.

Tip: press / to turn pages.