translate — Mova's translator through a meta-world

translate is the first version of Mova's own deterministic translator, and its hard test. A text is read down the standard stack of its language into a world, read from there into a meta-world that belongs to no language and no author, and written out of the meta-world by the standard encoder of the target language with the target author's delta. The standard stack of that language then takes it down to the text. The test is byte for byte. Whole blocks of verse-aligned Bibles must come back exactly: runs of chapters up to 2 500 words, with their layout (blocks.rs). What that takes, the residual, is measured in bits per block, per 1 000 words and per verse, by stage and by class. No large model translates or teaches here: every table is counted from the texts, and every choice says why.

How it works

source text ─► tokens ─► UD tree ─► frames ─► world            (the standard stack of the source: tools/roundtrip)
                                      │
                         reader into the meta-world             (the interlingua lexicon; for Hebrew, the Hebrew reader)
                                      ▼
                                 meta-world                     (concepts, coarse grammar, tree: no author, no language)
                                      │
               standard encoder of the target language + the author's delta
                                      ▼
target words ─► UD tree ─► tokens ─► text                       (the standard stack of the target, with the encoder's
                                                                 order and forms as hints)

The meta-world

The meta-world of a verse is a graph of meta tokens. Each token has a concept, the coarse grammar the standard parse gives it (PTB tag), its head and its relation. With --meta-rel coarse the relation is a frame role (subject, object, oblique, a noun's modifier, a verb's modifier, a clause link, a function word, punctuation, root), and a punctuation mark hangs on the token before it. With --clauses flat a sentence's root and every coordinated or paratactic predicate hang on the top of the verse, so how an author joins clauses («…, and he said» or «…. He said») is not in the meta-world's tree.

Function words between two authors (fwt.rs, --fwt on) are the one part learned per author pair. For each trained pair, a small table holds the function tokens of the source the target drops in a context, and the runs of function tokens it inserts between two source tokens. A rule is kept with at least 3 cases and half of its context's. The table is applied to the source's meta-world before the target's encoder. Each token also keeps the source words it was read from, so an encoder can learn how an author writes it. What belongs to one author is left out:

• the spelling of a concept: thou, ye and you are one concept;
• the construction an author prefers: it came to pass and it happened are one concept, come_to_pass;
• the capital at the start of a sentence.

The interlingua lexicon (meta.rs) is learned once, for all authors, on the training verses of pairs of authors. The pairs are around two hubs: JPS–KJV, KJV–WEB and KJV–ASV, and with --hub2 on also JPS–ASV and ASV–WEB. JPS↔WEB is never paired. For each pair:

1. Each verse is read as a sequence of reading keys: the lemma in lower case; a punctuation mark as written; LORD and GOD (the divine name in capitals) in capitals.
2. The longest common subsequence of the two key sequences anchors the verse. The gaps between anchors are the places where the two authors differ.
3. Gap pairs of one to four keys on each side give word and phrase pairs. A word next to punctuation does not form a pair.
4. A pair is a candidate when it holds for at least 3 occurrences, 20% of the word's differing places and 2% of all its occurrences.
5. Each candidate is judged by the residual it moves (--lexicon judged, the default). What a merge saves the reader is measured (--judge measured): the reader's bits on up to 12 sampled training verse pairs where the two differ, with the merge and without it, times the merge's count (without the flag: an assumed 17 bits a word for every differing place it makes equal). With --judge-pairs on, a merge must also not cost any author pair more than it saves that pair's reader. A pair's cost counts its two authors' occurrences whose member the author and the tag no longer tell. It costs the encoder 17 bits a word for every occurrence, in all the judged corpora, whose member its context no longer tells: author, tag and relation for a word, author alone for a phrase. Candidates go in order of their counts, and a cluster's cost is recomputed as it grows. A merge is kept when it saves at least 51 bits more than it costs. --lexicon mutual is the earlier rule: each must be the other's most frequent partner, with 5 occurrences, 30% and 5%.

The concept is named after the most frequent member. The reader reads a verse with the longest known phrase first, then the word. A phrase's tree position is that of its word whose head lies outside it.

The Hebrew reader (hebrew.rs) is also learned, not written. It reads the Leningrad Codex as MACULA's UD trees.

