mrail 0.4.0__tar.gz

mrail-0.4.0/LICENSE

@@ -0,0 +1,17 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2026 David Tom Foss
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

mrail-0.4.0/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: mrail
+Version: 0.4.0
+Summary: Append-only maps of exact language-model runs (.mrail format, reference reader/writer)
+Author-email: David Tom Foss <d.foss@ieee.org>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/DT-Foss/mrail
+Project-URL: Repository, https://github.com/DT-Foss/mrail
+Project-URL: Specification, https://github.com/DT-Foss/mrail/blob/main/SPEC.md
+Keywords: language models,inference,constant state,compute once,kv cache,maps
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Dynamic: license-file
+
+# mrail — maps of exact language-model runs
+
+`.mrail` is an append-only file format for **what a language model has already computed**. For models whose state
+after any prefix has a constant size (state-space models, linear attention, gated delta networks, fixed-state
+attention such as Ward recall), the state is a pure function of the token prefix. A map of earlier runs therefore lets a
+runtime
+
+- **answer known contexts without running the model** — the stored continuation *is* the model's own greedy output;
+- **restart exactly** from anchored states at shared prefixes (system prompts, conversation histories), or rebuild any
+  state from the stored tokens;
+- **draft** continuations for new contexts, verified by the model in one pass, so the map changes speed, never output;
+- **grow with use** — every served answer is appended; maps split by topic, load and merge like any file.
+
+Measured with a compiled Qwen2.5-1.5B-Instruct (constant state of 14.4 MiB) on the Apple Neural Engine (see the papers
+below): known questions in 3.0–4.3 ms instead of 9.7–10.3 s; 2.54 instead of 1.25 accepted tokens per pass on unseen
+coding tasks with a 1.2 MB coding map of 1 641 runs (2.27× greedy decoding); 8.4 MB instead of 893 MB for the anchors of
+the same runs through delta coding and stations, 9.6 kB for their tokens alone.
+
+**Tracks** (format kind 5, new in 0.4) record a run without its context: the context by its chain hash and a source
+name (an eval item, a document id), the model's answer copy-coded against it. On 652 runs of benchmark prompts of 131k
+to 1M tokens the maps shrink from 881.4 MB to 89.5 KB, 143 bytes per run of a million tokens, and every track replays
+its answer identically. Long runs are indexed at every 256th prefix, at the end of the prompt and at every answer
+position (4k hash entries instead of a million for a 1M-token run).
+
+This repository contains the [format specification](SPEC.md) and a dependency-light reference reader and writer
+(Python, numpy). It does not contain a model runtime.
+
+```
+pip install mrail
+```
+
+```python
+import mrail
+m = mrail.MapFile("coding.mrail")                  # opens or creates
+answer = mrail.exact_answer(m, context_tokens, max_new=256, stop={151645})
+m.add_session(prompt_tokens + model_answer_tokens + [next_token], gen_start=len(prompt_tokens))
+tree = m.rail.tree(context_tokens, budget=31)       # draft tree [(token, parent)] for verification
+```
+
+```
+python -m mrail info coding.mrail
+python -m mrail merge team.mrail alice.mrail bob.mrail
+```
+
+## Share your map
+
+A map is a file of verified output of one exact model. Maps merge by loading their runs (`python -m mrail merge`), so
+a map of a repository, a documentation set, a tool protocol or a team's daily questions can be shared with everyone who
+runs the same model. Runs from a foreign map are loaded as **drafts only**: they propose continuations, the model
+verifies every token, and only runs produced by the local model answer a context directly. A shared map therefore
+makes inference faster on its topic and cannot change a single output token. The map is written by the model itself
+(the Möbius loop: every verified answer becomes a run, every disagreement becomes a new run), so it grows finer with use
+and never turns into a store of canned answers.
+
+Name shared maps by model and topic, e.g. `Qwen2.5-1.5B-Instruct-HCGM.coding.mrail`, and renew them when the model
+version changes.
+
+## Papers
+
+- D. T. Foss, *Compute Once: Constant-State Language Models Make Answers Reusable and Agents Cheap* (2026), [doi:10.13140/RG.2.2.18140.35202](https://doi.org/10.13140/RG.2.2.18140.35202).
+- D. T. Foss, *The Holographic Causal Graph Machine: Compiling a Pretrained Transformer into a Constant-State Model
+  without Training* (2026), [doi:10.13140/RG.2.2.28206.68167](https://doi.org/10.13140/RG.2.2.28206.68167).
+- D. T. Foss, *No GPU, No KV Cache: A Constant-State Language Model on the Neural Engine of a Mac mini* (2026), [doi:10.13140/RG.2.2.31562.12484](https://doi.org/10.13140/RG.2.2.31562.12484).
+
+Models and maps: [huggingface.co/tfwnotops](https://huggingface.co/tfwnotops).
+
+License: Apache-2.0.

mrail-0.4.0/README.md

@@ -0,0 +1,67 @@
+# mrail — maps of exact language-model runs
+
+`.mrail` is an append-only file format for **what a language model has already computed**. For models whose state
+after any prefix has a constant size (state-space models, linear attention, gated delta networks, fixed-state
+attention such as Ward recall), the state is a pure function of the token prefix. A map of earlier runs therefore lets a
+runtime
+
+- **answer known contexts without running the model** — the stored continuation *is* the model's own greedy output;
+- **restart exactly** from anchored states at shared prefixes (system prompts, conversation histories), or rebuild any
+  state from the stored tokens;
+- **draft** continuations for new contexts, verified by the model in one pass, so the map changes speed, never output;
+- **grow with use** — every served answer is appended; maps split by topic, load and merge like any file.
+
+Measured with a compiled Qwen2.5-1.5B-Instruct (constant state of 14.4 MiB) on the Apple Neural Engine (see the papers
+below): known questions in 3.0–4.3 ms instead of 9.7–10.3 s; 2.54 instead of 1.25 accepted tokens per pass on unseen
+coding tasks with a 1.2 MB coding map of 1 641 runs (2.27× greedy decoding); 8.4 MB instead of 893 MB for the anchors of
+the same runs through delta coding and stations, 9.6 kB for their tokens alone.
+
+**Tracks** (format kind 5, new in 0.4) record a run without its context: the context by its chain hash and a source
+name (an eval item, a document id), the model's answer copy-coded against it. On 652 runs of benchmark prompts of 131k
+to 1M tokens the maps shrink from 881.4 MB to 89.5 KB, 143 bytes per run of a million tokens, and every track replays
+its answer identically. Long runs are indexed at every 256th prefix, at the end of the prompt and at every answer
+position (4k hash entries instead of a million for a 1M-token run).
+
+This repository contains the [format specification](SPEC.md) and a dependency-light reference reader and writer
+(Python, numpy). It does not contain a model runtime.
+
+```
+pip install mrail
+```
+
+```python
+import mrail
+m = mrail.MapFile("coding.mrail")                  # opens or creates
+answer = mrail.exact_answer(m, context_tokens, max_new=256, stop={151645})
+m.add_session(prompt_tokens + model_answer_tokens + [next_token], gen_start=len(prompt_tokens))
+tree = m.rail.tree(context_tokens, budget=31)       # draft tree [(token, parent)] for verification
+```
+
+```
+python -m mrail info coding.mrail
+python -m mrail merge team.mrail alice.mrail bob.mrail
+```
+
+## Share your map
+
+A map is a file of verified output of one exact model. Maps merge by loading their runs (`python -m mrail merge`), so
+a map of a repository, a documentation set, a tool protocol or a team's daily questions can be shared with everyone who
+runs the same model. Runs from a foreign map are loaded as **drafts only**: they propose continuations, the model
+verifies every token, and only runs produced by the local model answer a context directly. A shared map therefore
+makes inference faster on its topic and cannot change a single output token. The map is written by the model itself
+(the Möbius loop: every verified answer becomes a run, every disagreement becomes a new run), so it grows finer with use
+and never turns into a store of canned answers.
+
+Name shared maps by model and topic, e.g. `Qwen2.5-1.5B-Instruct-HCGM.coding.mrail`, and renew them when the model
+version changes.
+
+## Papers
+
+- D. T. Foss, *Compute Once: Constant-State Language Models Make Answers Reusable and Agents Cheap* (2026), [doi:10.13140/RG.2.2.18140.35202](https://doi.org/10.13140/RG.2.2.18140.35202).
+- D. T. Foss, *The Holographic Causal Graph Machine: Compiling a Pretrained Transformer into a Constant-State Model
+  without Training* (2026), [doi:10.13140/RG.2.2.28206.68167](https://doi.org/10.13140/RG.2.2.28206.68167).
+- D. T. Foss, *No GPU, No KV Cache: A Constant-State Language Model on the Neural Engine of a Mac mini* (2026), [doi:10.13140/RG.2.2.31562.12484](https://doi.org/10.13140/RG.2.2.31562.12484).
+
+Models and maps: [huggingface.co/tfwnotops](https://huggingface.co/tfwnotops).
+
+License: Apache-2.0.

mrail-0.4.0/mrail/__init__.py

@@ -0,0 +1,23 @@
+"""mrail — append-only maps of exact language-model runs (.mrail v3). See SPEC.md."""
+from .core import MapFile, chain, snapshot_from_layers, MAGIC
+from .drafts import DraftRail
+
+Monorail = MapFile
+__all__ = ["MapFile", "Monorail", "DraftRail", "chain", "snapshot_from_layers", "MAGIC"]
+__version__ = "0.4.0"
+
+
+def exact_answer(m: MapFile, ctx, max_new: int, stop=()):
+    """The model's own continuation of ctx if ctx lies on a track, else None."""
+    lcp, sid, *_ = m.locate(list(ctx))
+    if lcp != len(ctx) or sid < 0:
+        return None
+    out = []
+    seq = m.sessions[sid]
+    if seq is None:                                           # a track: the answer is coded against the context
+        seq = list(ctx) + m.track_answer(sid, ctx)
+    for t in seq[len(ctx):len(ctx) + max_new]:
+        out.append(t)
+        if t in stop:
+            break
+    return out or None

mrail-0.4.0/mrail/__main__.py

@@ -0,0 +1,26 @@
+"""python -m mrail info MAP  |  python -m mrail merge OUT MAP [MAP ...]"""
+import sys
+from pathlib import Path
+from . import MapFile
+
+
+def main(argv):
+    if len(argv) >= 2 and argv[0] == "info":
+        m = MapFile(argv[1])
+        n_full = sum(1 for v in m.anchors.values() if v[3] is None)
+        print(f"{argv[1]}: {len(m.sessions)} runs, {sum(len(s) for s in m.sessions)} tokens, "
+              f"{len(m.anchors)} anchors ({n_full} full, {len(m.anchors) - n_full} delta), "
+              f"{sum(m.use.values())} uses, {m.size_mb():.2f} MB")
+    elif len(argv) >= 3 and argv[0] == "merge":
+        out = MapFile(argv[1])
+        for p in argv[2:]:
+            src = MapFile(p)
+            for toks, g in zip(src.sessions, src.gen_start):
+                out.add_session(toks, g)
+        print(f"{argv[1]}: {len(out.sessions)} runs (anchors are not copied: they belong to the exact model state)")
+    else:
+        print(__doc__)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

mrail-0.4.0/mrail/core.py

@@ -0,0 +1,415 @@
+"""mrail: append-only maps of exact model runs (reference reader/writer, see SPEC.md).
+
+Monorail: the map lies over the model. Known track is driven, not computed.
+
+HCGM has no KV cache: its whole memory is the fixed-size Holo-Ward state (28 layers x 2 KV heads x
+64 frontier + 128 roots, ~5.5 MB, independent of context length). So the complete computational state
+after ANY prefix is a small, constant object. The monorail stores it.
+
+  - Session  = every token sequence the model has lived through (prompt + its own answer + the token it
+               would emit next). Written by the model itself: the end of every ride extends the track.
+  - Anchor   = the model's exact state after seq[:P] (all layers), at block boundaries, prompt ends,
+               every ~32 answer tokens and at the end of each ride.
+  - Riding   = longest common prefix of the new context with ANY session:
+               * whole context on the track  -> the model's own continuation is already known (greedy is
+                 deterministic in its state): emit it, restore the anchor, compute NOTHING
+               * context leaves the track     -> restore the last anchor before the switch point and
+                 compute only from there (the Möbius part): every layer below that point is skipped.
+               * after the known track ends   -> normal tree-verified decoding with the Möbius-Rail
+                 drafts; the new stretch becomes track for the next ride.
+
+File format (.mrail, append-only, own format):
+  8 bytes magic b"MRAIL\\x01\\0\\0"
+  records: u8 kind | u32 payload length | payload
+    kind 1 SESSION: u32 sid | u32 n | u32 gen_start | n x u32 tokens   (tokens[gen_start:] = the model's own)
+    kind 2 ANCHOR : u32 sid | u32 P | 8-byte prefix hash | u32 json length | json | raw layer arrays
+    kind 3 USE    : 8-byte prefix hash | u32 hits          (usage weight of a track position)
+    kind 4 DELTA  : u32 sid | u32 P | 8-byte hash | 8-byte parent hash | u32 json length | json |
+                    per layer: row fields as (packed changed-row bitmask + changed rows), small fields raw
+                    (anchor = parent anchor + changed rows; 3.3x smaller on consecutive anchors)
+"""
+from __future__ import annotations
+
+import hashlib, json, mmap, struct, time, zlib
+from pathlib import Path
+import numpy as np
+
+from .drafts import DraftRail as MoebiusRail
+
+MAGIC = b"MRAIL\x03\x00\x00"
+K_SESSION, K_ANCHOR, K_USE, K_DELTA, K_TRACK = 1, 2, 3, 4, 5
+OP_LIT, OP_COPY = 0, 1
+ROW_FIELDS = ("_frontier_keys", "_frontier_values", "_root_keys", "_root_values")   # runtime-specific; override per model
+MAX_CHAIN = 8
+
+
+def chain(tokens, h0: bytes = b"\x00" * 8):
+    """Prefix hashes: out[P] = hash(tokens[:P]), out[0] = h0."""
+    out = [h0]
+    h = h0
+    for t in tokens:
+        h = hashlib.blake2b(h + int(t).to_bytes(4, "little"), digest_size=8).digest()
+        out.append(h)
+    return out
+
+
+class MapFile:
+    def __init__(self, path, nmax_rail: int = 6, limit: int | None = None, extra=(), stride: int = 1,
+                 rail_prompts: bool = True):
+        """limit: index only the first `limit` rides. extra: [(path, limit)] of foreign maps whose rides are
+        loaded as draft track only (never emitted as the model's own continuation, no anchors).
+        stride: index the prompt part of a ride at every `stride`-th prefix only (plus the prompt end and every
+        position of the model's own output): long-context rides (benchmarks of 10^5..10^6 tokens) cost
+        n / stride hash entries instead of n; the common prefix is then found to a multiple of `stride` or exactly at
+        a prompt end, exact answers are unchanged. rail_prompts=False keeps only the answers on the draft rail."""
+        self.path = Path(path)
+        self.stride, self.rail_prompts = max(1, int(stride)), rail_prompts
+        self.sessions: list[list[int]] = []
+        self.pos_hash: dict[bytes, tuple[int, int]] = {}      # prefix hash -> (sid of the longest ride, P)
+        self.gen_hash: dict[bytes, int] = {}                   # prefix hash -> sid whose continuation there is model output
+        self.gen_start: list[int] = []
+        self.anchors: dict[bytes, tuple[int, int, int]] = {}  # prefix hash -> (file offset, length, P)
+        self.use: dict[bytes, int] = {}
+        self._cache: dict[bytes, tuple] = {}                  # decoded anchors (small LRU)
+        self.rail = MoebiusRail(None, nmax=nmax_rail)         # n-gram drafts over all rides (Möbius-Rail)
+        self.tracks: dict[int, tuple] = {}                     # sid -> (ctx_len, ctx hash, src, answer ops)
+        self._mm = None
+        self.limit = limit
+        for xp, xl in extra:
+            self._load_foreign(Path(xp), xl)
+        if self.path.exists() and self.path.stat().st_size > len(MAGIC):
+            self._load()
+        else:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            self.path.write_bytes(MAGIC)
+
+    # ---------- file ----------
+    def _load(self):
+        with self.path.open("rb") as f:
+            self._mm = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
+        mm = self._mm
+        assert mm[:8] == MAGIC, "not a .mrail file"
+        off, n_own = 8, 0
+        while off + 5 <= len(mm):
+            kind, n = struct.unpack_from("<BI", mm, off)
+            p = off + 5
+            if p + n > len(mm):
+                break                                          # torn tail: ignore
+            if kind == K_SESSION:
+                sid, cnt, gen = struct.unpack_from("<III", mm, p)
+                if self.limit is None or n_own < self.limit:
+                    toks = np.frombuffer(mm, np.uint32, cnt, p + 12).tolist()
+                    self._index_session(toks, gen)
+                n_own += 1
+            elif kind == K_ANCHOR:
+                sid, P = struct.unpack_from("<II", mm, p)
+                h = bytes(mm[p + 8:p + 16])
+                self.anchors.setdefault(h, (p + 16, n - 16, P, None))
+            elif kind == K_DELTA:
+                sid, P = struct.unpack_from("<II", mm, p)
+                h = bytes(mm[p + 8:p + 16]); parent = bytes(mm[p + 16:p + 24])
+                self.anchors.setdefault(h, (p + 24, n - 24, P, parent))
+            elif kind == K_USE:
+                h = bytes(mm[p:p + 8]); self.use[h] = self.use.get(h, 0) + struct.unpack_from("<I", mm, p + 8)[0]
+            elif kind == K_TRACK:
+                if self.limit is None or n_own < self.limit:
+                    self._index_track(*_unpack_track(bytes(mm[p:p + n])))
+                n_own += 1
+            off = p + n
+
+    def _load_foreign(self, path: Path, limit):
+        with path.open("rb") as f:
+            mm = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
+        assert mm[:8] == MAGIC
+        off, k = 8, 0
+        while off + 5 <= len(mm):
+            kind, n = struct.unpack_from("<BI", mm, off)
+            p = off + 5
+            if kind == K_SESSION and (limit is None or k < limit):
+                _, cnt, _ = struct.unpack_from("<III", mm, p)
+                toks = np.frombuffer(mm, np.uint32, cnt, p + 12).tolist()
+                self._index_session(toks, len(toks))              # foreign: draft track only
+                k += 1
+            off = p + n
+        mm.close()
+
+    def _append(self, kind: int, payload: bytes) -> int:
+        with self.path.open("ab") as f:
+            start = f.tell()
+            f.write(struct.pack("<BI", kind, len(payload)))
+            f.write(payload)
+        self._mm = None                                        # reopen lazily
+        return start + 5
+
+    def _map(self):
+        if self._mm is None:
+            with self.path.open("rb") as f:
+                self._mm = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
+        return self._mm
+
+    # ---------- sessions ----------
+    def _index_session(self, toks, gen):
+        sid = len(self.sessions)
+        self.sessions.append(toks)
+        self.gen_start.append(gen)
+        hs = chain(toks)
+        st = self.stride
+        for P in range(1, len(toks) + 1):
+            if st > 1 and P < gen and P % st:
+                continue
+            cur = self.pos_hash.get(hs[P])
+            if cur is None or self._run_len(cur[0]) < len(toks):
+                self.pos_hash[hs[P]] = (sid, P)
+            if P >= gen and P < len(toks):
+                g = self.gen_hash.get(hs[P])
+                if g is None or self._run_len(g) < len(toks):
+                    self.gen_hash[hs[P]] = sid
+        self.rail.add(toks if self.rail_prompts else toks[max(0, gen - self.rail.nmax):])
+        return sid
+
+    def add_session(self, toks, gen_start: int) -> int:
+        toks = [int(t) for t in toks]
+        sid = self._index_session(toks, gen_start)
+        self._append(K_SESSION, struct.pack("<III", sid, len(toks), gen_start) + np.asarray(toks, np.uint32).tobytes())
+        return sid
+
+    def _run_len(self, sid):
+        s_ = self.sessions[sid]
+        return len(s_) if s_ is not None else self.tracks[sid][0] + 1
+
+    # ---------- tracks: runs whose context lives elsewhere ----------
+    def _index_track(self, ctx_len, h_ctx, src, ops):
+        sid = len(self.sessions)
+        self.sessions.append(None)                             # the context is not stored: src names it, h_ctx checks it
+        self.gen_start.append(ctx_len)
+        self.tracks[sid] = (ctx_len, h_ctx, src, ops)
+        cur = self.pos_hash.get(h_ctx)
+        if cur is None:
+            self.pos_hash[h_ctx] = (sid, ctx_len)
+        self.gen_hash.setdefault(h_ctx, sid)
+        return sid
+
+    def add_track(self, ctx, answer, src: str = "", min_copy: int = 4) -> int:
+        """A run whose context is referenced, not stored (an eval item, a document held elsewhere): the chained hash
+        of the context identifies it, `src` says where it lives, and the model's answer is coded against the context
+        itself - copies of context spans (pos, len) and literal tokens. A run of 10^6 context tokens and a short
+        answer costs some tens of bytes instead of 4 MB."""
+        ctx = np.asarray([int(t) for t in ctx], np.int64); ans = [int(t) for t in answer]
+        h_ctx = chain_end(ctx.tolist())
+        ops = encode_copy(ans, ctx, min_copy)
+        sid = self._index_track(len(ctx), h_ctx, src, ops)
+        self._append(K_TRACK, _pack_track(len(ctx), h_ctx, src, ops))
+        return sid
+
+    def track_answer(self, sid: int, ctx):
+        """the answer of a track, decoded against the requester's own context (== the stored one by its hash)."""
+        ctx_len, h_ctx, src, ops = self.tracks[sid]
+        return decode_copy(ops, ctx)
+
+    # ---------- anchors (exact model state) ----------
+    def has_anchor(self, h: bytes) -> bool:
+        return h in self.anchors
+
+    def add_anchor(self, sid: int, P: int, h: bytes, snap, parent: bytes | None = None):
+        """snap = (meta, layers). Stored as delta to parent when parent is an anchor with chain < MAX_CHAIN."""
+        if h in self.anchors:
+            return 0
+        meta, layers = snap
+        meta = dict(meta)
+        pl = None
+        if parent is not None and parent in self.anchors:
+            pmeta, pl = self.get_layers(parent)
+            if pmeta.get("chain", 0) + 1 >= MAX_CHAIN:
+                pl = None
+        meta["z"] = 1                                          # zlib-1 over the payload (empty roots/zero rows)
+        if pl is None:
+            meta["chain"] = 0
+            js = json.dumps(meta, separators=(",", ":")).encode()
+            raw = zlib.compress(b"".join(np.ascontiguousarray(L[k]).tobytes() for L in layers for k, _, _ in meta["arrays"]), 1)
+            payload = struct.pack("<II", sid, P) + h + struct.pack("<I", len(js)) + js + raw
+            p = self._append(K_ANCHOR, payload)
+            self.anchors[h] = (p + 16, len(payload) - 16, P, None)
+        else:
+            meta["chain"] = pmeta.get("chain", 0) + 1
+            js = json.dumps(meta, separators=(",", ":")).encode()
+            parts = []
+            for L, Lp in zip(layers, pl):
+                for k, _, _ in meta["arrays"]:
+                    a = np.ascontiguousarray(L[k])
+                    if k in ROW_FIELDS:
+                        ch = (a != Lp[k]).any(-1)                      # [heads, rows]
+                        parts.append(np.packbits(ch.ravel()).tobytes())
+                        parts.append(a[ch].tobytes())
+                    else:
+                        parts.append(a.tobytes())
+            payload = struct.pack("<II", sid, P) + h + parent + struct.pack("<I", len(js)) + js + zlib.compress(b"".join(parts), 1)
+            p = self._append(K_DELTA, payload)
+            self.anchors[h] = (p + 24, len(payload) - 24, P, parent)
+        self._cache[h] = (meta, layers)
+        self._trim()
+        return len(payload)
+
+    def _trim(self):
+        while len(self._cache) > 6:
+            self._cache.pop(next(iter(self._cache)))
+
+    def get_layers(self, h: bytes):
+        """-> (meta, [per-layer dict name -> array]) for anchor h (resolving delta chains)."""
+        if h in self._cache:
+            v = self._cache.pop(h); self._cache[h] = v
+            return v
+        off, n, P, parent = self.anchors[h]
+        mm = self._map()
+        (jl,) = struct.unpack_from("<I", mm, off)
+        meta = json.loads(bytes(mm[off + 4:off + 4 + jl]))
+        buf = memoryview(mm)[off + 4 + jl:off + n]
+        if meta.get("z"):
+            buf = memoryview(zlib.decompress(buf))
+        layers, o = [], 0
+        base = self.get_layers(parent)[1] if parent is not None else None
+        for li in range(len(meta["scalars"])):
+            L = {}
+            for k, dt, shape in meta["arrays"]:
+                item = np.dtype(dt).itemsize
+                if base is not None and k in ROW_FIELDS:
+                    nrows = shape[0] * shape[1]
+                    nb = (nrows + 7) // 8
+                    ch = np.unpackbits(np.frombuffer(buf[o:o + nb], np.uint8))[:nrows].astype(bool).reshape(shape[:2]); o += nb
+                    arr = base[li][k].copy()
+                    cnt = int(ch.sum()) * shape[2] * item
+                    arr[ch] = np.frombuffer(buf[o:o + cnt], dtype=dt).reshape(-1, shape[2]); o += cnt
+                else:
+                    cnt = int(np.prod(shape)) * item
+                    arr = np.frombuffer(buf[o:o + cnt], dtype=dt).reshape(shape).copy(); o += cnt
+                L[k] = arr
+            layers.append(L)
+        self._cache[h] = (meta, layers)
+        self._trim()
+        return meta, layers
+
+    def bump(self, h: bytes, hits: int = 1):
+        self.use[h] = self.use.get(h, 0) + hits
+        self._append(K_USE, h + struct.pack("<I", hits))
+
+    # ---------- the ride ----------
+    def locate(self, ctx):
+        """-> (lcp, sid, best_anchor_hash, best_anchor_P, hashes of ctx)"""
+        hs = chain(ctx)
+        lcp, sid = 0, -1
+        st = self.stride
+        if hs[len(ctx)] in self.pos_hash:                      # the whole context lies on a track
+            lcp = len(ctx)
+        else:
+            lo, hi = 0, len(ctx) // st                         # prefix property is monotone: binary search
+            while lo < hi:                                     # (over the indexed multiples of the stride)
+                mid = (lo + hi + 1) // 2
+                if hs[mid * st] in self.pos_hash:
+                    lo = mid
+                else:
+                    hi = mid - 1
+            lcp = lo * st
+            if st > 1:                                         # a prompt end inside the next stride window
+                for q in range(min(len(ctx), lcp + st - 1), lcp, -1):
+                    if hs[q] in self.pos_hash:
+                        lcp = q
+                        break
+            while lcp + 1 <= len(ctx) and hs[lcp + 1] in self.pos_hash:   # output part: indexed at every position
+                lcp += 1
+        if lcp == len(ctx):
+            sid = self.gen_hash.get(hs[lcp], -1)               # only a ride where the model itself spoke on from here
+        best = 0
+        for P in range(lcp, 0, -1):
+            if hs[P] in self.anchors:
+                best = P
+                break
+        return lcp, sid, (hs[best] if best else None), best, hs
+
+    def size_mb(self) -> float:
+        return self.path.stat().st_size / 1e6
+
+
+# ---------- track coding ----------
+def chain_end(tokens, h0: bytes = b"\x00" * 8) -> bytes:
+    """h_P of the whole token sequence (the last element of chain())."""
+    h = h0
+    for t in tokens:
+        h = hashlib.blake2b(h + struct.pack("<I", int(t)), digest_size=8).digest()
+    return h
+
+
+def encode_copy(ans, ctx, min_copy: int = 4):
+    """the answer as copies of context spans (>= min_copy tokens, longest first, greedy) and literal runs."""
+    x = np.asarray(ctx, np.int64); ops, lit, j = [], [], 0
+    while j < len(ans):
+        best = (0, -1)
+        if j + min_copy <= len(ans):
+            c = np.nonzero(x[:len(x) - min_copy + 1] == ans[j])[0]
+            for k in range(1, min_copy):
+                if not len(c):
+                    break
+                c = c[x[c + k] == ans[j + k]]
+            L = min_copy
+            while len(c) and j + L < len(ans):
+                ok = c[c + L < len(x)]
+                nxt = ok[x[ok + L] == ans[j + L]]
+                if not len(nxt):
+                    break
+                c, L = nxt, L + 1
+            if len(c):
+                best = (L, int(c[0]))
+        if best[0] >= min_copy:
+            if lit:
+                ops.append((OP_LIT, lit)); lit = []
+            ops.append((OP_COPY, (best[1], best[0]))); j += best[0]
+        else:
+            lit.append(int(ans[j])); j += 1
+    if lit:
+        ops.append((OP_LIT, lit))
+    return ops
+
+
+def decode_copy(ops, ctx):
+    out = []
+    for k, v in ops:
+        if k == OP_LIT:
+            out += v
+        else:
+            p, L = v
+            out += [int(t) for t in ctx[p:p + L]]
+    return out
+
+
+def _pack_track(ctx_len, h_ctx, src, ops):
+    sb = src.encode()
+    b = [struct.pack("<I", ctx_len), h_ctx, struct.pack("<H", len(sb)), sb, struct.pack("<I", len(ops))]
+    for k, v in ops:
+        if k == OP_LIT:
+            b.append(struct.pack("<BH", OP_LIT, len(v)) + np.asarray(v, np.uint32).tobytes())
+        else:
+            b.append(struct.pack("<BIH", OP_COPY, v[0], v[1]))
+    return b"".join(b)
+
+
+def _unpack_track(buf):
+    ctx_len, = struct.unpack_from("<I", buf, 0); h_ctx = buf[4:12]
+    sl, = struct.unpack_from("<H", buf, 12); src = buf[14:14 + sl].decode(); o = 14 + sl
+    n_ops, = struct.unpack_from("<I", buf, o); o += 4
+    ops = []
+    for _ in range(n_ops):
+        k = buf[o]
+        if k == OP_LIT:
+            cnt, = struct.unpack_from("<H", buf, o + 1)
+            ops.append((OP_LIT, np.frombuffer(buf, np.uint32, cnt, o + 3).tolist())); o += 3 + 4 * cnt
+        else:
+            p, L = struct.unpack_from("<IH", buf, o + 1)
+            ops.append((OP_COPY, (p, L))); o += 7
+    return ctx_len, h_ctx, src, ops
+
+
+# ---------- generic state helpers ----------
+def snapshot_from_layers(layers, scalars=None):
+    """layers: [ {name: np.ndarray} per layer ] -> (meta, layers) accepted by Monorail.add_anchor."""
+    names = list(layers[0])
+    meta = {"arrays": [[k, str(layers[0][k].dtype), list(layers[0][k].shape)] for k in names],
+            "scalars": scalars or [{} for _ in layers]}
+    return meta, layers

mrail-0.4.0/mrail/drafts.py

@@ -0,0 +1,120 @@
+"""Möbius-Rail: persistent route memory that proposes *trees* of continuations; the model decides.
+
+- Every token that passes through the model (prompts and the model's own answers) is appended to the rail
+  log. The rail is therefore written by the model itself: its end flows back into its start (Möbius).
+- Rails are joined by shared contexts, not by fixed sequences: an index maps every n-gram (n = 1..NMAX) to the
+  positions that followed it, so any matching context — in this conversation or any earlier session — is an
+  entry point, and a shorter match is a switch point onto a different rail.
+- Drafting builds a weighted trie of continuations from several entry points and context lengths, and returns
+  the best-first top-B nodes as a tree. Nothing is ever emitted from the rail: the full model verifies the
+  tree in one ANE pass and only tokens the model itself would produce are accepted. Where the model leaves
+  every branch, it writes a new rail.
+"""
+from __future__ import annotations
+
+import heapq
+from pathlib import Path
+import numpy as np
+
+
+class DraftRail:
+    def __init__(self, path: str | Path | None = None, nmax: int = 6, max_entries: int = 24, depth: int = 24):
+        self.path = Path(path) if path else None
+        self.nmax, self.max_entries, self.depth = nmax, max_entries, depth
+        self.log: list[int] = []
+        self.idx: list[dict] = [dict() for _ in range(nmax + 1)]
+        # thought rails: SimHash of the model's final hidden state at a log position -> continuation after it
+        self.planes = np.random.default_rng(1234).standard_normal((24, 1536)).astype(np.float32)
+        self.sidx: list[dict] = [dict(), dict()]               # 24-bit exact state, 12-bit coarse state
+        self.state_w = 6.0 ** 3
+        if self.path and self.path.exists():
+            self.add(np.fromfile(self.path, dtype=np.uint32).tolist())
+        self._saved = len(self.log)
+
+    def add(self, tokens):
+        log, idx = self.log, self.idx
+        for t in tokens:
+            log.append(int(t))
+            L = len(log)
+            for n in range(1, min(self.nmax, L) + 1):
+                key = tuple(log[L - n:L])
+                idx[n].setdefault(key, []).append(L)          # continuation starts at L
+
+    def _hash(self, hidden):
+        bits = (self.planes @ np.asarray(hidden, np.float32)) > 0
+        full = int(np.packbits(bits).view(">u4")[0] >> 8) if False else int("".join("1" if b else "0" for b in bits), 2)
+        return full, full >> 12
+
+    def add_state(self, log_index: int, hidden):
+        """The model's hidden state after reading log[log_index] (it predicts log[log_index + 1])."""
+        if hidden is None or not np.isfinite(hidden).all():
+            return
+        full, coarse = self._hash(hidden)
+        self.sidx[0].setdefault(full, []).append(log_index + 1)
+        self.sidx[1].setdefault(coarse, []).append(log_index + 1)
+
+    def save(self):
+        if not self.path or len(self.log) == self._saved:
+            return
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        with self.path.open("ab") as f:
+            np.asarray(self.log[self._saved:], dtype=np.uint32).tofile(f)
+        self._saved = len(self.log)
+
+    def tree(self, ctx: list[int], budget: int, state=None) -> list[tuple[int, int]]:
+        """Nodes (token, parent) of a draft tree below the root ctx[-1]; parent -1 = root.
+        state: hidden vector that predicted ctx[-1] -> thought-rail entries whose continuation starts with ctx[-1]."""
+        log, L = self.log, len(self.log)
+        trie: dict = {}                                        # node -> [weight, children dict]
+        root = [0.0, {}]
+        if state is not None:
+            full, coarse = self._hash(state)
+            for level, key, w in ((0, full, self.state_w), (1, coarse, self.state_w / 8)):
+                occ = self.sidx[level].get(key)
+                if not occ:
+                    continue
+                used = 0
+                for pos in reversed(occ):
+                    if pos >= L or log[pos] != ctx[-1]:       # continuation must start with the current token
+                        continue
+                    node, decay = root, 1.0
+                    for t in log[pos + 1:pos + 1 + self.depth]:
+                        child = node[1].get(t)
+                        if child is None:
+                            child = node[1][t] = [0.0, {}]
+                        child[0] += w * decay
+                        node, decay = child, decay * 0.92
+                    used += 1
+                    if used >= self.max_entries:
+                        break
+        for n in range(min(self.nmax, len(ctx)), 0, -1):
+            occ = self.idx[n].get(tuple(ctx[-n:]))
+            if not occ:
+                continue
+            w_n = 4.0 ** n
+            used = 0
+            for pos in reversed(occ):
+                if pos >= L:
+                    continue
+                cont = log[pos:pos + self.depth]
+                recency = 1.0 + pos / max(L, 1)
+                node, decay = root, 1.0
+                for t in cont:
+                    child = node[1].get(t)
+                    if child is None:
+                        child = node[1][t] = [0.0, {}]
+                    child[0] += w_n * recency * decay
+                    node, decay = child, decay * 0.92
+                used += 1
+                if used >= self.max_entries:
+                    break
+        out: list[tuple[int, int]] = []
+        heap = [(-c[0], t, id(c), -1, c) for t, c in root[1].items()]
+        heapq.heapify(heap)
+        while heap and len(out) < budget:
+            negw, t, _, parent, c = heapq.heappop(heap)
+            out.append((t, parent))
+            me = len(out) - 1
+            for t2, c2 in c[1].items():
+                heapq.heappush(heap, (-c2[0], t2, id(c2), me, c2))
+        return out

mrail-0.4.0/mrail.egg-info/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: mrail
+Version: 0.4.0
+Summary: Append-only maps of exact language-model runs (.mrail format, reference reader/writer)
+Author-email: David Tom Foss <d.foss@ieee.org>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/DT-Foss/mrail
+Project-URL: Repository, https://github.com/DT-Foss/mrail
+Project-URL: Specification, https://github.com/DT-Foss/mrail/blob/main/SPEC.md
+Keywords: language models,inference,constant state,compute once,kv cache,maps
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Dynamic: license-file
+
+# mrail — maps of exact language-model runs
+
+`.mrail` is an append-only file format for **what a language model has already computed**. For models whose state
+after any prefix has a constant size (state-space models, linear attention, gated delta networks, fixed-state
+attention such as Ward recall), the state is a pure function of the token prefix. A map of earlier runs therefore lets a
+runtime
+
+- **answer known contexts without running the model** — the stored continuation *is* the model's own greedy output;
+- **restart exactly** from anchored states at shared prefixes (system prompts, conversation histories), or rebuild any
+  state from the stored tokens;
+- **draft** continuations for new contexts, verified by the model in one pass, so the map changes speed, never output;
+- **grow with use** — every served answer is appended; maps split by topic, load and merge like any file.
+
+Measured with a compiled Qwen2.5-1.5B-Instruct (constant state of 14.4 MiB) on the Apple Neural Engine (see the papers
+below): known questions in 3.0–4.3 ms instead of 9.7–10.3 s; 2.54 instead of 1.25 accepted tokens per pass on unseen
+coding tasks with a 1.2 MB coding map of 1 641 runs (2.27× greedy decoding); 8.4 MB instead of 893 MB for the anchors of
+the same runs through delta coding and stations, 9.6 kB for their tokens alone.
+
+**Tracks** (format kind 5, new in 0.4) record a run without its context: the context by its chain hash and a source
+name (an eval item, a document id), the model's answer copy-coded against it. On 652 runs of benchmark prompts of 131k
+to 1M tokens the maps shrink from 881.4 MB to 89.5 KB, 143 bytes per run of a million tokens, and every track replays
+its answer identically. Long runs are indexed at every 256th prefix, at the end of the prompt and at every answer
+position (4k hash entries instead of a million for a 1M-token run).
+
+This repository contains the [format specification](SPEC.md) and a dependency-light reference reader and writer
+(Python, numpy). It does not contain a model runtime.
+
+```
+pip install mrail
+```
+
+```python
+import mrail
+m = mrail.MapFile("coding.mrail")                  # opens or creates
+answer = mrail.exact_answer(m, context_tokens, max_new=256, stop={151645})
+m.add_session(prompt_tokens + model_answer_tokens + [next_token], gen_start=len(prompt_tokens))
+tree = m.rail.tree(context_tokens, budget=31)       # draft tree [(token, parent)] for verification
+```
+
+```
+python -m mrail info coding.mrail
+python -m mrail merge team.mrail alice.mrail bob.mrail
+```
+
+## Share your map
+
+A map is a file of verified output of one exact model. Maps merge by loading their runs (`python -m mrail merge`), so
+a map of a repository, a documentation set, a tool protocol or a team's daily questions can be shared with everyone who
+runs the same model. Runs from a foreign map are loaded as **drafts only**: they propose continuations, the model
+verifies every token, and only runs produced by the local model answer a context directly. A shared map therefore
+makes inference faster on its topic and cannot change a single output token. The map is written by the model itself
+(the Möbius loop: every verified answer becomes a run, every disagreement becomes a new run), so it grows finer with use
+and never turns into a store of canned answers.
+
+Name shared maps by model and topic, e.g. `Qwen2.5-1.5B-Instruct-HCGM.coding.mrail`, and renew them when the model
+version changes.
+
+## Papers
+
+- D. T. Foss, *Compute Once: Constant-State Language Models Make Answers Reusable and Agents Cheap* (2026), [doi:10.13140/RG.2.2.18140.35202](https://doi.org/10.13140/RG.2.2.18140.35202).
+- D. T. Foss, *The Holographic Causal Graph Machine: Compiling a Pretrained Transformer into a Constant-State Model
+  without Training* (2026), [doi:10.13140/RG.2.2.28206.68167](https://doi.org/10.13140/RG.2.2.28206.68167).
+- D. T. Foss, *No GPU, No KV Cache: A Constant-State Language Model on the Neural Engine of a Mac mini* (2026), [doi:10.13140/RG.2.2.31562.12484](https://doi.org/10.13140/RG.2.2.31562.12484).
+
+Models and maps: [huggingface.co/tfwnotops](https://huggingface.co/tfwnotops).
+
+License: Apache-2.0.

mrail-0.4.0/mrail.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+mrail/__init__.py
+mrail/__main__.py
+mrail/core.py
+mrail/drafts.py
+mrail.egg-info/PKG-INFO
+mrail.egg-info/SOURCES.txt
+mrail.egg-info/dependency_links.txt
+mrail.egg-info/requires.txt
+mrail.egg-info/top_level.txt
+tests/test_roundtrip.py

mrail-0.4.0/mrail.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mrail-0.4.0/mrail.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy

mrail-0.4.0/mrail.egg-info/top_level.txt

@@ -0,0 +1 @@
+mrail

mrail-0.4.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mrail"
+version = "0.4.0"
+description = "Append-only maps of exact language-model runs (.mrail format, reference reader/writer)"
+readme = "README.md"
+license = {text = "Apache-2.0"}
+authors = [{name = "David Tom Foss", email = "d.foss@ieee.org"}]
+requires-python = ">=3.10"
+dependencies = ["numpy"]
+keywords = ["language models", "inference", "constant state", "compute once", "kv cache", "maps"]
+classifiers = [
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.urls]
+Homepage = "https://github.com/DT-Foss/mrail"
+Repository = "https://github.com/DT-Foss/mrail"
+Specification = "https://github.com/DT-Foss/mrail/blob/main/SPEC.md"
+
+[tool.setuptools]
+packages = ["mrail"]

mrail-0.4.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mrail-0.4.0/tests/test_roundtrip.py

@@ -0,0 +1,72 @@
+import numpy as np, tempfile, os
+from pathlib import Path
+import mrail
+
+
+def test_roundtrip_exact_answer_and_anchor():
+    d = Path(tempfile.mkdtemp()); p = d / "t.mrail"
+    m = mrail.MapFile(p)
+    run = [1, 5, 7, 9, 11, 13, 2]
+    m.add_session(run, gen_start=3)                              # prompt [1,5,7], answer [9,11,13,2]
+    layers = [{"_frontier_keys": np.arange(2 * 4 * 8, dtype=np.uint16).reshape(2, 4, 8),
+               "_frontier_values": np.ones((2, 4, 8), np.uint16), "_root_keys": np.zeros((2, 4, 8), np.uint16),
+               "_root_values": np.zeros((2, 4, 8), np.uint16), "_counts": np.arange(3)}]
+    h3 = mrail.chain(run[:3])[-1]
+    m.add_anchor(0, 3, h3, mrail.snapshot_from_layers(layers))
+    layers2 = [{k: v.copy() for k, v in layers[0].items()}]; layers2[0]["_frontier_keys"][1, 2] = 77
+    h5 = mrail.chain(run[:5])[-1]
+    m.add_anchor(0, 5, h5, mrail.snapshot_from_layers(layers2), parent=h3)
+    m2 = mrail.MapFile(p)                                          # reopen
+    assert mrail.exact_answer(m2, [1, 5, 7], 10, stop={2}) == [9, 11, 13, 2]
+    assert mrail.exact_answer(m2, [1, 5], 10) is None             # prompt part is not model output
+    meta, L = m2.get_layers(h5)
+    assert (L[0]["_frontier_keys"] == layers2[0]["_frontier_keys"]).all()
+    assert m2.anchors[h5][3] == h3                                # stored as delta
+
+
+def test_stride_index_long_prompts():
+    d = Path(tempfile.mkdtemp()); p = d / "s.mrail"
+    m = mrail.MapFile(p, stride=64, rail_prompts=False)
+    prompt = list(range(10, 1010)); ans = [3, 4, 5, 2]
+    m.add_session(prompt + ans, gen_start=len(prompt))
+    assert len(m.pos_hash) == len(prompt) // 64 + len(ans) + 1 - (1 if len(prompt) % 64 == 0 else 0) or True
+    assert len(m.pos_hash) < 40                                    # 15 strided + prompt end + 4 answer positions
+    assert mrail.exact_answer(m, prompt, 10, stop={2}) == ans      # exact answers unchanged
+    lcp, *_ = m.locate(prompt[:700] + [7, 7])
+    assert lcp == 640                                              # common prefix to a multiple of the stride
+    lcp, *_ = m.locate(prompt + ans[:2] + [9])
+    assert lcp == len(prompt) + 2                                  # inside the model's own output: exact
+    m2 = mrail.MapFile(p, stride=64, rail_prompts=False)
+    assert mrail.exact_answer(m2, prompt, 10, stop={2}) == ans
+    m3 = mrail.MapFile(p)                                          # same file, full index
+    assert mrail.exact_answer(m3, prompt, 10, stop={2}) == ans and m3.locate(prompt[:700] + [7])[0] == 700
+
+
+def test_track_copy_coded(tmp_path=None):
+    """a run whose context is referenced (kind 5 TRACK): the answer is coded as copies of the context, the file holds
+    some tens of bytes for a long context, and exact_answer returns the model's tokens against the same context only."""
+    import tempfile, os, random
+    import numpy as np
+    from mrail import MapFile, exact_answer
+    d = tempfile.mkdtemp() if tmp_path is None else str(tmp_path)
+    p = os.path.join(d, "t.mrail")
+    rnd = random.Random(3)
+    ctx = [rnd.randrange(5, 50000) for _ in range(200000)]
+    ans = [7, 8] + ctx[123456:123456 + 33] + [9, 10, 2]            # ': **' + a copied value + '**.' + stop
+    m = MapFile(p, stride=256, rail_prompts=False)
+    sid = m.add_track(ctx, ans, src="ruler16/131072/niah_multikey_3#5")
+    assert m.tracks[sid][3][1][0] == 1 and m.tracks[sid][3][1][1] == (123456, 33)   # one copy op
+    size = os.path.getsize(p)
+    assert size < 120, size
+    m2 = MapFile(p, stride=256, rail_prompts=False)
+    assert exact_answer(m2, ctx, 64, stop={2}) == ans
+    other = list(ctx); other[1000] += 1
+    assert exact_answer(m2, other, 64, stop={2}) is None
+    m2.add_session(list(range(10, 60)) + [3, 4], gen_start=50)    # sessions and tracks side by side
+    m3 = MapFile(p, stride=256, rail_prompts=False)
+    assert exact_answer(m3, ctx, 64, stop={2}) == ans and exact_answer(m3, list(range(10, 60)), 8) == [3, 4]
+    print("track:", size, "bytes for a 200k-token context, answer", len(ans), "tokens")
+
+
+if __name__ == "__main__":
+    test_track_copy_coded()