@hviana/sema 0.9.2 → 0.9.4

package/docs/PHILOSOPHY.md

@@ -0,0 +1,317 @@
+# Philosophy — The Path of Information
+
+`docs/INDEX.md` routes the laws. This file follows one piece of information from
+the moment it enters Sema to the moment it is used, and says at each step what
+happens, why it must happen that way, and what it makes possible. One principle
+runs through the whole path:
+
+> **Keep exactly what was given. Build ways of finding it. Decide only on what
+> was kept. Charge for what was not found.**
+
+Every structure below is either something kept (exact, it may decide) or a way
+of finding (approximate, it may only propose). Holding that distinction is what
+lets a reader predict how any part of Sema behaves.
+
+## 1. Information enters
+
+**What enters.** A deposit is a pair, a context and what followed it, or a bare
+experience. That is the only relation Sema assumes of the world: _this came
+after that_. It imposes no schema, no entities and no types. Everything else
+must be discovered from what follows what.
+
+**As bytes.** There is no tokenizer, no vocabulary and no language. A modality
+is only a reading order: text is read as written, and a grid along a Hilbert
+curve, which keeps most of the plane's locality in the stream. Whatever can be
+read as a stream can be learnt.
+
+**Into a tree, cut by the content itself.** A rolling hash runs over the bytes.
+Where it vanishes, a cut falls, and the more digits it vanishes on, the higher
+the cut's level. Higher cuts nest inside lower ones, so the stream folds into a
+tree of about `W` children per node (`W` = 4 by default), level by level
+(`fold-contract.md`). There are three reasons for this shape:
+
+- **Content-defined cuts make identity independent of position.** A phrase is
+  cut the same way wherever it occurs, so in two different deposits it is the
+  same subtree. After a shift, 99.7% of cuts survive, against 14.3% for a fixed
+  grid.
+- **A tree, not a flat list.** Recurrence happens at every scale: a word, a
+  phrase, a sentence. The hierarchy makes every scale a node, so recurrence is
+  caught wherever it happens, and an edit touches only the path from the change
+  to the root.
+- **Nothing is imposed that a later question could not reproduce.** No turn
+  boundaries, no metadata: a question will be cut by the same rule from its own
+  bytes, and any cut it could not reproduce would make the same thing two
+  things. When the two sides disagreed, alignment went quadratic (5.2M cells
+  against 0) and turns asked verbatim stopped resolving to themselves.
+
+**Interned by content.** Every subtree becomes a node named by what it contains:
+a branch by its children, a short run by its bytes. The same subtree in a
+thousand deposits is one node with a thousand parents, so the store is a DAG,
+not a forest. Every window of `W−1` and `W` bytes is also indexed as a node of
+its own and linked to the chunks that contain it, so a span can be found
+whatever the fold did around it. Teaching the same thing twice creates no
+structure.
+
+**Linked by succession.** The context's root gets an edge to the continuation's
+root. Each suffix of the context that is already a known form inherits that edge
+too, and inside a bare experience the parts are chained in order. An edge is a
+unique pair, so how many contexts lead to a continuation counts distinct
+contexts, not repetitions.
+
+**What this structure can answer, exactly:**
+
+- **Is this stored?** Fold it and look the name up. One byte apart is another
+  name.
+- **What contains this, and what is it part of?** Climb the parents and
+  containers.
+- **What followed this?** Read its edges.
+- **How common is this?** Count the contexts that reach it: a minority
+  discriminates, and what reaches nearly everything is scaffolding
+  (`commonality.md`).
+- **What of a question is already known?** Recognition decomposes the question
+  into every stored form inside it that leads somewhere, with a bounded number
+  of probes per byte.
+
+**What it cannot answer:** what is _near_. A content address destroys locality
+on purpose, because that is what makes it a name. `colour` and `colours` are as
+far apart, by name, as `colour` and `Zanzibar`. Everything from here on exists
+because of that gap.
+
+## 2. Two ways of being near
+
+Every node also gets vectors in a high-dimensional space (a vector-symbolic
+architecture: Plate 1995; Kanerva 2009). There are two of them, because there
+are two independent ways for things to be near.
+
+**The gist: nearness of form.** Each byte value has a vector from an alphabet
+built by refinement (16 coarse directions, then 64, then 256), so neighbouring
+values resemble each other. A node's gist binds each child to its position, by a
+fixed permutation per seat, counted from both ends so that growth at one edge
+keeps the other edge's coordinates, and then adds them up. The fold is linear,
+so the cosine of two gists reads how many bytes they share in place. The gist
+exists at birth: it is computed from the bytes alone. It puts `colour` near
+`colours`.
+
+**The halo: nearness of use.** Each time a fact is deposited, two pours happen:
+
+- every newly seen part of the context receives the continuation's signature, in
+  the seat for _what it led to_;
+- the continuation receives each part's signature, in the seat for _what led to
+  it_.
+
+A signature is keyed on a node's identity, never on its gist. Read as whole
+partners, company would almost never recur, since whole deposits rarely repeat.
+So each partner contributes its own signature together with a sketch of its
+constituents: `√D` of them, the capacity of a superposition before each term
+falls below noise, with scaffolding excluded (`halo-sketch.md`). Two words that
+never meet can therefore still share the _kinds_ of things around them. Each
+episode adds one unit, by addition, so order is forgotten and proportion kept.
+The halo is earned by experience. It puts `colour` near `hue`.
+
+**Why two, and why kept apart.** Form and use are different axes of meaning, and
+neither predicts the other. The halo is built from identities and never from
+gists, so that resemblance of spelling cannot leak into resemblance of use. When
+the two agree, it is corroboration, not echo.
+
+**Why vectors at all, and why they never decide.** A vector restores the
+locality the name destroyed. An index over the vectors (RaBitQ-IVF) finds the
+near ones among millions in one query. But a vector is a lossy summary, and its
+score is an estimate. So the space proposes and the structure decides
+(`exact-vs-approximate.md`). The bars are set against the space's own chance:
+random vectors are nearly orthogonal, with noise `1/√D`, so a resemblance counts
+at `3/√D`, and two halos share a concept at `0.5 + 0.5/√D` (`thresholds.md`).
+The single exception is the store's near-merge at deposit, bounded to one window
+of difference.
+
+**Two memories.** The deposits are a record: verbatim, enumerable, each with
+provenance. The halos are a statistic accumulated over that record. This is the
+episodic/semantic distinction (Tulving 1972) with fixed roles: **the statistic
+proposes, the record decides.** A halo can say that two things are of a kind; it
+never says they are the same thing, and it never establishes a fact.
+
+**How the three readings are ordered.** Where Sema looks for a span, it tries
+exact bytes first, then the halo's role, then the gist (`match.ts`). A form
+counts as knowledge only if it _leads somewhere_: it has a continuation, or it
+has a halo. Something that never led anywhere is not used.
+
+**What the vectors add to reasoning.** They add three things:
+
+- **Paraphrase:** a question one byte off its stored twin is found by its gist.
+- **Substitution:** a form with no continuation of its own may borrow a halo
+  sibling's, at the price of a concept hop.
+- **Imagination, bounded:** binding stored parts gives the gist of a whole never
+  seen, which can be searched for. That search is the most approximate tier of
+  all, and is gated hardest, because nothing about it is contained in bytes.
+
+## 3. A question arrives
+
+The question is folded by the same rule as every deposit, and the identity fold
+names each part by asking the store as it folds. So perceiving a question is
+already recognising what of it memory holds; representation and search begin as
+one act. Recognition returns the question's _sites_: every stored form inside it
+that leads somewhere, each with its exact identity.
+
+## 4. Attention, built on the structure
+
+The sites say what the question contains. They do not say what the question is
+_about_, meaning which stored contexts its parts point to together. That is
+attention's job, the consensus climb (`attention.ts`).
+
+1. **Regions.** Every node of the question's tree, and every recognised site, is
+   a region.
+2. **Lookup.** A region that is a stored form looks itself up exactly. Any other
+   region searches by gist, and pays a margin: it must beat the best rival
+   conclusion by the noise floor, scaled by how much of it is not stored.
+3. **Climb.** Each region climbs the DAG, through parents and containers, to the
+   stored contexts it reaches. The climb stops at a named saturation when a node
+   reaches more than `√N` contexts, because past that point reading further
+   cannot discriminate (`saturation.md`).
+4. **Weigh by rarity.** A region that reaches `c` of `N` contexts weighs
+   `ln(N/c)`. This is inverse document frequency, read over structure.
+5. **Agree.** Independent regions add, pooled in the (+, +) semiring of the same
+   deduction engine the search uses.
+6. **Join.** When two regions point to different contexts, the stored whole that
+   contains both is sought, by exact junction first, then through halo synonyms,
+   then by an imagined whole. Exact joint evidence explains the separate votes
+   away.
+
+The output is a set of points of attention: stored contexts where independent
+parts of the question agree, ranked.
+
+Compared with a transformer's attention, which is soft content addressing over a
+context window:
+
+- **The keys are stored contexts,** reached by containment across the whole
+  memory, not tokens in a window. This is cross-attention, from the question
+  into memory.
+- **The weights are rarity,** derived and not learned.
+- **The votes are absolute.** A softmax must attend somewhere, because its
+  weights sum to one. Sema's anchors count only above floors derived from `D`
+  and `N`, so attention can come back empty.
+- **Nothing is blended.** Mixing values would produce bytes nobody deposited.
+  Attention selects, and does not mix.
+- **Exact evidence outranks resemblance.** Only exact evidence may explain a
+  vote away.
+
+Attention is also spent, not assumed. The climb is the shared analysis the
+market defers until no cheaper bound can rule it out (`mechanism-market.md`).
+
+**Why this is the right notion of relevance.** Every judgement of relevance in
+Sema divides a population into what it shares (frame) and what varies (filler).
+Commonality and discrimination are the two sides of that one cut, and the answer
+depends on the population. Sema reads three populations and never confuses them:
+the corpus, the cohort of structures aligned to this question, and the
+containers of a window (`commonality.md`). The rarity weighting is the graded
+form of the cut over the corpus. Attention's deeper role is to _choose the
+population_: its points are the cohort the next steps cut.
+
+## 5. How it is used
+
+**Many ways of thinking.** Each grounding mechanism reads the same material
+differently:
+
+- `cover` composes the question from its sites and follows their edges, by graph
+  search.
+- CAST aligns the attention points to the question and cuts that cohort into
+  frame and filler. It then carries structure between them: substitution,
+  redirection, comparison.
+- `confluence` intersects what independent anchors share, as long as it is not
+  scaffolding.
+- `extraction` reads out a located frame.
+- `reference` learns a frame from worked examples and voices its slot with the
+  asker's own bytes.
+- `recall` takes the nearest stored form by gist.
+- `prefix-completion` completes a known beginning.
+- The ALU computes, and what it computes is authoritative.
+
+**One price.** Every candidate weighs `moves + PASS·unaccounted`, and `PASS` per
+byte of unexplained question outweighs any move (`cost-model.md`). The price is
+not confidence. It is how much of the question remains unaccounted for, so the
+winner is the reading that explains the most. When nothing accounts for the
+question, silence wins, and silence is a first-class answer. An answer that is
+only near says so.
+
+**Reasoning that answers to the question.** The winner may be extended, step by
+step, along succession. A step is admitted only if it closes the derivation,
+moves to structure not yet consumed, or carries what the question still owes
+(`closure.md`). A step counts as _named_ when the question, together with the
+node the step stands on, witnesses one of the contexts that establish it
+(`evidence.md`). A step the question did not name is paid from its remaining
+debt. The question owns the inference, so a chain cannot wander off to a fact
+nobody asked for.
+
+**Generalization, read and never stored.** When no context is named outright,
+attention's points may hold another instance of the question.
+`Where was Peter Jackson born?` shares the frame of
+`Where was the director of film Beat Girl born?`. Peter Jackson's fact is also
+established by `Peter Jackson place of birth`, which is how the corpus spells
+the relation. The node at hand, `Edmond T. Gréville`, is put into that frame,
+and the result is looked up by content.
+
+This is anti-unification (Plotkin 1970): keep what two instances share, put a
+variable where they differ. It is admitted only under three conditions:
+
+- the variable is a thing the store knows;
+- two instances agree;
+- what the corpus files under one filler is not credited to the frame.
+
+The third condition comes from a real failure. Two people born in Wellington
+once gave an unknown `Zorblax` the same birthplace (`test/76`), Goodman's (1955)
+accidental generalization. The frame is never stored, and neither is any answer.
+A conclusion kept as a deposit would become evidence for itself.
+
+**Every answer replays.** The derivation is a hyperpath in an AND/OR hypergraph
+whose axioms are stored nodes (`src/derive/`). Its trace replays byte for byte,
+and ties are broken by the order of teaching, never by chance
+(`determinism.md`). A correction erases nothing. It is a further deposit, and it
+prevails by evidence.
+
+## 6. The path, seen whole
+
+| Step              | What it adds                                   | Kept or finding | It may           |
+| ----------------- | ---------------------------------------------- | --------------- | ---------------- |
+| bytes, fold       | one tree per stream, cut by content            | kept            | decide identity  |
+| DAG, edges        | identity, parthood, succession, commonality    | kept            | decide           |
+| gist              | nearness of form                               | finding         | propose          |
+| halo              | nearness of use                                | finding         | propose          |
+| recognition       | what of the question is known                  | kept            | decide           |
+| attention         | where the question's parts agree; a population | finding         | propose          |
+| mechanisms        | readings of the same material                  | both            | offer candidates |
+| price and closure | what remains unexplained; what may follow      | kept            | decide           |
+
+Representation, search and reasoning are separate modules, but not separate
+ideas. One fold serves deposit and question. One identity serves every lookup.
+One price serves every mechanism. One law admits every step. Everything that
+finds is kept out of every decision, and everything that decides rests on what
+was given.
+
+## 7. Hypotheses the path invites
+
+Each of these follows from a gap visible on the path, and none is a plan.
+
+- **One cut.** Frame against filler is computed in several places: the three
+  commonality measures, `frameSlots`, `coInstanceFiller` and CAST's `depth[]`.
+  Is it one operation read over different populations, or several, as
+  `commonality.md` holds?
+- **Form, use and identity together.** Two forms with near halos that can stand
+  for each other in every stored frame — Leibniz's substitution _salva veritate_
+  — would be one referent. That is aliases (`Clara Novello` and
+  `Clara Anastasia Novello`) seen by the record, with the halo proposing.
+- **Imagination as hypothesis.** Binding stored parts proposes wholes never
+  seen, and today it only joins regions. Proposals made this way, then checked
+  by content, are abduction with a guaranteed verifier.
+- **Derivations as instances.** Anti-unify derivations, not texts, and `father`
+  twice reads as `grandfather` wherever an instance shows it. Derived material
+  must never count as a new context.
+- **Richer company.** The halo has two seats, _what it led to_ and _what led to
+  it_. What other relations of use would a seat capture, and what would they let
+  attention see?
+- **Other streams.** Whatever has a reading order that preserves locality can
+  enter by the same path.
+
+## References
+
+Goodman (1955), _Fact, Fiction, and Forecast_ · Kanerva (2009), _Cognitive
+Computation_ 1(2) · Plate (1995), _IEEE TNN_ 6(3) · Plotkin (1970), _Machine
+Intelligence_ 5 · Tulving (1972), "Episodic and semantic memory", in
+_Organization of Memory_.

