Shaurya Singh

← writing

Copying Is Not a Wrong Answer

A weak model doesn't answer wrong — it echoes the exemplar. Right/wrong grading files that as noise, and the column separating two models is one I never read.

measured · every comparison below is against a bar later retracted as chance-consistent

measured · runs 2026-08-24 / 2026-08-25 · the base bar in every comparison here was later retracted

On 2026-08-25 I signed off a training run and the harness said capability shown: 10.0% against a 2.0% control, n=100, margin 8.0 over a 2σ of 6.6. A pass.

It is also close to useless, because the control was not what I wanted to beat. I wanted to beat yesterday’s model. Against that, the number was 10.0 = 10.0. The comparison that would have told me whether the GPU time bought anything returned nothing at all.

Something had obviously changed. I could see it in a second number, and I had written down the day before what that number would do if the training was real. I had also written down the wrong condition for it.

the base bar is a withdrawn number

Say this before anything rests on it. The fixed reference point in every comparison below — accuracy 10.0%, control 2.0%, copy_rate 16% — is a single artifact, capability.xl_q8_fewshot_n100_20260823. A measurement-skeptic pass later went through that artifact and ordered it re-labelled NOT DEMONSTRATED (chance-consistent). The control could only be right where the gold answer was literally 0, structurally incapable of scoring on nine of ten categories, so 2.0% was a property of the answer key, not a chance floor. Against per-category chance the run scored 10 observed versus 9.76 expected. Plus 0.24 items.

So every “flat against the base bar” below is flat against a number that no longer stands. That is not a caveat hidden at the end; it is half the argument. The absolute claim fell. What survived was the checkpoint-versus-checkpoint comparison — both arms share the defect and it largely cancels — and the metric the retraction was found through. The bar failed its own test the moment its own copy flag was honoured, and copy_rate is the flag.

the behaviour hiding inside “wrong”

Scoring a base model — no chat template, no instruction tuning — means handing it a few worked examples and letting it continue the pattern. Do that to a model too weak for the task and it does not produce a wrong answer. It produces the exemplar’s answer.

Here is the mechanism, as I wrote it into the handover at the time:

copy_rate is the metric to read first. A weak model in few-shot form doesn’t answer, it echoes an exemplar answer back (the xl said 89 for both arithmetic items, 3 for both char_count items). That scores identically to a wrong answer but is a different failure: nothing was computed. copy_rate falls before accuracy rises, so it shows learning while accuracy is still noise.

89 twice. 3 twice. Not two attempts at arithmetic that missed — one string, lifted and returned, the question ignored entirely. A right/wrong grader has exactly one bin for that, and it is the same bin holding every genuine miscalculation on the sheet.

So the eval has three behaviours and two labels. Compute and get it right. Compute and get it wrong. Don’t compute. The first is the only one that scores; the other two are indistinguishable in the column I was reading.

That would be a merely annoying loss of detail if the three moved together. The claim is that they don’t: a model stops copying before it starts computing, so across that stretch copies convert into misses, one label to the same label, and accuracy does not move. Stronger version — a model that has stopped copying can attempt its way off a lucky exemplar that happened to be right, so accuracy falls while the model improves, and the grader doesn’t lose the improvement signal, it inverts the sign of it.

I have partial evidence for that mechanism and I never observed the inversion. Both halves are below.

the run where both numbers agreed

The day before the 10.0 = 10.0 run, the head-to-head looked like this:

base arm      accuracy 10.0%   control 2.0%   copy_rate 16%   n=100
              capability shown (margin 8.0 > 2σ 6.0)

trained arm   accuracy  8.0%   control 2.0%   copy_rate 21%   n=100
              NOT DEMONSTRATED (margin 6.0 < 2σ 6.1)

Training loss fell 2.4373 to 2.4261 — real and significant by the trainer’s own measure. Capability did not follow.

I originally read that table as copy rate moving the wrong way, 16 to 21 — applying a standard to accuracy that I was not applying to the metric I was arguing for. Accuracy gets a noise band everywhere here. copy_rate never got one: the harness never computed it and I never asked. So I computed it. At n=100 the 2σ band on a difference of two proportions at 16% and 21% is about ±11 points. The observed move is 5. Inside the band, and by my own standard not a move at all.

