docs(readme): align with canonical source-of-truth (cond-4 framing, cond-5 pipeline, source-file control)

README.md

@@ -907,19 +907,27 @@ dataset_info:
 
 # Language Decoded | Multilingual Code Dataset
 
+> **Experiment and proposed paper title:** _Language Decoded: Exploring the Impact of Native Code on Multilingual Models_
+
 > **Note (2026-05-18):** Current Phase 3 configs use the short `condition-*` namespace and include `103k`, `20k`, and `5k` sizes for Conditions 1--2. Phase 2 configs remain available under the `phase-2-the-stack-v1-*` namespace for reproducibility.
 
-Multilingual Python code datasets for the **Language Decoded** project (part of [Cohere's Tiny Aya Expedition](https://aya.for.ai)), investigating whether code's reasoning benefit for language models is **language-dependent** or **structure-dependent**.
+Multilingual Python code datasets for the **Language Decoded** project (part of [Cohere's Tiny Aya Expedition](https://aya.for.ai)). See [legesher/language-decoded-experiments](https://huggingface.co/datasets/legesher/language-decoded-experiments) for the canonical project description, the full experimental ladder, and the paper-grade evaluation results.
 
 ## Research Question
 
-> Does fine-tuning on non-English code (Python with translated keywords) improve multilingual reasoning as much as English code does?
+> **How does fine-tuning on non-English code — whether transpiled, mixed-native, or fully translated — affect a model's multilingual reasoning, and how does that impact _differ_ from fine-tuning on English code?**
 
-Prior work ([Aryabumi et al., 2024 -- "To Code or Not to Code"](https://arxiv.org/abs/2408.10914)) demonstrated that including English code in pre-training data improves downstream reasoning performance by approximately 8%. However, that study only tested English code. This dataset enables the natural follow-up: does the reasoning benefit come from the _structure_ of code, or from the _language_ of its keywords?
+Prior work ([Aryabumi et al., 2024 -- "To Code or Not to Code"](https://arxiv.org/abs/2408.10914)) demonstrated that including English code in pre-training data improves downstream reasoning performance by approximately 8%. However, that study only tested English code. This dataset enables the natural follow-up: how does the impact of non-English code differ from English code, and how does that vary by language, structure, and corpus construction?
 
 ## Dataset Description
 
-This dataset provides filtered, quality-controlled Python source code in multiple configurations: the original English, three keyword-swapped variants (Chinese, Spanish, Urdu), a blended native+transpiled mix, strictly native Chinese code, and a model-translated set in which an LLM translates the full source (identifiers, strings, and comments, not just keywords). Python source for Conditions 1, 2, and 5 is drawn from [bigcode/the-stack-v2-dedup](https://huggingface.co/datasets/bigcode/the-stack-v2-dedup) (Python subset) for the current Phase 3 configs; the legacy `phase-2-the-stack-v1-*` configs are sourced from [The Stack v1](https://huggingface.co/datasets/bigcode/the-stack). Conditions 3 and 4 additionally draw on natively-authored code (see those conditions below). Source files are filtered for quality using the following criteria:
+This dataset provides filtered, quality-controlled Python source code in multiple configurations: the original English (cond-1); three Legesher-transpiled variants (cond-2 zh/es/ur, with Python's reserved words translated to the target language); a community-collected raw native-source corpus (cond-3); strictly native code (cond-4, pending); and a model-translated set (cond-5, where `c4ai-aya-expanse-32b` translates everything translatable inside the file). Python source for Conditions 1, 2, and 5 is drawn from [bigcode/the-stack-v2-dedup](https://huggingface.co/datasets/bigcode/the-stack-v2-dedup) (Python subset) for the current Phase 3 configs; the legacy `phase-2-the-stack-v1-*` configs are sourced from [The Stack v1](https://huggingface.co/datasets/bigcode/the-stack) (non-dedup). Conditions 3 and 4 draw on natively-authored or community-contributed code (see those conditions below).
+
+### Source-file control
+
+Cond-1, cond-2, and cond-5 all train on the **same 5,000-file subset** drawn from `bigcode/the-stack-v2-dedup` (with a parallel 20k subset for the 20k tier). Differences across these conditions reflect the processing pipeline (raw / transpiled / fully translated), not file-quality or content drift. Cond-3 is the deliberate exception — its source files are a different population by design (community-collected from varied online sources, potentially including non-Python files).
+
+Source files for cond-1/2/5 are filtered using:
 
 - AST-valid Python only (must parse without errors)
 - Permissive licenses only (MIT, Apache-2.0, BSD, etc.)
@@ -928,7 +936,7 @@ This dataset provides filtered, quality-controlled Python source code in multipl
 - No autogenerated files
 - SHA-256 deduplication
 
-Keyword-swapped variants are produced using [Legesher](https://github.com/legesher/legesher) v0.7.3, which translates Python reserved words (37 keywords, 72 builtins, 66 exceptions) into the target language while preserving code structure and semantics.
+Cond-2 variants are produced using [Legesher](https://github.com/legesher/legesher) v0.7.3, which translates Python's reserved words (37 keywords, 72 built-in functions, 66 exceptions, plus the numerical system for some target languages) into the target language while preserving code structure and user logic. Cond-5 takes the Legesher-transpiled output and runs it through `c4ai-aya-expanse-32b` via the Cohere API to translate the remaining content — identifiers, comments, docstrings, string literals, and any other natural-language wording — into the target language. Logic and structure are preserved throughout.
 
 ## Available Configs
 
@@ -939,13 +947,13 @@ Conditions 1--2 are available in three current Phase 3 sizes: `-103k` full corpo
 | `condition-1-en-103k`     | 1 (control) | English  | Unmodified filtered Python                       | 93,549 | 10,395 |
 | `condition-1-en-20k`      | 1 (control) | English  | Random 20k subset of `condition-1-en-103k`       | 18,000 | 2,000  |
 | `condition-1-en-5k`       | 1 (control) | English  | Compact 5k subset                                | 4,500  | 500    |
-| `condition-2-zh-103k`     | 2           | Chinese  | Keyword-swapped Python via Legesher v0.7.3       | 93,547 | 10,395 |
+| `condition-2-zh-103k`     | 2           | Chinese  | Legesher v0.7.3 reserved-word translation       | 93,547 | 10,395 |
 | `condition-2-zh-20k`      | 2           | Chinese  | Random 20k subset of `condition-2-zh-103k`       | 18,000 | 2,000  |
 | `condition-2-zh-5k`       | 2           | Chinese  | Compact 5k subset                                | 4,500  | 500    |
-| `condition-2-es-103k`     | 2           | Spanish  | Keyword-swapped Python via Legesher v0.7.3       | 93,547 | 10,395 |
+| `condition-2-es-103k`     | 2           | Spanish  | Legesher v0.7.3 reserved-word translation       | 93,547 | 10,395 |
 | `condition-2-es-20k`      | 2           | Spanish  | Random 20k subset of `condition-2-es-103k`       | 18,000 | 2,000  |
 | `condition-2-es-5k`       | 2           | Spanish  | Compact 5k subset                                | 4,500  | 500    |
-| `condition-2-ur-103k`     | 2           | Urdu     | Keyword-swapped Python via Legesher v0.7.3       | 93,547 | 10,395 |
+| `condition-2-ur-103k`     | 2           | Urdu     | Legesher v0.7.3 reserved-word translation       | 93,547 | 10,395 |
 | `condition-2-ur-20k`      | 2           | Urdu     | Random 20k subset of `condition-2-ur-103k`       | 18,000 | 2,000  |
 | `condition-2-ur-5k`       | 2           | Urdu     | Compact 5k subset                                | 4,500  | 500    |
 | `condition-3-zh-5k`       | 3           | Chinese  | Blended: native Chinese code + transpiled Python | 4,500  | 500    |
@@ -962,7 +970,7 @@ Used by: `condition-1-en-*`, `condition-2-zh-*`, `condition-2-es-*`, `condition-
 
 | Column        | Type   | Description                                                                                                                                          |
 | ------------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `code`        | string | Python source code. For condition-2 configs, this is the transpiled (keyword-swapped) version. For condition-1, this is the original English source. |
+| `code`        | string | Python source code. For condition-2 configs, this is the Legesher-transpiled (reserved-word translated) version. For condition-1, this is the original English source. |
 | `code_en`     | string | Original English Python source code. Identical to `code` for condition-1-en.                                                                         |
 | `language`    | string | ISO 639-1 language code: `en`, `ur`, `zh`, or `es`.                                                                                                  |
 | `file_path`   | string | Original file path in the source dataset.                                                                                                               |
@@ -989,7 +997,9 @@ Condition 5 uses the conditions 1--2 schema plus an `idx` column. `code` is the
 
 Used by: `condition-3-zh-5k`
 
-Condition 3 blends native Chinese code with transpiled code and adds a `source_type` column to distinguish them. `code_en` is populated for transpiled rows (keeping them in sync with conditions 1--2) but null for native code rows, which have no English equivalent.
+In Phase 3, Condition 3 ("Mixed Native Sources") refers to **community-collected raw Chinese code from varied online public-source repositories** — reflecting how non-English Python is actually used in real-world projects. The "Mixed Native Sources" name carries from Phase 2, where it originally referred to a planned composite (native code padded with cond-2 transpiled files); in Phase 3 the "mixed" refers to the diversity of source locations, not a cond-2/native composite. The physical dataset has not changed across phases.
+
+The schema includes a `source_type` column from the Phase 2 composite design, which remains `"native"` or `"transpiled"` depending on each row's origin. `code_en` is populated for transpiled rows (keeping them in sync with conditions 1--2) but null for native code rows, which have no English equivalent.
 
 | Column        | Type        | Description                                                                        |
 | ------------- | ----------- | ---------------------------------------------------------------------------------- |
@@ -999,13 +1009,15 @@ Condition 3 blends native Chinese code with transpiled code and adds a `source_t
 | `language`    | string      | ISO 639-1 language code (`zh`)                                                     |
 | `license`     | string      | Source license (SPDX identifier, `UNKNOWN`, or `varies`)                           |
 | `token_count` | int64       | Token count computed using the CohereLabs/tiny-aya-base tokenizer                  |
-| `source_type` | string      | `"native"` (natively Chinese-authored) or `"transpiled"` (keyword-swapped English) |
+| `source_type` | string      | `"native"` (natively Chinese-authored) or `"transpiled"` (Legesher reserved-word translation of English) |
 
 ### Condition 4
 
 Used by: `condition-4-zh-5k`
 
-Condition 4 contains strictly native Chinese code -- code written by developers who think and code in Chinese. This uses the same schema as the [language-decoded-community](https://huggingface.co/datasets/legesher/language-decoded-community) dataset rather than the transpilation schema, since there is no English original to reference.
+Condition 4 ("Community-Contributed Native Code") is intended to contain code whose problem-solving logic is itself native — written as if a native speaker were approaching the problem, not English code that was later translated. The current dataset reflects an earlier Phase 2 attempt to assemble this corpus; community contributions were insufficient for stable training, so cond-4 was not evaluated in either Phase 2 or Phase 3. Cond-5's fully-translated data served as Phase 3's practical proxy because gathering native-authored code at scale proved difficult. Direct contributions to the cond-4 corpus are open at the [`legesher/legesher-native-code`](https://huggingface.co/spaces/legesher/legesher-native-code) HF Space.
+
+Uses the same schema as the [language-decoded-community](https://huggingface.co/datasets/legesher/language-decoded-community) dataset rather than the transpilation schema, since there is no English original to reference.
 
 | Column         | Type    | Description                                                    |
 | -------------- | ------- | -------------------------------------------------------------- |
@@ -1022,23 +1034,24 @@ Condition 4 contains strictly native Chinese code -- code written by developers
 
 ## Experimental Conditions
 
-The Language Decoded experiment uses a ladder of conditions to isolate the mechanism behind code's reasoning benefit:
+The Language Decoded experiment uses a ladder of conditions to isolate the mechanism behind code's reasoning benefit. For the full ladder including future directions, see [legesher/language-decoded-experiments](https://huggingface.co/datasets/legesher/language-decoded-experiments).
 
-| Condition   | Name                 | Purpose                                                                                   |
-| ----------- | -------------------- | ----------------------------------------------------------------------------------------- |
-| Baseline    | No fine-tuning       | Establishes the performance floor                                                         |
-| Condition 1 | English code         | Tests whether code fine-tuning helps at all (replicates Aryabumi et al.)                  |
-| Condition 2 | Keyword-swapped code | Tests whether the _language_ of keywords matters for the reasoning benefit                |
-| Condition 3 | Mixed native sources | Tests whether diverse native-language code adds value beyond keyword swapping             |
-| Condition 4 | Strictly native code | Tests whether code authored by native speakers carries unique signal beyond transpilation |
-| Condition 5 | Model-translated code | Tests whether full LLM translation (identifiers, strings, comments -- not just keywords) changes the reasoning benefit, relative to Condition 2's keyword-only swap |
+| Condition   | Name                                    | Purpose                                                                                                                                                                  |
+| ----------- | --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Baseline    | No fine-tuning                          | Establishes the performance floor                                                                                                                                        |
+| Condition 1 | English code                            | Tests whether code fine-tuning helps at all (replicates Aryabumi et al.)                                                                                                 |
+| Condition 2 | Reserved-Word Translation (Legesher)    | Tests whether translating Python's reserved words (keywords, exceptions, built-in functions, numerical system for some target languages) into the target language matters |
+| Condition 3 | Mixed Native Sources                    | Tests whether code pulled from real-world public-source repositories (humans actually writing in the target language) adds value beyond Legesher's mechanical translation |
+| Condition 4 | Community-Contributed Native Code       | Tests whether code whose problem-solving logic is itself native (not translated from English) carries unique signal — pending sufficient community contributions          |
+| Condition 5 | Synthesized Native Code                 | Tests whether full translation (Legesher reserved words + `c4ai-aya-expanse-32b` full file translation) changes the picture relative to Condition 2's partial translation |
 
 ### The Experimental Ladder
 
-- **Baseline --> 1**: Does code help at all?
-- **1 --> 2**: Does the language of keywords matter?
-- **2 --> 3**: Does diversity of native-language sources add value beyond keyword swap?
-- **3 --> 4**: Does code written in the cultural context of a language carry something that transpiled+mixed can't?
+- **Baseline → 1**: Does code help at all?
+- **1 → 2**: Does the language Python is _written in_ matter? (Cond-2 translates Python's reserved words; user logic preserved.)
+- **2 → 3**: Does code humans actually wrote in or with the target language add value beyond Legesher's mechanical translation?
+- **2 → 5**: Cond-2 translates only Python's reserved words; cond-5 goes further by also translating identifiers, comments, docstrings, and string literals via `c4ai-aya-expanse-32b`. Logic preserved. Does full translation produce different effects than partial translation?
+- **3 → 5** (implicit): Human-authored vs. machine-synthesized native code.
 
 ## Usage
 
@@ -1057,7 +1070,7 @@ ds = load_dataset("legesher/language-decoded-data", "condition-2-ur-20k")
 # Load 5k subset (for QLoRA fine-tuning)
 ds = load_dataset("legesher/language-decoded-data", "condition-1-en-5k")
 
-# Load keyword-swapped variants
+# Load Legesher-transpiled variants (reserved-word translation)
 ds = load_dataset("legesher/language-decoded-data", "condition-2-zh-5k")
 ds = load_dataset("legesher/language-decoded-data", "condition-2-es-5k")
 ds = load_dataset("legesher/language-decoded-data", "condition-2-ur-5k")
@@ -1101,14 +1114,14 @@ native_only = train.filter(lambda x: x["source_type"] == "native")
 - **Keyword-only transpilation**: Legesher translates Python reserved words (keywords, builtins, exceptions) but leaves comments, docstrings, string literals, and variable/function names in their original language (typically English). This means condition-2 code is a hybrid of translated keywords and English identifiers.
 - **Token count variation**: Transpiled code may have different token counts than the English original due to multi-byte characters (especially for Chinese and Urdu), even though the code structure is identical.
 - **Single programming language**: Currently limited to Python. Results may not generalize to other programming languages.
-- **Condition 4 scope**: Native Chinese code is limited to publicly available sources (The Stack, Wenyan, Program-in-Chinese, Qi, Mulan) and may not represent the full spectrum of Chinese-language programming.
+- **Condition 4 not yet evaluated**: Community contributions to the [`legesher/legesher-native-code`](https://huggingface.co/spaces/legesher/legesher-native-code) HF Space have been insufficient for stable training. The existing `condition-4-zh-5k` data is a Phase 2 attempt limited to publicly available sources (The Stack, Wenyan, Program-in-Chinese, Qi, Mulan). Cond-5's fully-translated data served as the Phase 3 practical proxy for cond-4's "logic in the target language" goal.
 - **Condition 5 is raw model output**: The `condition-5-*` configs contain prompt-leakage contamination -- translator-model preamble text, JSON wrappers, and explanation commentary leaked into string literals and identifier names, in AST-valid and AST-invalid rows alike. Cleaned configs will be published separately. See the note at the top of this card.
 
 ## Citation
 
 ```bibtex
 @misc{language-decoded-2026,
-  title={Language Decoded: Investigating Language-Dependent vs. Structure-Dependent Reasoning Benefits of Code},
+  title={Language Decoded: Exploring the Impact of Native Code on Multilingual Models},
   author={Madison Edgar and Saad Ahmed Bazaz and Tom Sherborne and Rashik Shahjahan and Khojasteh Mirza and Sarah Jawaid and Rafay Mustafa and Sohaib Ahmed Bazaz},
   year={2026},
   publisher={Hugging Face},