Plain-English pass on the card and text files

README.md

@@ -11,7 +11,7 @@ pretty_name: PHerc. 0306B First Letters data and results
 
 # PHerc. 0306B First Letters: training data, ink maps and Docker image
 
-Data for our First Letters result on the Herculaneum scroll PHerc. 0306B (Vesuvius Challenge, 2026; scan volume `20250521133212`, 8.64 µm, 116 keV). It holds every stage of the ink model's training data, the claim's ink maps and render, and the Docker image that reproduces the claim image.
+The data behind our First Letters result on the Herculaneum scroll PHerc. 0306B (Vesuvius Challenge, 2026; scan volume `20250521133212`, 8.64 µm, 116 keV). It has every stage of the ink model's training data, the claim's ink maps and render, and the Docker image that reproduces the claim image.
 
 - Code, method and the claim package: https://github.com/SirProdigle/pherc0306b-first-letters
 - Model weights: https://huggingface.co/Prodigle/pherc0306b-ink-ahn
@@ -25,7 +25,7 @@ Data for our First Letters result on the Herculaneum scroll PHerc. 0306B (Vesuvi
 | `0_inputs/` | 0 | The five other PHerc. 0306B surfaces the machine labels were made on: tifxyz meshes and 41-layer CT renders (`regions_pool.json`). The renders can be made again from the meshes and the public volume. |
 | `1_pool_masks/` | 1 | Per surface: the distance to the zone, the on-sheet score and the CT coverage. |
 | `2_teacher_maps/` | 2 | The maps of the four public models on those surfaces: v8-in, Reader V3, TRACE v3B and Reader v2. CT inside the zone's buffer was set to zero first. |
-| `3_machine_labels/` | 3 | The machine labels. `main` was used for training; `sc` and `decoy` are control variants. Also here: statistics (`stats.json`) and overview JPGs. |
+| `3_machine_labels/` | 3 | The machine labels. Training used `main`; `sc` (sharp core) is a stricter variant, and `decoy` holds the shifted labels of the decoy control. Also here: statistics (`stats.json`) and overview JPGs. |
 | `3b_cloud_packs/` | 3 | The exact arrays the seeds trained from (`306_*.npz`), plus the PHerc. 1447 w058 and w060 anchor packs, re-hosted from `YoussefMoNader/ink-8um-pherc1447-surfaces` (CC BY-NC 4.0). |
 
 The label rule:
@@ -53,4 +53,4 @@ All maps are on the render raster (4900 × 7780 px). The claim frame is u = −3
 
 ## Licence
 
-CC BY-NC 4.0 (`LICENSES/`); the code in `0_exclusion_zone/` is MIT. Derived from the Vesuvius Challenge open data (PHerc. 0306B; PHerc. 1447 scan, renders and team labels; CC BY-NC 4.0). The teachers were v8-in (Youssef Nader, MIT), Reader V3 and Reader v2 (domenicor046, MIT) and TRACE v3B (Jashann). `SHA256SUMS` covers every file.
+The data is CC BY-NC 4.0 and the code in `0_exclusion_zone/` is MIT (`LICENSES/`). It derives from the Vesuvius Challenge open data (the PHerc. 0306B scan and the PHerc. 1447 scan, renders and team labels, all CC BY-NC 4.0). The teachers were v8-in (Youssef Nader, MIT), Reader V3 and Reader v2 (domenicor046, MIT) and TRACE v3B (Jashann). `SHA256SUMS` covers every file.

SHA256SUMS

@@ -2,7 +2,7 @@
 bd47aee131eef231ad45d53eeb7eae6c0438725e849ec156e680f760decac187  LICENSES/MIT.txt
 206959daf862f45f02a39352d7171acb0c9d312fd771d09db9595f90b131cd39  LICENSES/NOTICE.md
 45a32f2cbb2cc13e14391052e04dca8ba5fdf797e70612541e53d9c522a3a7c1  LICENSES/THIRD_PARTY.md
-9e6ba1361900c888f735cf811f64d5523fafe52100ceaf6057ba2e9bf3e049f1  data/0_exclusion_zone/README.md
+f34ce9b5582b57037ddc1dffc05e16f62390ecc86687524424e152c3d314fc21  data/0_exclusion_zone/README.md
 a2c800f7913e7b031fc91d8bea6b4b222007cdb75cb0741e4bd8e3cfab4553ca  data/0_exclusion_zone/build_zone.py
 9b622526ae42abb8324368bf36de2a278b6a2309f288df609ff1b7b2c15423fa  data/0_exclusion_zone/check.py
 1dff1942d2e9b4cf097c9bf0accbbd7c4c01d71cb7d570558edb17e789616a09  data/0_exclusion_zone/exclusion_audit.json
@@ -7024,8 +7024,8 @@ b4375a625fa7d8134c9ba36ea8709f0f2d458ee216600812a77a2af9e57354e5  data/3b_cloud_
 80084f2a001bc8a3222f1c2f16d14a6fff0387e081d637f6928c66ffb2c939cd  data/3b_cloud_packs/a_w058.npz
 9e092b87ddaed4f54d7ba2a45ca094cc084d15d9b1e7d5390064d2b0783cb666  data/3b_cloud_packs/a_w060.npz
 7243392431c702199701a29f34e84530f2884a4fe37aba54c0ee2ccd361d052b  docker/GPL-3.0.txt
-3760e178c70fa32a58f2ff5170c8b9b448a29bb9fbaf264e9e7aa3db7fb6d457  docker/README.md
-0c43d1af41dddce7f60a8478cfb5344e8ddf3b090e55d7682a303aae6eaea69f  docker/THIRD_PARTY_NOTICES.md
+07be1b540ba1e520b162236eb3222750bf2fd39b4523d22f07075fed3f0f6373  docker/README.md
+c06bbf2deeb72bcd258613f20c75ff11b9365dc328d8478b6dfe81454e99c626  docker/THIRD_PARTY_NOTICES.md
 1832832330ab67b134795eaedd43d6d5c3dcf004596e1fd287d2e71b3af73536  docker/fl-claim-a7_final.tar.zst
 d36b5c2b5cdd15a72f9eb735c9b81670534b25ad48f65300721809ce62ad4b80  docker/fl-claim-a7_final.tar.zst.sha256
 4de6da3b5533408c81abf2fe3358e12e637b94ccdaf0a59d490b9bd1ddc88301  results/claim_map_fwd_fin.npy

data/0_exclusion_zone/README.md

@@ -1,50 +1,66 @@
-# A-click exclusion zone (lane P306)
-
-Use: `import sys; sys.path.insert(0, '<P3>/aclick/p306/exclusion'); import check` then
-`check.allowed(zarr_or_mesh, ys, xs, pad_mm=...)` (bool, True = allowed), `check.assert_allowed(...)`,
-`check.allowed_mask(zarr, roi=(y0, y1, x0, x1), pad_mm=...)` (full-res bool mask), `check.distance_mm(...)`.
-CLI: `envs/vcpy/bin/python check.py ZARR y,x [y,x ...]` (exit 1 if any point is rejected), `check.py ZARR --mask OUT.npz
-[--roi y0 y1 x0 x1] [--pad 0.4]`, `check.py register ZARR MESH [--offset y x]`, `check.py selftest`.
-
-## What the zone is
-`zone.npz` = 2,386,014 3-D points (volume voxels x, y, z of PHerc0306B 20250521133212) of every surface shown in any lead-A
-claim image (`build_zone.py`, provenance + sha256 in `zone.json`):
-1. mesh **V5Rc** (claim v2, v3, v4, v4b, v4c and the v5 builds; x.tif sha256 e6f14ec2...): all points whose render pixel is in
-   the main image / context window **u -30..+30 x v -20..+15 mm** (claim frame u = -36 + x/K, v = -21 + y/K, K = 115.741
-   px/mm; `v5/code/claimlib_v2.py` CTX; v4c image json map 6945 x 4051 px = 60 x 35 mm), plus a 2 mm in-plane margin. Every
-   supplementary view of v2-v5 (threshold rungs, single models, big box u -16..26 x v -12..5, blank control R u 25..30,
-   mirror control = box + 3 mm, letter table, side-by-side, form overlays) is a crop of that window. 1,254,679 points.
-2. mesh **w074own auto_grown_20261012144243662** (claim v1, 14 Oct; x.tif sha256 831220...): its levelled frame
-   (`x_submit/make_submission_A.frame()`: centre and directions in render (x, y)), the superset u -34..+30 x v -20..+18 mm
-   of its view (u -24..16 x v -11..8) and its 60 x 36 mm context jpg, plus 2 mm. 1,131,335 points. Check: the v1 4 cm²
-   area's points lie within 0.43 mm (median 0.02 mm) of the V5Rc context surface, i.e. the same place (`scratch/v1_frame_check.py`).
-Meshes are densified 4x (bilinear in valid quads; point spacing <= 5 render px = 0.043 mm).
-
-## The rule check.py applies
-A render pixel is mapped to 3-D by bilinear lookup in its tifxyz mesh (render px = grid / scale, the `vc_render_tifxyz
---scale 1` convention; verified for every registered render: canvas == grid / scale, `renders.json`). It is **allowed iff
-its 3-D point is >= 2.0 mm + 0.2 mm (SLAB_MM: render slab half-depth 0.17 mm + densify spacing) + pad_mm from every zone
-point**. Pixels without a valid mesh quad are not allowed. The distance is 3-D, so it covers the claim sheet in-plane
-(2 mm around the shown window) and every other winding/sheet passing within 2 mm of it.
-- For a training **click** whose model input is a 64 px v8-in tile, pass `pad_mm=0.4` (tile half-diagonal 0.39 mm): then
-  the whole input tile is >= 2.2 mm from the zone. For 17-layer 256 px Reader tiles, pad 1.6 mm.
-- `allowed_mask` samples every `step` px and adds a step x 0.71 px tolerance, so it never allows a pixel the exact test
-  would reject.
-- Renders: `renders.json` maps known render zarrs to their meshes (`make_registry.py`). Crop zarrs with a `crop.json`
-  (`render`, `box` = y0, y1, x0, x1) resolve through their parent render with the offset. Anything else: pass `mesh=`.
-
-## Verification (`check.py selftest`, `scratch/region_fracs.py` -> `region_fracs.json`)
-| test | result |
+# Exclusion zone
+
+The zone holds every point of PHerc. 0306B that we showed in any image of the claimed line, across all seven versions of our claim. `check.py` measures how far a render pixel lies from it in 3-D and decides whether the pixel may be used for training.
+
+| file | what it holds |
 |---|---|
-| 4000 random pixels of the V5Rc main image (u -30..30, v -20..15) | 3924 have a mesh, **0 allowed** |
-| v1 render w074own (48 x 48 mm patch around lead A) | 4.2 % of all px allowed (its far corners) |
-| lane render w074 (the z8400 lane winding through lead A) | 12.6 % allowed |
-| pick 2 row, lane render w050 (y 1000-1650, x 3000-6600) | **96.6 % allowed**; min distance 2.08 mm, median 3.10 mm |
-| pick 2 row, own patch A_own_r41 (y 2400-3900, x 1800-4500) | 96.2 % allowed; min 1.89 mm, median 3.10 mm |
-| pick 2 own patch, whole render | 86.1 % allowed (min 0.18 mm: its far edge reaches lead A's sheet) |
-| w052 lower row | 99.8 % allowed (min 2.29 mm) |
-| w053 rows | 97.9 % allowed (min 1.90 mm) |
-| w059 band (F6Y box) | **23.9 % allowed** (min 0.015 mm, median 1.69 mm: most of the band is inside the buffer) |
-| w109 two rows | 99.97 % allowed (min 3.84 mm) |
-These match OM4's independent figures (pick 2 min 2.28 mm, w059 1.3 mm, w109 4.3 mm to the 4 cm² box surface; our zone is
-the whole 60 x 35 mm image, so ours are smaller).
+| `zone.npz` | the zone: 2,386,014 points, in voxels (x, y, z) of volume `20250521133212` |
+| `zone.json` | how the zone was built: its sources, margins and checksums |
+| `build_zone.py` | the code that built it |
+| `check.py` | the distance test |
+| `renders.json` | our renders and the meshes they came from |
+| `tile_regions.json`, `training_tiles.npz` | the training regions and the position of every training tile |
+| `exclusion_audit.json` | the test of all 23,331 PHerc. 0306B training tiles: all allowed, the nearest 2.925 mm from the zone |
+
+## What the zone covers
+
+The zone comes from two meshes. Both are densified 4× by bilinear interpolation inside valid quads, so neighbouring points are at most 0.043 mm (5 render pixels) apart.
+
+1. The claim mesh, V5Rc: every point whose render pixel falls in the claim image's window, u −30..+30 × v −20..+15 mm, plus 2 mm on the surface. That comes to 1,254,679 points. The claim frame is u = −36 + x / 115.741 and v = −21 + y / 115.741 mm.
+2. The mesh of our first version (`w074own`, auto_grown_20261012144243662, 14 Oct): the window u −34..+30 × v −20..+18 mm, which contains its view and its 60 × 36 mm context image, plus 2 mm. That comes to 1,131,335 points. Its 4 cm² area lies within 0.43 mm of the V5Rc surface (median 0.02 mm), so the two meshes describe the same place.
+
+## The rule
+
+`check.py` maps a render pixel to 3-D by bilinear lookup in its tifxyz mesh, using the `vc_render_tifxyz --scale 1` convention (render pixel = grid / scale). A pixel is allowed when its 3-D point is at least 2.0 mm + 0.2 mm + `pad_mm` from every zone point. The 0.2 mm covers the render slab's half-depth (0.17 mm) and the point spacing. A pixel with no valid mesh quad is rejected. Since the distance is measured in 3-D, the rule covers the claimed sheet and every other sheet that passes within reach of it.
+
+`pad_mm` stands for the size of whatever the pixel feeds: half the diagonal of the model's input tile. That is 0.39 mm for a 64 px v8-in tile and 1.6 mm for a 256 px Reader tile. The A-hn training audit checked each tile's centre and corners at pad 0.7 mm, and a 5 × 5 grid of points at pad 0.
+
+`allowed_mask` samples every `step` pixels and adds a tolerance of 0.71 × `step` pixels, so it never allows a pixel that the exact test rejects.
+
+## Use
+
+```python
+import sys; sys.path.insert(0, 'data/0_exclusion_zone'); import check
+
+check.allowed(zarr_or_mesh, ys, xs, pad_mm=0.7)                # bool per pixel, True = allowed
+check.assert_allowed(zarr_or_mesh, ys, xs, pad_mm=0.7)         # raises if any pixel is rejected
+check.allowed_mask(zarr, roi=(y0, y1, x0, x1), pad_mm=0.7)     # full-resolution bool mask
+check.distance_mm(zarr_or_mesh, ys, xs)                        # distance to the zone in mm
+```
+
+From the shell:
+
+```bash
+python check.py ZARR y,x [y,x ...]                             # exit 1 if any point is rejected
+python check.py ZARR --mask OUT.npz [--roi y0 y1 x0 x1] [--pad 0.4]
+python check.py register ZARR MESH [--offset y x]              # add a render to renders.json
+```
+
+`renders.json` lists our renders by their local paths. To test your own render, register it with its mesh or pass `mesh=`. A crop zarr with a `crop.json` (`render`, and `box` = y0, y1, x0, x1) resolves through its parent render. `check.py selftest` reads our local renders, so it only runs on our machine.
+
+## Measured distances
+
+| region | allowed | distance to the zone |
+|---|---|---|
+| 4,000 random pixels of the claim window on V5Rc | 0 of the 3,924 that have a mesh | |
+| our first version's render, 48 × 48 mm around the line | 4.2 % (its far corners) | |
+| the screening lane's render of winding 74 | 12.6 % | |
+| another candidate row, on lane winding 50 (y 1000–1650, x 3000–6600) | 96.6 % | min 2.08 mm, median 3.10 mm |
+| the same row on its own GrowPatch (y 2400–3900, x 1800–4500) | 96.2 % | min 1.89 mm, median 3.10 mm |
+| that GrowPatch, whole render | 86.1 % | min 0.18 mm, where its far edge reaches the claimed sheet |
+| w052, lower row | 99.8 % | min 2.29 mm |
+| w053 rows | 97.9 % | min 1.90 mm |
+| w059 band | 23.9 % | min 0.015 mm, median 1.69 mm: most of the band is inside the buffer |
+| w109, two rows | 99.97 % | min 3.84 mm |
+
+An earlier measurement to the 4 cm² box alone gave 2.28 mm for the candidate row, 1.3 mm for w059 and 4.3 mm for w109. The distances above are smaller because the zone covers the whole 60 × 35 mm image.

docker/README.md

@@ -1,6 +1,6 @@
 # Docker image fl-claim-a7
 
-`fl-claim-a7_final.tar.zst` ships beside the package: 6.62 GB, sha256 `1832832330ab67b134795eaedd43d6d5c3dcf004596e1fd287d2e71b3af73536`. The image is `fl-claim-a7:final`, ID `sha256:78d5ced4f8731c440bf36fd6fdc1b488719d1f6e8193e5e7a401f6ade0b56c2e`, 12.0 GB.
+`fl-claim-a7_final.tar.zst` is 6.62 GB, sha256 `1832832330ab67b134795eaedd43d6d5c3dcf004596e1fd287d2e71b3af73536`. It loads as `fl-claim-a7:final`, image ID `sha256:78d5ced4f8731c440bf36fd6fdc1b488719d1f6e8193e5e7a401f6ade0b56c2e`, 12.0 GB.
 
 ```bash
 zstd -dc fl-claim-a7_final.tar.zst | docker load
@@ -9,14 +9,14 @@ docker run --rm --network none --cpus 4 -v $PWD/out:/out fl-claim-a7:final smoke
 docker run --rm --network none --cpus 4 -v $PWD/out:/out fl-claim-a7:final exclusion  # exclusion
 ```
 
-| mode | what it does | result on 23 Oct 2026 |
+| mode | what it does | result, 23 Oct 2026 |
 |---|---|---|
-| `final` (default) | redraws the claim image and the build's 19 other views from the shipped maps, and checks each PNG's sha256 | MATCH, 20 of 20 (459 s, CPU, offline) |
-| `smoke` | runs the three member models again on the CPU on a 169 × 169 px CT crop inside the box, compares them with the shipped maps on the 43 × 43 px fully inside the crop, and rebuilds the product rule byte for byte | PASS: largest difference 0.00174, r 0.99999 |
-| `exclusion` | re-checks all 23,331 PHerc0306B training tiles against the exclusion zone in 3-D | ALL ALLOWED |
-| `train` (GPU, about 1 to 2 h) | the whole training again: pool masks, teacher maps, machine labels, exclusion audit, fine-tune, claim map | prepared, not re-run |
-| `pipeline` (GPU) | the ink models again on the full render, then `final` | not re-run |
+| `final` (default) | redraws the claim image and 19 other views from the shipped maps and checks each PNG's sha256 | MATCH, 20 of 20 |
+| `smoke` | re-runs the three A-hn seeds on a 169 × 169 px CT crop inside the box, compares them with the shipped maps on the 43 × 43 px fully inside the crop, and rebuilds the product byte for byte | PASS: largest difference 0.00174, r 0.99999 |
+| `exclusion` | re-checks all 23,331 PHerc. 0306B training tiles against the exclusion zone in 3-D | ALL ALLOWED |
+| `train` (GPU, 1 to 2 hours) | repeats the training: pool masks, teacher maps, machine labels, exclusion audit, fine-tune, claim map | prepared, not run end to end |
+| `pipeline` (GPU) | runs the ink models on the full render, then `final` | not run end to end |
 
-For `train`, the image holds the training code at the paths it ran from, with its configs, the zone and the meshes. Mount the CT renders and labels it lists (`docker run --rm fl-claim-a7:final shell -c 'cat /opt/fl/train/INPUTS.tsv'`) read-only at the same paths, then run `docker run --rm --gpus all -v $PWD/out:/out -v <data>:<path>:ro ... fl-claim-a7:final train`. GPU kernels are not bit-exact across cards, so new weights differ in sha256; the run reports how closely the new map matches the shipped one.
+For `train`, the image holds the training code at the paths it ran from, with its configs, the zone and the meshes. List the CT renders and labels it needs with `docker run --rm fl-claim-a7:final shell -c 'cat /opt/fl/train/INPUTS.tsv'`, mount them read-only at those paths (all are in this dataset), then run `docker run --rm --gpus all -v $PWD/out:/out -v <data>:<path>:ro ... fl-claim-a7:final train`. GPU kernels are not bit-exact across cards, so new weights differ in sha256; the run reports how closely the new map matches the shipped one.
 
-Logs of the three tests: `../method/checks/docker_tests/`. Building the image: `PKG=<package> bash build.sh fl-claim-a7:draft CTX`, offline, from our version 1 image `fl-claim-a:final` with `Dockerfile.from_v1`; the self-contained `Dockerfile` (`FULL=1`) ends the same way. We built it as `fl-claim-a7:draft` and tagged the same image `:final`.
+The build recipe and our test logs are in the GitHub repo, https://github.com/SirProdigle/pherc0306b-first-letters, under `submission/docker/` and `submission/method/checks/docker_tests/`. `PKG=<package> bash build.sh fl-claim-a7:draft CTX` builds the image from our first version's image (`fl-claim-a:final`) with `Dockerfile.from_v1`; the self-contained `Dockerfile` (`FULL=1`) ends in the same steps. We tagged that build `:final`.

docker/THIRD_PARTY_NOTICES.md

@@ -1,19 +1,18 @@
 # Third-party notices for the Docker image `fl-claim-a7:final`
 
-The image `fl-claim-a7_final.tar.zst` (sha256 `1832832330ab67b134795eaedd43d6d5c3dcf004596e1fd287d2e71b3af73536`) was built
-before release and carries no licence files of its own, apart from villa's MIT licence. This file goes with it. Each component
-keeps its own licence:
+The image `fl-claim-a7_final.tar.zst` (sha256 `1832832330ab67b134795eaedd43d6d5c3dcf004596e1fd287d2e71b3af73536`) has no
+licence files of its own apart from villa's MIT licence, so this file lists the licence of each component:
 
 | component | where in the image | licence | source |
 |---|---|---|---|
-| VC3D AppImage (`vc_render_tifxyz`), build `a4979b9`, 13 Oct 2026 | `/opt/vc3d` | **GPLv3** (`GPL-3.0.txt`) | binary: https://github.com/ScrollPrize/villa/releases (`VC3D-a4979b9-2026-10-13-linux-x86_64.AppImage`, sha256 `e897cdc9…794c`); corresponding source: https://github.com/ScrollPrize/villa at commit `a4979b9` (`volume-cartographer/`) |
+| VC3D AppImage (`vc_render_tifxyz`), build `a4979b9`, 13 Oct 2026 | `/opt/vc3d` | GPLv3 (`GPL-3.0.txt`) | binary: https://github.com/ScrollPrize/villa/releases (`VC3D-a4979b9-2026-10-13-linux-x86_64.AppImage`, sha256 `e897cdc9…794c`); corresponding source: https://github.com/ScrollPrize/villa at commit `a4979b9` (`volume-cartographer/`) |
 | villa ink-detection sources (`vesuvius/src`) | `/opt/villa` | MIT (Vesuvius Challenge) | https://github.com/ScrollPrize/villa at commit `a329895ea5e9bde78752e60dbc0a4878dd2ab909` |
 | v8-in weights and loader | `/opt/fl/third_party/v8in/` | MIT (Youssef Nader) | HF `YoussefMoNader/ink-8um-v8in` |
 | Reader v2, Reader V3 weights | `/opt/fl/models/community/` | MIT (domenicor046) | HF `domenicor046/reader-v2`, `domenicor046/reader-v3` |
 | TRACE v3B weights | `/opt/fl/models/community/trace/` | CC BY-NC-SA 4.0 (Jashann) | GitHub `Jashann/vesuvius-scrolling`, release v1.0 |
-| Hecate 9.6 µm weights and code (present, **not used** by the claim; kept from our version 1 image) | `/opt/fl/models/ink9_ens/` | MIT (Vesuvius Challenge) | HF `scrollprize/hecate` |
-| A-hn members, v8Q (our fine-tunes) | `/opt/fl/third_party/v8in/finalist/`, `/opt/fl/third_party/v8in/v8Q_final.safetensors` | CC BY-NC 4.0 (ours) | the Hugging Face model repo `pherc0306b-ink-ahn` (linked from the GitHub README) |
-| our code | `/opt/fl` (`claim/`, `final/`, `train/`, `x_*/`) | MIT (ours) | this repository |
+| Hecate 9.6 µm weights and code (kept from our first version's image; the claim does not use it) | `/opt/fl/models/ink9_ens/` | MIT (Vesuvius Challenge) | HF `scrollprize/hecate` |
+| A-hn members, v8Q (our fine-tunes) | `/opt/fl/third_party/v8in/finalist/`, `/opt/fl/third_party/v8in/v8Q_final.safetensors` | CC BY-NC 4.0 (ours) | HF `Prodigle/pherc0306b-ink-ahn` |
+| our code | `/opt/fl` (`claim/`, `final/`, `train/`, `x_*/`) | MIT (ours) | GitHub `SirProdigle/pherc0306b-first-letters` |
 | claim maps, CT layer, mesh | `/opt/fl/data`, `/opt/fl/mesh` | CC BY-NC 4.0 | Vesuvius Challenge open data (PHerc. 0306B, CC BY-NC 4.0) and ours |
 | zlib-ng-compat 2.3.3 `libz.so.1` | `/opt/zlib-ng` | zlib licence | https://github.com/zlib-ng/zlib-ng |
 | Python 3.14, PyTorch and the pip packages in `constraints.txt` | `/opt/python`, `/opt/venv` | their own licences (BSD, MIT, Apache 2.0 and others) | PyPI and download.pytorch.org at the pinned versions |