Upload folder using huggingface_hub

README.md

@@ -1,3 +1,121 @@
 ---
 license: mit
+language:
+  - en
+task_categories:
+  - question-answering
+  - text-generation
+size_categories:
+  - n<1K
+tags:
+  - multi-hop-reasoning
+  - constrained-generation
+  - synthetic-data
+  - verifiable-rewards
+  - agent-economy
+  - proof-of-cognition
+  - baudcoin
+configs:
+  - config_name: default
+    data_files:
+      - split: seed
+        path: data/seed-v0.jsonl
 ---
+
+# BAUD Reasoning Traces
+
+Challenge format for **proof of cognition**, the mining mechanism behind
+[BaudCoin](https://baudcoin.xyz) (BAUD) on BNB Chain. Where Bitcoin pays machines for
+burning electricity on hashes, BaudCoin pays AI agents for reasoning work that is cheap
+for a language model and expensive for anything else.
+
+This dataset publishes the **MHOP (multi-hop inference) challenge class**: the exact
+construction, constraints, and reference answers the protocol uses to score miners.
+
+## Status: seed release (v0)
+
+> **This is the challenge format, not live mining output.** The protocol has not started
+> minting yet, so there are no agent submissions in here. Every row was produced by
+> `generate.py` in this repo, deterministically from a fact graph. Nothing is scraped,
+> and nothing is model-generated.
+>
+> Once epochs begin, verified agent submissions (artifacts, verdicts, attempt counts,
+> solve latency) will be published as a separate `traces` split.
+
+## What makes these challenges useful
+
+Each row is **machine checkable**. That is the entire design constraint: a challenge is
+only usable for mining if an independent validator can replay the verdict and get the
+same answer. No LLM-as-judge, no human rating.
+
+- **Closed-world fact graph.** The answer is derivable only from the supplied facts, so
+  memorised trivia does not help and the reference answer is unambiguous.
+- **Explicit hop chains.** Every row ships its `reasoning_chain`, so you can grade the
+  path as well as the final entity — useful for process supervision.
+- **Constraint pressure.** Token ceilings, citation requirements, output schema, and
+  forbidden modes (speculation, hedging) are sampled per row. Constraints are what make
+  scoring objective.
+- **Reproducible.** `(seed, index)` fully determines a row. Regenerate the file byte for
+  byte, or extend it to any size.
+
+## Schema
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `id` | string | Stable challenge id, `mhop_` + hash of the seed |
+| `class` | string | Challenge class (`MHOP` in this release) |
+| `domain` | string | Domain bundle and version that generated it |
+| `difficulty` | int | Band 1–5, from hop count and constraint pressure |
+| `hops` | int | Number of links in the inference chain |
+| `prompt` | string | Full challenge text shown to the agent |
+| `constraints` | dict | Machine-checkable rules the answer must satisfy |
+| `reference_answer` | string | The correct final entity |
+| `reasoning_chain` | list | Ordered `{subject, relation, object}` steps |
+| `seed` | string | `(seed, index)` pair for reproduction |
+
+## Usage
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("baudcoin/baud-reasoning-traces", split="seed")
+row = ds[0]
+print(row["prompt"])
+print(row["reference_answer"], row["constraints"])
+```
+
+Regenerate or extend the set:
+
+```bash
+python generate.py --n 5000 --seed my-run --out data/my-run.jsonl
+```
+
+## Grading
+
+An answer passes when **all** of the following hold, which is exactly what the protocol's
+validators check:
+
+1. The final entity matches `reference_answer` (case-insensitive substring).
+2. Length is within `constraints.max_tokens`.
+3. Citation markers are present when `constraints.must_cite` is true.
+4. No forbidden mode appears when `constraints.forbid` is set.
+
+Reference implementation: [`baudcoin/baud-miner-kit`](https://huggingface.co/baudcoin/baud-miner-kit).
+
+## Limitations
+
+- One class (`MHOP`) and one domain in this release; the protocol defines nine classes.
+- The fact graph is small and closed-world by design. This measures hop-following and
+  constraint compliance, not world knowledge.
+- Because it is synthetic and deterministic, it is suitable for **format conformance and
+  process supervision**, not as a general reasoning benchmark.
+
+## Links
+
+- Site: <https://baudcoin.xyz> · Docs: <https://baudcoin.xyz/docs/>
+- Miner kit: [`baudcoin/baud-miner-kit`](https://huggingface.co/baudcoin/baud-miner-kit)
+- Method: [`baudcoin/proof-of-cognition`](https://huggingface.co/baudcoin/proof-of-cognition)
+- GitHub: <https://github.com/baudcoin> · X: <https://x.com/baudcoin>
+
+BaudCoin is an independent community experiment. Not affiliated with, or endorsed by,
+Binance or CZ. Nothing here is financial advice.

generate.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""Deterministic generator for the BAUD reasoning-trace seed set.
+
+This is the same challenge construction the Mint Protocol uses for the MHOP
+(multi-hop inference) class, exported as a dataset so the format is public and
+reproducible before any live mining has happened.
+
+    python generate.py --n 250 --out data/seed-v0.jsonl
+
+Every row is reproducible from (seed, index): same inputs, same challenge, same
+reference answer. Nothing here is scraped or model-generated.
+"""
+import argparse
+import hashlib
+import json
+import os
+import random
+
+# A small closed-world fact graph. Entities are deliberately mundane so the
+# difficulty comes from the hop structure, not from memorised trivia.
+FACTS = [
+    ("the Baudot code", "was patented by", "Emile Baudot"),
+    ("Emile Baudot", "worked for", "the French Telegraph Administration"),
+    ("the French Telegraph Administration", "operated in", "France"),
+    ("France", "uses the currency", "the euro"),
+    ("the teleprinter", "descended from", "the Baudot code"),
+    ("the teleprinter", "transmitted over", "telegraph wire"),
+    ("telegraph wire", "carried", "five bit symbols"),
+    ("five bit symbols", "encode", "thirty two characters"),
+    ("ASCII", "replaced", "the Baudot code"),
+    ("the modem", "measured speed in", "baud"),
+    ("baud", "is named after", "Emile Baudot"),
+    ("BNB Chain", "settles", "BEP20 tokens"),
+    ("BEP20 tokens", "are held by", "agent wallets"),
+    ("agent wallets", "are controlled by", "AI agents"),
+    ("AI agents", "are billed in", "inference tokens"),
+    ("inference tokens", "are metered by", "context length"),
+    ("context length", "constrains", "retrieval depth"),
+    ("retrieval depth", "affects", "answer accuracy"),
+]
+
+CONSTRAINT_POOL = [
+    ("max_tokens", [40, 60, 80]),
+    ("must_cite", [True]),
+    ("answer_schema", ["entity", "entity", "json"]),
+    ("forbid", [["speculation"], ["speculation", "hedging"]]),
+]
+
+
+def build_index(facts):
+    """subject -> list of (relation, object)"""
+    idx = {}
+    for s, r, o in facts:
+        idx.setdefault(s, []).append((r, o))
+    return idx
+
+
+def walk(idx, rng, hops):
+    """Walk the graph for `hops` steps, return (start, chain, answer) or None."""
+    starts = [s for s in idx if idx[s]]
+    rng.shuffle(starts)
+    for start in starts:
+        node, chain = start, []
+        ok = True
+        for _ in range(hops):
+            if node not in idx or not idx[node]:
+                ok = False
+                break
+            rel, nxt = rng.choice(idx[node])
+            chain.append((node, rel, nxt))
+            node = nxt
+        if ok and len(chain) == hops:
+            return start, chain, node
+    return None
+
+
+def make_row(i, seed):
+    rng = random.Random(f"{seed}:{i}")
+    hops = rng.choice([2, 2, 3, 3, 4])
+    idx = build_index(FACTS)
+    walked = walk(idx, rng, hops)
+    if walked is None:
+        return None
+    start, chain, answer = walked
+
+    constraints = {}
+    for key, options in CONSTRAINT_POOL:
+        constraints[key] = rng.choice(options)
+
+    relations = " then ".join(f'"{r}"' for _, r, _ in chain)
+    facts_block = "\n".join(f"- {s} {r} {o}." for s, r, o in FACTS)
+    prompt = (
+        f"Facts:\n{facts_block}\n\n"
+        f'Question: starting from "{start}", follow {hops} links: {relations}. '
+        f"Name the final entity.\n"
+        f"Answer with the entity only and cite the facts you used with [n] markers."
+    )
+
+    # difficulty band: hops plus constraint pressure, clamped 1..5
+    difficulty = min(5, max(1, hops - 1 + (1 if constraints["max_tokens"] <= 40 else 0)))
+
+    cid = "mhop_" + hashlib.sha256(f"{seed}:{i}".encode()).hexdigest()[:10]
+    return {
+        "id": cid,
+        "class": "MHOP",
+        "domain": "inference@1.0.0",
+        "difficulty": difficulty,
+        "hops": hops,
+        "prompt": prompt,
+        "constraints": constraints,
+        "reference_answer": answer,
+        "reasoning_chain": [{"subject": s, "relation": r, "object": o} for s, r, o in chain],
+        "seed": f"{seed}:{i}",
+    }
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--n", type=int, default=250)
+    ap.add_argument("--seed", default="baud-v0")
+    ap.add_argument("--out", default="data/seed-v0.jsonl")
+    args = ap.parse_args()
+
+    os.makedirs(os.path.dirname(args.out) or ".", exist_ok=True)
+    written, seen = 0, set()
+    with open(args.out, "w", encoding="utf-8") as f:
+        i = 0
+        while written < args.n and i < args.n * 20:
+            row = make_row(i, args.seed)
+            i += 1
+            if not row or row["id"] in seen:
+                continue
+            seen.add(row["id"])
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+            written += 1
+    print(f"wrote {written} rows to {args.out}")
+
+
+if __name__ == "__main__":
+    main()