package/docs/architecture/evidence.md

@@ -2,8 +2,11 @@
 
 > **Law:** a stored form is identified by the material at hand when every one of
 > its bytes lies in a W-window that material holds — in any order, at any place,
-> and wherever each piece of the material came from. A step the question did not
-> name has to be paid for by material the question still owes.
+> and wherever each piece of the material came from. A form witnessed in every
+> byte but one contiguous span of content is ANOTHER INSTANCE of the same
+> question: it says what the question's relation is, never what it asks about. A
+> step the question did not name has to be paid for by material the question
+> still owes.
 
 ## The operation — `src/mind/evidence.ts`
 
@@ -13,7 +16,8 @@
 (which finds containers). It is exact, deterministic and linear: one index per
 source and one probe per window of the form. A window is credited to the LAST
 source that holds it, so source 0 (the question) is credited only with what
-nothing else at hand supplies. A form shorter than W is never witnessed.
+nothing else at hand supplies. A form shorter than W is never witnessed. The
+form's own unwitnessed bytes come back as its `residue`.
 
 ## Where the material comes from
 
@@ -35,15 +39,119 @@ question nor the first hop's fact, only by both. Measured over 5,236 held-out
 2WikiMultihopQA compositional questions, such a context is wholly witnessed by
 the question alone 69 times, and by the question plus the first hop 2,153 times.
 