Conceding that costs the section nothing, because the five points were never the point. What the run bought was a sentence written on 2026-08-24, before any number existed on the other side — and the sentence has an antecedent I left out of the first version of this piece:

Next training run should mix it in; the eval will show it working when copy_rate falls before accuracy rises.

“It” is a specific corpus — 49,999 deterministically generated computational items, wall-verified, built and unused. That is the intervention the prediction was written about, and not the one that satisfied it. The run that delivered 16 to 5 was a continued-pretrain under a digit-split tokenizer on a different corpus build, and the arm this sentence was written against was a different lane on a generic web/code/math corpus. A prediction that came true under a substituted condition is weaker than one that came true under its stated condition, and the honest version says so rather than presenting two days as one clean program.

One more thing this table does that I missed. If the sign-inversion claim is right, the run that falsifies it is a run where accuracy and copy rate move together. This is that run. Accuracy fell two points, copying rose five, both said the model got worse. The claim’s own falsification condition was met on the only day it could have been tested.

the confirmation, and what it does and doesn’t cover

The next day, 2026-08-25:

accuracy    10.0%  →  10.0%   (flat vs the base bar)
copy_rate     16%  →     5%   (95/100 attempted, up from 84/100)
training     ~30 of 400 planned steps
tokens       ~8M of 105M

Eleven points in copy rate against a 2σ band of about ±8.5 on that difference. Resolvable — and the only copy-rate move in this piece that is comfortably so.

Eleven items. Not ninety-five. Ninety-five of a hundred got a real attempt after the run; eighty-four were already getting one before it, because copy_rate was 16%. What moved is eleven items in a hundred that stopped being echoes and started being attempts — a ninth of what I claimed in the first draft of this piece. Eleven is still the whole argument, because the right/wrong column recorded none of it while accuracy sat at zero movement.

On roughly 7.5% of the planned training, because the pod died early. Less died with it than I first wrote: the step-450 snapshot survived via an off-pod snapshot lattice, which is the only reason there is a score at all, and a replacement was retraining the same afternoon, reproducing the original curve. That one died too — four pods across this chain, to two stacked causes since root-caused and fixed — and a completion run fired the next day behind the fixes. Whether the full 400 steps ever produced a scored result, I have no record. UNKNOWN. I am not going to tell you what 400 steps would have shown, because I did not read it.

copy rate separates two models that accuracy cannot order

The effect isn’t confined to one checkpoint’s before-and-after. Two different models on the same sheet:

500M rung   accuracy  7.0%   copy_rate 31%
xl trunk    accuracy 10.0%   copy_rate 16%

Three points of accuracy. Fifteen of copy rate. And once the skeptic pass nets both arms of copied hits the way it netted the flagship — the xl had four copies among its ten hits, the 500M two among its seven — the accuracy separation is 6 against 5. One item. Both arms sit at or below the 9.76 expected by chance, at +0.24 and −2.76. Accuracy does not order these two models at all. It puts both of them on the floor.

Copy rate does order them. Fifteen points against a 2σ of about ±11.8 — resolvable, and only just; 1.27 times a band is not a wide margin. But it is a separation on identical items at identical n, from a sheet where accuracy has no signal whatsoever. The information didn’t vanish when the grader collapsed two behaviours into one bin. It went into the bin I wasn’t reading.

then it turns out my cheap instrument leaks too

The retraction above turned on copied answers landing on gold and scoring as correct — four of the flagship run’s ten hits, netting it to 6/100. That is on the record elsewhere; I won’t re-litigate it.

What that incident says about the instrument, rather than the result, is the part worth keeping. copy_rate and ok were computed on the same rows, in the same pass, and nothing in the harness forbade a row from carrying both. copied_exemplar: true and ok: true were never treated as contradictory because nobody had written down that they were. A model that computed nothing and a model that got it right were the same row, and the sheet had no state to say so. The binary grader does not merely lose the signal — on some items it scores the absence of the capability as a demonstration of it, and it did that inside my own instrument.

