Take It Out · labbook

1. What we are doing

A generator whose every output pixel is an exact, owner-labelled blend of training pixels, and an instrument around it that lets the viewer take a source out and watch the picture change. The viewer brings a drawing, generates from a small owned corpus (six public-domain artists plus a museum pool), reads the receipt, switches any artist or sheet off, and regenerates with the same noise. The instrument shows the difference map and pays contributors three ways side by side: by use (what the receipt says was copied), by leave-one-out (what changed when that one source was removed), and by Shapley (average change over all orders of removal). The viewer's own drawing is its own line in the receipt, because it steers the output more than any corpus source.

Working name: Take It Out.

Source: BRIEF.md (sections 0 and 1), read at build time.

2. Status

3. Engine

The generator is the patch-ledger ELS machine (Kamb and Ganguli 2025), ported with provenance and extended: explicit device and dtype, a true float64 CPU reference, float64 schedule arithmetic, an exact class sub-ledger and class removal. Every output pixel is an exact convex combination of training pixels, decomposed by owner: m(x) = Σ_c W_c(x) m_c(x), Σ_c W_c(x) = 1.

Test run

51/51 passed in 13.2 s · torch 2.12.0.dev20260315 · backends cpu/float64, mps/float32 · engine/tests/last_run.json sha256 3b97fdf3f565

Measurements recorded by the tests

Cost of one exact 32 px generation

Provenance of the ported code

Provenance of ORIGINAL/

Verbatim copies, never edited. Copied 2026-09-30T10:49:16Z from the earlier patch-ledger project.

Source hashes at copy time (must match):

• pl/__init__.py e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
• pl/machine.py 2ee175aa061da6dc30fe932f9415ba7219f109b84c7f390493e08540c8b6e4b4
• pl/corpus.py 0dea3aaedcc892e93a34bd3be92e801e3dc6be5824349b0099c23317ee98836b
• tests/test_machine.py ba583f25d321720c6f79a8c9fcdd9b4826d8f30bbceff4f914e594f790e7554b

4. Corpus

Rules

Build the Take It Out corpus (BRIEF.md M2).