+An establishing context is a DEPOSITED context: a predecessor with structural
+parents or containers is a span interned inside bigger forms, and it inherits
+their edges. Witnessing such a fragment named every fact it is a piece of (the
+fragment `born?` named nine strangers' birthplaces on the 2Wiki fixture with
+one-hop questions), so it never counts — the same structural predicate
+`pivotInto` reads.
+
+## Another instance of the question — `coInstanceFiller`, `byCoInstance`
+
+The question rarely spells the relation the way the corpus does.
+`When was the
+director of film Jinpa born?` reaches `Pema Tseden`, whose fact is
+established by `Pema Tseden date of birth`: no window joins `born` to
+`date of birth`, so nothing is witnessed. What joins them is another instance of
+the question.
+
+A **co-instance** is a stored context that shares the question's FRAME, its
+opening and its close byte for byte under the response's equivalence, around ONE
+different filler, and whose filler is a thing the corpus knows: a stored context
+with continuations of its own. `Where was Peter Jackson born?`, read against
+`Where was the director of film Beat Girl born?`, shares `Where was` and `born?`
+and leaves `Peter Jackson`. Three conditions make the reading exact, and each
+was measured necessary:
+
+- **Order.** A frame is not a bag of windows. Read order-free,
+  `Lyon is a city in France` passes for an instance of
+  `what if the capital of France were Lyon?`, which NAMES Lyon, and a
+  coincidental window inside a filler splits it.
+- **The filler is an entity.**
+  `Explain how photosynthesis converts sunlight
+  into chemical energy.` shares
+  a frame with `Explain how photosynthesis
+  works.`, but its slot holds a
+  description of the frame's own subject, and it answers the question. The
+  filler is the longest stored context opening where the slot opens (up to one
+  window earlier: the `T` of `Taika` can sit in the question's `as t`).
+- **The frame is unsaid.** Every frame window must be held by the material, so
+  on the walk a frame a product already said cannot name a second step.
+  `Who is the father of …?` names the second hop of
+  `Who is the father of the director of film Beat Girl?` and not the
+  grandfather. Scaffolding windows are exempt, because they are nobody's
+  evidence (`is` in `Which country Leo Mittler is from?`).
+
+The co-instance's continuation is established by other contexts too
+(`Peter Jackson place of birth`), and the one holding the filler spells the
+relation the corpus's way: a RELATION FRAME, `` · `place of birth`. A frame
+counts only where two co-instances spell it alike. One alignment agrees with
+nothing, which is the bar `reference` holds a frame to (`MIN_INSTANCES`). The
+exact tier's second reading (`byCoInstance`, run only when no establishing
+context is witnessed outright) puts the node the derivation stands on in each
+frame and looks the result up by content: `Edmond T. Gréville place of birth`
+exists, so its continuation is named. Neither the equivalence nor the frame is
+stored as a unit, and nothing is approximate.
+
+**The proposals are the consensus climb's.** The climb already scores the stored
+forms the question's regions reach, and the co-instances are among its points.
+Its scored anchors are published on the question when it runs, and the tier
+reads the `chainReach(W)` most corroborated of them. It climbs nothing of its
+own. A first version climbed every question window itself and cost the 116-query
+battery +16% climb visits for zero namings. Two consequences follow, both
+pinned:
+
+- A pick made before the climb read less evidence than one made after, so the
+  response's pick memo is cleared when the points arrive. Traced and untraced
+  responses agree.
+- Recall's argument binding, which runs before the climb, asks for it first when
+  the argument has several continuations and the question names none outright.
+  That is exactly where the choice would otherwise be blind.
+
+A question the corpus holds verbatim is its own instance and reads no frames.
+Frames are read once per question (and once per walk material), and every node
+pays only the exact lookups.
+
+The same reading refuses the co-instance as an ANSWER, because its own
+continuation speaks of its own filler. Recall's consensus-anchor tier does not
+ground it: `Where was the performer of song God (John Lennon Song) born?`
+elected `Where was Nicki Minaj (Nicki Minaj Song) born?`. Fusion does not fuse
+it as a further topic. A CAST comparison does not take it as its dominant: it
+set `Where was Shakira (Shakira Song) born?` against `John Lennon` and voiced
+Shakira's birthplace.
+
+## Arguments the question holds under the response's equivalence
+
+Recognition matches bytes and the query fold's own boundaries. 2Wiki title-cases
+its questions (`… of film Man At Bath work at?` for the stored `Man at Bath`),
+and a title inside a question lines up with none of the fold's cuts. When
+recall's argument binding finds no recognised argument, the stored forms the
+consensus climb reaches become candidates if the question holds them under the
+response's equivalence (`canonHeldPoints`: canonical containment,
+offset-preserving, so the span is the question's own). The approximate climb
+proposes and exact containment decides. This is read after the clean-resonance
+tier, so a near-identical question pays no climb for it. The canonical-form
+index it relies on is the one the trainer builds after training
+(`buildCanonIndex`, progress.ts).
+
+A fragment that answers other questions is no argument and no independent piece
+of the question either. It is set aside BEFORE the binding looks for one maximal
+argument, so `director` no longer cancels `Man at Bath`. The same predicate
+gates CAST's redirection: the substitute `ong)?`, the tail of every
+`… (… Song)?` question, voiced a stranger's birthplace.
+
 ## Its consumers
 
