Content-addressed verification: proving independent reproductions match the original construction

AlphaEvolve's mathematical constructions have a property that makes them unusually well-suited for tamper-evident verification: the verification code is **purely deterministic**. There are no LLM calls, no random seeds, no external API dependencies — just numpy arithmetic on exact arrays of floats/integers. Running the verification code always produces the same result for the same construction.

This determinism means a SHA-256 hash over the construction data (the actual numpy arrays) is a uniquely strong claim:

- **Identity**: two groups that independently discover AlphaEvolve's exact rank-32 decomposition of `⟨2,4,5⟩` over `0.5Z` will produce the same hash — proving the constructions are identical, not just of the same rank.
- **Integrity**: if any entry in a factor matrix is modified post-publication (to correct an error, or update to a better construction), the hash changes — making the change auditable independently of git history.

This seems especially relevant given issue #2 ("Potential Error in Verification of B.11 Kissing Number") — exactly the kind of dispute where a committed hash would immediately tell both parties whether they are looking at the same construction or different ones.

---

### What the bundle would contain

For the tensor decomposition section as an example: each "sample" in the bundle is one construction — the three factor matrices plus the `(n, m, p, rank)` metadata, plus the boolean verification output. The `content_hash` (a SHA-256 Merkle root over all constructions) would be a stable fingerprint of the entire set of mathematical results in `mathematical_results.ipynb`.

```python
from valichord_attestation import build_bundle, hash_bundle
import numpy as np

# Each construction is one sample
samples = [
{
"id": "tensor_245_rank32",
"description": "Rank-32 decomposition of <2,4,5> over 0.5*Z",
"n": 2, "m": 4, "p": 5, "rank": 32,
"verified": True,
# SHA-256 of the concatenated factor matrix bytes for compactness
"data_hash": sha256_of_arrays(decomposition_245),
},
# ... one entry per construction
]

bundle = build_bundle(
model_id="AlphaEvolve",
task_id="alphaevolve_results",
raw_metrics=[{"key": "verified_constructions", "value": len(samples)}],
samples=samples,
samples_total=len(samples),
)
content_hash = hash_bundle(bundle)
# content_hash: a 64-char hex string that uniquely fingerprints this set of constructions
```

The library is [`valichord_attestation`](https://github.com/topeuph-ai/ValiChord/tree/main/valichord_attestation) (pip-installable, no infrastructure). A complete script for this notebook would be ~60 lines.

---

Two questions rather than a proposal:

1. **Has there been interest from groups wanting to prove they independently reproduced a specific AlphaEvolve construction** — not just "I also found a rank-32 decomposition" but "I found the exact same one"? If so, a content_hash published alongside the notebook would be the right primitive.

2. **Is there a policy on post-publication updates?** If constructions are updated (better solutions found, errors corrected), a content_hash commitment at publication time would make the revision history self-describing — the diff between the published hash and the updated hash tells you exactly what changed.

The same approach would apply to [alphaevolve_repository_of_problems](https://github.com/google-deepmind/alphaevolve_repository_of_problems), which is live and expanding — a `bundle.json` per problem notebook would let contributors prove their verification runs match the reference.