bshepp/round-reduced-sha256-learnability

Round-Reduced SHA-256 Learnability: A Controls-Gated Negative Result

TL;DR

A small CNN learns to distinguish round-reduced SHA-256 outputs from random with ~100% accuracy through 3 rounds, then collapses to chance at round 4 and stays there through the full 64 rounds — a sharp learnability cliff, replicated across 5 seeds and 2 dataset sizes. Full SHA-256 is statistically indistinguishable from random to these probes at this budget (a bounded null, not a proof). An apparent iterated-hash "orbit" signal turned out to be a label-prior artifact — and the experiment's own permuted-label control caught it.

This is a negative result reported honestly. It is a personal AI/ML-capability and reproducibility exploration, not new cryptographic science: a competent distinguisher failing on a hash function it should fail on is the expected outcome. The value here is the methodology — every claim is gated on positive/negative controls, and one of those controls is shown in the act of converting a false positive into a correct negative.

Dataset Description

This dataset is the distilled, verified evidence from a learnability instrument built on top of the bfl-asic toolkit (a codebase for a Butterfly Labs BF0005G "Jalapeno" SHA-256 mining ASIC, which also contains a numpy-vectorized, hashlib-anchored round-reduced SHA-256 and a controls-gated train/eval harness).

It contains only the results — accuracy points, confidence intervals, control outcomes, verdicts. The synthetic training data is deliberately not hosted: it is exactly regenerable from a seed, which is cheaper and more reproducible than a multi-gigabyte download. What you cannot regenerate for free — the curated, controls-verified conclusions of ~16 CPU-hours of Hugging Face compute — is what lives here.

Four small Parquet tables, 83 rows total:

Config	Rows	What it answers
learnability_sweep	70	At how many SHA-256 rounds does a CNN stop being able to tell real from reduced?
bounded_null	7	Is full 64-round SHA-256 distinguishable from random to these probes, at this budget?
dynamics_validated	4	Is iterated-hash orbit-tail length predictable from the seed? (and: is the apparent signal real?)
feature_probe	2	Is the round-4 cliff an artifact of the input feature?

Headline findings

1. A sharp learnability cliff at round 4. Per-hash TinyCNN distinguisher accuracy: rounds 1–3 ≈ 1.000; round 4 onward ≈ 0.500, flat through round 64. The cliff lands at the same boundary for all 5 seeds (Tier A n=200k ×3, Tier B n=500k ×2) and on a finer round grid. Of the 55 post-cliff points, exactly one has a 95% CI lower bound clearing chance (Tier A seed 1, round 6: acc 0.5057, +1.1%, ci_lo 0.5007) — fewer than the ≈ 2.7 spurious one-sided 95% exceedances expected from 55 points, isolated (rounds 4/5/8 of that seed are at chance), and below the rounds-1–3 signal by ~50×. It is reported, not hidden: learnable is a per-point ci_lo > 0.5 flag precisely so this is queryable.

2. Full SHA-256 is indistinguishable from random — bounded. Across 3 seeds at n=800k, best-of-{TinyCNN, linear probe} accuracy is 0.499–0.501; the 95% CI brackets 0.5 in every seed; controls_ok. A dedicated indistinguishability probe then tightens the bound at n=4,000,000: accuracy 0.50006, 95% CI [0.4990, 0.5012] (brackets 0.5), controls passed — pushing the CI-resolution floor down from ≈ 0.49% to ≈ 0.22%. Verdict: no structure above ≈ 0.22%. This is a bounded null at this budget, explicitly not a claim that SHA-256 is random.

3. The dynamics "signal" was an artifact — and the control caught it. Predicting a binned iterated-SHA-256 orbit-tail length from the seed gave width-1 accuracy 0.354 (chance 0.25), CI [0.339, 0.369] — apparently above chance. But the permuted-label negative control scored identically (0.354, same CI): negative_ok = false. The model learns nothing from the seed and collapses to the most-frequent quantile bin; the "+10%" is the non-uniform label prior. Verified conclusion: no learnable seed→orbit-tail structure at any truncation width. A first, under-validated harness reported this as a positive; the fixed harness (real Clopper–Pearson CI + permuted-label control) converted it into a correct, controlled negative — which is the entire point of the control.

4. The cliff is not feature-bottlenecked. A per-batch deviation-map feature reproduces the same round-4 cliff as the per-hash feature (qualitative, coarse floor — see provenance).

Quick Start

from datasets import load_dataset

# 1. The learnability cliff (the spine)
sweep = load_dataset("bshepp/round-reduced-sha256-learnability",
                      "learnability_sweep")["train"].to_pandas()