1. It learns on two kinds of training verse pairs:
   • Hebrew with the meta-world read from JPS 1917, cut at the Hebrew verse numbers. Meta tokens align to Hebrew words by IBM Model 1. MACULA's English glosses act as a prior: 2 pseudo-counts per gloss word in each of 5 iterations. A place prior favours words at the same relative position.
   • Hebrew with the meta-world read from the KJV, where its verse numbers are the Hebrew ones (--strong <eng-kjv>). eBible's KJV writes each translated word with the Strong's number of the Hebrew word it renders, and MACULA writes the same numbers on the Hebrew words (strong.rs). A meta token with a number aligns to the Hebrew word with that number; the rest align by IBM Model 1.
2. The meta tokens aligned to a Hebrew word, and the unaligned tokens after them, form that word's chunk: וַיְהִי reads as it come_to_pass, and אֵת reads as nothing.
3. A Hebrew word reads as its most frequent chunk, in the most specific context seen at least twice: lemma, part of speech, verb type, person and number; then lemma, part of speech and verb type; then the lemma alone.
4. A lemma never seen reads as MACULA's gloss through the lexicon.
5. Chunk heads hang on the chunk of their Hebrew head.
6. With --heb-grammar on (grammar_plan), the reader also writes what Hebrew says by structure and English by words:
   • an of before a construct dependent;
   • a the before a construct head whose chain is definite;
   • each possessive suffix as a possessive before its noun;
   • a subject that follows its verb, moved before the verb.

The Hebrew world level uses MACULA's verbs and their frame arguments (Frame=A0/A1/A2), and the negation of macula prag.

The standard encoder and the authors

The standard encoder (profile.rs) is learned on all the English we have:

• the training books of the four Bibles;
• a fifth of the school's training lessons, in three registers;
• the tales of the 0.3 treebank;
• the Talmud's English (Guggenheimer, CC BY).

That comes to 3.6 M meta tokens. Each text is read into the meta-world, and each meta token is seen next to the chunk of words written for it. The sentence capital is taken off, because it is the stack's rule. To encode a token, the standard takes the most specific context that was seen often enough and writes its most frequent chunk. The contexts, from most to least specific, are:

1. concept, tag and both neighbours;
2. concept, tag and relation;
3. concept and tag;
4. the concept alone.

A concept never seen gets its bare form: the concept inflected by morph from its tag.

An author is a delta over the standard: a sparse set of overrides, learned only from what the standard gets wrong on that author's training text. The overrides are learned from the coarsest context to the finest. An override «in this context write this chunk» is kept only when both of these hold:

• it fixes at least 3 more of the author's tokens than the prediction before it;
• it holds for at least half of that context's tokens.

A finer override wins over a coarser one. Where the delta says nothing, the standard decides. «Author» can be any style. Here there are eight: JPS 1917, KJV, WEB, ASV, the school's book lines (school-plain: explain, fact), its conversational test questions (school-talk: the voice that is half slang), its formal exam questions (school-exam), and the tales.

Exact mode: the split code and the gate

For each target verse, the residual is split by stage (measure.rs):