-| Where                             | What it decides                                                                                                                                                                                                                                                                                                                                              |
-| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `chooseNext` (traverse.ts)        | **The exact tier.** It names the continuation one of whose establishing contexts (other than the node) is witnessed by the question plus the node, with the question supplying at least one window the node does not. It ranks first among the readings; the distributional ladder decides only when nothing is named, or among continuations named equally. |
-| `askedEvidence` (traverse.ts)     | The question spans that named a pick. A mechanism projecting through the pick accounts for them, because evidence travels (mechanism-market.md). Recall's argument binding uses this.                                                                                                                                                                        |
-| `preConsumed` (pipeline.ts)       | When a grounding does not declare `used`, what it spoke for is the forms inside its answer that the question already holds. The entity the answer added stays pivotable.                                                                                                                                                                                     |
-| The walk (reasoning.ts)           | A pivot is NAMED when one of its continuation's establishing contexts is witnessed by what of the question no product has said yet, plus the pivot. A named pivot MOVES. An unnamed one is offered only while the derivation still owes something, and the law then decides by carrying.                                                                     |
-| Cover sites (mechanisms/cover.ts) | A FRAGMENT is a form that sits inside other forms, has several continuations, and leaves at least one window of the question beyond it. It answers other questions, so it leads somewhere for this question only when the question names one of its continuations.                                                                                           |
+| Where                                                                             | What it decides                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| --------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `chooseNext` (traverse.ts)                                                        | **The exact tier.** It names the continuation one of whose establishing contexts (other than the node) is witnessed by the question plus the node, with the question supplying at least one window the node does not. It ranks first among the readings; the distributional ladder decides only when nothing is named, or among continuations named equally.                                                                                                                     |
+| `askedEvidence` (traverse.ts)                                                     | The question spans that named a pick. A mechanism projecting through the pick accounts for them, because evidence travels (mechanism-market.md). Recall's argument binding uses this.                                                                                                                                                                                                                                                                                            |
+| `preConsumed` (pipeline.ts)                                                       | When a grounding does not declare `used`, what it spoke for is the forms inside its answer that the question already holds. The entity the answer added stays pivotable.                                                                                                                                                                                                                                                                                                         |
+| The walk (reasoning.ts)                                                           | A pivot is NAMED when one of its continuation's establishing contexts is witnessed by what of the question no product has said yet, plus the pivot. A named pivot MOVES. An unnamed one is offered only while the derivation still owes something, and the law then decides by carrying. No grounding owns the next step: a CAST grounding used to move through any term inside its answer, unasked (`Who is the director of The Jerk?` walked on to Carl Reiner's citizenship). |
+| `answersOtherQuestions` (traverse.ts) — cover sites and recall's argument binding | A FRAGMENT is a form that sits inside other forms, has several continuations, and leaves at least one window of the question beyond it. It answers other questions, so it leads somewhere for this question only when the question names one of its continuations. Recall's binding read the same fragment (`director`) and voiced the most-poured stranger's fact.                                                                                                              |
+| `byCoInstance` (traverse.ts)                                                      | The exact tier's second reading: the relation read off another instance of the question, transferred to the node by an exact substitution.                                                                                                                                                                                                                                                                                                                                       |
+| Recall's consensus anchor, fusion roots                                           | A co-instance of the question is never voiced as its answer, nor fused as a further topic.                                                                                                                                                                                                                                                                                                                                                                                       |
+| CAST comparison (mechanisms/cast.ts)                                              | A comparison voices two structures, so the question must evidence the analog with a window of its own: neither inside the dominant's runs nor scaffolding. `father of Frederick II?` evidenced `Peter III of Aragon father` only with `father` and `of`, and the comparison glued that bare question onto the answer.                                                                                                                                                            |
 
 A cover span made of nothing but scaffolding (every window a hub,
 `scaffoldSpans`) is not accounted. The form recognised there, such as the song