print(sweep[sweep.seed == 0][["tier", "rounds", "accuracy",
                              "ci_lo", "ci_hi", "learnable"]])
# rounds 1-3 -> learnable=True (~1.0); rounds >=4 -> learnable=False (~0.5)

# 2. The bounded null on full SHA-256
bn = load_dataset("bshepp/round-reduced-sha256-learnability",
                   "bounded_null")["train"].to_pandas()
print(bn[bn.is_best_model][["seed", "model", "accuracy",
                            "ci_resolution_floor", "conclusion"]])

# 3. The verified dynamics negative: real signal vs the control
dyn = load_dataset("bshepp/round-reduced-sha256-learnability",
                   "dynamics_validated")["train"].to_pandas()
lead = dyn.iloc[0]
print(f"width-1 acc={lead.accuracy:.4f}  "
      f"permuted-label control={lead.permuted_label_accuracy:.4f}  "
      f"negative_ok={lead.negative_ok}")
# identical -> the apparent signal is a label-prior artifact

Methodology (read this before using the numbers)

This dataset is opinionated about honest measurement. Three conventions matter:

• Controls gate every verdict. A "no structure" null is only trustworthy if a positive control (a low-round model that must be learnable) did learn, and a negative control (random-vs-random, or shuffled labels) did not beat chance. controls_ok / positive_ok / negative_ok are carried on the rows. When a control fails, the row's conclusion says so instead of emitting a null.

• ci_resolution_floor is a CI-resolution floor, NOT a power-based MDE. It is the smallest above-chance gain whose 95% accuracy CI excludes chance at that eval-set size. For the distinguisher configs (learnability_sweep, bounded_null) the harness reports it in advantage units (2·acc−1): floor = 2z·√(0.25/n_val). "No structure" means none above this floor at this budget — it is not a statement that the effect is zero, and not a power calculation. The ci_resolution_floor value is taken verbatim from the run; every "no structure above X" claim rests on it directly.

