Update README.md

Add first version of dataset card and raw files.

README.md

@@ -1,3 +1,240 @@
 ---
 license: cc-by-4.0
+task_categories:
+- text-generation
+language:
+- en
+tags:
+- code
+- reinforcement-learning
+- rlvr
+- test-cases
+- code-generation
+- competitive-programming
+size_categories:
+- 10K<n<100K
 ---
+
+# RobustTests
+
+## Dataset Description
+
+RobustTests is a high-quality test case dataset specifically designed for **reinforcement learning from verifiable rewards (RLVR)** in code generation tasks. It addresses the fundamental limitation of insufficient test coverage that often causes **false positives** and **reward hacking** in RL-based code training.
+
+📄 **Paper**: [Robust Code RL via Faulty-Code-Driven Test Case Synthesis and Dense Reward Shaping](https://arxiv.org/abs/2608.24135) — Findings of EMNLP 2026
+
+**Important**: To avoid copyright issues, this dataset only provides the test case collections — it does not include the original problem descriptions. Each problem is identified by its `id` and `source`, which can be used to match with the corresponding problems in [Code-Contests-Plus](https://huggingface.co/datasets/ByteDance-Seed/Code-Contests-Plus) or the original competitive programming platforms.
+
+## Key Features
+
+- **High-Coverage Test Cases**: Each problem is equipped with a rich set of test cases covering various edge cases, boundary conditions, and corner cases, significantly reducing false positives in reward computation.
+- **Anti-Reward-Hacking**: By providing thorough test coverage, RobustTests mitigates reward hacking — a common failure mode where models learn to pass a small number of visible test cases without producing genuinely correct solutions.
+- **RLVR-Ready**: Designed specifically for reinforcement learning from verifiable rewards, the test cases serve as reliable verification oracles for code generation tasks.
+- **Compact Encoding**: Test cases are encoded using a multi-layer compression scheme (Base64 → Zlib → Pickle) to keep storage efficient while preserving all data fidelity.
+
+## Dataset Statistics
+
+| Metric | Value |
+|--------|-------|
+| Total problems | 11,636 |
+| Number of files | 4 (sharded parquet) |
+| License | CC-BY-4.0 |
+
+### Source Distribution
+
+| Source | Count | Percentage |
+|--------|-------|------------|
+| Codeforces | 7,525 | 64.7% |
+| AIZU | 2,028 | 17.4% |
+| AtCoder | 1,318 | 11.3% |
+| CodeChef | 765 | 6.6% |
+
+## Dataset Structure
+
+### Data Fields
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `source` | `string` | The competitive programming platform the problem originates from (e.g., Codeforces, AIZU, AtCoder, CodeChef) |
+| `id` | `string` | Unique identifier for the problem, which can be used to match with the corresponding problem in Code-Contests-Plus |
+| `testcase` | `struct` | Test case container with the following sub-fields: |
+| `testcase.inputs` | `list<string>` | List of encoded input strings for each test case (Base64 → Zlib → Pickle compressed) |
+| `testcase.outputs` | `list<string>` | List of encoded expected output strings for each test case (Base64 → Zlib → Pickle compressed) |
+
+### Data Format
+
+The dataset is stored in Parquet format, sharded across 4 files:
+- `part-00000-of-00004.parquet` (2,909 rows)
+- `part-00001-of-00004.parquet` (2,909 rows)
+- `part-00002-of-00004.parquet` (2,909 rows)
+- `part-00003-of-00004.parquet` (2,909 rows)
+
+## How to Use
+
+### Installation
+
+```bash
+pip install datasets
+```
+
+### Loading the Dataset
+
+```python
+from datasets import load_dataset
+
+# Load the complete dataset
+dataset = load_dataset("Anonymous/robusttests")
+
+# Access a specific problem
+problem = dataset['train'][0]
+print(f"Source: {problem['source']}")
+print(f"ID: {problem['id']}")
+print(f"Number of test cases: {len(problem['testcase']['inputs'])}")
+```
+
+### Decoding Test Cases
+
+Test cases are stored using a multi-layer compression encoding. Use the following code to decode:
+
+```python
+import base64
+import zlib
+import pickle
+
+
+def decode_testcase(encoded_testcase):
+    """Decode a single encoded test case.
+
+    Decoding chain: Base64 → Zlib → Pickle → UTF-8 string
+
+    Args:
+        encoded_testcase: Base64-encoded compressed test case string
+
+    Returns:
+        str: Decoded raw input/output text
+    """
+    # Step 1: Base64 decode - convert the encoded string back to binary data
+    decoded = base64.b64decode(encoded_testcase)
+
+    # Step 2: Zlib decompress - restore the compressed binary data
+    decompressed = zlib.decompress(decoded)
+
+    # Step 3: Pickle deserialize - reconstruct Python object from binary
+    data = pickle.loads(decompressed)
+
+    # Step 4: Decode bytes to UTF-8 string
+    if isinstance(data, bytes):
+        data = data.decode('utf-8')
+
+    return data
+
+
+def parse_testcase(testcase):
+    """Parse the entire testcase field by decoding all inputs and outputs.
+
+    Args:
+        testcase: A dict with 'inputs' and 'outputs' fields,
+                  where each element is a Base64-encoded compressed string
+
+    Returns:
+        dict: Decoded testcase in the format:
+              {'inputs': [str, ...], 'outputs': [str, ...]}
+    """
+    return {
+        'inputs': [decode_testcase(x) for x in testcase['inputs']],
+        'outputs': [decode_testcase(x) for x in testcase['outputs']]
+    }
+```
+
+### Usage Example
+
+```python
+from datasets import load_dataset
+
+dataset = load_dataset("Anonymous/robusttests")
+problem = dataset['train'][0]
+
+# Decode all test cases
+decoded = parse_testcase(problem['testcase'])
+
+# Inspect test cases
+for i, (inp, out) in enumerate(zip(decoded['inputs'], decoded['outputs'])):
+    print(f"--- Test Case {i+1} ---")
+    print(f"Input:\n{inp}")
+    print(f"Expected Output:\n{out}")
+```
+
+## Evaluation
+
+### Benchmark Results
+
+When used to train **Qwen3-32B** via **GRPO**, replacing the original test cases with RobustTests leads to consistent improvements across benchmarks:
+
+| Benchmark | Metric | CodeContests+ | RobustTests | Gain |
+|-----------|--------|---------------|-------------|------|
+| LiveCodeBench (2024.08–2025.01) | Score | 65.41 | 68.39 | +2.98 |
+| Codeforces | Score | 35.56 | 38.50 | +2.94 |
+| Codeforces | Rating | 83.96 | 85.99 | +2.03 |
+| Codeforces | Percentile | 91.45 | 94.67 | +3.22 |
+
+### Dense Reward Function
+
+The dataset is designed to work with a stepwise dense reward function:
+
+```python
+def compute_reward(pass_count, total_count):
+    """
+    Stepwise dense reward based on pass rate.
+
+    Args:
+        pass_count: Number of test cases passed
+        total_count: Total number of test cases
+
+    Returns:
+        float: Reward value
+    """
+    if pass_count == total_count:
+        return 1.1        # All tests passed
+    elif pass_count == 0:
+        return -0.1       # All tests failed
+    else:
+        return 0.1 * (pass_count / total_count)  # Partial credit
+```
+
+## Intended Uses
+
+- **RLVR Training**: Serve as high-quality verification oracles for reinforcement learning from verifiable rewards in code generation.
+- **Code Generation Evaluation**: Provide comprehensive test cases for evaluating code generation models on competitive programming problems.
+- **Anti-Reward-Hacking Research**: Enable research into mitigating reward hacking in RL-based code training.
+
+## Limitations
+
+- The dataset only provides test cases — problem descriptions must be obtained from [Code-Contests-Plus](https://huggingface.co/datasets/ByteDance-Seed/Code-Contests-Plus) or the original platforms.
+- The dataset covers competitive programming problems, which may not represent the full diversity of real-world software engineering tasks.
+- While test coverage is significantly enhanced compared to the original problems, it may still not be exhaustive for all possible edge cases.
+- The test cases are designed for programs that read from stdin and write to stdout, following the competitive programming convention.
+
+## Source Data
+
+The test cases in this dataset are designed for problems from [Code-Contests-Plus](https://huggingface.co/datasets/ByteDance-Seed/Code-Contests-Plus), a dataset published by ByteDance Seed that aggregates competitive programming problems from platforms including Codeforces, AIZU, AtCoder, and CodeChef.
+
+## Citation
+
+If you find RobustTests useful in your research, please cite our paper:
+
+```bibtex
+@article{zhang2026robust,
+  title={Robust Code RL via Faulty-Code-Driven Test Case Synthesis and Dense Reward Shaping},
+  author={Zhang, Yiwen and Yan, Xiaodong and Huang, Zhenyu and Zhao, Deng and Jiang, Liang and Cui, Qing and Wen, Zujie and Zhang, Zhiqiang and Zhou, Jun},
+  journal={arXiv preprint arXiv:2608.24135},
+  year={2026}
+}
+
+## License
+
+This project is licensed under **CC-BY-4.0**. See the [LICENSE](LICENSE) file for details.
+
+## Acknowledgements
+
+- [Code-Contests-Plus](https://huggingface.co/datasets/ByteDance-Seed/Code-Contests-Plus) — the ByteDance Seed dataset that provides the problems these test cases are designed for.
+- The competitive programming platforms (Codeforces, AIZU, AtCoder, CodeChef) that originally host these problems.