@@ -85,24 +193,44 @@ memoized per node per question.
 
 ## Measured
 
-| Measure                                                                                | Before | After  |
-| -------------------------------------------------------------------------------------- | ------ | ------ |
-| 2Wiki held-out fixture (300 rows, deposited as `wiki2.ts` does), compositional correct | 13/133 | 47/133 |
-| Same fixture, pivot steps                                                              | 3      | 90+    |
-| Same fixture, inference correct                                                        | 8/37   | 6/37   |
-
-The inference drop is real. Two hops of `father` from a question that says
-`father` once, as in `paternal grandfather`, used to be reached by
-over-extension and are no longer. The store holds no evidence that `grandfather`
-composes `father` twice.
-
-On the 31.7M-node store's 116-query battery, two answers became correct
-(`What country is Jerry Bock a citizen of?` and
-`What is the country of citizenship of Frederick II?`), two lost a junk
-composition, three changed between wrong answers, and no correct answer was
-lost. CPU was 150 s against two baseline runs of 139 s and 166 s, inside the
-noise. The deterministic read counters rose about 20% (`bytesRead`,
-`nodeRecords`), with ANN queries unchanged.
+2Wiki held-out fixture: the evidence triples of 300 validation rows, deposited
+as `wiki2.ts` does, with the canonical-form index built as the trainer builds
+it, and asked the rows' own composed questions. Same evidence "plus instances":
+261 one-hop questions about OTHER entities, built from other validation rows by
+replacing the first hop's phrase with its referent
+(`Where was the director of film X born?` → `Where was Óskar Jónasson born?`)
+and answered with the second hop's fact. No test entity has one.
+
+| Compositional correct (of 133) | Witnessing only (655b192) | Final |
+| ------------------------------ | ------------------------- | ----- |
+| Fixture                        | 52                        | 56    |
+| Plus instances                 | 41                        | 89    |
+
+The first hop is now right on 114 and 109 of the 133. Of the first hops still
+wrong, most name the entity differently from the corpus (`Clara Novello` for
+`Clara Anastasia Novello`). That is an alias, which no byte reading recovers.
+
+Removing CAST's unasked step cost six right answers on the fixture without
+instances: second hops that were right paraphrases taken without evidence
+(`work at`, `is from`, `When was … born`). The same licence produced the Carl
+Reiner extension on the trained store. Without an instance, nothing names those
+relations, and the chain stops at the first hop. The answers gained plus
+instances are those relations: `born` → place of birth, `Why did … die` → cause
+of death, `study`/`graduate from` → educated at, `work at` → employer, `is from`
+→ country of citizenship.
+
+The inference count stays low. Two hops of `father` from a question that says
+`father` once, as in `paternal grandfather`, are not composed: the store holds
+no evidence that `grandfather` composes `father` twice.
+
+On the 31.7M-node store's 116-query battery, two dialogue answers changed
+(neither was correct before). The deterministic read counters rose about 4%
+(`bytesRead`, `ancestorVisits`, `edgeProbes`), with ANN queries up 1%. CPU on
+this workstation varies by ±15% between back-to-back runs of one build, and
+paired runs read 163 s against 152 s and 171 s, then 223 s against 203 s under
+outside load. The co-instance tier read 190 forms over the battery and named
+nothing there: on that store a frame's windows are scaffolding, and the one-hop
+questions it would need are not in the corpus.
 
 ## Pins
 