• n_val is the literal eval-set size. It is the exact inversion of the advantage-unit floor above, n_val = (z/floor)², so e.g. the n=4,000,000 indistinguishability probe resolves to n_val = 800k. Included for transparency alongside n_train (the run's dataset size).

• The permuted-label control is the dynamics analog of random-vs-random. Train on shuffled labels; if the shuffled model still "beats chance", the apparent signal is a dataset/setup artifact. In dynamics_validated it fires: that is the headline.

CIs are Clopper–Pearson (exact binomial). Models are deliberately small (a tiny CNN and a linear probe) on modest data on CPU — this measures easy, cheap learnability, the appropriate first question, not the limit of what any model could ever extract.

Dataset Splits

learnability_sweep (70 rows)

Round-reduced vs full SHA-256 distinguisher accuracy as a function of the number of compression rounds. Real SHA-256 vs an R-round-reduced variant, per-hash feature, TinyCNN. 5 seeds across 2 tiers.

Column	Type	Description
tier	str	A (n_train=200k) or B (n_train=500k, finer round grid)
n_train	int	Training examples
n_val	int	Eval examples (exact inversion of the advantage-unit CI floor)
seed	int	RNG seed (0–2 for A, 0–1 for B)
rounds	int	SHA-256 compression rounds (1–64)
accuracy	float	Validation accuracy (chance = 0.5)
advantage	float	2·accuracy − 1
ci_lo, ci_hi	float	95% Clopper–Pearson CI on accuracy
ci_resolution_floor	float	Smallest CI-resolvable gain at this n_val
learnable	bool	ci_lo > 0.5 (above chance with 95% confidence)

bounded_null (7 rows)

Full 64-round SHA-256 vs random. Six rows: one per (seed, model) for the n=800k full-structure sweep, plus the standalone n=4,000,000 indistinguishability probe that tightens the CI-resolution floor to ≈ 0.22%. conclusion is verbatim from the harness.

Column	Type	Description
experiment	str	full_structure or indistinguishability
seed	int	RNG seed
model	str	tiny_cnn or linear_probe
rounds	int	64 (full SHA-256)
n_train, n_val	int	Dataset size n / eval examples. full_structure: 800k / 160k. indistinguishability: 4,000,000 / 800k
accuracy, advantage	float	Validation accuracy and 2·acc−1
ci_lo, ci_hi	float	95% Clopper–Pearson CI
ci_resolution_floor	float	CI-resolution floor (full_structure ≈ 0.0049; indistinguishability ≈ 0.0022)
is_best_model	bool	Best-accuracy model for this seed
controls_ok	bool	Positive and negative control passed
positive_ok, negative_ok	bool	Individual control outcomes
structure_detected	bool	ci_lo > 0.5 (always False here)
conclusion	str	Verbatim harness verdict

dynamics_validated (4 rows)

Predicting a binned iterated-SHA-256 orbit-tail length from the seed, vs how many seed bytes the model sees (trunc_width_bytes). The permuted-label control fields are constant across rows on purpose so one table answers "is this signal real?".

Column	Type	Description
seed, n_train, epochs, n_bins	int	Run config (0, 20000, 25, 4)
trunc_width_bytes	int	Seed bytes the model sees (1–4)
accuracy	float	Validation accuracy (chance = 0.25)
chance	float	1 / n_bins
advantage	float	accuracy − chance
ci_lo, ci_hi	float	95% Clopper–Pearson CI
ci_resolution_floor	float	CI-resolution floor at this n_val
permuted_label_accuracy	float	Shuffled-label control accuracy
permuted_label_ci_lo/hi	float	Control 95% CI
negative_ok	bool	False ⇒ the apparent signal is an artifact
verdict	str	Plain-language conclusion

feature_probe (2 rows)

Is the round-4 cliff an artifact of the input feature? per-hash is exact (HF Tier B seed0); per-batch is a local n=2M probe whose CI floor is coarse (~0.10, few per-batch examples), recorded qualitatively and labelled with its provenance.

Column	Type	Description
feature	str	per-hash or per-batch
n_train	int	Training examples
rounds_learnable	str	JSON list of rounds with ci_lo > 0.5
rounds_at_chance	str	JSON list of probed rounds at chance
ci_resolution_floor	float	CI-resolution floor (coarse for per-batch)
conclusion	str	Plain-language finding
provenance	str	Exact-vs-qualitative source and caveats

Reproduction

The data is regenerable from a seed — that is why none of the inputs are hosted. The results above were produced by the bfl-asic toolkit's ml subsystem (numpy round-reduced SHA-256 anchored to hashlib, TinyCNN/linear-probe distinguishers, a controls-gated harness), run on Hugging Face Jobs (cpu-xl, ~16 CPU-hours total).

Source code: github.com/bshepp/bfl-asic (MIT) — the bfl_asic/ml/ subsystem and dataset/build_dataset.py.

git clone https://github.com/bshepp/bfl-asic
cd bfl-asic
pip install -e ".[ml]"              # PyTorch is isolated behind [ml]

# Regenerate the spine (one seed, scaled down for a laptop):
bfl-asic ml run sweep --seed 0 --n 20000 --epochs 10
bfl-asic ml report runs/ml/<timestamp>/sweep_seed0.json

# Rebuild these exact Parquet tables from the shipped source JSON
# (dataset/source/ travels with the repo — no external data needed):
python dataset/build_dataset.py     # deps: pandas, pyarrow

This HF dataset repo is itself self-contained: git clone it, pip install pandas pyarrow, run python build_dataset.py, and the four Parquet rebuild from the bundled source/ JSON — no external data, no GitHub checkout required.

The harness is deterministic: the same seed reproduces the same curve. The dynamics_validated table is the output of the fixed harness (real Clopper–Pearson CI + permuted-label control); the earlier under-validated harness is preserved in the toolkit's history as the honest record of the false positive that the control corrected.

Limitations

• Negative results, by design. A small/cheap distinguisher failing on full SHA-256 is expected; absence of evidence here is not evidence that SHA-256 has no structure. The bounded null is bounded.
• Budget-bounded. Small models, modest n, CPU. This measures easy, cheap learnability — the right first question, not a ceiling.
• ci_resolution_floor is not a power calculation. See Methodology. Do not read it as a minimum detectable effect.
• Multiple comparisons are not corrected. Per-point 95% CIs are reported raw; across ~80 rows a small number of one-sided exceedances are expected by chance (and observed — see Finding 1). Treat learnable / structure_detected as per-point flags, not family-wise significance.
• Not novel cryptographic research. This is a personal AI/ML capability and reproducibility exploration; its contribution is methodological transparency, not a new attack or a security claim.

Citation

@dataset{sheppard2026sha256learnability,
  title  = {Round-Reduced SHA-256 Learnability: A Controls-Gated
            Negative Result},
  author = {Sheppard, B.},
  year   = {2026},
  publisher = {Hugging Face},
  url = {https://huggingface.co/datasets/bshepp/round-reduced-sha256-learnability},
  note = {Code: https://github.com/bshepp/bfl-asic}
}

License

MIT — see the bfl-asic repository.