Publish curated, controls-verified results

README.md

@@ -0,0 +1,319 @@
+---
+license: mit
+task_categories:
+  - tabular-classification
+tags:
+  - cryptography
+  - sha-256
+  - hash-functions
+  - round-reduced
+  - learnability
+  - distinguisher
+  - neural-network
+  - negative-result
+  - reproducibility
+  - bounded-null
+  - statistical-validation
+  - controls
+  - sgd-dynamics
+  - butterfly-labs
+  - asic
+language:
+  - en
+pretty_name: "Round-Reduced SHA-256 Learnability: A Controls-Gated Negative Result"
+size_categories:
+  - n<1K
+configs:
+  - config_name: learnability_sweep
+    data_files: learnability_sweep.parquet
+  - config_name: bounded_null
+    data_files: bounded_null.parquet
+  - config_name: dynamics_validated
+    data_files: dynamics_validated.parquet
+  - config_name: feature_probe
+    data_files: feature_probe.parquet
+---
+
+# 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`](#reproduction) 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.** At
+   n=800k (n_val=40k), best-of-{TinyCNN, linear probe} accuracy is
+   0.499–0.501; the 95% CI brackets 0.5 in every seed; `controls_ok`.
+   Verdict: *no structure above a CI-resolution floor of ≈ 0.49%*.
+   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
+
+```python
+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
+  (`floor = z·√(p(1−p)/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. `n_val` is the exact
+  inversion of that formula and is included for transparency.
+
+- **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 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. One row per (seed, model) plus the
+standalone indistinguishability run. `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 | Training / eval examples (800k / 40k) |
+| `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 (≈ 0.0049) |
+| `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).
+
+```bash
+pip install "bfl-asic[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 synced run JSON:
+python dataset/build_dataset.py     # deps: pandas, pyarrow
+```
+
+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
+
+```bibtex
+@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}
+}
+```
+
+## License
+
+MIT.

bounded_null.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5e895dce9a62e9f5601a48c44ec7f515cf1c20f306d74e5935511ab13c2da85
+size 10224

build_dataset.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+"""Build the curated, verified HF dataset tables from the synced run JSON.
+
+Mirrors the convention of the author's other HF dataset
+(`bshepp/pairwise-poisson-algebras`): a deterministic script that reads
+the raw result JSON and emits one Parquet table per config, sitting next
+to the dataset card (README.md) in this directory.
+
+Only *verified* results go in (controls passed, or — for the dynamics
+negative — the permuted-label control actively fired). The synthetic
+training data itself is NOT hosted: it is regenerable from a seed, which
+is cheaper and more reproducible than a download. This dataset is the
+distilled *evidence*, not the inputs.
+
+Run:  python dataset/build_dataset.py
+Deps: pandas, pyarrow  (pip install pandas pyarrow)
+"""
+from __future__ import annotations
+
+import io
+import json
+from pathlib import Path
+
+import pandas as pd
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+HF = SCRIPT_DIR.parent / "hf_results"
+_Z = 1.959963984540054  # 97.5th pct of N(0,1); matches the harness
+
+
+def _load(path: Path) -> dict:
+    # utf-8-sig: tolerate a Windows BOM on synced artifacts.
+    with io.open(path, "r", encoding="utf-8-sig") as fh:
+        return json.load(fh)
+
+
+def _n_val(floor: float, chance: float) -> int:
+    """Invert the CI-resolution floor to the eval-set size that produced it.
+
+    floor = Z * sqrt(chance*(1-chance)/n_val)  ->  exact integer n_val.
+    """
+    return round(chance * (1.0 - chance) * (_Z / floor) ** 2)
+
+
+def build_learnability_sweep() -> pd.DataFrame:
+    """#1 the spine: round-reduced SHA-256 distinguisher accuracy vs rounds.
+
+    Real vs round-reduced (compress-function-reduced) SHA-256, per-hash
+    feature, TinyCNN. Five independent seeds across two compute tiers.
+    """
+    rows = []
+    sources = [
+        ("A", 200_000, HF / "bfl-ml-tierA" / "sweep_seed0.json", 0),
+        ("A", 200_000, HF / "bfl-ml-tierA" / "sweep_seed1.json", 1),
+        ("A", 200_000, HF / "bfl-ml-tierA" / "sweep_seed2.json", 2),
+        ("B", 500_000, HF / "bfl-ml-tierB" / "sweep_seed0.json", 0),
+        ("B", 500_000, HF / "bfl-ml-tierB" / "sweep_seed1.json", 1),
+    ]
+    for tier, n_train, path, seed in sources:
+        doc = _load(path)
+        for p in doc["points"]:
+            lo, hi = p["accuracy_ci"]
+            floor = p["min_detectable_advantage"]
+            rows.append(
+                {
+                    "tier": tier,
+                    "n_train": n_train,
+                    "n_val": _n_val(floor, 0.5),
+                    "seed": seed,
+                    "rounds": p["rounds"],
+                    "accuracy": p["accuracy"],
+                    "advantage": p["advantage"],  # 2*acc - 1
+                    "ci_lo": lo,
+                    "ci_hi": hi,
+                    "ci_resolution_floor": floor,
+                    # Above chance iff the 95% CI lower bound clears 0.5.
+                    "learnable": bool(lo > 0.5),
+                }
+            )
+    return pd.DataFrame(rows)
+
+
+def build_bounded_null() -> pd.DataFrame:
+    """#4/#2 full SHA-256 (64-round) vs random: a controls-gated null.
+
+    `conclusion` is verbatim from the harness. NOTE: ci_resolution_floor
+    is a CI-RESOLUTION floor (smallest gain whose 95% CI clears chance at
+    this n), NOT a power-based minimum detectable effect. "no structure"
+    means "none above this floor at this budget", not "SHA-256 is random".
+    """
+    rows = []
+    for seed in (0, 1, 2):
+        doc = _load(HF / "bfl-ml-tierA" / f"full_structure_seed{seed}.json")
+        ctl = doc["controls"]
+        bn = doc["bounded_null"]
+        for p in doc["points"]:
+            lo, hi = p["accuracy_ci"]
+            floor = p["min_detectable_advantage"]
+            rows.append(
+                {
+                    "experiment": "full_structure",
+                    "seed": seed,
+                    "model": p["model"],
+                    "rounds": 64,
+                    "n_train": 800_000,
+                    "n_val": _n_val(floor, 0.5),
+                    "accuracy": p["accuracy"],
+                    "advantage": p["advantage"],
+                    "ci_lo": lo,
+                    "ci_hi": hi,
+                    "ci_resolution_floor": floor,
+                    "is_best_model": p["model"] == bn["best_model"],
+                    "controls_ok": bool(bn["controls_ok"]),
+                    "positive_ok": bool(ctl["positive_ok"]),
+                    "negative_ok": bool(ctl["negative_ok"]),
+                    "structure_detected": bool(lo > 0.5),
+                    "conclusion": bn["conclusion"],
+                }
+            )
+    ind = _load(HF / "bfl-ml-tierA" / "indistinguishability.json")
+    p = ind["points"][0]
+    lo, hi = p["accuracy_ci"]
+    floor = p["min_detectable_advantage"]
+    rows.append(
+        {
+            "experiment": "indistinguishability",
+            "seed": 0,
+            "model": ind["model"],
+            "rounds": 64,
+            "n_train": 800_000,
+            "n_val": _n_val(floor, 0.5),
+            "accuracy": p["accuracy"],
+            "advantage": p["advantage"],
+            "ci_lo": lo,
+            "ci_hi": hi,
+            "ci_resolution_floor": floor,
+            "is_best_model": True,
+            "controls_ok": bool(ind["controls"]["positive_ok"]
+                                and ind["controls"]["negative_ok"]),
+            "positive_ok": bool(ind["controls"]["positive_ok"]),
+            "negative_ok": bool(ind["controls"]["negative_ok"]),
+            "structure_detected": bool(lo > 0.5),
+            "conclusion": "no structure detected above the detection floor",
+        }
+    )
+    return pd.DataFrame(rows)
+
+
+def build_dynamics_validated() -> pd.DataFrame:
+    """#3 iterated-hash orbit learnability — the VERIFIED negative.
+
+    Predict a binned iterated-SHA-256 orbit-tail length from the seed,
+    vs how many seed bytes the model sees. The width-1 point sits above
+    chance, but the permuted-label control scores IDENTICALLY: the
+    apparent signal is the non-uniform label prior, not orbit structure.
+    Those control fields are constant across rows on purpose so a single
+    table answers "is this signal real?".
+    """
+    doc = _load(HF / "dynamics_validated_seed0.json")
+    cfg = doc["config"]
+    ctl = doc["controls"]
+    pl_lo, pl_hi = ctl["permuted_label_ci"]
+    rows = []
+    for p in doc["points"]:
+        lo, hi = p["accuracy_ci"]
+        rows.append(
+            {
+                "seed": cfg["seed"],
+                "n_train": cfg["n"],
+                "epochs": cfg["epochs"],
+                "n_bins": cfg["n_bins"],
+                "trunc_width_bytes": p["rounds"],  # generic knob axis
+                "accuracy": p["accuracy"],
+                "chance": p["chance"],
+                "advantage": p["advantage"],  # accuracy - chance
+                "ci_lo": lo,
+                "ci_hi": hi,
+                "ci_resolution_floor": p["min_detectable_advantage"],
+                "permuted_label_accuracy": ctl["permuted_label_accuracy"],
+                "permuted_label_ci_lo": pl_lo,
+                "permuted_label_ci_hi": pl_hi,
+                "negative_ok": bool(ctl["negative_ok"]),
+                "verdict": (
+                    "ARTIFACT: width-1 gain == permuted-label control "
+                    "(label-prior, not orbit structure); no learnable "
+                    "seed->orbit-tail structure at any width"
+                ),
+            }
+        )
+    return pd.DataFrame(rows)
+
+
+def build_feature_probe() -> pd.DataFrame:
+    """Robustness check: is the round-4 cliff an artifact of the feature?
+
+    per-hash row is exact (Tier B seed0, n=500k). per-batch is the local
+    DEVLOG 2026-05-16 n=2M probe — its CI floor is coarse (~0.10) because
+    the per-batch deviation map yields few examples, so it is recorded
+    qualitatively and labelled with its provenance. Same cliff either
+    way: the boundary is not feature-bottlenecked.
+    """
+    tb0 = _load(HF / "bfl-ml-tierB" / "sweep_seed0.json")
+    by_round = {p["rounds"]: p for p in tb0["points"]}
+    ph_learn = sorted(r for r, p in by_round.items()
+                      if p["accuracy_ci"][0] > 0.5)
+    ph_chance = sorted(r for r in (4, 5, 6, 8) if r in by_round)
+    rows = [
+        {
+            "feature": "per-hash",
+            "n_train": 500_000,
+            "rounds_learnable": json.dumps(ph_learn),
+            "rounds_at_chance": json.dumps(ph_chance),
+            "ci_resolution_floor": tb0["points"][0]["min_detectable_advantage"],
+            "conclusion": "sharp learnability cliff after round 3",
+            "provenance": "HF Tier B seed0 (exact)",
+        },
+        {
+            "feature": "per-batch",
+            "n_train": 2_000_000,
+            "rounds_learnable": json.dumps([3]),
+            "rounds_at_chance": json.dumps([4, 5, 6, 8]),
+            "ci_resolution_floor": 0.10,  # coarse: few per-batch examples
+            "conclusion": (
+                "same round-4 cliff reproduced; not feature-bottlenecked"
+            ),
+            "provenance": (
+                "DEVLOG 2026-05-16 local n=2M probe; coarse floor; "
+                "qualitative (r3=1.00; r4-8 CI brackets 0.5)"
+            ),
+        },
+    ]
+    return pd.DataFrame(rows)
+
+
+def main() -> None:
+    tables = {
+        "learnability_sweep": build_learnability_sweep(),
+        "bounded_null": build_bounded_null(),
+        "dynamics_validated": build_dynamics_validated(),
+        "feature_probe": build_feature_probe(),
+    }
+    total = 0
+    for name, df in tables.items():
+        out = SCRIPT_DIR / f"{name}.parquet"
+        df.to_parquet(out, index=False, engine="pyarrow")
+        total += len(df)
+        print(f"  {name:22s} {len(df):4d} rows  -> {out.name}")
+    print(f"Total: {total} rows across {len(tables)} Parquet tables.")
+
+
+if __name__ == "__main__":
+    main()

dynamics_validated.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b36b3fc48c24410c41e1886f245f840848a81e8fb82bb6f9bff3ebc329dc8126
+size 10653

feature_probe.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33af0867937a24f7fa677652a1fcb98aff174acfad54512ae410d4e5214d7737
+size 5289

learnability_sweep.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:264b3ce05dd65fdace91512a3933d979c1fe4f356cf1f4e69333e4731957cb01
+size 8878

publish_dataset.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""Publish this directory as a public Hugging Face *dataset* repo.
+
+Mirrors `bfl_asic/ml/publish.py` (HfApi.create_repo + upload_folder) but
+with `repo_type="dataset"` and public-by-default, matching the author's
+existing HF dataset convention (`bshepp/pairwise-poisson-algebras`).
+
+Uploads only the curated card + Parquet + the two build/publish scripts
+(no synced run JSON, no payloads). Auth comes from the already-configured
+`hf` CLI token (HF_TOKEN env var or `~/.cache/huggingface/token`).
+
+Usage:
+    python dataset/publish_dataset.py                       # default repo, public
+    python dataset/publish_dataset.py --repo-id bshepp/...  # override
+    python dataset/publish_dataset.py --private             # private first
+    python dataset/publish_dataset.py --dry-run             # show, do not push
+"""
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+DEFAULT_REPO = "bshepp/round-reduced-sha256-learnability"
+ALLOW = ["README.md", "*.parquet", "build_dataset.py", "publish_dataset.py"]
+
+
+def publish(repo_id: str, *, private: bool, dry_run: bool) -> str:
+    folder = Path(__file__).resolve().parent
+    url = f"https://huggingface.co/datasets/{repo_id}"
+    files = sorted(
+        p.name
+        for p in folder.iterdir()
+        if p.suffix in (".parquet", ".md", ".py")
+    )
+    if dry_run:
+        print(f"[dry-run] would create dataset repo {repo_id} "
+              f"(private={private}) and upload from {folder}:")
+        for f in files:
+            print(f"  + {f}")
+        print(f"[dry-run] -> {url}")
+        return url
+
+    from huggingface_hub import HfApi  # lazy: only needed to actually push
+
+    api = HfApi()
+    api.create_repo(
+        repo_id, repo_type="dataset", exist_ok=True, private=private
+    )
+    api.upload_folder(
+        repo_id=repo_id,
+        repo_type="dataset",
+        folder_path=str(folder),
+        allow_patterns=ALLOW,
+        commit_message="Publish curated, controls-verified results",
+    )
+    return url
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--repo-id", default=DEFAULT_REPO)
+    ap.add_argument("--private", action="store_true",
+                    help="create private (default: public)")
+    ap.add_argument("--dry-run", action="store_true",
+                    help="list what would be pushed; do not push")
+    args = ap.parse_args()
+    url = publish(args.repo_id, private=args.private, dry_run=args.dry_run)
+    print(url)
+
+
+if __name__ == "__main__":
+    main()