# Examples

Two kinds of artifact, both verbatim and unedited:

**1. Full-size training rows** — so the scale of the corpus is visible, not just described.

| file | what it is | size |
|---|---|---|
| `training_example_ru_whole_building_trunk.md` | Russian. One whole building read from the architecture angle — massing, datum stack, apartment programme — synthesized from an IFC extraction. | **42,685 chars** (5,585 scenario / 12,787 reasoning / 25,510 code) |
| `training_example_en_rebar_forensics.md` | English. Rebar-to-host integrity forensics on a stadium raker frame: the model refuses the detailer's hypothesis and sets a falsifiable anchor before touching anything. | **17,147 chars** |

Projects are de-identified. In the Russian record, every figure marked `store-точно` ("store-exact")
came out of the IFC extraction, not out of the model; where the model reconstructs instead of reads,
it says so.

Both rows were compiled against the real Revit assemblies while preparing this release:

| record | builds on |
|---|---|
| Russian whole-building trunk (standalone file, 25,511 chars of C#) | 2021, 2024, 2026 — verified |
| English rebar forensics (3 fragments) | **2024, 2025, 2026 only** — fails 2021–2023 with `CS1503`, because it uses `ElementId.Value`, which exists from 2024 (earlier versions want `IntegerValue`) |

The English row's version lock is not a mistake for a Revit-2026 corpus, but it makes the point of the
`wall_with_window` example below: hand-written code carries a silent version dependency, while the
compiler emits correct code for all six versions from one source.

**2. A worked KIR example: the same building fragment in KIR and in emitted C#**

A 6 m exterior wall with a window in it, on one level.

| file | what it is | size |
|---|---|---|
| `wall_with_window.kir.json` | what the **model** writes — the typed IR program | 336 chars / **132 tokens** |
| `wall_with_window.emitted.cs` | what the **compiler** produced from it, verbatim | 10,010 chars / **193 lines** / 3,125 tokens |

Token counts measured with this repository's own `tokenizer.json`. Line count:
`wc -l wall_with_window.emitted.cs`.

The emitted file is unedited compiler output (`kukai.ir.compiler.compile_program`, target Revit 2026).
Read it and note what the model never had to get right: foot/millimetre conversion at every boundary,
transaction start-status checking, a rollback on every null return, `FamilySymbol.Activate()` followed
by `doc.Regenerate()`, resolving the window's level from its host wall, and a post-`Regenerate()`
read-back that compares the built element's actual position against the request to within 10 mm and
rolls the whole transaction back if it disagrees.

That is the 23.7× token ratio in the model card, in full, so you can check it rather than trust it.

## Verification

The emitted file in this folder was compiled against the **real Autodesk Revit assemblies**
(`RevitAPI.dll`, `RevitAPIUI.dll`) for every supported version, through the same compile gate the
project uses in production:

```
Revit 2021: OK    Revit 2024: OK
Revit 2022: OK    Revit 2025: OK
Revit 2023: OK    Revit 2026: OK
                  => 6/6
```

So the 193 lines are not illustrative pseudo-code: every API call in them exists and type-checks on
all six Revit versions, from one 336-character source program.