@@ -110,4 +238,19 @@ noise. The deterministic read counters rose about 20% (`bytesRead`,
   most-poured one. The second hop is named by the question plus the introduced
   entity, whatever grounded the first hop. A question that names no further step
   is not extended. A fragment voices none of its continuations unless the
-  question names one. Each assertion was verified by mutation.
+  question names one, in the cover and in recall's argument binding. A
+  comparison needs two things named. An argument held only under the response's
+  equivalence binds. Each assertion was verified by mutation.
+- `test/155` — the relation read off another instance of the frame; absent
+  without two instances that agree; refused for a partly shared frame; never
+  voiced as the answer; a frame a product already said names no further step; a
+  description in the slot is no other instance; traced and untraced responses
+  agree; fusion does not fuse a co-instance, nor does a comparison take one as
+  its dominant. Verified by mutation.
+- `test/76` — a fact the corpus files under an instance's filler is no carriage:
+  `reference` does not construct one for a new referent.
+- `test/29` C3 — a further hop inside a comparison's seat waits to be asked.
+- Unpinned, measured only at fixture scale. Excluding fragments from
+  establishing contexts is worth 16 answers on the fixture with one-hop
+  questions. Refusing a fragment as CAST's redirection substitute is worth four.
+  Fragments with inherited edges appear only at that scale.

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://jsr.io/schema/config-file.v1.json",
   "name": "@hviana/sema",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "exports": "./src/index.ts"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hviana/sema",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "Sema: a non-parametric, instance-based reasoning system.",
   "repository": {
     "type": "git",

package/src/meter.ts

@@ -275,6 +275,12 @@ export class Meter {
    *  came back at the √N cap, or its predecessor budget ran out before every
    *  continuation was asked about — the distributional ladder decided. */
   askedReadsSaturated = 0;
+  /** Picks named by a CO-INSTANCE of the question — another instance of its
+   *  frame whose continuation carries the relation over to this node by an
+   *  exact substitution (traverse.ts, `byCoInstance`). */
+  coInstanceNamings = 0;
+  /** Proposed co-instances that tier read and witnessed. */
+  coInstanceReads = 0;
   /** Cover sites dropped as FRAGMENTS whose several continuations the question
    *  names none of (mechanisms/cover.ts). */
   unaskedFragments = 0;

package/src/mind/evidence.ts

@@ -63,6 +63,12 @@ export interface Witnessing {
   spans: Array<[number, number]>;
   /** Bytes of source 0 inside `spans`. */
   bytes: number;
+  /** The form's own bytes no source witnesses, as merged spans of the FORM —
+   *  empty exactly when `complete`.  ONE residue span is the shape of a
+   *  co-instance: the same frame around a different filler (`When was Peter
+   *  Jackson born?` read against `When was the director of film Jinpa
+   *  born?` leaves `Peter Jackson`). */
+  residue: Array<[number, number]>;
 }
 
 /** Witness `form` against `sources` (their window indexes, same order).  A
@@ -73,8 +79,14 @@ export function witness(
   indexes: ReadonlyArray<WindowIndex>,
   W: number,
 ): Witnessing {
-  const none: Witnessing = { complete: false, spans: [], bytes: 0 };
-  if (form.length < W || indexes.length === 0) return none;
+  if (form.length < W || indexes.length === 0) {
+    return {
+      complete: false,
+      spans: [],
+      bytes: 0,
+      residue: form.length > 0 ? [[0, form.length]] : [],
+    };
+  }
   const covered = new Uint8Array(form.length);
   const own: Array<[number, number]> = [];
   for (let o = 0; o + W <= form.length; o++) {
@@ -93,7 +105,13 @@ export function witness(
     covered.fill(1, o, o + W);
     if (from === 0) own.push([at, at + W]);
   }
-  for (let i = 0; i < form.length; i++) if (!covered[i]) return none;
+  const residue: Array<[number, number]> = [];
+  for (let i = 0; i < form.length; i++) {
+    if (covered[i]) continue;
+    const last = residue[residue.length - 1];
+    if (last !== undefined && last[1] === i) last[1] = i + 1;
+    else residue.push([i, i + 1]);
+  }
   own.sort((a, b) => a[0] - b[0]);
   const spans: Array<[number, number]> = [];
   for (const [s, e] of own) {
@@ -103,5 +121,5 @@ export function witness(
   }
   let bytes = 0;
   for (const [s, e] of spans) bytes += e - s;
-  return { complete: true, spans, bytes };
+  return { complete: residue.length === 0, spans, bytes, residue };
 }