Case Study 1: The Advantage That Was Real and Bought Nothing

DataField.Dev

Case Study 1: The Advantage That Was Real and Bought Nothing

The argument, which is correct

A team has read Part VI and drawn exactly the right conclusion. Chapter 32 identified the input problem as the structural obstacle: loading $N$ classical numbers costs $\mathcal{O}(N)$ gates, per sample, per epoch, and no exponential speedup survives it.

So they find an application where the data is already quantum.

Ground states of a transverse-field Ising model, classified by phase. The states come out of a physics simulation; on real hardware they would come out of an experiment or another quantum computation. The classifier acts on them directly.

   Chapter 32's amplitude encoding, 64 amplitudes:
     57 two-qubit gates PER SAMPLE, PER EPOCH
     over 28 samples x 40 steps:  63,840 encoding gates

   Quantum data:
     0 gates

Every single encoding gate is gone. Not reduced — eliminated. The dominant term in Chapter 32's cost analysis simply does not apply, because there is nothing to load.

And the argument for why is airtight. Chapter 32's bound is information-theoretic: an arbitrary $N$-dimensional state has $N$ independent real parameters, so loading one costs $\mathcal{O}(N)$ gates. A state prepared by dynamics was never loaded. The bound does not apply.

The classifier works, too:

   36 parameters, 28 training states
   train accuracy  1.0000

Perfect separation. The write-up is drafted around this: the input problem solved, the classifier trained, the phase transition learned.

The number that ends it

   test accuracy   0.6429

Train 1.0000, test 0.6429 — 36 parameters on 28 samples, overfitting exactly as much as you would expect. That alone would be a reason to temper the claim.

But the decisive number is the one Part VI has spent four chapters insisting on:

   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.

A 6-qubit state is a 64-dimensional complex vector — 128 real numbers. That is an ordinary feature vector, and sklearn reads it for free.

🔬 Honest Assessment: the saving was on an operation the classical model never performs.

The encoding cost is what it takes to get $N$ numbers into a quantum register. A classical model does not have a register. It reads the numbers.

Eliminating a cost your competitor never paid is not an advantage.

The detail that makes it worse

Probabilities beat full amplitudes — 0.7857 against 0.5714 for both SVC and kNN.

The phase information is not useful for distinguishing these phases, and including it adds 64 dimensions of noise. So the best classical result uses strictly less information than the quantum classifier has access to, and still wins.

That closes off the natural rescue — "but the classical model does not see the full quantum state." It does, and it does better when it sees less.

Where the argument survives

This is the part that matters, and the chapter does not retract it.

The obstacle disappears with scale rather than getting worse. Every other problem in Part VI compounds: Chapter 32's encoding cost grows with $N$, Chapter 33's inference bill grows with usage, Chapter 34's Gram matrix grows as $n^2$, and barren plateaus and concentration both worsen exponentially with qubits.

This one is the opposite. At 6 qubits the state is 128 numbers and sklearn wins. At 50 qubits:

   50-qubit state:  2^50 = 1.1e15 amplitudes = 2.3e15 real numbers

There is no classical feature vector to hand a baseline. The comparison that defeated the team's claim at 6 qubits cannot be run at all.

The zero-encoding-cost advantage is worth nothing below the classical-simulation boundary and is the whole game above it. It is the only claim in Part VI with that property.

That boundary — around 30–35 qubits by Chapter 26 §26.2's memory measurement — is the same one that governs Chapter 21's Grover crossover, Chapter 23's Shor, Chapter 25's threshold, and Chapter 30's XEB. The quantum case begins where classical simulation ends, and every honest demonstration below that line demonstrates the method rather than an advantage.

What the write-up should have said

Not "we solved the input problem and the classifier works." Instead:

"On a 6-qubit problem the quantum classifier reaches 0.6429 test accuracy against an SVM's 0.7857. The encoding cost is genuinely zero, which is a real structural difference from Chapter 32's setting — but at this scale the state is 128 real numbers that a classical model reads directly, so the saving does not translate into an advantage. The approach is worth pursuing at scales where the state cannot be written down, and this experiment does not test that regime."

Every clause is supported, the structural point is preserved, and the limits are stated by the authors rather than by a reviewer.

The project module's refusal

quantum_data_verdict will not call a result an advantage claim below the boundary:

if classically_writable(n_qubits):
    return QuantumDataVerdict(
        Verdict.CLASSICALLY_CHECKABLE, ...,
        reason=(f"a {n_qubits}-qubit state is {2*2**n_qubits:,} real numbers, so a "
                f"classical model can be given the SAME information... "
                f"Run the baseline before claiming anything."),
    )

Above the boundary the verdict flips to ADVANTAGE_POSSIBLE, with the reason naming why: there is no classical feature vector to hand a baseline.

The lessons

A saving is only a saving relative to what the alternative pays. Zero encoding gates against zero encoding gates is a tie.

Run the baseline even when the structural argument is airtight. The argument here was airtight, and the measurement still reversed the conclusion.

Check whether your demonstration is in the regime your claim is about. The claim was about scales where classical simulation fails; the demonstration was at six qubits.

State the boundary explicitly. "This approach applies above ~30 qubits and this experiment is at 6" is honest, publishable, and prevents the objection.

And notice this is Part VI's fourth version of the same finding. Chapter 32 tied with logistic regression on a solved dataset. Chapter 33 tied with logistic regression on an unsolved one. Chapter 34 lost to an RBF kernel using the same solver. Here the structural argument was the strongest of the four, and the baseline still won.

Reproduce it: code/example-01-quantum-data.py measures the encoding saving, trains the classifier, and then runs all six classical baselines on the same states; quantum_data_verdict in code/vqelab/hybrid.py refuses the advantage claim below the boundary, and test_the_classical_baseline_WON_at_checkable_scale asserts both the 0.7857 and that the winner used less information.