Chapter 35 — Key Takeaways (Hybrid Architectures)
Part VI closes here, on the one claim that survives the scaling.
Where to put the boundary
Ch. 32/33 variational quantum evolves AND is optimized -> plateaus, shots x samples x steps
Ch. 34 kernel quantum only EVALUATES -> convex, but n^2 evaluations
Ch. 35 quantum data quantum SUPPLIES the input too -> no encoding cost
Every algorithm in Parts IV and VI is hybrid — you have no choice. The question is where the boundary goes, and each move trades one cost for another. Ch. 34's convexity removed the optimization and introduced a quadratic; this chapter's move removes the encoding and constrains what the data can be.
★ Quantum data: the encoding cost is zero
$$H(h) = -\sum_i Z_i Z_{i+1} - h\sum_i X_i$$
Ordered for $h<1$, disordered for $h>1$, phase transition at $h=1$. A real physics question with a known answer.
Chapter 32's amplitude encoding, 64 amplitudes:
57 two-qubit gates PER SAMPLE, PER EPOCH -> 63,840 over 28 samples x 40 steps
Quantum data:
0 gates
⚛️ The input problem is a statement about CLASSICAL data. Ch. 32 §32.2's bound is information-theoretic: an arbitrary $N$-dimensional state has $N$ independent parameters, so loading one costs $\mathcal{O}(N)$ gates.
A state produced by a physical process was never loaded. The bound does not apply because there is nothing to encode. This is the strongest structural argument in QML, and unlike most of Part VI's claims it is not in dispute.
The classifier
Train away from criticality, test near it — the hard cases:
36 parameters, 28 train / 14 test
train accuracy 1.0000
test accuracy 0.6429
Perfect separation, poor generalization — what 36 parameters on 28 samples should do, and worth reporting rather than quoting only the train number.
★★★ And the baseline that has to be run
classical model input test acc
LogisticRegression full amplitudes 0.6429
SVC (rbf) full amplitudes 0.5714
kNN full amplitudes 0.5714
LogisticRegression probabilities only 0.6429
SVC (rbf) probabilities only 0.7857
kNN probabilities only 0.7857
quantum classifier the state itself 0.6429
An SVM on measurement probabilities scores 0.7857.
And probabilities beat full amplitudes (0.7857 against 0.5714) — the phase information adds 64 noise dimensions. The best classical result uses strictly less information than the quantum model has.
🔬 The saving was on an operation the classical model never performs. A 6-qubit state is 128 real numbers;
sklearnreads them for free. Eliminating a cost your competitor never paid is not an advantage.
★ But this is the obstacle that gets BETTER with scale
Every other problem in Part VI compounds — encoding cost grows with $N$, inference with usage, the Gram matrix as $n^2$, plateaus and concentration exponentially in qubits.
6 qubits: 128 real numbers -> sklearn wins
50 qubits: 2.3e15 real numbers -> there is no classical feature vector at all
The zero-encoding-cost advantage is worth nothing below the classical-simulation boundary (~30–35 qubits, Ch. 26 §26.2) and is the whole game above it. It is the only claim in Part VI with that property.
That boundary governs Ch. 21's Grover crossover, Ch. 23's Shor, Ch. 25's threshold and Ch. 30's XEB. The quantum case begins where classical simulation ends.
★★ Classical shadows
Same shots per observable, 12 repetitions:
shots direct |err| shadow |err| ratio
1,000 0.0202 0.0542 2.7x
20,000 0.0050 0.0113 2.3x
Shadows look 2.5× worse — and that comparison silently gave direct estimation 17× the total budget. At equal total budget:
total budget direct (split 17 ways) shadows (one record) winner
1,700 0.0645 0.0431 SHADOWS 1.50x
8,500 0.0284 0.0172 SHADOWS 1.65x
34,000 0.0157 0.0087 SHADOWS 1.80x
Splitting a budget 17 ways costs $\sqrt{17} = 4.1\times$. Shadows pay only ~2.5× for reusing one record. The difference is the win.
Not "17× fewer shots" — "a better use of whatever budget you have, once the observables outnumber a handful."
And the advantage scales: the $\sqrt{n}$ penalty grows, the ~2.5× shadow penalty does not.
observables 4 17 50 200 1,000
sqrt(n) 2.0x 4.1x 7.1x 14.1x 31.6x
shadows ~2.5x ~2.5x ~2.5x ~2.5x ~2.5x
⚛️ You are not measuring the observable — you are measuring the STATE and asking the record afterwards. Snapshot count grows with the locality of the observables, not their number.
This is the only technique in this book that attacks Ch. 24's shot budget from the side that helps: not fewer shots per estimate, but more estimates per shot.
The loop in production
- The round trip is the bottleneck. Ch. 31 measured the circuit at 7.10 μs; queue latency is seconds. Over 99.9% of wall-clock is waiting — which is why hybrid runtimes co-locate the classical update.
- Batching is not optional. Ch. 33 and Ch. 34 both measured ~500× from submitting many circuits at once.
- Ch. 33 §33.6's inference bill does not go away. Quantum data changes the input cost, not the measurement cost.
★ What Part VI adds up to
Ch. 32 input problem: O(N) gates per sample per epoch
VQC ~20,000x slower than LogReg, same accuracy; training 2.38 QPU-days
Ch. 33 data re-uploading: 1 qubit, 6 params -- elegant
kNN beats it by +0.0626 +/- 0.0067; TIES WITH LOGISTIC REGRESSION
inference 27.8 QPU-hours per million, forever
Ch. 34 training is CONVEX -- a real structural advantage
SVC(rbf) beats it by +0.0576 +/- 0.0083, SAME SOLVER
Gram matrix 38.6 QPU-days at 10 qubits
Ch. 35 encoding cost is ZERO -- the claim is true
and sklearn still wins at checkable scale
No quantum model in Part VI beat a tuned classical baseline on any dataset. Three of four tied with logistic regression.
Three things belong alongside that:
The techniques are real and some are elegant. Data re-uploading's single-qubit universality, the kernel formulation's convexity, classical shadows. None depends on QML being useful to be worth knowing.
The negative results are the field's most valuable output. Barren plateaus, the input problem, concentration, dequantization — all discovered by people trying to make QML work, and now among the sharpest tools for evaluating any quantum proposal. A field that produces impossibility results is doing science.
And the quantum-data case survives the scaling. If a practical QML advantage is demonstrated, current evidence points here — states that cannot be written down, measured by shadows, classified by circuits that never had to load anything.
Common pitfalls
- Treating a saving as an advantage without asking what the alternative pays.
- Demonstrating below the boundary a claim is about.
- Comparing methods at equal per-item cost when their cost structures differ.
- Reading a single-$n$ measurement as a scaling result.
- Reporting train accuracy without test accuracy.
- Assuming quantum data removes the inference bill (it removes the input cost only).
- Round-tripping every evaluation through a queue.
Project piece added this chapter
vqelab/hybrid.py — encoding_cost_saved, which reports the saving AND whether it is
checkable; quantum_data_verdict, which returns CLASSICALLY_CHECKABLE rather than an advantage
claim below ~32 qubits, naming the state's size in real numbers; shadow_advantage, which requires
the TOTAL budget and exposes the $\sqrt{n}$ splitting penalty; and hybrid_round_trips, which prices
queue latency against Ch. 31's 7.10 μs circuit. 18 tests pass, including
test_quantum_data_verdict_REFUSES_below_the_simulation_boundary,
test_the_classical_baseline_WON_at_checkable_scale,
test_shadows_lose_per_observable_and_win_at_equal_budget, and
test_no_quantum_model_in_part_vi_beat_a_tuned_baseline.