tgi-foundation 0.2.0.dev0__tar.gz

tgi_foundation-0.2.0.dev0/LICENSE

@@ -0,0 +1,3 @@
+Copyright (c) 2026 Emylton Leunufna
+
+No reuse allowed without permission.

tgi_foundation-0.2.0.dev0/MANIFEST.in

@@ -0,0 +1,8 @@
+include README.md
+include LICENSE
+recursive-include tgi *.py
+recursive-include tests *.py
+recursive-include contracts *.json
+recursive-include examples *.jsonl
+recursive-include paper/technical *.md *.json
+recursive-include output/pdf *.pdf

tgi_foundation-0.2.0.dev0/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: tgi-foundation
+Version: 0.2.0.dev0
+Summary: Native character-identity and geometric knowledge mechanisms for Topological Geometric Intelligence
+Author: Emylton Leunufna
+License: Copyright (c) 2026 Emylton Leunufna
+        
+        No reuse allowed without permission.
+        
+Project-URL: Homepage, https://github.com/rfls-emyton/TGI
+Project-URL: Source, https://github.com/rfls-emyton/TGI
+Keywords: topological geometric intelligence,TGI,NMU,crystal memory
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# TGI: Topological Geometric Intelligence
+
+Research implementation by Emylton Leunufna. This repository contains the Python runtime, a minimal reproducible acceptance example and regression tests, and six manuscripts with PDF renderings. NMU retains one static ID per Unicode scalar; the mechanisms are derived from the TGI program.
+
+Python >=3.11. Local check: `python -m unittest discover -s tests -q`. CLI: `python -m tgi --help`. See `paper/technical/README.md` for the foundational and five technical papers. Raw research evidence and historical hypotheses are intentionally outside this public code tree.
+
+Copyright (c) 2026 Emylton Leunufna. No reuse allowed without permission.

tgi_foundation-0.2.0.dev0/README.md

@@ -0,0 +1,7 @@
+# TGI: Topological Geometric Intelligence
+
+Research implementation by Emylton Leunufna. This repository contains the Python runtime, a minimal reproducible acceptance example and regression tests, and six manuscripts with PDF renderings. NMU retains one static ID per Unicode scalar; the mechanisms are derived from the TGI program.
+
+Python >=3.11. Local check: `python -m unittest discover -s tests -q`. CLI: `python -m tgi --help`. See `paper/technical/README.md` for the foundational and five technical papers. Raw research evidence and historical hypotheses are intentionally outside this public code tree.
+
+Copyright (c) 2026 Emylton Leunufna. No reuse allowed without permission.

tgi_foundation-0.2.0.dev0/contracts/user_acceptance_frame_v1.json

@@ -0,0 +1,54 @@
+{
+  "id": "TGI-USER-ACCEPTANCE-FRAME-V1",
+  "created_utc": "2026-09-21T21:36:34.160894+00:00",
+  "authority": "User acceptance package supplied during active task",
+  "experiences": [
+    {
+      "source_id": "experience-A",
+      "text": "SISTEM TGI AMAN DARI HALUSINASI",
+      "anchor": 3,
+      "start_coordinate": [
+        2,
+        1,
+        0,
+        3,
+        5
+      ]
+    },
+    {
+      "source_id": "experience-B",
+      "text": "SISTEM REAKTOR NUKLIR MEMBUTUHKAN PENDINGIN",
+      "anchor": 8,
+      "start_coordinate": [
+        2,
+        1,
+        0,
+        8,
+        2
+      ]
+    }
+  ],
+  "queries": [
+    {
+      "trigger": "S",
+      "anchor": 3,
+      "expected": "SISTEM TGI AMAN DARI HALUSINASI"
+    },
+    {
+      "trigger": "S",
+      "anchor": 8,
+      "expected": "SISTEM REAKTOR NUKLIR MEMBUTUHKAN PENDINGIN"
+    },
+    {
+      "trigger": "S",
+      "anchor": 9,
+      "expected": null
+    }
+  ],
+  "criteria": [
+    "exact NMU reconstruction of both complete frames",
+    "no cross-anchor traversal",
+    "unknown anchor returns NULL without a generated answer"
+  ],
+  "causal_interpretation": "Receive complete frame before assigning final context address and locking its initial node. No suffix information is available at initial S."
+}

