Romenagri — Measured Results

The Linguistic Equity Optimality Theorem

Not a claim about a better implementation — a statement that any architecture satisfying the constraints of linguistic equity necessarily converges to this architectural class.

Theorem (Linguistic Equity Optimality). For any architecture maximizing linguistic equity across the computing continuum while preserving Identity (I=1), Reversibility (R=1), Interoperability, and Execution Independence (X=1), any valid solution must contain

Human Language ↔ Canonical Identity ↔ Reversible Projection ↔ Unmodified Ecosystem

and any competing architecture satisfying all constraints is structurally isomorphic to the Canonical Reversible Architecture. ∴ it is the unique Pareto-optimal class. ∎

Adversarial proof: every competitor tested either sacrifices ecosystem reuse, determinism, or identity — or reintroduces a canonical identity layer structurally identical to this one. Full proof: Paper 1 · langspec/output.

Three Axes — measured coverage

Axis 1 — Script (writing systems)

Per-script Unicode projection tables → Devanagari hub → fixed reversible kernel. N tables + 1 kernel, never N². A new script is one table row; the kernel never changes. Measured across three families below.

Axis 2 — Language (vocabulary)

Each language's own words — not transliterations. 68 languages × 201 constructs in the registry, and the langspec generator lets anyone add a language, dialect, or personal idiolect by writing a CSV.

Axis 3 — Standard (ontology)

One construct identity localizes into every standard (KW_IF → C/Python/VHDL/Rust if; ISO/IEC 9899 · 14882 · IEEE 1800 · 1076 · 754 · Khronos · OMG · ONNX). Localization of existing standards, not re-authorship. Linguistic-layer adaptation cost across any future execution paradigm = 0.

The full AGI stack — one substrate, every layer

L9 AGI / ASI alignment modality-agnostic canonical identity L8 Applications / JS LIVE: ilm.codes/map.html (41 Perso-Arabic languages) L7 WASM bridge one C kernel -> browser and systems L6 AI / ML substrate lossless byte+alphabet compression; reversible, not lossy L5 Distributed / GPU CUDA / OpenCL / MPI localized L4 Systems programming HPS: C, C++, ASM, LEX, YACC, BASIC in native script -> unmodified GCC L3 Firmware / OS Indic-language OS infrastructure L2 Synthesis -> GDSII OpenLane / Sky130 L1 Verification UVM / SystemVerilog Assertions L0 RTL VHDL (IEEE-1076) / Verilog (IEEE-1800) ^ all languages x all standards span L0 through L9

The same reversible identity that lets a Hindi program compile (L4) is what AI tokenization needs (L6) and AGI alignment requires (L9). System first; software is one medium.

Reversibility — exhaustive and corpus, kernel variant named

Reversibility is a property of the Romenagri grammar, not of any byte encoding: the same parser over an ISCII substrate or a UTF-8 Devanagari substrate classifies identically. We report the figure for the kernel currently in bindings/c and name it explicitly.

Corpus round trip — codepoint-classified (UTF-8 substrate)

The Unicode substrate consumes/emits UTF-8 directly (no uni2acii/acii2uni). Core Devanagari letters and matras/signs are the kernel's domain; digits and danda/abbreviation punctuation — the codepoints the 8-bit ISCII table drops — are recovered by the UTF-8 substrate.

Alphabet limits — heuristic totality

A maximal Romenagri phoneme is up to 5 Latin characters (the 4–5-char ceiling). The kernel is exact on canonical Romenagri and undefined on arbitrary Latin — those gaps are alphabet limits, not bugs. A heuristic front-end (filters/rom2deva_heur.py) longest-prefix-matches the token inventory and applies fallback rules, making every Latin string project to Devanagari, with the kernel left unchanged.

Perso-Arabic completeness is additive: the attested base map is left untouched where it suffices; a heuristic fills the remainder so the whole family reaches the hub. Short-vowel residue (abjad underspecification) is documented, not hidden.

All script families — N tables + 1 kernel

Brahmi by Unicode name-projection; Perso-Arabic total via the additive heuristic; NW-Semitic by attested consonant correspondence (Hebrew, Syriac; Aramaic/Phoenician/Samaritan/Mandaic/Nabataean share the abjad skeleton). Residual graphemes are completed by the heuristic layer. A new script adds one table — the kernel never changes.

Language-standard generator — anyone, any register, even an idiolect

The software-engineering process, recollected: localization is presentation + ontology, not compiler reinvention. Keywords are translated; semantics are preserved (KW_IF → if); surface keywords map to reversible canonical Romenagri ASCII-7 identifiers; GCC/LLVM/debuggers/SCM/IDEs/libraries are untouched. Pipeline: native .uhin → hincc → Romenagri identifiers → unmodified GCC.

A CSV of construct,native_keyword,romenagri yields a localized standard document and a compile-verified C program. Demonstrated here for a language, a dialect, and a pure invented idiolect — all compiled and ran:

Standard-register process (idiolect → standards body)

Measured, public, honest

Claim	Evidence (this repository)

Every number is regenerated from the repo. Coverage frontiers are flagged, never faked. The kernel variant is always named: the bindings/c kernel here is the post-guard variant; the fully-hardened 2004-derived kernel (the 98.68% figure on ilm.codes) is a separate build.

Reproduce

git clone https://github.com/project-ilm/romenagri # place the pipeline scripts under ~/work/11jun/scripts/ then: bash INSTALL_AND_RUN.sh # 110 substrate -> 120/121 reversibility -> 125..129 REV_MAXN=4 bash ~/work/11jun/scripts/120_reversibility_suite.sh # full exhaustive sweep

Outputs land in results/*.json and regenerate this page. Full runbook: docs/RUNBOOK.md.