Update README.md

README.md

@@ -1,3 +1,121 @@
----
-license: apache-2.0
----
+---
+license: apache-2.0
+---
+
+# 🧩 NumPuzzle-Easy: The 1,500-Step Spatial Reasoning Nightmare
+
+**"Simple for Humans, Impossible for Machines."**
+
+NumPuzzle-Easy is a high-density benchmarking dataset designed to expose the fundamental limitations of modern Large Language Models (LLMs) in spatial reasoning, sequential state tracking, and recursive simulation. While humans can solve these puzzles with basic clerical accuracy using tools like Excel, even the most advanced "Reasoning" models—such as OpenAI's o1-series, DeepSeek-R1, and Qwen 3.6 Plus—struggle to achieve even a 1% accuracy rate.
+
+## 🔴 The Core Challenge: Numerical Hell
+
+The task is deceptively simple:
+1. **The Grid:** A 9x9 matrix filled with single-digit integers (0-9).
+2. **The Manipulation:** 15 consecutive swap operations (moves) from a starting coordinate.
+3. **The Recurrence:** After the moves, the system resolves up to 4 recursive "Chain Reactions" (Match-3 and Gravity).
+4. **The Goal:** Provide the final state of the top row (Row 1) as a 9-digit string.
+
+### Why LLMs Fail (The Three Walls)
+1. **The Tokenization Trap:** LLMs process numbers as tokens, not as spatial entities. Swapping digits changes the token boundaries, causing the model to lose the physical "anchor" of each coordinate.
+2. **State Tracking Collapse:** Each move depends on the previous state. A single 1-pixel error at Step 3 renders the remaining 12 moves and 4 chains purely hallucinatory.
+3. **Recursive Gravity Simulation:** Calculating how numbers "fall" into empty spaces requires a consistent internal 2D world model, which autoregressive transformers fundamentally lack.
+
+## 📊 Dataset Statistics
+- **Total Samples:** 1,500
+- **Grid Size:** 9x9 (81 cells)
+- **Difficulty:** High (Sequential dependency + 4-layer recursion)
+- **Ground Truth:** Generated via deterministic Python simulation (Accuracy: 100%).
+
+## 📂 Files in this Repository
+- `NumPuzzle_Easy_AutoEval.csv`: Optimized for automated evaluation (Columns: `prompt`, `target`).
+- `numpuzzle_easy_1.5k.csv`: Raw data for custom scripts (Columns: `instruction`, `answer`).
+
+---
+
+## 🏆 Community Leaderboard & Transparency
+**I do not solve these puzzles myself.** As the creator, my role is to design the maze; it is the AI's role to fail within it. 
+
+To ensure the benchmark remains objective and untainted by author bias, **we do not maintain an internal leaderboard.** Instead, we rely on the community for ground truth reporting.
+
+### 📢 Submit Your Results
+We invite all researchers and AI enthusiasts to post their evaluation logs in the **[Community Tab](https://huggingface.co/datasets/56m/NumpuzzleEasy/discussions)**.
+
+**When posting, please include:**
+- **Model Name:** (e.g., GPT-5.5, Qwen 3.6, Gemini, Kimi K, GLM, etc)
+- **Sample Size:** (How many out of 1,500 you tested, In the case of more than 1500 questions, did you repeat it or did you measure it randomly)
+- **Accuracy:** (e.g., 1%)
+- **Logs:** A snippet of the Thinking Process or the final JSON results.
+
+> **Note on Integrity:** Figures posted in the Community tab by verified users will be considered the official record of a model's performance. The "Truth" of this benchmark lies in the collective failures of the world's most powerful AIs.
+
+
+---
+
+### 🛠 Evaluation Protocol: The Strict Mandate
+
+This benchmark is not a test of linguistic creativity or "vibes." It is a cold, binary assessment of a model's ability to maintain a deterministic world model. To maintain the integrity of NumPuzzle-Easy, all evaluators must adhere to the following rigorous protocol.
+
+#### 1. The "Exact Match" (EM) Mandate
+We reject the use of fuzzy matching, BLEU, ROUGE, or any other semantic similarity metrics. In the realm of spatial reasoning, "almost correct" is fundamentally "wrong." If a model calculates 14 out of 15 moves correctly, its 15th move and the subsequent 4-chain reaction will be catastrophic. Therefore, the **only valid metric is Exact Match (EM).**
+- **Criteria:** The output must be exactly the 9-digit sequence representing Row 1.
+- **Fail Case:** `086738476` vs `086730476` (Result: **0**).
+
+#### 2. The Leading Zero Trap (The "No Mercy" Policy)
+One of the most common failures in LLMs is the loss of numeric context. In this puzzle, Row 1 can frequently begin with one or more zeros (e.g., `001234567`). 
+- **The Rule:** The model must output exactly **9 digits**. 
+- **The Rationale:** If a model outputs 8 digits (e.g., `12345678`), it indicates that the LLM has collapsed the grid representation into a standard integer, losing the spatial awareness of the 9-column architecture. This is an immediate failure. No post-processing or "fixing" of the output is allowed. 
+
+#### 3. Zero-Shot vs. Reasoning Trace 
+To observe the pure architectural limits, we recommend **Zero-Shot evaluation**. However, for "Reasoning" models (o1, DeepSeek-R1, Qwen 3.6 Plus), the internal "Thinking Process" or "Chain of Thought" (CoT) should be preserved in logs.
+- **What to look for:** Does the model's internal grid representation "drift" over time? Most models will lose the position of the active orb around Move 7 or 8. We encourage evaluators to share these logs in the Community tab to visualize the "moment of collapse."
+
+#### 4. Community-Driven Verification (Transparency Protocol)
+As the creator, I do not provide an "Official Leaderboard" based on my own tests. To prevent "Benchmark Laundering" (where providers cherry-pick successful runs), the truth must be crowdsourced. 
+- **How to Submit:** Please open a thread in the **[Community Tab]** with your model's name. 
+- **Requirements:** 
+    - Full transparency on the prompt used.
+    - If testing a subset (e.g., 100/1500), specify the exact row indices.
+    - Post a screenshot or a JSON dump of the failed responses. 
+- **Verification:** Only results that can be replicated by other community members will be recognized as the definitive score for a given model version.
+
+#### 5. Cost-Effective Testing
+We recognize that 1,500 samples of o1-level reasoning are expensive. 
+- **Sampling:** For quick validation, a random sample of **100 rows** is acceptable. Given the 1% failure rate, a 100-sample test is statistically sufficient to prove a model's inability to solve this benchmark. 
+- **Stop-Loss:** If your model fails the first 50 consecutive puzzles, it is safe to assume an accuracy of <2%. You may stop there and report the result as "Complete Failure."
+
+**"The grid does not care about your reasoning. It only cares about the truth."**
+
+---
+
+# 📂 File Structure & Usage
+
+This repository contains the following files:
+
+| File Name | Description | Column Mapping |
+| :--- | :--- | :--- |
+| **`NumPuzzle_Easy_AutoEval.csv`** | **Recommended for Evaluators.** Specifically formatted for Hugging Face Auto-Post, LightEval, and other automated evaluation tools. | `prompt`, `target` |
+| **`numpuzzle_easy_1.5k.csv`** | The raw dataset containing 1,500 unique problems. Best for manual inspection or custom scripts. | `instruction`, `answer` |
+| **`.gitattributes`** | Standard Git LFS configuration to handle CSV files efficiently. | N/A |
+
+### 🚀 How to Start Benchmarking
+
+#### 1. Quick Automated Eval (The "I'm Busy" Way)
+If you want to test your model via **Hugging Face Model Evaluator** or **LightEval**, use `NumPuzzle_Easy_AutoEval.csv`. 
+- **Prompt Column:** `prompt`
+- **Reference Column:** `target`
+- **Metric:** `Exact Match`
+
+#### 2. Custom Evaluation Script
+If you are running your own Python script, you can use either file. 
+- **Sample count:** 1,500 (Designed to be completed overnight via most APIs).
+- **Format:** The `prompt`/`instruction` includes the 9x9 grid, 15 swap moves, and the rules for gravity/chains.
+
+### 🧩 Why 1,500 samples?
+1. **Statistical Power:** With 1,500 problems, any "lucky guess" from an LLM is statistically irrelevant. 
+2. **Cost-Efficiency:** Small enough to be processed via OpenAI/Anthropic APIs within a few hours (overnight), keeping benchmarking costs reasonable while ensuring total failure for the model.
+
+
+---
+
+"Let the GPUs burn, while we watch the logic crumble."