tgi_foundation-0.2.0.dev0/examples/acceptance_frames.jsonl

@@ -0,0 +1,2 @@
+{"source_id": "experience-A", "text": "SISTEM TGI AMAN DARI HALUSINASI"}
+{"source_id": "experience-B", "text": "SISTEM REAKTOR NUKLIR MEMBUTUHKAN PENDINGIN"}

tgi_foundation-0.2.0.dev0/paper/technical/BAND_OWNED_PHASE_AND_ORGANIZATION.md

@@ -0,0 +1,218 @@
+# Band-Owned Phase Formation and Source-Valid Organization in TGI
+
+Emylton Leunufna  
+Technical manuscript, 4 October 2026  
+No affiliation
+
+## Abstract
+
+The TGI lattice substrate addresses raw NMU occurrences but does not decide
+which organizations may become durable knowledge. This paper owns that next
+step. Eight fast C banks receive adjacency witnesses; eight slow L banks
+retain temporal coverage through binary carry. Neither path merges, drops, or
+renames character identities. Source validity is checked from the raw frame,
+its band ownership, and phase receipt. At the occurrence level, the frozen
+foundation instance uses `Omega_i=(c_i+l_i)/2`, threshold one, and a separate
+lock `xi_i` conditioned on completeness, address ownership, and uniqueness.
+At the organization level, `Omega_H` counts distinct unambiguous realizations
+of raw interval structure and must not be confused with `Omega_i`.
+Counterevidence can revoke a crystal while retaining the original experience.
+The paper reports the mechanical evidence and the failed-receipt controls
+separately from functional interpretation. It derives TGI operators from its
+own goal of source-valid structural memory using the NMU, MULTIPITA, and
+Emylton principles as constraints, not as VEYRA NYRA implementation templates.
+
+## 1. Problem and contribution
+
+The identity and lattice paper provides ordered atoms and addresses. Without
+a validity rule, any adjacency could be read as established knowledge simply
+because it was stored. TGI instead needs an evidence-dependent phase
+transition and a way to withdraw the reading right after contradiction. The
+NINMENI MULTIPITA paper [2] supplies the principle that bands own work rather
+than partitioning identities. Emylton [3] supplies the distinction among
+organization state, scalar projection, and valid observation. Crystal Memory
+[4] demonstrates why a memory store is not itself a semantic claim. TGI
+derives a different, discrete source-evidence mechanism from those principles.
+
+Four contributions are made: (1) event-preserving C/L ownership; (2) an
+occurrence validity law separate from an organization support law; (3) a
+replayable phase certificate that keeps negative evidence; and (4) an explicit
+decision boundary between a structural crystal and a justified output.
+
+## 2. Band ownership without identity pooling
+
+For a frame `f=(c_0,...,c_{T-1})`, fast bank `j mod 8` owns the adjacency
+witness between positions `j` and `j+1`. Ownership answers *where the check
+is maintained*, not which characters exist. Every character still has its
+own static NMU ID and ordered event. The eight slow banks receive temporal
+coverage through binary carry. A completed block can be incorporated into a
+larger block while the raw occurrence order and source remain recoverable.
+An empty bank is not filled with inferred support.
+
+The invariant is stronger than equal output after processing. Given a stored
+receipt, an independent checker must recompute the expected owner of each
+adjacency and temporal block from the original frame length and event order.
+A receipt that attributes a valid-looking value to the wrong bank is invalid.
+This protects against the common failure in which a plausible scalar is
+accepted while the mechanism purported to produce it never ran. The C/L
+organization here is a TGI structural implementation; it is not the trained
+channel-partitioned MP2 cell of [2].
+
+## 3. Two levels of density and the lock
+
+The foundation occurrence law uses `c_i,l_i in {0,1}` as validity witnesses
+for the local and temporal paths:
+
+`Omega_i = (c_i + l_i)/2`, with `Omega_crit = 1`.
+
+An occurrence becomes structurally eligible only if both checks pass. The
+versioned `xi_i` lock additionally requires a complete frame, an owned
+coordinate, and a unique occurrence. This is a certificate bit or scalar
+projection of the checked state, not an independent source of truth. In
+particular, a high value caused by a normalization invariant is not a health
+metric and cannot license a world claim.
+
+An organization `H` is inferred from multiple raw episodes. Stable intervals
+remain literal NMU occurrences. Intervals that vary together may become
+binding axes, but the axis is an organizational relation over occurrences,
+not a new token identity. An episode supports `H` only when its complete raw
+sequence has exactly one valid interpretation under `H`. Let `D_k(H)` be the
+set of distinct realizations of axis `k` among such episodes. The frozen
+candidate measure is `Omega_H = min_k |D_k(H)|` with threshold three.
+`Omega_H` and `Omega_i` have different domains and should never be substituted
+for one another in a derivation or in a plot.
+
+The phase decision is therefore source-bound. A candidate with enough
+realizations cannot be promoted if a contributing source has a malformed
+frame, false C/L ownership, invalid receipt, or counterexample. The checker
+stores the original evidence scope used for the decision, making a later
+revocation and re-evaluation possible. No negative raw event is deleted to
+make a crystal appear stable.
+
+## 4. Falsification protocol
+
+The tests challenge four separable properties:
+
+| Challenge | Required outcome | Why it matters |
+|---|---|---|
+| C/L owner altered, output unchanged | reject receipt | output parity alone misses wrong ownership |
+| incomplete or fabricated bank support | no crystallization | prevents support from an empty path |
+| counterexample after crystal | revoke affected reading right | tests knowledge validity through time |
+| old certificate after new evidence | reject or revalidate against full history | prevents stale confidence |
+
+The raw-organization and phase acceptance reports [6,7] carry the first
+versioned evidence. The source distribution [8] rebuilds and evaluates the
+phase from extracted archive bytes, rather than relying on a workspace whose
+history can change. Historical negative audits are retained in the long-form
+TGI evidence ledger [9]. The experiment classification follows [2]: a
+structural check, a regression pass, a systems measurement, and a functional
+capability claim are distinct kinds of evidence.
+
+## 5. Results, interpretation, and successor interfaces
+
+The accepted raw-organization report [6] records nine gate decisions; the
+phase report [7] records source-valid phase, counterexample, and polarity
+checks. The source archive [8] passes its material/hash gates and runs both
+phase and distribution verifiers from extraction. These results establish a
+reproducible mechanism for source-valid structural promotion and withdrawal
+on the tested inputs. The acceptance chain [10] also tests the exact route
+consequence when the source and frame are valid.
+
+The original TGI manifesto [5] writes a general resonance accumulation for
+Omega and an integral expression for xi. The equations above are operational
+laws for this implementation. Matching names or dimensions would not prove
+mathematical equivalence to the exploratory manifesto expressions. The paper
+therefore states the implemented operator and its falsifier directly. This
+choice makes the chain testable: the next manuscript may form relations only
+from events whose source and phase are certified. It may not relabel the phase
+scalar as a semantic predicate.
+
+## 6. Reproducibility and artifacts
+
+The source entry points are `tgi/resonance.py`, `tgi/organization.py`,
+`tgi/phase_evidence.py`, and their checkers and tests in the source archive.
+The frozen contracts [11,12] specify the frame and receipt rules. Raw JSON
+reports [6–8] and the V71R manifest bind exact bytes and preserve failure
+cases. No model optimizer, continuous embedding, softmax attention, or
+subword tokenizer is part of this mechanism. The four NINMENI PDFs [1–4]
+serve as a derivation reference and remain separate from TGI source code.
+
+## 7. Phase verification algorithm and failure analysis
+
+The independent phase check can be described without relying on a particular
+Python data structure. It first decodes the declared raw frame and rejects
+invalid scalar identities. It then reconstructs every fast-bank owner from
+its adjacency index and every slow-bank block from chronological binary
+carry. It compares these reconstructed structures with the stored receipt.
+Only after this equality holds does it compute occurrence validity and the
+candidate lock. At the organization level it enumerates source episodes,
+requires complete unambiguous interpretation, derives the set of distinct
+axis realizations, and checks the current source-validity state. A later
+counterexample forces a new evaluation over the preserved event history.
+
+This order matters causally. If the checker read an asserted `xi` first and
+used it to excuse a malformed C/L record, it would make the claimed
+mechanism self-certifying. If it counted every episode that resembles an
+axis but has two valid interpretations, `Omega_H` would be inflated by an
+undecided source. If it removed an opposing source, the subsequent crystal
+would appear stronger only because evidence was destroyed. The tested
+implementation rejects those routes and exposes why promotion is withheld.
+
+| Evidence object | Unit of observation | What it may justify | What it cannot justify alone |
+|---|---|---|---|
+| `c_i,l_i` | one occurrence check | local and temporal ownership | factual truth of text |
+| `Omega_i,xi_i` | source/frame phase receipt | structurally readable occurrence | organization across episodes |
+| `Omega_H` | distinct unambiguous axis realizations | candidate organization | correct world referent |
+| counterexample | later original source event | revocation or context refinement | deletion of older source history |
+
+The table also prevents a nomenclature failure. NINMENI's Emylton state
+uses `Omega` for organization history and `xi` as a projected observation;
+TGI's occurrence and organization receipts use similar letters but own
+different objects. The shared principle is that organization and projection
+must be separated. Equality of symbols is not a derivation from Emylton.
+
+## 8. What the results test
+
+The organization report's nine gates and the phase report's six checks
+are meaningful only with their input scope, exact source bytes, and
+negative controls. The source-distribution verifier adds a different
+guarantee: it checks that the same files appear inside the archive with
+the expected hashes, then executes phase and distribution checks from
+the extracted tree. It cannot by itself enlarge the functional input
+class beyond the declared contracts. The functional consequence relevant
+to this paper is narrower and constructive: a route can be read only
+through source-valid crystals; when a counterexample revokes that source
+or organization, the old certificate cannot continue to authorize
+resolution. The actual query-level effect is checked by the separate
+resolution manuscript.
+
+## References
+
+[1] E. Leunufna, *NMU: One Character, One Identity*, revision V2, 2026,
+`REFERENSI_NINMENI/NMU_One_Character_One_Identity_Revision_V2.pdf`.
+
+[2] E. Leunufna, *MULTIPITA: Band-Owned Iso-Budget Computation*, revision V3,
+2026, `REFERENSI_NINMENI/MULTIPITA_Band-Owned_Iso-Budget_Revision_V3.pdf`.
+
+[3] E. Leunufna, *Emylton: A Falsifiable Native Crystallization-State Chain*,
+revision V2, 2026, `REFERENSI_NINMENI/EMYLTON_Organization_Ownership_Revision_V2.pdf`.
+
+[4] E. Leunufna, *Crystal Memory for Native Character-Identity Streams*,
+revision V3, 2026,
+`REFERENSI_NINMENI/CRYSTAL_MEMORY_Rangkaian_Aksi_Kristal_V3_Revision.pdf`.
+
+[5] `KONSEP.txt`.
+
+[6] `evidence/raw_organization_20260924T201845505122Z/result.json`.
+
+[7] `evidence/raw_phase_20260924T201845327366Z/result.json`.
+
+[8] `evidence/source_distribution_20261004T084916022662Z/result.json`.
+
+[9] `paper/TGI_FOUNDATION_DRAFT.md`, V71R.
+
+[10] `evidence/acceptance_20260924T201845597182Z/result.json`.
+
+[11] `contracts/FRAME_CRYSTAL_V1.md`.
+
+[12] `contracts/RECEIPT_PHASE_INTEGRITY_V1.md`.