Sources (read only, never edited):
  six artists   96 cleaned sheets from the hands books (five in hands/books, Rembrandt in know-between's book);
                metadata and licence from each book's things.json (museum-API or Commons records)
  commons       100 Met images in ZTOYBOX/Museum Pics named DP-*/DT-*.jpeg (Met image IDs). Verified afterwards against
                Met object records by corpus/verify_met.py (99 matched, all public domain; 1 duplicate download)
  msv           9 Cezanne Mont Sainte-Victoire paintings (Cezanne/CezanneReal; public domain by age;
                image source not recorded)

Rules (declared, deterministic):
  sheet crop    Book sheets still show the museum mount around the paper. Marks are pixels darker than the sheet's
                paper tone: the dark class of Otsu's two-class luminance split (guarded). The crop is the 1st to 99th percentile box of mark
                coordinates on each axis, grown by 2% of the image size and clipped. Paintings (commons, msv) are not
                cropped.
  views         As in patch-ledger (pl/corpus.py): from the crop, the centred square of its short side resized to a
                256 px master; view 0 is the master; views 1-3 are 128 px squares at positions drawn from
                numpy default_rng(crc32(id)); each view is resized to L (LANCZOS). Stored in [-1, 1].
  mark maps     The same crop and view geometry applied to the mark mask gives, per view and L, the fraction of each
                pixel covered by marks (for the blank-paper measurement).
  controls      CONTROL-duplicate: a verbatim copy of sheet du-01's views, a separate owner.
                CONTROL-scrambled: vg-01's views with pixel positions permuted (seed 7), colours kept, structure gone.
                CONTROL-constant: 4 constant images at value 4.0, outside the data range. At t = 1 the posterior is
                uniform over all patches, so every source touches every output at the first step; this control's
                influence is predicted to be that first-step share and essentially nothing after.

Sheet view profiles (paintings and the commons always use "half"):
  half          the patch-ledger rule above (view 0 = short-side square; views 1-3 = seeded half-side squares)
  marks64       the demo profile, chosen by the O12 tests (LOG.md 2026-09-30): 4 squares of side 64 source pixels
                (of the 1200 px book image), centres drawn inside the sheet crop box with probability proportional to
                the mark mask, from numpy default_rng(crc32("<id>|64|marks")); each resized to L. A declared choice
                that favours where the artist drew; stated on every receipt.

Outputs: corpus/build/L<res>/<id>.npy (half views, float32), <id>.marks.npy (mark fraction);
corpus/build/marks64/L<res>/<id>.npy and .marks.npy for sheets and controls; manifest.json; a contact sheet.
Run: python3 corpus/build_corpus.py

Every source, view 0 at 64 px

Mark detection

5. Source IDs and verification

Every source with its identifiers. Sheets: licence and accession recorded from museum or Commons metadata when the hands corpus was built. Commons: matched to Met object records by exact image filename (corpus/verify_met.py); unmatched files stay unverified. The last column is the first 10 hex digits of the source file's SHA-256.

Met verification (scope: cache only), 6615 object records: 99 files matched, 1 duplicate download(s), 0 unmatched, 0 matched but not public domain.

6. Duplicates

20910 pairs compared. Identical files: 0. Identical pixels: 0. Near-duplicates (normalised RMS distance below 0.35):

• met-dt872-1 and met-dt872: distance 0.0

Pair-distance percentiles: 0.1th 0.6008, 1st 0.8021, 5th 0.9919, median 1.2973.

Interpretation. The one near-duplicate is the same painting saved as two differently encoded files. Hash and pixel checks miss it, and because views are seeded from the id, the two copies even produce different training views. Dedupe now runs on the source image. This is the duplicate-gaming case of the brief, met naturally.

7. Measurement: does use-based credit over-pay blank paper?

Rule fixed in LOG.md before the run: F ≥ 2 in 3 of 4 seeds, pool paper use mass; F ≤ 1 in 3 of 4, no policy; otherwise inconclusive.

Verdict: NOT OVER-CREDITED: no policy

Paper fraction of each artist's use mass, per seed

Interpretation. Paper is not over-credited; by consequence it is under-credited. The reason matters more than the verdict: at 32 px a pen or graphite stroke is under one pixel wide, so the outputs are paper-toned blotches and removing every mark barely changes them. At this scale the instrument would pay artists for the colour of their paper. This became requirement O12.

8. Test: can a tighter crop make the marks matter (O12)?

Rule fixed in LOG.md before the run: a configuration passes if Q = R_mark / R_paper ≥ 1 in at least 3 of 4 seeds; among passing ones prefer the largest crop, then uniform placement.

Choice: None

Interpretation (written after the result). The crops worked on the training data: at 64 px strokes are several pixels wide, and the marks' share of use rises from about 0.2 to 0.6 with tighter, mark-centred crops. Q stays below 1 because the criterion compares removing all paper with removing all marks under pixel MSE, which weights area; even a resolved drawing is mostly paper. The criterion measured whether marks dominate the area, not whether they carry the hand. A measurement-design error in O12 as written.

Second test: the edge value function (designed after the first test, registered before it ran)

Same corpus builds, seeds and conditions for the two 64 px configurations; removal effect measured on Sobel edge maps of luminance instead of pixels. Pass: Q_edges ≥ 1 in at least 3 of 4 seeds.

Confirmation on the final corpus (paid-artist works removed from the commons)

Registered before it ran: the chosen configuration re-run on the corpus as it now stands, same seeds, same rule. The pixel Q is expected to differ from the first test here, because the corpus changed.

Exclusions in force: 14 (met-dp-20099-001, met-dp124808, met-dp320128, met-dp346474, met-dt1396, met-dt1494, met-dt1926, met-dt1939, met-dt1943, met-dt1947, met-dt1977, met-dt2163, met-dt403, met-dt872-1).

9. M3: the removal instrument's first run

Protocol measure/M3_PROTOCOL.md, frozen before any run (measure/m3_freeze.json). Game A: the six artists, commons as baseline. Games B and C: planted controls with and without the duplicate. Seeds 6000 to 6003; exact Shapley over all 64 coalitions.

Shares by rule, edges value function, four seeds

Post hoc: how visible is removing one artist?

Mean absolute change in 0 to 255 levels (fraction of values changing by more than 8 levels). Not predicted; computed after the verdicts.

Interpretation. The instrument measures exactly (efficiency to 1e-16, the duplicate symmetric) and separates use from consequence by about a third of the money. The constant control earning 3 to 7% shows removal credit paying for trajectory perturbation through the t = 1 average; that needs a design fix, registered before testing, before any payout is shown. Single artists move the picture only a few levels; the page shows the difference map with an adjustable gain.

10. The t = 1 vote and its fix (T0FIX)

M3's constant control (a source of nonsense images) earned 3 to 7% of the credit. Two exploratory diagnostics, then a protocol frozen before its run (measure/T0FIX_PROTOCOL.md).

Diagnostic 1: how much of a source's removal effect enters at t = 1?

Interpretation. At t = 1 the posterior ignores the picture: every source votes by head count in a blind average, and the trajectory carries the shift. All of the constant's effect, and half of a real sheet's, is that vote.

Diagnostic 2: chaos floor, leave-one-out effects (pixel MSE)

T0FIX results (schedule S1, paired with M3)

K2 re-check on the float64 reference (registered after the results, before running)

HOLDS: S1 adopted (instrument/config.py)

11. How big a pool can the demo keep?

Rule fixed in LOG.md before the run: an artist is visible at pool size N if its median removal change is at least 5 levels of 255; choose the largest N with at least 4 of 6 visible, else the smallest tested. Schedule S1, seeds 8000 to 8003.

Choice: pool of 10 (none passed: smallest N)

Interpretation. A smaller pool raises the artists' share of the picture from about half to about nine tenths, but a single artist's removal levels off at 3 to 7 levels: the other five hands fill in. The page shows single removals through the difference map, with the gain stated.

12. Receipts, verifier and the page

Receipts (receipt/make.py, format take-it-out-receipt/1) record generator and corpus hashes, the request, every coalition's value and output hash, and the credit, under a SHA-256 seal. The verifier (receipt/verify.py) is written independently of the instrument. The page (page/, served on 127.0.0.1:7472) reads sealed receipts only.

Tamper tests

Found by these tests: the first verifier compared only regenerated output hashes, so a receipt with a forged value, recomputed consistently and re-sealed, passed even a full replay. Fixed: the replay also recomputes every value exactly. A spot replay remains probabilistic, and the page says so.

13. M4: the viewer's drawing as a paid party

Protocol measure/M4_PROTOCOL.md, frozen before any run. The drawing is a seventh player: absent, sampling starts from noise; present, it starts at step k from the drawing blended with the same noise. Three test drawings, k in 4, 9, 14, seeds 9100 and 9101, commons 10, schedule S1.

Post hoc: lines or paper? (exploratory, after the verdicts)

Share of the drawing's effect added by its lines on top of a blank sheet in the same paper colour.

Interpretation. By pixels, 94 to 99% of what a drawing does is its paper tone; by edges the lines matter more and rise with k. The drawing is paid mostly for its paper, as the artists were in M2. Next: register a split of the input into ground and lines. At k = 14 the drawn shape appears, made of the artists' marks.

14. SPLIT: the drawing as paper and lines

Protocol measure/SPLIT_PROTOCOL.md, frozen before any run. The input becomes two players: its ground (a blank sheet in the corpus paper colour) and its lines (the drawing minus that sheet, float64, so the two add back to the drawing exactly). Same seeds, drawings and pool as M4; k in 9, 14; 256 coalitions per game.

Shares per case

Splitting a player moves the others' pay (reported, not predicted)

Interpretation. By pixels a drawing is paid for its paper (lines 0 to 13%); by edges at k = 14 its lines out-earn its paper, and the lines' share grows with strength. Cutting the input into two players lowered the artists' total by 0.008 to 0.12: Shapley is not splitting-proof, so a payee could raise their share by declaring more parts. Decision: the split is shown as description only; pay uses the drawing as one player. Cross-run check: the one-player game read off the split game reproduces M4's separately run Shapley values exactly (difference 0 in all 24 case and value-function pairs, computed in the page).

15. POOL: does the use gap grow with the pool?

Protocol measure/POOL_PROTOCOL.md, frozen before any run. Nested commons pools N = 86, 43, 21, 10 (one fixed order); fresh seeds 9200 to 9203; six artists as players; S1, MPS float32.

Why: the pool substitutes for the artists

Interpretation. By pixels (and blur, colour) paying by use drifts further from Shapley as the pool grows; by edges there is no trend (P2 failed). Leave-one-out does the opposite: it drifts as the pool shrinks, because the artists then make up most of the mass and substitute for each other. No cheap rule tracks Shapley across pool sizes, so the receipt states the rule and the pool size, and exact Shapley pays wherever it is affordable.

16. M5 diagnostic: can exact credit be bought cheaply?

Exploratory (measure/m5_prune_diag.py): one trajectory, CPU float64, 64 query pixels per step, every allowed candidate computed exactly. need: the fewest candidates holding all but 1e-6 of the mass (the ceiling for any pruning). certified: candidates a scheme with a provable bound must evaluate (projection onto the top 16 principal directions).

Interpretation. The posterior is broad until the last steps: an oracle saves 1.4x over the schedule, a certified bound 1.05x to 1.10x. Pruning is retired as the speed lever; 64 px receipts will be precomputed, and any structural speed-up is a declared model change.

Cost at 64 px (one full-coalition picture each, MPS float32)

Resolution alone does not make drawings appear; the viewer's drawing does (M4, SPLIT).

17. RESOLVE: can you tell in advance whether credit is recoverable?

Protocol measure/RESOLVE_PROTOCOL.md, frozen before the sweep (measure/resolve_freeze.json). The attribution literature retreats to crediting data groups because exact removal needs retraining; here removal is exact, so the question can be asked directly: does a bank's geometry decide whether credit to its individual members is recoverable? 16 banks of 7 from the 205 sources, 4 noise seeds, exact Shapley over 2⁷ = 128 coalitions per game, CONTROL-constant as the baseline so the empty coalition is defined, schedule S1, MPS float32, 64 games. Primary measure R: the Spearman correlation between the per-member Shapley vectors from two different noise seeds, averaged over the 6 seed pairs. A ranking that cannot be reproduced is not credit.

Verdicts against the frozen predictions

The headline question is answered no. R is not flat (edges 0.006 to 0.702 across banks, pixel 0.202 to 0.851); it simply does not vary with anything measured about the corpus. The hoped-for capability, telling a contributor at ingest whether their collection is individually creditable, does not follow from either predictor, and compositional vocabulary is retired as a candidate value function. R2 failing is its own small result: 7 paintings of one mountain give R = 0.488 and 6.94 of 7 effective members, indistinguishable from any other bank, so compositional near-duplication does not make contributors interchangeable here.

Control bank, before the sweep

The first control run failed K4 at 2.9 to 6.5% and is kept as measure/resolve_controls.S0_failed.json. The cause was the runner, not the bank: Machine.__init__ defaults to schedule S0 and neither script had set S1, so the values reproduced M3's T5d almost exactly. Fixed and rerun. The planted duplicate pays exactly 2.0000 of du-01 alone on usage while taking the same Shapley share as its twin.

Per bank

What was not predicted: credit is near-uniform under pixel MSE

Across all 64 games, exact Shapley under pixel gives a largest-to-smallest member share ratio with median 1.02, never above 1.06, so every game reads 7.00 of 7 effective members. In the same games usage mass varies by 2.92× and leave-one-out by 2.37×. Under edges Shapley does discriminate (ratio median 2.00) but its ranking reproduces only moderately. The three payout columns therefore disagree structurally, not marginally, on the same bank in the same run.

Alternative explanation, stated. This uniformity is equally consistent with the weakness O12 already recorded for pixel MSE, that it weights area: seven members each supplying about a seventh of a 32 px mosaic would give near-equal pixel effects for that reason alone. This run does not separate “credit is uniform” from “pixel MSE cannot see it”, and the two have opposite consequences for per-item settlement. It is carried as an open question in BRIEF section 13, testable by re-running the frozen banks with a third value function and at 64 px. Either way it is direct support for design rule 9: the value function is a declaration, and the same bank yields uniform or discriminating credit depending on which one is declared.

Scope: 32 px, banks of 7, one engine, 191 sources, two value functions. Exact Shapley is only available at this scale; nothing here speaks to banks of thousands.

Banks span the predictor from 1.017 to 3.142; the composition and pixel predictors correlate at 0.024 across them, and bank overlap is 0.18 shared members per pair (max 1), so R1 and R5 are separable and the banks are close to independent.

Stage two: attention

Machine: engine/tio/static_attention.py, Riley's static-attention construction with several heads and support-aware rank handling from Russell's library (ch. 48); 9/9 tests, including agreement with Riley's code (2.9e-15) and a brute-force Gaussian (1.0e-15). Exact vs frozen attention law: instrument/attention_law.py (ch. 49), matching the library's Study 13 fixtures to 1e-16.

ATTN1: does attention change who gets paid?

Interpretation. Attention shares information across patches; the posterior collapses toward one image, pay concentrates, use drifts from Shapley, and with global attention one output is a verbatim copy of an unpaid commons painting while the artists are paid 100%. Receipts now report the nearest training image and the players' total effect beside the shares.

ATTN2: do frozen-attention receipts report the source?

Last step, beta 4: exact posterior r, then the frozen receipt m, over cezanne, durer, ingres, kollwitz, rembrandt, vangogh, pool.

Interpretation. Plugging realised attention into the static formula pays a near-fixed Dürer/Kollwitz split whatever the picture, while the exact posterior names a different artist per seed. Static-attention receipts are not receipts for attention models. Limits: scalar tokens, one head, 16 px greyscale, row retained; posterior accounting, not removal credit.

Reconciliation with Riley Peterlinz's repository

github.com/CardiacMangoes/diffusion at commit 6b757a546369, used with his permission. Script measure/riley_reconcile.py, CPU float64.

Our engine equals the repository's whole-image form, and its static-attention form at patch size 1 with S = I up to the jitter level. Removal is exact in the static-attention form, so the removal instrument applies to it unchanged. Russell's library (ch. 48) extends the same construction to several heads with an exact rank condition; engine/tio/static_attention.py implements that and is checked against both (9/9 tests).

Receipts format 3: context and planted controls

Every receipt states the players' total effect, their share of all posterior mass and the nearest training image (copy flag), and runs its own planted controls (T0FIX game B on its own noise and pool; rules F1 to F3 from T0FIX, registered on the 86-painting pool). Main games are bit-identical to formats 1 and 2. Demo receipts (pool 10) and paid receipts (pool 86, receipt/receipts_full/, made 2026-10-02 by receipt/make_paid.py, which calls make.py unchanged), edges:

With the 10-painting demo pool the nonsense contributors' shares exceed the 1% rule on 2 of 4 seeds (the 86-pool test never exceeded 0.0036). Decision: paid receipts use the full pool; the visual demo keeps the 10-pool, labelled. On the full pool every control passes on all four seeds.

Sketch receipts

receipt/make_drawing.py: the drawing as one paid player at strength k = 14, pixels stored for replay, paper and lines as description. Edges:

6922bc251f is the circle test drawing (seed 9100): it matches M4's frozen run to three decimals and its replay is bit-identical. 1c2e1bd456 was made from the page.

Running elsewhere: Colab Tesla T4 (O9)

Tesla T4, Python 3.13.15, torch 2.11.0+cu128 (this Mac: torch 2.12.0.dev20260315, MPS). Shipped receipt replayed on CUDA: worst value difference 0.005 of the tolerance. Fresh receipt on CUDA against the shipped one:

Engine T3 (masses sum to 1) measured 1.5e-5 in float32 on CUDA against a 1e-5 threshold taken from MPS runs; a plain log-sum-exp on the T4 is tight (2.4e-7), and the error grows at the last, lowest-noise step with the log-mass magnitude. T3 is now pass/fail in float64 and a reported measurement in float32.

Stage two (O7): the bridge to trained networks

Protocol measure/O7_PROTOCOL.md, frozen. 64 px, demo pool, width-128 convolutional networks (patch-ledger recipe, ported with provenance). Phase A trains the full network, calibrates the machine to it and gates on agreement (median r >= 0.85); phase B trains six leave-one-artist-out networks and a second full network (training-noise floor); phase C (direction, resolvability, magnitude) runs after.

Gate: median r 0.970 vs 0.85: passed.

2026-10-01 23:26:55 end (exit 0) python3 stage2/train.py --L 64 --seed 0 --steps 10000 --tag no_rembrandt --exclude rembrandt
2026-10-01 23:26:55 start python3 stage2/train.py --L 64 --seed 0 --steps 10000 --tag no_vangogh --exclude vangogh
done no_vangogh in 6008s
2026-10-02 01:07:04 end (exit 0) python3 stage2/train.py --L 64 --seed 0 --steps 10000 --tag no_vangogh --exclude vangogh
2026-10-02 01:07:04 start python3 stage2/train.py --L 64 --seed 1 --steps 10000 --tag full_s1
done full_s1 in 6007s
2026-10-02 02:47:13 end (exit 0) python3 stage2/train.py --L 64 --seed 1 --steps 10000 --tag full_s1
2026-10-02 02:47:13 PHASES A AND B COMPLETE

Phase C results

D: rows are the machine's predicted change for removing an artist, columns the network trained without an artist; diagonal in bold.

F and M (edges): finished-image distance from full_s0, median over 16 noises; training-noise floor (full_s0 vs full_s1) 0.064.

Interpretation. Direction transfers at 64 px (p = 1/720, positive at every step); size does not (Spearman across artists negative); single-artist removal is visible above training noise for one artist. Limits: one start seed for the leave-out networks, one network family.

18. Re-trace every step

Run from this experiment's folder, in order (steps that need data or clones outside it say so). Hashes are the first 12 hex digits of SHA-256 at the time this page was built; if a script's hash differs from the one here, the results on this page came from a different version of it.

19. Sources

From BRIEF.md section 11, read at build time.

Status key: R read in full; P read in part; U used as data; X external, not yet read. Originals are never edited; copies are made into this project with provenance.

11.1 Local sources (paths relative to the local research archive)

11.3 Literature

Checked means the source page or full text was read on the date shown (carried from the patch-ledger paper unless stated).

---

20. Log

From LOG.md, newest first.

2026-10-14 (RESOLVE sweep complete: the headline prediction FAILS, and credit is near-uniform)

64 bank-seed games, 16 banks of 7, 4 seeds, 128 coalitions each, schedule S1, MPS float32. Run against resolve_freeze.json; the six games that survived a session crash mid-run verified against the freeze and were kept, the rest resumed. Results in measure/resolve_results.json, per-game files in measure/resolve/.

Verdicts against the frozen predictions

The headline question is answered no. Credit reproducibility is not predicted by the bank's geometry, in either space. R is not flat (edges: 0.006 to 0.702 across banks; pixel: 0.202 to 0.851), it simply does not vary with anything we measured about the corpus. So the hoped-for product capability, telling a contributor in advance whether their collection is individually creditable, does not follow from either predictor. The vocabulary-as-value-function idea is retired, which is the reason this was run before building it.

R2 failing is its own small result: 7 paintings of the same mountain give R = 0.49 and 6.94 effective members, indistinguishable from any other bank. Compositional near-duplication does not make contributors interchangeable in this posterior.

The larger finding, which was not pre-registered

Across all 64 games, exact Shapley under pixel MSE assigns essentially uniform credit: the ratio between the largest and smallest member share has median 1.02 and never exceeds 1.06, so the effective number of credited members is 7.00 of 7 in every game. In the same games, usage mass varies by 2.92x and leave-one-out by 2.37x, median.

Under the edge value function Shapley does discriminate (share ratio median 2.00), but the ranking it produces reproduces across noise seeds only moderately (R median 0.45) and unpredictably.

So the three payout columns do not disagree at the margin, they disagree structurally: usage says some members matter three times more than others, Shapley-on-pixels says every member is equal, and leave-one-out says something else again. TV(use, shapley) median 0.144 on pixel and 0.112 on edges.

Alternative explanation, stated: the uniformity under pixel MSE is consistent with the weakness O12 already recorded for that value function, that it weights area. Seven members each supplying about a seventh of a 32 px mosaic would produce near-equal pixel effects for that reason alone. This run does not separate "credit really is uniform" from "pixel MSE cannot see the difference", and the edge criterion exists in this project precisely because of that failure mode. Design rule 9 gains direct support: the value function is a declaration, and the same bank yields uniform or discriminating credit depending on which one is declared.

Scope

32 px, banks of 7, one engine, 191 sources, two value functions. Exact Shapley is only available at this scale. Nothing here speaks to banks of thousands.

2026-10-14 (RESOLVE steps 1 and 2; protocol frozen, sweep not yet run)

Banks built and the control bank checked. No sweep result exists. measure/resolve_freeze.json written 2026-10-14T14:21:55Z over the protocol, the four scripts, the bank file, the engine, instrument/removal.py, corpus/load.py and the manifest.

Five corrections came out of doing steps 1 and 2, all before any frozen result.

• Cost was wrong by about four times. The protocol's estimate counted one image per bank member, but every source contributes 4 views and the baseline adds 4 more. Banks of 10 would have been 44 images, 1.76 s per generation, 1024 coalitions, 12.0 hours. Banks of 8 give 36 images, 1.44 s, 256 coalitions, 6.1 min per bank-seed, 2.5 hours for 6 banks x 4 seeds. Measured on two real bank-seeds: 342.2 s and 339.6 s, so the corrected arithmetic holds. Bank size changed to 8; exact Shapley stays exact and the predictor is still stable.
• The spine decision was wrong. It read the spine on the L64 views because "the machine sees nothing else". An L64 view is 4 x 3 x 64 x 64 and the Parallax Portrait config is tuned for a 1536 px long edge: edge_margin_px = 2 discards 6% of each edge at 64 px against 0.13% at 1536, and mt_min_island_distance = 24 spans 37% of the frame. Replaced by each source's crop at native resolution. A pixel control predictor in L32 view space was added beside it, which turns the "different spaces" objection into measurements R5 and R6.
• K4 was unattainable as written ("constant receives exactly 0"). The project already knew: M3's T5d failed at 3 to 7% under schedule S0, and T0FIX replaced the schedule with S1 and set the standard at under 1%. K4 now reads that way. K1, K3 and the duplicate reproduction are likewise pre-validated by M3 and T0FIX.
• The first control run failed K4 at 2.9 to 6.5%, reproducing M3's T5d almost exactly. The cause was the runner, not the bank: Machine.__init__ defaults to S0 and neither script had set S1. Kept as measure/resolve_controls.S0_failed.json. Fixed with machine.schedule = default_schedule()[1:] in both runners.
• Corpus.subset keeps the original owner indices rather than renumbering, which made the first sweep attempt raise "a coalition has no present contributor with images". Also found: corpus/load.py drops 14 paid-artist commons entries, and sheet views live under corpus/build/marks64/L32 while paintings use corpus/build/L32.

Control bank, schedule S1, after the fix: all four pass. K1 efficiency 2.78e-17; K2 coalition mask equals the physically reduced corpus at exactly 0.0 on CPU float64; K3 scrambled 0.000 to 0.006 of positive Shapley mass; K4 constant 0.0002 to 0.0004, against 0.029 to 0.065 under S0. The planted duplicate pays exactly 2.0000 of du-01 alone on usage while taking the same Shapley share as its twin (0.0058 each on edges).

Banks (measure/resolve_banks.json): six of eight, composition predictor from 0.978 to 3.053 (3.1x). The composition and pixel predictors correlate at Spearman +0.60 across the banks and dissociate usefully: ingres8 is the closest bank in pixel space (6.4) but mid-range in composition (1.6).

Baseline decided: CONTROL-constant alone for the sweep banks, because the POOL round measured that a commons pool substitutes for removed members and would mask the ranking R is trying to reproduce; the commons pool for the control bank, so it matches M3 game B unchanged.

Re-cut before any run, same day: 6 banks of 8 became 16 banks of 7. The first freeze was discarded unused. Reason: R1, R5 and R6 are correlations across banks, so the bank count is the sample size for the headline claim, and 6 is not enough. At 6 banks the registered R1 threshold of +0.6 carries p = 0.21 two-tailed and significance would need rho = 0.81; at 16 banks the same +0.6 gives p = 0.014 and the threshold for p < 0.05 falls to 0.50. Cost is 32 images, 2.7 min per bank-seed, 2.9 h for 16 x 4, against 2.5 h for the underpowered version. Trading one member per bank for ten more banks barely changes what the question means and is the difference between answerable and not.

Two unplanned improvements came with it. The twelve filler banks are drawn by binning 3,000 seeded candidates on the predictor and taking one per bin, so coverage of the x axis is built rather than hoped for, and composition now spreads evenly from 1.02 to 3.14. And across the 16 stratified banks the composition and pixel predictors correlate at +0.02, against +0.60 across the old 6, so R6's partial correlation is no longer fighting collinearity. Bank overlap is 0.18 shared members per pair, maximum 1.

Frozen again 2026-10-14. All 16 banks dry-load at 7 players, 32 images, 19 schedule steps (S1).

Next: python3 measure/resolve_run.py run (about 2.9 hours, resumable), then resolve_analyze.py.

2026-10-14 (prior-art sweep on RFS's transformer notes; RESOLVE drafted, not frozen)

No run. Prior-art sweep on RFS_transformers and on the attribution literature, with the results added to BRIEF 11.3 (one row upgraded, four added).

• The contraction mathematics in those notes is published. Lemma 1 (Dobrushin contraction on attention rollout) is Rola, arXiv:2610.05558, 4 October 2026, which also proves the equality condition the notes lack and measures how often it holds across eight trained models (essentially always for DINOv2 and the language models, 91% for DeiT-B, 64% for ViT-B/16, 11 to 44% for FT-Transformer). Theorem 2 has the shape of Mitrophanov's 2005 ergodicity-coefficient perturbation bound; the collapse picture is Dong, Cordonnier and Loukas, ICML 2021. Decision: do not build contraction or drift-bound experiments in this project. Three were sketched on 2026-10-13 (credit-resolution decay, receipt drift bound, non-closure as a settlement rule) and all three are dropped. Russell's own DINOv2 measurement in russell/disagreement-halflife already tested the mechanism on 1,341 portraits and did not support it once input spread was matched, which is stronger evidence than those experiments would have produced.
• Already in the registry, re-checked: Zhao et al. arXiv:2510.14269 (read in full 2026-09-19) and Lin et al. ICLR 2025 arXiv:2407.03153 (checked 2026-09-19). The second is the published form of the collection-level credit conclusion, so this project does not get to claim that conclusion as new.
• Newly registered: Wang, Hertzmann, Efros, Zhu and Zhang, NeurIPS 2024, arXiv:2406.09408, which states the premise from the other side (exact removal is the gold standard and is infeasible, so they simulate unlearning); and arXiv:2401.09031 on timestep-induced bias, whose topic the 2026-10-02 sweep had already found to be known.
• Gap this project still occupies: removal here is exact and costs one rerun. What the literature lacks is not a contraction theorem but a statement of when individual credit is recoverable at all. ICLR 2025 concludes "use groups" without saying which groups or why.
• Drafted: measure/RESOLVE_PROTOCOL.md. Does a bank's compositional spread decide whether credit to its individual members is recoverable? Not frozen, nothing generated, no bank built. Order of work is in the file: build banks, run the control-bank checks K1 to K4, freeze, then sweep.

2026-10-02 (Patch Ledger paper, version 2)

report/build_paper_v2.py builds ~/Documents/parallaxmetrology/patch_ledger_paper.v2.html from the first draft there (read only, unchanged) plus this project's frozen results, every number read from the result files. Added: section 3.10 (the blind first step: M3 T5d, the t = 1 and chaos-floor diagnostics, T0FIX, the float64 K2 recheck), section 4.6 (O7 at 64 px), key findings 12 and 13, design rule 8, a related-work paragraph, and rows or items in the evidence ledger, sections 6 to 8 and appendices B and C; two references (Lin, S. et al. 2024; Xie et al. 2024). Prior-art search on 2026-10-02: the mechanism (the terminal step predicts the data mean) and timestep bias in influence estimators are known; not found: the effect as a real counterfactual change paid by exact credit, measured with planted null sources, with starting below pure noise as the remedy. Stated in the paper: the first draft's study 1 sampled from t = 1, so its numbers include the vote and have not been rerun. Then added: section 3.11 (study 1's usage, duplicate and generation-time-input findings re-tested on this corpus under T0FIX F3/F4, M4 D1/D3, POOL P1/P3; SPLIT post hoc), key finding 14, design rule 9 (declare the unpaid pool and each party's division), the 64 px size result beside section 4.5's "No evidence", and section 3.10 in the reading guide by role.

2026-10-02 (paid receipts on the full pool; two frozen versions preserved)

Paid receipts, seeds 9000 to 9003, 86-painting pool (receipt/make_paid.py, make.py unchanged; receipt/receipts_full/): every planted control passes on 4 of 4 seeds (constant at most 0.78%, scrambled at most 0.37%, copy ratio 1.91 to 1.99; the 10-painting demo pool failed one control on 2 of 4). With the full pool the six artists hold 48% to 63% of the posterior mass (demo 89% to 94%) and their total effect under edges is 0.073 to 0.156 (demo 0.237 to 0.373). Shapley shares, edges: Ingres first on every seed (0.25 to 0.27). No copies (nearest training image 42.4 to 48.9 levels against typical 72.8 to 77.6). Verifier on every receipt: all checks pass. Page: a Pool selector (10 paintings, visual demo / 86 paintings, paid receipts); browser-checked on seed 9000 with a 4-combination replay (bit-identical, V1 to V7 pass). Report finding 15, built list and open items, labbook receipts section and status rows (M6, O6) updated.

Freeze audit while preparing the package: 91 frozen file hashes match; two do not, both engine/tio/static_attention.py (ATTN1 and ATTN2 froze it). Traced from the session record: after ATTN1 the documented batch-invariance fix (above, ATTN1 K2); after ATTN2 a docstring wording change only (code identical with docstrings removed). Both earlier versions reconstructed by reversing the recorded edits; each matches its freeze hash exactly. Kept, read-only, in measure/frozen_code/ with a checker (check.py, 2/2) and instructions for re-running either test exactly. Frozen files themselves untouched.

2026-10-02 (preparing to share: names and channel references removed from the brief)

For sharing: the brief no longer cites team-channel or thread IDs or names people from team discussion; those sources are described by date and topic. One phrase in section 2 reworded ("keeps returning to one question"). A stale description of a collaborator's public profile was replaced. Credit for work (Riley Peterlinz's construction and repository, RFS's training-data release) keeps its names. Labbook rebuilt (it embeds the brief's source list).

2026-10-02 (O6 cost table; paid receipts on the full pool started)

measure/o6_cost.py -> measure/o6_cost.json (measurement): one full-coalition picture, MPS float32. At 32 px: pool 10 (424 images) 11.3 s, 21 (468) 12.7 s, 43 (556) 15.6 s, 86 (728) 20.7 s: time grows about linearly with the images in play. At 64 px: pool 10, 148 s; pool 86, 258 s. GPU memory flat at 1.1 GB (32 px) and 2.2 GB (64 px) because the engine works in chunks. A receipt (64 artist coalitions plus 64 control coalitions) at most 0.4 to 0.74 hours at 32 px and 5.3 to 9.2 hours at 64 px. Speed measured in M5 (pruning 1.05 to 1.10x) completes O6. Paid receipts on the full pool (receipt/make_paid.py, wrapper around make.py, unchanged; output receipt/receipts_full/) started for seeds 9000 to 9003.

2026-10-02 (O7 result: direction transfers strongly at 64 px; size and finished-image visibility do not)

Phase C finished 09:22 (measure/o7_results.json; frozen record stage2/phase_c_freeze.json). Ledger reconstruction of the machine's predictions 1.3e-7 to 1.9e-7 at every step.

• P1 HOLDS: direction, p = 1/720, the smallest possible (S = 0.142; own-prediction rank per network cezanne 1, durer 2, ingres 1, kollwitz 1, rembrandt 1, vangogh 2). At 32 px the patch-ledger had S 0.039 and 0.059: the specificity is stronger at 64 px.
• P2 FAILS: 1 of 6 artists resolvable above the training-noise floor in finished images (edges floor median 0.0636; artists cezanne 0.0081, durer 0.0258, ingres 0.0228, kollwitz 0.0365, rembrandt 0.1248, vangogh 0.0261; only Rembrandt exceeds it).
• P3 FAILS: Spearman -0.14 between the machine's exact leave-one-out sizes and the networks' (edges). Rembrandt is the largest network effect (0.125) and the smallest machine effect (0.0077).
• P4 FAILS, in the opposite direction from the 32 px pattern: the per-step direction agreement is positive at every measured step (t 0.85: 0.040, peak near t 0.4 to 0.55, t 0.15: 0.119); at 32 px it was negative in the early, noisy steps.

Reading: at 64 px the exact machine tells which way a trained network changes when an artist is removed, more specifically than at 32 px, and from the noisiest measured step on; it does not tell how much, and in finished images single-artist removal is mostly below the difference between two training runs. Limits: one start seed for the leave-out networks; a network's leave-out difference includes training divergence (same start weights, different data), the floor uses a different start seed; one network family (convolutional, receptive field 17).

2026-10-02 (O7 phase B complete; phase C frozen and running)

Phase B finished 02:47 with no errors: no_cezanne, no_durer, no_ingres, no_kollwitz, no_rembrandt, no_vangogh and full_s1, about 100 minutes each. Phase C frozen 04:43 (stage2/phase_c_freeze.json: the code, the protocol, the calibration and all eight networks' final.pt hashes) and started (stage2/phase_c.log), estimated 5.5 GPU hours.

2026-10-01 (O7 phase C code written and tested; not yet frozen)

The Claude session crashed mid-afternoon; the overnight run (a separate process) was unaffected: no_cezanne finished 16:20, no_durer started 16:20. stage2/phase_c.py implements the protocol's D, F, M and T exactly (D ported from patch-ledger score_test.py). Tests: (1) CPU smoke on one noise and two steps with the two finished networks: the per-contributor ledger reconstructs the machine's prediction to 1.8e-7 and 2.2e-7 (float32); (2) synthetic_check() on planted data (network changes = machine predictions + noise for the matching artist): D recovers the planted assignment at the smallest possible p (1/720), every own-rank 1; F and M computable (6 resolvable, Spearman 1.0). Each stage now saves its pieces to stage2/phase_c/. Freeze (stage2/phase_c.py freeze, code plus every network's final.pt hash) after phase B completes, then run; estimated 5.5 GPU hours (machine leave-one-out at 64 px dominates).

2026-10-01 (O7 phase A: the gate passes, median r 0.970)

full_s0 trained 10:33 to 12:26 (113 minutes, 10,000 steps, 64 px). Calibration 12:26 to 14:11 (105 minutes): the machine's best patch size per step falls from coarse to fine as noise falls, 13 13 13 13 13 11 9 9 7 7 7 5 5 5 5 3 3 3 3 (t 0.95 to 0.05). Agreement on 8 noises (seed 70000): Pearson r 0.965 to 0.973, median 0.970 against the registered 0.85: gate passed (prediction G held). At 32 px the patch-ledger reference was 0.94. Phase B started 14:35 (six leave-one-artist-out networks and full_s1; about 113 minutes each, finishing about 03:50).

2026-10-01 (RFS's cost arithmetic, checked)

measure/rfs_scale.py reads SCALE.md from his zip (read-only): people $311,825 of $319,421 = 97.62% (stated as 98%); edit triplets $170,000, 22.5 times the $7,562 compute. Under the same assumptions one training run is about 420 GPU-hours, $1,260; ten group-level retrainings (how removal credit is measured on trained models) about $12,603, 4.0% of the people bill. Added to the findings' smaller results as arithmetic on his stated assumptions.

2026-10-01 (how strong each registered result is: sign tests and family-bootstrap intervals)

measure/intervals.py -> measure/intervals.json (post hoc; verdicts unchanged). Independent units are noise seeds. With four seeds the best possible one-sided sign-test p is 0.0625 (POOL P1, ATTN1 Q3, ATTN2 R2, O12 all 4/4, p 0.0625); with two seeds (M4, SPLIT) it is 0.25. No single registered result reaches p < 0.05 on its own. Effects are large relative to seed spread (e.g. SPLIT L1 paper minus lines 0.581 [0.532, 0.629]; POOL P1 0.119 [0.102, 0.136]); POOL P2, which failed, is the one interval containing zero (0.053 [-0.007, 0.113]). Bootstrap over 2 to 4 seeds understates uncertainty; stated in the findings. Added to the findings as "How strong each result is", with RFS's release in the smaller results.

2026-10-01 (RFS's training-data release: read and reproduced)

RFS_training/training-data.zip unpacked to the scratchpad (original untouched). check.py: 109/109; check.py --rebuild: the rebuild reproduces the identical release fingerprint, 110/110; evaluate.py re-run: evals/report.json byte-identical to the shipped one. The toy attention training (tens of CPU minutes) was not run while stage two holds the GPU. Links to this project: its record mapping separates what went into a picture, how payment is divided (shares) and measured influence ("needs its own method and its own evaluation"), the separation this project measures (use, LOO, Shapley); its tombstone record asks for a review of models trained on earlier releases, the question O7 tests; family splits, a graded oracle and the attention-map caveat parallel this project's duplicate rule, planted controls and ATTN2. Opportunity taken from it: intervals and sign tests for this project's per-seed results.

2026-10-01 (resumed: paid sketch receipts work end to end; stage two launched)

• First sketch receipt run failed at the last stage: the shared receipt writer listed the drawing as a corpus party (KeyError 'input'). Fixed in receipt/make_drawing.py (artists only passed as request players; the drawing is described in request.input and named "drawing" in results.players); receipt/make.py untouched.
• Circle test drawing, seed 9100, k 14 (receipt/receipts/drawings/6922bc251f_*): verifier V1 to V7 all pass, including a spot replay of input-present coalitions from the stored pixels, bit-identical. Shares (edges) drawing 0.943, Kollwitz 0.057, others 0, matching M4's frozen run on the same seed to three decimals (the receipt's drawing is the uint8-rounded one); description paper 0.417, lines 0.542, matching SPLIT. Seed 9100's planted controls all pass.
• Page: a drawn X through "Pay the artists for this drawing" produced sealed receipts in 278.6 s (job 1c2e1bd456): drawing 93.8%, Kollwitz 6.2%; paper 44.8%, lines 50.9%; not a copy; controls pass. Browser-checked.
• Stage two: smoke run (timings, disclosed in the protocol): training 0.636 s per step at 64 px (about 106 minutes per network), calibration about 98 minutes. O7 frozen (measure/o7_freeze.json) and stage2/overnight.sh launched 10:33: phase A (full_s0, calibration, agreement, gate) then phase B (six leave-one-artist-out networks and full_s1), about 16 hours. Log: stage2/overnight.log.

2026-10-01 (paused for the day, Russell travelling)

The first sketch receipt (circle test drawing, seed 9100) was stopped by hand at its third stage (drawing combinations) so nothing runs while the laptop travels. Its two caches finished and are kept (receipt/cache/absent_9100_...pt, controls_9100_...json); the next sketch receipt starts from them. Nothing else was running. Resume list: sketch receipt and paid-button browser check; stage-two smoke test, disclose, freeze, launch stage2/overnight.sh; findings report rebuild; memory update.

2026-10-01 (receipts format 3 made; planted controls fail on 2 of 4 seeds with the small pool; stage two prepared)

• Demo receipts regenerated as format 3 (version 2 moved to receipt/receipts_v2/): every main game bit-identical to version 2. Planted controls per receipt (rules from T0FIX, registered on the 86-painting pool): seed 9000 copy 1.81 pass, scrambled 0.00% pass, constant 1.18% (colour) fail; seed 9001 copy 1.85 pass, scrambled 2.19% (edges) fail, constant 0.44% pass; seed 9002 copy 1.84, scrambled 0.33%, constant 0.59%, all pass; seed 9003 copy 1.82, scrambled 0.15%, constant 0.18%, all pass. With the 10-painting pool every share is larger, the nonsense contributors' included. Rules not changed; receipts and page show the failures.
• Decision (Russell, on recommendation): paid receipts will use the full 86-painting pool (controls hold there); the visual demo keeps the 10-painting pool, labelled. Remaking paid receipts on the full pool (about 4 to 5 GPU hours) is queued after stage two.
• Tests after these changes: engine 51/51 (T3 float32 on MPS reported: 5.25e-6); tamper suite 8/8 including E7.
• Stage two prepared (stage2/): patch-ledger train.py, phase3_checks.py, score_test.py, phase3_predict.py copied verbatim and read-only into stage2/ORIGINAL/ (hashes in its PROVENANCE.md, identical to source). Ported: net.py (network class, time embedding and schedule checked verbatim against the original), train.py (demo corpus at L, leave-one-artist-out, NaN abort), check.py (calibration and agreement on this engine and schedule S1), o7.py (freeze, verify, gate), overnight.sh. Protocol measure/O7_PROTOCOL.md (64 px, demo pool, gate median r >= 0.85, phases A and B overnight, phase C fixed now and coded later).

2026-10-01 (findings report; receipts format 3 with planted controls; paid sketch receipts; T3 redefined)

• report/build_report.py -> report/FINDINGS.html (local): what was built, ten findings with their numbers read from the result files at build time, each labelled held / mixed / failed / exploratory / measured with its evidence, implications, limits, open items. Colab numbers saved as measure/o9_cuda_run.json so the report can cite them.
• Receipts format 3 (receipt/make.py): a controls block in every receipt, T0FIX game B on the receipt's own noise and pool (copy, scrambled, constant), C read off B's outputs, pass rules = T0FIX F1 to F3; control views hashes. Verifier V7 recomputes Shapley for B and C from the recorded v by permutation, the shares, the copy ratio and the pass flags; new tamper test E7 (a flipped pass flag). Page section 5 shows the picture's own controls.
• receipt/make_drawing.py: sealed, paid receipts for a viewer's own sketch (drawing as one player, pixels stored for replay, paper/lines as description, the seed's controls and no-drawing half cached and reused exactly). Verifier V5 replays input-present coalitions from the stored pixels with its own copy of the coupled start (same operation order as the engine). Server job endpoints and a page button. Not yet run (waits for the GPU).
• Engine test T3 in float32 changed from pass/fail to a reported measurement (float64 keeps the check at 1e-12), after the CUDA run showed the float32 sum error is rounding that grows with log-mass magnitude (1.5e-5 on a T4, under 1e-5 on MPS) and the old threshold was taken from MPS runs. Recorded here as a definition change made after a measurement.
• measure/O7_DRAFT_PROTOCOL.md: stage-two draft (trained networks at 64 px; direction, magnitude, resolvability), for review; nothing trained.

2026-10-01 (O9: first CUDA run, Colab Tesla T4; the receipts hold across hardware)

Run by Claude in Russell's signed-in Chrome with his explicit go-ahead for the upload (notebook Untitled7.ipynb in his Drive; the bundle went to the Colab session's temporary storage, deleted when the runtime ends). Environment: Tesla T4, Python 3.13.15, torch 2.11.0+cu128 (ours: torch 2.12 dev on MPS), so a different GPU vendor and torch build.

The result O9 asks for:

• Shipped receipt (made on MPS) replayed on CUDA: V1 to V6 pass; V5 worst |dv| at 0.005 of the cross-backend tolerance; source images NOT RUN (not in the bundle), as designed.
• Fresh receipt made on the T4 against the shipped one: worst |dv| / tolerance pixel 0.003, edges 0.005, blur 0.005, colour 0.000; Shapley shares moved by TV 1.7e-7, 5.9e-7, 1.1e-7, 0. About 3.5 minutes for 64 coalitions (MPS: about 7).
• Tests on CUDA (second run, corrected bundle): engine 51/52, removal 16/16, input 5/5, parts 4/4.

Found by the run, and what was done: 1. The bundle was missing files the tests import: measure/crop_scale_edges.py and its imports (crop_scale.py, corpus/build_corpus.py) for test R5, and engine/ORIGINAL/ for test N5. Added; the bundle builder now has these, and every test was run from an unpacked bundle on this Mac before re-uploading (52/52, 16/16, 5/5, 4/4). 2. V6 compared the nearest-image distance across backends at 1e-6; across hardware the distance differs in the sixth decimal (39.603884 vs 39.603886). V6 now uses 1e-6 only when the output is bit-identical to the receipt's and 0.01 levels otherwise (owner and flag must still match exactly). Passed on the second run. 3. The notebook's cells relied on imports in its first (upload) cell; each cell now imports what it uses. 4. T3 [cuda/float32] masses sum to 1: 1.51e-05 against a 1e-5 tolerance (open). Diagnosed in the same session: a plain log-sum-exp normalisation on the T4 is tight (2.4e-7), while the engine's mass sums are 1.3e-6 to 3.9e-6 at every step and 1.5e-5 at the final, lowest-noise step, where log-masses are largest, so float32 rounding of exp(lse_c - lse) grows with their magnitude. A float32 conditioning limit of the engine, larger on CUDA than on MPS, not a hardware fault; the CPU float64 reference passes T3 exactly and payouts are unaffected (above). The tolerance was set from MPS runs. Not loosened after the fact: the next step is to state the float32 bound from the log-mass magnitudes and test against that bound on every backend, or to normalise against a per-pixel reference inside the engine (which changes outputs bit-for-bit, so it would need new receipts).

2026-10-01 (receipts format 2: total effect and copy check, after ATTN1)

• receipt/make.py -> take-it-out-receipt/2: a context block with the players' total effect (v(all) - v(none), which the Shapley values sum to), their fraction of all posterior mass, and the nearest training image to the full output among the owners in play (owner, group, RMS in levels of 255, typical distance, and a declared flag: copy <= 1 level, near copy <= 8 levels).
• receipt/verify.py V6: total effect and mass fraction recomputed from the receipt's own numbers; the nearest image recomputed independently from the corpus arrays on disk and the full output (from a replay, or from --outputs after its hash is checked); NOT RUN, and reported so, when no output is available.
• Version-1 demo receipts moved (not deleted) to receipt/receipts_v1/. Seeds 9000 to 9003 regenerated on MPS: every output hash and every v(S) identical to version 1. Context: total effect (edges) 0.249, 0.237, 0.322, 0.373; artists hold 89% to 94% of the mass; nearest training images 39.6 to 46.6 levels away against typical 59.8 to 72.0: no copies in the demo.
• Tamper tests on the format-2 receipt: 7/7, including new E6 (an edited nearest-image claim, re-sealed, is caught by V6 from the saved outputs with no generation; the untouched receipt passes).
• Page: section 2 states what is being shared and the copy check under the payouts (browser-checked on seeds 9000 and 9003, and the copy branch checked with a substituted context, then restored). Bundle rebuilt.

2026-10-01 (ATTN2: frozen-attention receipts do not report the source; they pay a fixed pair)

instrument/attention_law.py (library ch. 49 in VP coordinates), tests 3/3: our exact and frozen posteriors reproduce the library's Study 13 fixtures to 1e-16 (three-token reversal: exact 0.924 / 0.076, frozen 0.158 / 0.842; two-token equality), and query plus row recovers a 16 x 16 noisy image to 1.3e-15. Static-attention engine made batch-invariant (rows denoised one at a time) after ATTN1's K2; new test A9 (batch of 8 equals one at a time, bit for bit): 9/9.

Protocol measure/ATTN2_PROTOCOL.md frozen after a timing-only smoke run; 12 runs (4 seeds x beta 1, 4, 16), greyscale 16 x 16 demo corpus, CPU float64. measure/attn2_results.json.

• K1 HOLDS (weights sum to 1 within 3.3e-15); K2 HOLDS (row inversion error 5.6e-16).
• R1 HOLDS (4/4): mean TV between the frozen receipt and the exact posterior over steps 10 to 18 (beta 4): 0.89, 0.53, 0.52, 0.75.
• R2 HOLDS (4/4): the gap grows as noise falls (last step 1.00, 0.56, 0.51, 1.00 against step 5 0.42, 0.33, 0.49, 0.25).
• R3 HOLDS (4/4): the top-paid group at the last step is wrong on every seed.
• Reported: at beta 4 and 16 the frozen receipt converges to about Dürer 0.5, Kollwitz 0.5 on every seed, while the exact posterior names one artist that changes with the seed (beta 4: Rembrandt, Dürer, Kollwitz, Van Gogh). The frozen receipt describes the generator's attractor, not the picture's source. At beta 1 it is diffuse (every group 0.1 to 0.3) while the exact posterior is one artist. The fraction of pixels whose own frozen top group matches the exact one at the last step: 0.00 to 0.55.

Reading. Plugging realised attention into the static formula, the natural first route for extending any static-attention construction to attention models, gives payouts that are neither the posterior of what the layer observed nor stable to the picture. The library's three-token counterexample (C72) holds at image scale and is the typical case, not an edge case. Limits, stated with it: scalar tokens, one head, greyscale 16 px, no learned projections or residual stream; the exact posterior here is the whole-image one because the row is retained (a layer that keeps only its output has a different, harder law, ch. 49 section 6); and this is posterior accounting, not removal credit (ch. 48 section 7). Consequence: static-attention receipts are not receipts for attention models. The static machine stays useful as a generator in its own right (its attention is genuinely fixed).

2026-10-01 (ATTN1: attention changes who gets paid; global attention copies; a receipt flaw)

Static-attention machine extended to several heads with support-aware rank handling (library ch. 48); tests 8/8 (A6 two heads equal a brute-force Gaussian over the full observation, 1.0e-15; A7 a duplicated head and A8 a self-only head change nothing, difference 0, no jitter). Protocol measure/ATTN1_PROTOCOL.md frozen after a timing-only smoke run; 12 games, CPU float64, about 4 s each. measure/attn1_results.json.

• K1 efficiency HOLDS (2.2e-16).
• K2 FAILS as registered (bitwise): batched coalitions differ from one-at-a-time runs in 53,964 values. Diagnosed: one denoise step differs by 1.3e-15 between batch sizes (summation order in the batched contraction), 1.5e-13 in outputs after a full run; Shapley values move by 6e-16 relative. Not a logic error, but this machine is not batch-invariant to the last bit, so a receipt from it replays bit for bit only at the same batch size. Fix after this test: rows denoised one at a time. (Correction, 2026-10-02: engine/tio/static_attention.py was one of ATTN1's frozen files, so this fix changed a frozen file; the frozen version is preserved, hash-checked, in measure/frozen_code/attn1/.)
• Q1 HOLDS (3/4): by edges, local attention moves 9% to 27% of the money compared with none (0.27, 0.15, 0.27, 0.09).
• Q2 FAILS (1/4): global context moves pay far more than local, not less: by pixels TV(none, global) 0.16, 0.50, 0.22, 0.74 against TV(none, local) 0.12, 0.05, 0.05, 0.08.
• Q3 HOLDS (4/4): local attention concentrates pay on the top artist (edges: 0.35 vs 0.18, 0.26 vs 0.21, 0.34 vs 0.21, 0.23 vs 0.19).
• Reported: the posterior sharpens with attention. Effective training images per patch at steps 0, 5, 10, 15, 18 (seed 9300): none 421, 343, 213, 72, 7.1; local 385, 132, 38, 4.5, 1.1; global 270, 25, 3.8, 1.2, 1.0. Use vs Shapley TV (pixel) grows with attention: none 0.15 to 0.17, local 0.16 to 0.33, global 0.36 to 0.52. Global pay is winner-take-most and seed-dependent (9301: Van Gogh 0.49; 9303: Kollwitz 0.49, Rembrandt 0.51, the rest 0).

Post hoc, exploratory (measure/attn1_posthoc_copy.py, panel measure/attn1/attn1_panel.png): nearest training image to each full-coalition output, RMS in levels of 255. None 54 to 56; local 31 to 41; global 22 to 48, and on seed 9303 0.0: a verbatim copy of a commons painting (met-dp-20645-001). In that game the artists' summed effect is small (pixel 0.065 against 0.21 to 0.46 elsewhere under global) and they hold 21% of the posterior mass, yet normalised shares pay them 100% of the artist pool (Kollwitz 0.49, Rembrandt 0.51) while the copied work, in the unpaid pool, gets nothing. Reading: attention shares information across patches, the posterior collapses toward a whole image, which is the library's ch. 49 point (observing the full row recovers the input) seen at image scale. The more global the attention, the closer the machine comes to the memorising ideal score, the more pay concentrates, and the further use drifts from Shapley.