LEXICON.md

Lexicon

The working vocabulary for pattern-buffer. One name per concept, used identically in code, docs, tests, and specs. A term not in this file is added here before it is used twice.

The two rules

1. The double-read test. Every exported name (class, function, CLI command) must parse correctly for an engineer with zero Star Trek context. Canon homage that only works as fan service stays out of the code and lives in doc prose.
2. Nouns carry the flavor; verbs stay boring. The operation algebra (set, relate, event, resolve, retract, merge, refer) and the role matrix (Ingestor, Classifier, Resolver, Projector, Renderer) keep plain engineering names — they are authority boundaries and must be instantly legible.

Working terms (code symbols)

Term	Definition	Double-read
World	The named, individual unit: one PatternBuffer + its physics (resolution policy + decay configuration) + derived indexes. The thing hosts bind to, name, and ship.	Universal.
PatternBuffer	The append-only assertion log — the only truth (P1). Each World owns exactly one; a buffer never holds two worlds; a world never spans two buffers (the 1:1 invariant). world_id is lineage/identity; the file is the buffer instance — never-joined playthrough forks may share a world_id (whitepaper A5).	Trek: holds the pattern between materializations. Systems: a buffer of patterns (cf. protocol buffers).
materialize() / Materialization	The projector's read: (scope, as_of, frame, lens, budget) → the world served from pattern.	Trek: rematerialization — re-entry exactly as left. Databases: a materialized view is the canonical term for a derived, disposable projection over a log. Both readings are precisely correct.
neighborhood()	A bounded read around one entity: folded subject state plus identity-closed structural neighbors across containment, lateral, relation, and event axes.	Plain graph/search vocabulary; kept bounded, not a query language.
part_of / composition axis	The compositional structural relation (PLACE-FEATURE-ABSTRACTION-V1) — a burrow part_of a hillside, a desk part_of an office. A separate axis from containment: composition is constitutive structure (the part doesn't move out), containment (in) is movable location. A core structural predicate, classified CONSTITUTIVE, valid-timed (dug/boarded); a relating edge for identity (evidence against), never a containment merge-veto. locate/contents/route ignore it.	Plain (mereology: part-of-the-whole).
composition() / features()	The two compositional reads, mirroring locate/contents on the part_of axis: composition(e) walks the chain up (the entity's place-in-the-structure); features(p) returns the part_of-children (a place's sub-features). A sub-place is one entity answering both the place lens (locate/contents/route/state) and the feature lens (these) — structural retrieval-invariance, the compositional sibling of AKA's identity union. Both halt on a conflicted parent — never silently pick.	Plain.
salience()	A derived projection-time ranking score used to order neighborhoods and budgeted materializations. It never changes validity and is never stored as truth.	Plain attention/retrieval vocabulary.
aggregate()	A bounded collection rollup: sum, count, min, max, or avg over numeric folded values on a container's contents(), optionally recursive.	Plain analytics vocabulary; computed from present facts, never stored.
confidence()	A derived trust score for one functional folded key: provenance × recency × corroboration (halved if conflicted). Recency is mode-scoped (TRACKING-MODE-V1): permanent in fiction/deny worlds (the page is true — story-time liveness is salience's axis, not trust's); in tracking worlds it decays with unconfirmed wall time under the declared DecayPolicy, with fail-closed unconfigured/unconfirmed null branches (excluded + renormalized, never faked). Payload carries recency, recency_status, last_confirmed_at_wallclock (the "last confirmed June 19" join; null in fiction) beside last_observed_at (valid-time, both modes). frame may be a list — trust over the read-union (knows:O ∪ public). Validity untouched; never stored (the membrane).	Plain; the temporal-trust sibling of salience (relevance).
DecayPolicy / decay_halflife_seconds	Tracking-world time physics as declared, rebuildable data (TRACKING-MODE-V1): attr:<key> · decay_halflife_seconds · <finite positive n> rows, resolved exact-authored-attribute → attr:in (the public containment-family subject) → attr:__world__. Read fresh at each read (current-physics-over-history); malformed declarations skip-receipt at the gate. Deliberately separate from AttributeSemantics — decay is physics, not fold semantics. Selects on policy == "observe_or_unknown" only, never stance (the no-bias invariant: the engine never judges what can exist, in either stance — skepticism is structural, from conflict and corroboration, never ontological).	Plain (radioactive half-life).
situation lens	A materialize/snapshot lens for re-entry: the standing-truth fold ∪ only the live events anchored to the scope, with closed history dropped. The middle path between current_state (no events) and what_happened (all events). Derived every read, nothing stored.	Plain; "what's the situation here" reads in fiction and reality alike.
live thread	An event still worth surfacing on re-entry: one with an open thread (an unresolved winner with no resolved_by) or a surviving effect (a state it produced still un-superseded). The exhaustive partition of engine-knowable present relevance — a settled current fact or an open current question; anything else is host judgment. Anchored by where the live effect sits (walk back via caused_by), never by who participated. Computed, never stored; "dead" means "left no surviving effect," so suppressing it is correct, not lossy.	Plain.
Degradation	The named failure class: served state contradicting the buffer — drift, contradiction, mutated canon. The test suite's core negative assertion is "no degradation."	Trek: buffer/holomatrix degradation. Systems: data degradation.
Frame	Perspective scope on every assertion: canon, knows:<entity>, named frames. Carries knowledge, contested truth, and privacy by structural absence.	RDF named-graph heritage; kept plain deliberately.
who_knows()	The computed inverse of frame_diff (WHO-KNOWS-INVERSE-V1): given a fact (entity, attribute[, value]), the knows:* observer frames that know it — a frame qualifies iff its folded winner is present and value-matches (identity-aware). Derived from the frames that exist, never a stored known_by edge (which would breach the membrane); folded-not-raw, so a superseded/retracted belief drops.	Plain (the "who is aware of X" transpose).
Thunk	An explicitly unresolved aspect with a resolution policy. Forced exactly once; memoized forever. Thunks can move without resolving.	CS-canonical (lazy evaluation).
deny thunk	The established-unknowable state of the unknown: an unresolved aspect whose policy refuses resolution, carrying a reason. A positive assertion that a thing is canonically unknown (the mystery box). Distinct from an absent row (unestablished) and a stored tag (a membrane breach).	Plain.
relational absence	The doctrine (whitepaper A6) that the unknown is never stored or inferred — only the computed gap between two populations of present facts, across frames (frame_diff; the N-observer knowledge lattice) and time (freshness = now − t).	Plain.
membrane-test	The guard: could the engine recompute this row from other present facts? then it is derived and must never be stored — only an irreducible observation may be a fact. Sibling to RFC-001's rejection-test.	Plain (cell membrane: derived stays out of the log).
frontier	The explicitly-unresolved region: the thunk table plus everything below the resolution floor. Where nothing has been established, the system serves no invented detail.	Robotics-canonical (occupancy-grid mapping); heritage is the lidar ingestion parallel.
delta	A value_type for a signed numeric increment. It is admitted like any other row and only folds into totals for attributes declared accrue.	Plain math/database vocabulary.
accrue	A fold policy for fungible quantities: latest absolute numeric baseline plus later signed deltas.	Accounting-canonical.
quantity / ledger	The derived numeric total / the append-only rows that produced it. Totals surface through FoldResult.quantity and Materialization.quantities; the ledger remains ordinary assertions.	Plain accounting.
exact decimal / $decimal	An exactly-folding quantity (money, any real ledger): a Python Decimal in memory, the reserved tag dict {"$decimal": "12.50"} on every JSON boundary (storage, dump, host payloads). Authored scale is preserved (12.50 ≠ 12.5 in a value match); mixing exact-decimal with float in one fold raises (Decimal+int is fine); fold arithmetic runs under one fixed context (prec=50, HALF_EVEN) for byte-determinism. The tag key is reserved in value-space — only an exact one-key, finite-parseable dict is ever reconstructed.	Standard JSON convention for typed scalars ($-prefixed tag).
route()	Passability-aware routing (RFC-003): the structural path() graph with each portal segment classified clear/blocked/obscured under the host's declared traversal policy. Two-pass (classify, never delete-then-BFS); returns evidence for blocked, a computed unknown_basis for obscured. path() stays structural; route() owns passability.	Plain navigation vocabulary.
portal	An entity (door, gate, hatch) mediating a connects_to passage, carrying durable states (open/shut/locked) and obstruction relations (guarded_by). A blocked way is world detail on the portal — derived, inspectable, sticky — never a stored edge label.	Plain.
traversal policy	A host-declared, kind-scoped sidecar (traversal:<kind> with blocks_when_state/blocks_when_relation) saying which portal facts gate passage — so a shut door blocks but a shut cabinet does not. The engine reads the declaration (data, RFC-001 pattern), never host vocabulary. No policy ⇒ no obscured/blocked guess.	Plain.
Anchor	Composite identity signals on an entity: names/aliases, roles, recurring locations, distinguishing features.	Plain.
distinct_from	The authored anti-merge primitive — the inverse of same_as ("definitively not the same"). A hard merge veto; written by reject(). Keeps two same-named entities (two Clays, two bedrooms) apart against the auto-merger.	Plain (set-theoretic complement of identity).
aka	The third, non-collapsing identity relation (AKA-CORRELATION-V1) — between same_as (collapse) and distinct_from (separate). Two entities are facets of one identity (a reveal, a dual persona, an amalgamation) without merging: each keeps its own rows; the link is a valid-timed edge (valid_from = reveal). Stays out of resolve()/closure() and every default read; written by the guarded correlate() (vetoed by distinct_from). "The unknown of identity."	Plain (also-known-as).
correlation-union / state_union()	The explicit, opt-in correlated read: folds one key over an entity ∪ its aka facets (each expanded through same_as), as-of — returning the same view whether facts were authored on one entity or split across correlated facets (retrieval-invariance). Never a default read; as-of-before a reveal returns the uncorrelated view (no leak). Mirrors the knows:O ∪ public opt-in union. correlations() lists the facets as-of.	Plain.
reconcile() / adjudicate_deferred()	The two host-invoked identity finalize passes. reconcile() merges confident cross-chunk coreferents by shared anchor through the auto-gate and records the rest as proposals. adjudicate_deferred() (SHAPE-FIX-V1) merges only the structurally-decisive open proposals — anchor subsumption: a pure name-fragment whose entire distinctive anchor set ⊆ the other's (tovin ⊆ tovin beck) — leaving the semantic trap as residue. Both zero-model, deterministic, idempotent.	Plain (accounting reconcile).
retype()	A typing correction distinct from merge (SHAPE-FIX-V1): the containment veto blocks a merge, never a kind fix. absorb=None corrects one mistyped entity's kind (wrong kind rows retracted, correct one appended + classified); absorb=<target> absorbs a spurious duplicate at the wrong kind (person:harth shadowing place:harth) — slip signature verified, only the inter-closure artifact edges retracted (real child containment preserved), then a guarded merge. Never a veto bypass: a non-slip call is vetoed_not_a_slip.	Plain.
typing_conflicts()	Read-only surfacing of typing-slip candidates (SHAPE-FIX-V1): same-anchor cross-kind pairs carrying the slip signature (an outgoing-bare spurious twin beside a structurally real entity). reconcile() never re-proposes hard-blocked pairs, so without this read the slips are invisible; the host adjudicates each with retype().	Plain.
durable-contradiction veto	The kind-check generalized to every standing fact (SHAPE-FIX-V1): two entities whose shared, present, durable (CONSTITUTIVE/DISPOSITIONAL) attributes hold contradictory folded values are probably two things — auto-merge soft-declines to a proposal (a retrieval lead and a defense apprentice don't fuse on a shared first name). STATE differences (mood, position) never trigger it. Surfaces as decline code durable_contradiction.	Plain.
malformed-id gate / phantom suppression	The ingest defenses (SHAPE-FIX-V1) that kill non-diegetic entities at the source: an id violating the grammar (person:/you) is skipped with a typed malformed_id receipt, never normalized (that would manufacture the phantom well-formed); the extractor suppresses narrative-voice entities (the narrator is not a person); and pov (a validated viewpoint entity id) binds the full scoped deictic family (singular I/me/my/mine/myself + addressed you/your/yours exclusively; plural we/us/our/ours inclusively, never exclusive ownership) to the protagonist instead of minting a new person. Runs after the authority gate, so a violation still raises.	Plain.
merged_self_edge	The skip-receipt reason distinguishing a MERGE footprint from an authored bug (INGESTION-FIDELITY-V2 §D): a containment edge whose raw subject and value differ but resolve to one identity head post-same_as receipts merged_self_edge (both raw ids retained — actionable diagnosis); an authored self-edge keeps the original cycle reason. Gate behavior identical — the row never enters.	Plain.
entities() / facts()	The two frame-bounded roster/scan reads (BOUNDED-READS-V1). entities(frame, prefix=) lists the entity ids a frame carries; facts(frame, …) returns that frame's visible rows as Fact dicts for audited scans (receipt trails, knowledge digests), never folds. frame is required on both — a prefix-only enumeration would leak cross-frame entity existence (the §6 absence discipline applied to enumeration).	Plain.
build session	The porcelain build lifecycle (BUILD-SESSION-V1): begin_build(at=) enters defer-classification mode, seal_build(scope=) runs one classification pass at the end ("session" rows or "all" log), abort_build()/World.close() restore the toggle and classify nothing. with p.build(): is the context-manager sugar. A host-workflow concept living on the porcelain — the engine's classifier stays ignorant of it.	Plain (build/seal a scenario).
axis_heads()	The log's two-axis high-water mark (AXIS-HEAD-V1): asserted_head (the seq head) and valid_head (MAX(valid_from) over all rows, all frames — the entry-epoch read). A coordinate scalar, never content: no entity/attribute/value/frame crosses (distinct from horizon, the play/read cutoff).	Plain.
fidelity_audit() / name_collisions	The structural ingestion-fidelity read (INGESTION-FIDELITY-V1): derives where a freshly-built log is incomplete — name_collisions (distinct ids sharing a name/alias, each pair annotated correlated/hard_blocked/typing_slip/auto_declined/unlinked — the coreference-fragmentation metric, the tracked number driven down), unstamped_timed (classified STATE/EVENT off the time spine — rows the sidecar judges CONSTITUTIVE/DISPOSITIONAL sit outside this STATE/EVENT-only bin; their valid-time correctness is a separate extraction contract — acquired standing facts still carry valid_from; INGESTION-FIDELITY-V2), orphan_entities (unanchored obj:/person:), open_conflicts. Composes the shipped identity per-pair predicates over a frame/as-of-scoped candidate set; membrane-clean (derive-don't-store, zero writes). The engine surfaces gaps; the host joins arc/cast severity (host meaning, never engine) and drives targeted re-extraction.	Plain (a build/QA audit).
porcelain	The frozen, typed, JSON-serializable host contract (porcelain-v0.1; world.porcelain) — the verb set a host integrates against, additive-only from the tag (params gain defaults, verbs are added; nothing renamed/removed/re-typed). The operation algebra (§12) is the engine's internal surface; the porcelain is the public one. A reach below it signals a missing verb, not a missing capability.	Plain (plumbing vs. porcelain — the exposed fixtures over the internal pipes).
Scene cursor	The ingest-time "where is the narrated action happening" pose. The largest single precision multiplier in ingestion.	Heritage: lidar pose estimation, not Trek.
arch	The operator's inspection CLI: dump the buffer, query as-of, audit provenance — without touching the world.	Trek: "Computer, arch!" — the operator's control interface inside the simulation. Allowed in code as a tool nickname, not an API symbol.

Doc glosses (metaphor layer — docs and README only, never code)

Gloss	Maps to	Canon note
a pattern buffer that never degrades	The project thesis	Relics: Scotty survives 75 years suspended in a pattern buffer rigged against degradation, rematerialized exactly as he entered. The drawer test, personified.
a holomatrix	A World	The complete structured representation of one program; see The Swarm for what degradation does to one. Rejected as a code symbol (fails the double-read); preserved here as the canon mapping.
a ship in a bottle	The portable .world file	Ship in a Bottle: Moriarty's entire persistent universe, self-contained in one box. A world's durable identity is one file plus its policy row — copy it, ship it, archive it.
you see the grid	The frontier	The empty holodeck grid: bare substrate visible wherever nothing is materialized. "Where nothing has been established, you don't get invented detail — you see the grid."

The decoder paragraph (for the README)

The buffer holds the pattern; materialization is re-entry; degradation is the failure we exist to prevent; the arch is how the operator steps outside the world to inspect it; and where nothing has been established, you see the grid.