tgi_foundation-0.2.0.dev0/paper/technical/CHARACTER_IDENTITY_AND_LATTICE.md

@@ -0,0 +1,231 @@
+# Character Identity and Discrete Crystal-Lattice Addressing in Topological Geometric Intelligence
+
+Emylton Leunufna  
+Technical manuscript, 4 October 2026  
+No affiliation
+
+## Abstract
+
+Topological Geometric Intelligence (TGI) treats a raw character stream as an
+ordered sequence of persistent identities whose occurrences can acquire
+distinct geometric addresses. This manuscript defines the identity substrate,
+the distinction between a character ID and its event occurrence, a discrete
+five-coordinate frame layout, and the conditions under which traversal may
+reconstruct an output. The TGI instantiation maps each admitted Unicode scalar
+to `ord(c)+16`, reserves 0–15 for structural uses, rejects surrogate values,
+and does not normalize input. This differs from the normalized registry
+instantiation described in the companion NINMENI NMU preprint while preserving
+its one-character/one-identity axiom. A two-stream acceptance experiment places
+the repeated prefix `SISTEM` into separate context lanes. The specified
+queries reconstruct each complete raw sentence and return no path for an
+unformed third anchor. The outcome follows from a complete route certificate,
+not from an assumed semantic value of a coordinate or a probabilistic guess.
+Checkpoint-order falsifiers show why the original event sequence is part of the
+addressing contract. The manuscript separates the established exact-route
+result from the later tasks of forming knowledge and referents.
+
+## 1. Research question and contribution
+
+The NINMENI NMU paper [1] fixes identity granularity. TGI begins where that
+paper stops: if two experiences contain the same character and even the same
+initial phrase, how can a geometric memory keep their occurrences distinct
+and read a justified continuation? The answer must preserve the axiom
+`one Unicode character -> one static ID`; it may not create a new identity for
+`SISTEM`, replace positions by a pooled vector, or change identity according
+to frequency. The problem is one of **addressing and route validity**, not a
+new tokenization scheme.
+
+This manuscript contributes (a) a typed separation of identity, occurrence,
+frame, coordinate, and route; (b) a concrete discrete placement law that
+separates source lanes; (c) a complete-route versus absent-route decision; and
+(d) falsifiers that distinguish correct text output from correct geometric
+state. These responsibilities are upstream of band and phase formation in the
+companion phase manuscript. A route can be well-formed even when its text is
+false about the world; world-relation evidence is owned by the interventional
+relations manuscript.
+
+## 2. Identity and occurrence definitions
+
+Let `U` be the declared admitted Unicode scalar space. The TGI codec is
+`I: U -> N`, `I(c)=ord(c)+16`. The low 16 integers are not character IDs.
+For admitted scalars, the map is injective and static. A surrogate is rejected
+before it can become a stored identity. Input is neither NFC-normalized nor
+segmented. This is an explicit TGI instantiation choice. In [1], NINMENI's
+measured corpus and 10,240-slot registry use a declared normalization and
+hash-bound table; importing that registry's implementation into TGI would be
+an unjustified architectural shortcut. What TGI takes from [1] is the
+identity **axiom**, not its corpus-specific table.
+
+For a source `s`, frame `f`, and position `i`, define the occurrence
+`o=(s,f,i,I(c_i))`. The projection `identity(o)=I(c_i)` forgets event ownership,
+so two occurrences can share an identity without being interchangeable.
+The ordered stream is `O_f=(o_0,...,o_{T-1})`; its chronology and raw source
+must survive checkpointing. A valid bulk-native operator may process several
+occurrences together, but it must project back to every original identity and
+position in the same order. This is a stronger invariant than equality of the
+final rendered string.
+
+The distinction matters for repeated letters and shared prefixes. In the
+sentence `SISTEM TGI ...`, both `S` occurrences have the same static ID but
+not the same occurrence address. The `S` at the start of the other sentence
+also has that ID, while its source lane differs. Neither a numerical ID nor a
+single coordinate carries a meaning label such as *safe* or *reactor*.
+
+## 3. Discrete layout and route certificate
+
+The versioned foundation layout places occurrence `i` of the `n`th distinct
+frame at
+
+`P(n,i)=(2+i, 1, 0, 3+5n, (5-3n) mod 11)`.
+
+The first coordinate orders characters; the fourth and fifth create source
+lanes. This is a constructive address allocation, not a proof that Euclidean
+or hyperbolic geometry by itself forms knowledge. For an admitted frame, a
+forward adjacency bond joins `P(n,i)` to `P(n,i+1)` only within its own lane.
+The route certificate records source, ordered occurrence identities, addresses,
+bond validity, and an explicit terminal marker. A reader returns the original
+character stream only after reaching the terminal marker through checked
+bonds. Three outcome categories are kept distinct:
+
+| Outcome | Necessary observation | Interpretation |
+|---|---|---|
+| `COMPLETE` | every ordered occurrence and terminal bond verified | exact reconstruction of a stored route |
+| `NO_PATH` | requested anchor is absent from valid state | no certified continuation |
+| `INCOMPLETE` | a route is present but broken or stopped by a ceiling | no complete output claim |
+
+The codec can decode each visited ID back to its scalar. A complete certificate
+therefore implies exact output character by character for that stored route.
+It does not imply factual truth of the decoded sentence. The no-path rule is a
+decision about the current geometric memory, not a universal statement that a
+sentence is impossible.
+
+## 4. Method and falsifiers
+
+The frozen user acceptance case contains two raw streams:
+
+1. `SISTEM TGI AMAN DARI HALUSINASI`;
+2. `SISTEM REAKTOR NUKLIR MEMBUTUHKAN PENDINGIN`.
+
+The two streams share the first six characters. The accepted anchors are the
+first `S` in lane A and the first `S` in lane B; a third unformed anchor is an
+absence control. Successful evaluation requires exact reconstruction of both
+strings, zero cross-lane jumps after `SISTEM`, and no output from the absent
+anchor. The acceptance report [5] executes the route and the broader project
+regression in the same chain.
+
+Output equality is not sufficient to verify spatial ownership. A historical
+checkpoint fault sorted sources before replay, producing the same text while
+changing which frame obtained which lane. The spatial retention decision [6]
+therefore freezes the original raw insertion journal and verifies the lattice
+after fresh-process recovery. Frame equality is checked from the complete NMU
+sequence rather than trusting a potentially colliding digest. A broken bond,
+modified coordinate, or mismatched receipt must fail validation rather than
+fall back to a plausible text completion.
+
+The acceptance test is deliberately sharp: shared prefixes make a shallow
+character lookup appear sufficient for the first few positions, but only a
+lane-bound route can preserve the correct continuation. Conversely, an absent
+anchor should not be mapped to the closest observed source. The reader has no
+softmax sampling step that could hide absence behind an output string.
+
+## 5. Results and inference
+
+The source acceptance report [5] records both exact reconstructions and the
+absent-context decision. The checkpoint-order falsifier and fix are retained
+in [6]. The phase-validity requirements required before a frame contributes
+are defined separately in [7]; they prevent an invalid source receipt from
+silently serving as a route. The source distribution report [8] checks that
+the relevant implementation and tests can be reproduced from extracted
+package bytes. These evidence classes should not be collapsed: a regression
+checks behavior, a checkpoint check tests state transport, and a source archive
+check tests reproducibility.
+
+This establishes the TGI substrate and exact route behavior for the declared
+states. It does not claim that `P(n,i)` alone discovers a physical referent or
+that the original integral expression for `xi` in `KONSEP.txt` has been derived
+from this layout. That expression is a source hypothesis. The tested placement
+law is an explicit implementation whose premises and consequences are visible.
+
+## 6. Reproducibility and artifact statement
+
+The authoritative source is `KONSEP.txt` [4], the four NINMENI reference
+preprints, the acceptance contract and raw receipt [5], source-preserving
+checkpoint decision [6], and the hash-bound source distribution [8]. The
+relevant implementation entry points are `tgi/identity.py`, `tgi/spatial.py`,
+`tgi/frame_engine.py`, and their tests in the distribution. The publication
+bundle identifies exact SHA-256 bytes for the manuscript, source, and
+evidence. No training checkpoint or private corpus is required to reproduce
+the acceptance case.
+
+## 7. Formal invariants and a constructive argument
+
+The character mapping is injective because adding a fixed offset to two
+different Unicode scalar numbers cannot make them equal. This is an identity
+property, not a statistical observation. The occurrence projection is not
+injective: two events may share `I(c)`. Thus no proof about event ownership
+may be based on ID equality alone. The address allocation must additionally
+bind the frame number, within-frame position, and source journal. For two
+frames `n != m`, their fourth coordinates differ by `5(n-m)`; hence their
+lanes cannot coincide under the declared layout. For two positions in the
+same frame, first coordinates differ. This establishes occurrence separation
+inside the admitted finite frame set independently of the wording of the
+sentences. The fifth coordinate is an additional consistency check, not the
+only source of uniqueness.
+
+For exact reconstruction, take the route whose bonds connect the ordered
+occurrences `o_0,...,o_(T-1),END`. The base case reads `I(c_0)` from `o_0`.
+At step `i<T-1`, the validated forward bond has the same frame lane and
+the unique successor `P(n,i+1)`; decoding it appends `c_(i+1)`. Induction
+gives the original scalar sequence after `T` occurrences, provided the
+terminal bond is present. If a bond is missing, the induction premise fails
+and the route cannot emit a complete result. This is the scope of the
+constructive theorem. It does not establish that a different unstored
+sentence should have the same result.
+
+The absence decision is equally precise. An unformed anchor has no initial
+valid occurrence and therefore no initial route certificate. Returning an
+empty result is a property of the current state; returning one of the two
+stored sentences would be a counterexample to the contract. A safety ceiling
+interrupting a nonempty route is recorded as `INCOMPLETE`, avoiding the
+mistake of conflating unobserved data with a proof of absence.
+
+## 8. Test matrix and state provenance
+
+| Probe | Perturbation | Required certificate consequence |
+|---|---|---|
+| same prefix, two sources | trigger first `S` under each lane | exact respective full stream, no cross-lane edge |
+| third anchor | request a lane never formed | `NO_PATH`, no guessed phrase |
+| source order swap on recovery | reorder journal while keeping text | reject changed coordinate ownership |
+| damaged bond or terminal | remove one required route edge | `INCOMPLETE` or invalid certificate, never partial text labeled complete |
+| Unicode distinction | feed different scalar sequences with similar display | preserve distinct IDs and raw order |
+
+The journal and the certificate carry different roles. The journal is
+provenance of what entered and when; the certificate is a derivation from
+that journal under current rules. A certificate recovered without the
+underlying raw history would be insufficient to test whether source order
+changed. Conversely, merely retaining the journal does not prove that the
+current lattice still obeys the placement law. Both are checked after
+recovery. This mirrors the NINMENI papers' distinction between a declared
+identity rule and a measured state, while keeping TGI's own discrete
+addressing rule explicit.
+
+## References
+
+[1] E. Leunufna, *NMU: One Character, One Identity*, revision V2, 2026,
+`REFERENSI_NINMENI/NMU_One_Character_One_Identity_Revision_V2.pdf`.
+
+[2] E. Leunufna, *MULTIPITA: Band-Owned Iso-Budget Computation*, revision V3,
+2026, `REFERENSI_NINMENI/MULTIPITA_Band-Owned_Iso-Budget_Revision_V3.pdf`.
+
+[3] E. Leunufna, *Emylton: A Falsifiable Native Crystallization-State Chain*,
+revision V2, 2026, `REFERENSI_NINMENI/EMYLTON_Organization_Ownership_Revision_V2.pdf`.
+
+[4] E. Leunufna, *Topological Geometric Intelligence*, `KONSEP.txt`, 2026.
+
+[5] `evidence/acceptance_20260924T201845597182Z/result.json`.
+
+[6] `contracts/CHECKPOINT_SPATIAL_DECISION_V1.md`.
+
+[7] `contracts/FRAME_CRYSTAL_V1.md`.
+
+[8] `evidence/source_distribution_20261004T084916022662Z/result.json`.