• reader (world → meta-world): the edit script that turns the meta-world read from the source into the one read from the target. It is roundtrip's tree script on meta tokens: inserts, and patches of concept, tag, head or relation. To that come the meta tokens out of place: which ones (n choose k) and where each goes. The script first takes the pairs that a longest common subsequence and same-length gaps give. This stage is zero when source and target are the same text: it is the disagreement of the interlingua.
• encoder (meta-world → the author's words): the tree script from the parse of what the encoder writes for the target's own meta-world to the target's standard tree. It does not depend on the source: it is the encoder's loss as an autoencoder.
• stack: roundtrip's tree decoder takes the target tree to tokens. It is given the encoder's word order and forms as hints (tree::Hints), and the residual records what it still gets wrong: order, spelling, case and spacing. Then the tokens go to the verse text: the literal gaps and the tail.

The decoder runs the stages down: meta-world, encoder, parse, script, tree decoder, text. The gate compares the meta-world, the tree, the tokens and the text on the way. The direct code is gated too: it sends the target from the translation's own normal-mode output, with a tree script and the stack, the way the baselines are measured.

Classes are roundtrip's, in six groups:

• lexical: lexical, dropped, pronoun/name, quantity, negation;
• construction: attachment, tense/modality, sentence, links, quote, repetition;
• order;
• function words;
• punct/case: punct, case, spacing, typography, layout;
• morphology: form, lemma→form, source spelling.

Bits follow roundtrip's fixed rules: a dictionary lemma is 17 bits, a function word 8, a mark 5, a position log2(n+1).

Normal mode

In normal mode the encoder with the target author's delta writes the source's meta-world, with no residual. The output is scored against the target verse by exact match, chrF, and roundtrip's divergence classes on the parsed output.

Data

• Bibles: eBible's public-domain USFM, cut by school-sents usfm into verse pools: JPS 1917 (engjps), KJV (eng-kjv), WEB (eng-web), ASV (eng-asv), the 39 books of the Hebrew Bible. JPS is cut both at the English verse numbers and at the Hebrew ones (--hebrew-verses). The KJV is public domain everywhere but in the United Kingdom, where it stays under the Crown's perpetual letters patent. It is used here for measurement and for tables, and not shipped as text.
• Hebrew: corpora/judaism/text/tanakh-wlc-macula (MACULA Hebrew, CC BY 4.0) and parsedb-hbo/prag.tsv. Verses line up at the Hebrew numbers with JPS cut that way. For wlc → kjv and wlc → web, only the verses whose English and Hebrew numbers agree are used: those where the two JPS cuts give the same text (2,289 of the 2,389 dev verses).
• Other English: the school (world/data/school, our own; courses of other languages' grammars left out), the 0.3 tales treebank's text (Project Gutenberg, public domain), the Talmud pool of cycle-talmud-2026-10-18 (CC BY, for the standard only).
• Split by book, the same for every Bible. The test books are those at places 3 and 8 of every ten in the English order: NUM, 1SA, 2CH, PSA, JER, JOL, NAM, MAL. The dev books are at place 5: JOS, NEH, EZK, ZEP. The rest train. School lessons and tale books split the same way by their index. Of the school's held-out lessons, one in five is measured.
• Fix to school-sents usfm: Strong-tagged USFM (KJV, WEB, ASV) lost the punctuation after \w …\w* and split “\w Let in two. Character marks are now taken off the verse as a whole. JPS is cut byte for byte as before.

How to run

cargo build --release -p school-sents -p translate -p jobs
E=$RESEARCH_RAW/scripture/4-translations/ebible
P=$MOVA_DATA/runs/translate-<date>/pools
OT=GEN,EXO,LEV,NUM,DEU,JOS,JDG,RUT,1SA,2SA,1KI,2KI,1CH,2CH,EZR,NEH,EST,JOB,PSA,PRO,ECC,SNG,ISA,JER,LAM,EZK,DAN,HOS,JOL,AMO,OBA,JON,MIC,NAM,HAB,ZEP,HAG,ZEC,MAL
for a in jps:engjps kjv:eng-kjv web:eng-web asv:eng-asv; do
  target/release/school-sents usfm $E/${a#*:} $P/${a%%:*}.tsv ${a%%:*} $OT; done
target/release/school-sents usfm $E/engjps $P/jps-heb.tsv jps $OT --hebrew-verses
J=$MOVA_BIG/corpora/judaism
target/release/jobs run --name translate --mem-gb 14 -- target/release/translate eval \
  --pools $P --wlc $J/text/tanakh-wlc-macula --prag $J/parsedb-hbo/prag.tsv \
  --school world/data/school --tales <corpus-0.3>/treebanks/mova-tales-silver-en.conllu \
  --talmud $MOVA_BIG/runs/cycle-talmud-2026-10-18/talmud.tsv \
  --strong $RESEARCH_RAW/scripture/4-translations/ebible/eng-kjv \
  --meta-rel coarse --judge measured --lb on --judge-pairs on --hub2 on --clauses flat --fwt on --heb-grammar on \
  --own-words 0.8 --typo on \
  --usfm $RESEARCH_RAW/scripture/4-translations/ebible \
  --out $MOVA_DATA/runs/translate-<date>/run1 --split dev --threads 10
# measured alternatives: --lexicon mutual, --feats on, --meta-tree frames, --fw on, --clauses on|joined, --lattice on, --std-vote corpus|context, --reorder on
cargo test --release -p translate

A run writes report.md (every table below and more), examples.md (verses with the reason of every choice), numbers.tsv, lexicon.tsv (each concept's members and the pair that linked them) and deltas.tsv (every override with its counts). The test split runs with --split test, once.

Measured (2026-10-18)

Model en.bin of 2026-10-15; repo at the merge of main of 2026-10-18. The current system is:

--lexicon judged --judge measured --lb on --judge-pairs on --hub2 on --meta-rel coarse --clauses flat --fwt on --heb-grammar on --own-words 0.8 --typo on --strong <eng-kjv> --usfm <ebible>

Runs are in translate-2026-10-18:

• r8-final3 and r8-final4: dev runs of the current system;
• r2-* to r8-*: the dev runs of each change below;
• run4: the first version;
• test1, test2, test3: the three readings of the test split.

A run takes about 9 minutes on the shared 20-core server, 10 threads, and peaks at 8.4 GB.

The test split has been opened four times in all, once at the end of each of the first three rounds, and once on 2026-10-19 for the Tanakh pages (tr-test, the system with --pages below; its Bible tables are in that run's report.md). From now on it is read once per release. Every decision was made on dev.

Determinism. r8-final3 and r8-final4 gave byte-identical report.md, examples.md, numbers.tsv, lexicon.tsv and deltas.tsv.

The gate. Every block and every verse of every system came back byte for byte. The gate control fails on every verse and every block.

Blocks. The dev books (JOS, NEH, EZK, ZEP) cut into 37 blocks: whole chapters up to 2 500 words, cut at chapter boundaries. The cut uses roundtrip blocks' own rule (roundtrip::blocks::group); this crate's earlier maker and roundtrip::blocks::jps give the same runs, checked in every run.

Normal mode (dev): the translation as written

chrF and exact match of the translation against the target, per block (a block's whole text, layout included) and per verse.

No block is exact.

• KJV→WEB is now as good as the word-by-word table trained on that pair, and better per block: 78.5 against 77.9 chrF, from 75.1 in round 7. WEB's own words now replace KJV's (to, your, you stand), and the quotes and possessives are WEB's.
• JPS→KJV is level with copying the source.
• JPS→WEB, a pair never trained, is above copying and below the word-by-word table.
• From Hebrew the gap to MACULA's glosses is 1 chrF per block.

Live examples from r8-final3/examples.md (JOS 1:1, 5:15, 9:9):

JPS → KJV

• out: Now it came to pass after the death of Moses the servant of the LORD, that the LORD spake unto Joshua the son of Nun, Moses’ minister, saying: target: Now after the death of Moses the servant of the LORD it came to pass, that the LORD spake unto Joshua the son of Nun, Moses’ minister, saying,
• out: And the captain of the LORD’s host said unto Joshua: put off thy shoe from off thy foot; for the place whereon thou stand is holy. And Joshua did so. target: And the captain of the LORD’s host said unto Joshua, Loose thy shoe from off thy foot; for the place whereon thou standest is holy. And Joshua did so.
• out: And they said unto him: from a very far country thy servants are come because of the name of the LORD thy God; for we have heard the fame of him, and all that he did in Egypt, target: And they said unto him, From a very far country thy servants are come because of the name of the LORD thy God: for we have heard the fame of him, and all that he did in Egypt,

KJV → WEB

• out: Now after the death of Moses the servant of Yahweh it came to pass, that Yahweh spake to Joshua the son of Nun, Moses’ minister, saying, target: Now after the death of Moses the servant of Yahweh, Yahweh spoke to Joshua the son of Nun, Moses’ servant, saying,
• out: The captain of Yahweh’s host said to Joshua, loose your sandal from off your foot; for the place whereon you stand is holy. And Joshua did so. target: The prince of Yahweh’s army said to Joshua, “Take off your sandals, for the place on which you stand is holy.” Joshua did so.
• out: They said to him, from a very far country your servants are come because of the name of Yahweh your God: for we have heard the fame of him, and all that he did in Egypt, target: They said to him, “Your servants have come from a very far country because of the name of Yahweh your God; for we have heard of his fame, all that he did in Egypt,

JPS → WEB (never trained)

• out: And the captain of the LORD’s host said unto Joshua: “put off thy shoe from off thy foot; for the place whereon thou stand is holy.” And Joshua did so. target: The prince of Yahweh’s army said to Joshua, “Take off your sandals, for the place on which you stand is holy.” Joshua did so.
• out: And they said unto him: “from a very far country thy servants are come because of the name of Yahweh your God; for we have heard the fame of him, and all that he did in Egypt, target: They said to him, “Your servants have come from a very far country because of the name of Yahweh your God; for we have heard of his fame, all that he did in Egypt,

WLC → JPS

• out: And it came to pass after the death of Moses the servant of the LORD, and the LORD said unto Joshua the son of Nun servant of Moses saying. target: NOW IT came to pass after the death of Moses the servant of the LORD, that the LORD spoke unto Joshua the son of Nun, Moses' minister, saying:
• out: And the captain the of the host of the LORD said unto Joshua he put off thy off shoe of thy foot for the place thou stood holy, and Joshua did so. target: And the captain of the LORD'S host said unto Joshua: 'Put off thy shoe from off thy foot; for the place whereon thou standest is holy.' And Joshua did so.
• out: And said unto of land afar off very thy servants came the name of the LORD thy God for heard his fame forth throughout waxed, and all made Egypt. target: And they said unto him: 'From a very far country thy servants are come because of the name of the LORD thy God; for we have heard the fame of Him, and all that He did in Egypt,

What is still wrong:

• JPS→WEB keeps unto, thy and thou. These are concepts WEB never writes, and the swap table that maps them (unto → to) exists only for trained pairs.
• The author's own words override a finer context: KJV's stand where it writes standest after thou.
• From Hebrew:
  • the of the host: an article still lands before a chunk's of;
  • the order inside the quote (he put off thy off shoe);
  • made Egypt (עשה without כן).

Exact mode (dev): bits to give the target back

What normal mode gained, the bits lost in part:

• KJV→WEB improved in both modes: 15 683 bits a block, from 15 808.
• JPS→WEB lost 1 141 bits a block (from 14 037). The target's quotes come by parity inside a verse, and a quote that opens in one verse and closes in another comes out the wrong way round. The own-word overrides also push some places away from what WEB writes.
• JPS→KJV is now 4 bits a block behind copying the source.
• The shuffled-lexicon control is no longer red on JPS→KJV: 9 688 against 9 697 a block, 147.0 against 147.1 a verse. It stays red on KJV→WEB (17 647) and JPS→WEB (15 365).

The changes, each measured on dev (per verse)

Bits per verse of the split code (the Hebrew column is WLC→JPS). The mean is over the twelve any→any pairs of the four Bibles.

What each change of round 8 is:

• The author's own words (Delta::with_own_words, --own-words 0.8). For every concept and tag the author writes with one chunk in at least 80% of its places, the delta keeps that chunk as an override, even where the standard already writes it in the author's own contexts. Another author's neighbours lead the standard elsewhere: KJV's lead it to spake.
  • The share was picked on the archaism dial's curve (more overrides, fewer bits, up to a point). At 0.5 the overrides fight the finer contexts: JPS→KJV 161.0. At 0.8 the mean falls to 176.4 and KJV→WEB to 219.1 bits a verse.
  • The function-word tables also swap the concepts the target never writes for what it writes there (FwTable::subs): unto → to, thee → you, for trained pairs only.
• Typography (profile::Typo, --typo on). Each author's quotation marks, learned from its training text: WEB “ ”, JPS ' ', KJV and ASV none. And its possessive: WEB and KJV Moses’, JPS Moses'. The encoder writes them, and the normal-mode text joins them without the tokenizer's spaces («Moses’ minister», «“Take off …”»).
• The rest of the Hebrew grammar (hebrew::idioms). וַיְהִי with no subject of its own is it came to pass; עָשָׂה with כֵּן is did so; an article goes after a chunk's own leading of.
• Together they give the best normal mode so far: mean chrF 80.2 over the twelve pairs, from 79.2. But not the fewest bits: the own words and the typography each cost some pairs what they save others.

What each change of round 7 is:

• Modals on their own. The interlingua lexicon no longer takes a phrase that holds a modal (may, shall, will …). WEB's delta wrote the_LORD as «May Yahweh» (20 of 30) because «may Yahweh» had joined the concept. A test in meta.rs checks the rule (MODALS, side_ok). Lexicon phrases: 323 → 301.

• One vote per corpus in the standard. The aim was that thy, unto and hath come only from an archaic author's delta. Three ways were measured:

  • A weight per corpus (each corpus's tokens weigh 1 over its size) changes nothing measurable.
  • A vote per corpus in every context (Standard::train_voted) changes little: JPS→KJV 146.2 → 145.4, the rest within 0.3.
  • Requiring two corpora before a context is used makes the standard plain (WEB's delta grows from 492 to 748 overrides), but the encoder loses 3–9 bits a unit for everyone. School-plain then needs 2 596 overrides.

  The specific contexts (a concept with its neighbours) are written by the Bibles alone, so whatever stands there is Bible English. A plain standard costs more than the deltas save. None of the three is kept, and the wrong-delta control between the school registers stays a tie (8.1 against 8.0).

• The Hebrew reader's grammar (hebrew::grammar_plan, --heb-grammar on). MACULA's trees say by structure what English says by words. The reader now adds:

  • an of before a construct dependent (compound:smixut);
  • a the before a construct head whose chain is definite (it ends in a name, an article or a possessive suffix);
  • a suffix pronoun (nmod:poss) as a possessive before its noun, by person, number and gender (my, thy, his, her, our, your, their);
  • a subject that follows its verb moved before the verb, after the verb's conjunction.

  WLC→JPS falls from 679.2 to 630.6 bits a verse (40 812 a block, from 43 928). chrF rises from 39.2 to 44.3 a verse and from 48.2 to 54.4 a block. And the LORD said unto Joshua, the death of Moses, thy shoe and thy foot now come out right. An of or the the chunk already writes is not doubled, and the mark the first and brings at a verse's start goes.

• Where clause parts go (fwt::ReorderTable, --reorder on). For each target author, a table records where a source author's clause part (subject, object, oblique, modifier) stands against its predicate and where the target puts it. It is learned on the trained pairs; parts are aligned by the concepts each verse has once, since the longest common subsequence never sees a move.

  • Parts move rarely: KJV's fronted «Now after the death of Moses … it came to pass» is one verse in hundreds.
  • The tables keep 0 to 8 moves (WEB: not after the verb, in contractions). JPS→KJV and KJV→WEB move by 0.0–0.1 bits.
  • Not kept. The English order class is 5–13 bits a verse.

Measured in earlier rounds and kept as they were:

• The verse lattice (the standard on the four renderings' shared backbone) was worse: mean 182.3. Off.

• Joining as a conditioned choice (--clauses joined) was much worse: 272.3. Off.

• The archaism dial (arnold-1861), KJV → WEB with only WEB's k strongest overrides. Split bits per verse fall with every step:

  k	0	10	50	200	all 492
  split bits per verse	249.0	245.4	243.5	240.1	238.5

• False friends across centuries (postgate-1922), counted on the training verses:

  • meat is never anchored to itself: WEB and JPS write food or meal there, 119 times each.
  • suffer differs from WEB 27 times (allow), but anchors to archaic JPS 26 times.
  • prevent is the only one the lexicon merges, with confront.

The residual by class, and meta-world agreement (dev, per verse)

The reader stage alone (bits per verse): JPS→KJV 121.2, JPS→WEB 188.2, KJV→WEB 217.3, WLC→JPS 597.7. The Hebrew reader's grammar took the function class from 185 to 129 and order from 42 to 35.

At the world level, two English translations share 77–88% of a verse's events and 57–75% of its entities. The Hebrew reading finds 33% of JPS's events.

Authors as deltas (dev, encoder stage on the author's held-out text, bits per unit)

With the own words, a delta is mostly the author's word list: 5 500–5 800 overrides for a Bible.

• The own words help the Bibles and school-talk. The wrong-delta control between the school's registers is now red: talk's own 7.7 against plain's 7.9.
• They hurt where a text has few contexts of its own. The tales lose 1.6 bits a unit; school-plain and school-exam lose 0.1–0.3.
• WEB's delta gains only 0.5 bits on its own text (12.7 against 13.2). Its own words replace overrides that fixed more, but they carry WEB's words into foreign contexts.

Controls (dev)

• The gate control is red on every verse and every block.
• Verses shuffled inside each block raise JPS→KJV from 9 697 to 64 106 bits a block.
• The shuffled Hebrew reader is red.
• The wrong author's delta loses on every Bible, the tales and every school register. In translation, JPS→KJV with WEB's delta costs 184.1 bits a verse against 147.1.
• A delta trained on shuffled units is worse than the standard alone everywhere.
• The null delta loses: JPS→KJV 153.7 against 147.1.
• The lexicon learned on shuffled verse pairs is red on KJV→WEB (17 647 against 15 683 bits a block) and JPS→WEB (15 365 against 15 178). It is not red on JPS→KJV (9 688 against 9 697; 147.0 against 147.1 a verse): there the own words cost as much as the lexicon saves.
• The function-word table learned on shuffled verses is red: JPS→KJV 148.2 against 147.1, KJV→WEB 259.2 against 236.6.

What normal mode needs next

In order of what the examples show:

1. Quotes across verses. Learn the quote state per block, not per verse, so a quote that opens in one verse and closes in another comes out right; that is most of what typography cost JPS→WEB.
2. Swaps for pairs never trained. Compose the trained pairs' swap tables through the hub (JPS→KJV→WEB), so JPS→WEB writes to and you too.
3. Own words that yield to a finer context the author has seen (KJV's standest after thou), and a lower bound on the share instead of a flat 0.8. That would make the shuffled-lexicon control red again on JPS→KJV.
4. The Hebrew clause order inside quotes and objects, and the of: where an inserted article still meets a chunk's of.
5. The one-reader block code: a position code that names the verse first.

The parallel Tanakh as site pages, both ways (--pages)

The Tanakh corpus pages of the site (corpora/<part>/<BOOK>.<c>.<v>/: a verse in Hebrew with its MACULA tree, its pragmatics, its Targum and links to its English; corpora/<part>/jps/<BOOK>.<n>/: a JPS sentence with its tree and frames) are translated as page blocks, Hebrew pages → meta-world → English pages and English pages → meta-world → Hebrew pages (pages.rs). A chapter is its verse pages on one side and the sentence pages that begin in it on the other; the blocks are the JPS's chapter runs of roundtrip blocks (blocks::jps, blocks::group, 2,500 words), the other side cut the same (blocks::like).

A target page block costs the translation of its texts — each Hebrew verse, or each English unit (the JPS sentences that begin in a verse), with the split code (reader, encoder, stack) — and the page around them: the target pages through roundtrip blocks' site decoder (roundtrip::blocks::site_md) with the translated texts and the source's own texts given (site_md::give, class given), so the markup, the other prose, the trees and tables it writes from the layers, and the Targum are what is left.

English → Hebrew (heb_enc.rs). The Hebrew encoder is the Hebrew reader turned round, learned on the same training verse pairs: the reader's alignment gives each meta token to a Hebrew word (its chunk); the first token of a word's chunk emits the word (lemma, UPOS, XPOS, FEATS, relation), the others nothing; to encode, each meta token emits what it emitted most often in the most specific context seen twice (profile::ctx_keys), and a word hangs on the word its meta head's chain emitted first. The split code onto a Hebrew verse: reader — the script from the meta-world read from the English to the one the Hebrew reader reads from the target verse; encoder — the Hebrew tree script from what the encoder writes for the target's own meta-world to MACULA's words (roundtrip::mixed::heb::frames_encode), with the words out of place; stack — the words to their forms by the lookup generator of the training books' trees, a form looked up with the word before it in its written word (Lookup::from_conllu_ctx, --heb-forms ctx: the dagesh after וַ, the article's vowel), and the written words to the verse (mixed::heb::tree_encode, tokens_up); a verse whose written words are not its tree's (a paragraph mark glued to a word) stores its text. The gate decodes the meta-world, the words, the written words and the verse.

Run

roundtrip site-learn --site-md $S --site-target 1000 --out $L --model <en.bin> --lin-every 2   # tools/roundtrip README
jobs run --name translate --mem-gb 16 -- translate eval … (the current system's flags) \
  --pages $S --site-dict $L/markup.tsv --site-heb $L/hebrew.tsv --site-english $L/english.tsv --heb-forms ctx \
  --model $L/en-lin.bin --out <dir> --split dev

--site-english adds the site's train pages' English (english.tsv, 105,624 sentences; the Tanakh's held-out books left out) to the standard encoder's training text. The run appends «The parallel Tanakh as pages, both ways» to report.md and writes pages.tsv (a row per block and direction: verses, words, gate, the bits of each stage and of the page).

Measured (2026-10-19)

The site's pages from a copy of the md twin taken at 12:10 (md-snapshot); the tables of roundtrip site-learn in learn5/; runs in ae-md-2026-10-19 (tr.sh; tr-before, tr-after3, tr-after4, tr-test): 8 minutes each, 10 threads, 12.8 GB. The dev books (JOS, NEH, EZK, ZEP): 37 blocks, 2,389 Hebrew verse pages and 2,493 English sentence pages. Before: the current system as in «Measured (2026-10-18)», en.bin, no table of the site's train pages; after: --site-english, --heb-forms ctx, the site's tables and the adapted order (en-lin.bin).

The gate. Every block of both directions came back byte for byte, the translated texts and the pages around them (37/37 and 37/37 each way). Determinism: tr-after3 and tr-after4 gave byte-identical report.md, examples.md, numbers.tsv, lexicon.tsv, deltas.tsv and pages.tsv.

The target words are the translated texts' (70,690 English, 30,522 Hebrew). The page dominates: a sentence page is about 190 bits of text against 3,500 of template, trees and tables. The Hebrew pages' page bits fell by 56% with the site's Hebrew trees' lexicon (their CoNLL-U 1,335,518 → 309,468 bits a block; the Hebrew verbs' table, 65 bits a block, is rebuilt from the tree).

By stage and class group (bits per verse, after):

What each trained part removed (dev, bits per verse):

• The site's English in the standard encoder: every one of the twelve Bible pairs falls (mean 180.5 → 180.0; JPS→KJV 147.0 → 146.7, KJV→WEB 236.5 → 236.3), WLC→JPS 633.1 → 632.1, and every author's delta on its held-out text (school-plain 10.3 → 9.0, school-exam 7.5 → 5.7, the tales 13.4 → 12.1, JPS 12.5 → 11.8). Blocks: JPS→KJV 9,689 → 9,666, KJV→WEB 15,679 → 15,667, WLC→JPS 40,973 → 40,908 bits a block.
• The Hebrew stack's forms with the word before them: the stack 641.3 → 559.8 (form 478 → 366).
• The Hebrew encoder against the one learned on shuffled pairs: encoder 466.7 against 677.4, chrF 20.6 against 2.2.
• Measured and not kept: the Hebrew encoder emitting each word with the unaligned words before it (a prefix, אֵת): encoder 466.7 → 486.7. The adapted order (en-lin.bin) changes no translation stage (the encoder's order is the stack's hint); it takes 1,000–4,000 bits a block off the pages' prose.

The test split, once (NUM, 1SA, 2CH, PSA, JER, JOL, NAM, MAL; tr-test, after): see the table below.

By stage (bits per verse): Hebrew → English reader 512.9, encoder 10.4, stack 21.2; English → Hebrew reader 369.5, encoder 379.6, stack 457.6. The first attempt stopped at the 16 GB limit while it wrote the pages (the test split has 90 blocks); the run that counts had 24 GB (peak 18.6 GB, 19 minutes).

What the residual asks for next. Hebrew → English: the reader (599 bits a verse: dropped 213, function 129, attachment 110) — the Hebrew reader's chunks and its grammar plan. English → Hebrew: the stack's forms (366) and accents (108) — a Hebrew generator of pointing from lemma, binyan and the prefix, the accents as a layer of the verse's syntax; the encoder's dropped words (239) — Hebrew words no meta token emits (אֵת, prefixes, suffix pronouns), learned as inserts conditioned on the head they attach to, not as chunk tails (measured worse); the page's template (≈ 190,000 bits a block of markup on both sides) — markup from the page id.

Limits

• The meta-world of this version is a graph of concepts read from the parse, not yet a world of events. The generation path goes meta-world → words → parse. It does not go through roundtrip's frames and world, whose realizer loses about 370 bits per sentence (tools/roundtrip). The world level is measured as agreement only.
• The lexicon is learned on five pairs around KJV and ASV. «Never trained» (JPS↔WEB) means that no pair table and no lexicon pair joined those two authors directly; their words still meet through the hubs.
• Strong's numbers are used from the KJV only (WEB's and ASV's are projected and noisy). KJV text is used here for measurement and tables only; the Crown's rights in the United Kingdom are noted above.
• Bits are roundtrip's fixed-rule estimates, not an entropy code. The deltas' bits use the same rules.
• The school's held-out sample is one lesson in five of every tenth lesson index. The tales have 41 books, so their dev set is 357 sentences of a few books.
• A block's layout is the marks between verses; a poetry line that goes on inside a verse (\q2 with text) is not kept, the verse text being the pools' joined text. Blocks are cut by roundtrip blocks' rule over the pools' chapters; the block text with its USFM layout is this crate's (blocks.rs), since roundtrip blocks' JPS text has no verse lines.
• wlc → kjv and wlc → web use only the verses whose English and Hebrew numbers agree.
• The page blocks pair a Hebrew verse with the JPS sentences that begin in it; a sentence that runs into the next verse is counted with the verse it begins in.
• The Hebrew encoder writes words in the meta-world's (English) order and the order class pays for Hebrew's; it has no Hebrew word of its own for what English leaves unsaid.

This page in Markdown → https://md.mova.elamur.ai/free/en/docs/tools/translate/