The fix I owe is small and specific: make ok = true AND copied_exemplar = true report as its own third state rather than a success. It is a patch on a measurement that was always going to be fragile, because it depends on string-matching an answer against exemplars I happened to put in the prompt. Instrumenting copying is a stopgap. It is a better stopgap than not instrumenting it. It is not the fix.

the fix is task design, not a better label

The fix is to build the task so copying cannot produce a correct answer.

Start with the control rather than the headline. In argdep, a no-leak control confirms the value step two needs is absent from the request — not in the prompt, not in any exemplar, nonexistent until the model has actually run step one and produced it. A strategy that copies from the visible input scores zero on that control by construction, not by policy. A second control flips the argument and rejects a plausible decoy, confirming the model binds the value rather than pattern-filling the slot. Both passed. Against that pair, the capability itself went base 0/200 to trained 200/200 — published elsewhere in this corpus, and here it is the subordinate clause. The controls are the new thing.

The generalisation I’d defend is narrower than the one I reached for first. When a degenerate strategy can reach the gold value from the visible input, no amount of grader work makes the result safe — you subtract cheats forever and every subtraction is another thing to get wrong. Make the gold value causally downstream of the capability and the cheat scores zero without being detected at all.

What I can’t claim from this pair is that task design beats instrumentation in general, because they aren’t two graders on one task. argdep and the capability bar are different tasks, different training regimes, different scoring — structured tool-call fields versus free-form string match — and different item counts, 200 against 100. A task with parseable structured outputs is easier to grade, and some of argdep’s cleanliness is just that.

One more detail, because it says what the model had actually learned. A date item came back 2026-03-15 against a gold of 2026-03-16. Off by one day, a value no exemplar contained. Not a copy and not a computation: format and near-structure learned, arithmetic not learned, showing up in a single character. A right/wrong grader scores it identically to 89.

what I don’t know yet

The run that dropped copy_rate also changed the tokenizer to split digits, and every copied artifact I am counting is a number. 89. 3. A digit-split tokenizer with a digits-standalone gate mechanically changes how a model emits numeric strings — that is the entire reason it was adopted, and a standing memory law here says BPE number-merging caps arithmetic. I never ran the same corpus under the old tokenizer, so I cannot separate a model that stopped echoing from a tokenizer that made verbatim numeric echo harder to emit. That is the strongest confound in the piece, and it was not in the first version of it.

Behind it, the weaker one: no ablation separated “stopped copying” from “trained on fewer tokens than planned.” One arm, one seed, one truncated run.

The ±6 band I leaned on is not the band the audit left standing. The harness printed 2σ = 6.0 using 2·SE(accuracy) alone; a difference of two proportions needs 6.62, and with np(control) = 2 the normal approximation is invalid on the control arm, which wants an exact binomial or Fisher test rather than a sigma band at all. So “flat is a resolution statement, not a null” is true and then some — the resolution is worse than the number I quoted, and none of the accuracy moves here carry information. Which means I never watched accuracy fail to track learning. I watched an instrument with no resolution at n=100, and a second column on the same sheet that did resolve. That is a claim about which metric carries signal at a fixed sample size. The taxonomy claim — a copy and a miss being different failures under one label — rests on the copied-hits finding, a mislabel rather than a sample-size problem, and that is its only leg.

Sign inversion I have not observed. In the one run where accuracy fell, copying rose; both metrics agreed and both said worse. What I have is the mechanism’s ingredients: four hits that were copies, so copying demonstrably adds accuracy a model did not earn, and a model that stops copying gives those points back. A run where accuracy falls while copy rate also falls would show it. I don’t have one.

The third scoring state is owed and I have no record it shipped. Nobody has shown me the harness reporting it.

And copy_rate is defined against the exemplars in the prompt. It catches a model returning 89 verbatim. It says nothing about a model that emits an answer of the right shape without computing it. I used to file that as an untested worry; there is partial evidence it is real, one section away in the same source. In the routing task the trained model’s emitted expression copies both operands and the operator from the request and never the computed sum — structure lifted from the visible input, wrapped around a value downstream of it. That is the shape copy_rate cannot see, already measured, in a different lane. Whether the leading indicator survives a model good enough to fake the attempt would actually falsify the method, and I haven’t run it.

— Nothing Was Computed

← back to writing