Build / Concepts

Eight terms, exactly.

The API is small because the substrate is specific. These are the words the routes use, defined by the mechanics behind them rather than by analogy.

spatial path

UTF-8 bytes -> signed integer lattice -> integer Haar -> blake2b invariant
            -> 4-axis node -> directed edges -> cascade -> emission

Observation

An observation is text encoded as UTF-8 and projected verbatim onto a signed integer lattice. There is no normalization, tokenization, or embedding step. The bytes determine the structure; the text is carried as an epithet.

Invariant and node

The lattice is decomposed by an integer Haar transform. A blake2b invariant binds that spatial signature to the temporal matrix. The invariant becomes a node in a four-axis hypergraph and is returned as a 16-character hexadecimal hash.

Node identity is structural. The readable text is not the identity. Two texts that share a block structure can resolve to the same invariant; the epithet remains the readable projection.

Relation and edge

A relation is a validated directed edge between nodes. Edges are what traversal reads. Admitting a node does not create a relation; admitting a sequence does.

Sequence

/observe-seq admits an ordered list of epithets and wires consecutive nodes as directed transitions. The order is part of the evidence. A sequence also records a song when it is long enough, which the emission layer can use.

Cascade

The cascade is the four-tier inference path that proposes a traversal. It is deterministic: the same substrate, inputs, and configuration produce the same proposal. It does not sample candidates and it does not call a model.

Seam

A seam is a missing or fractured relation. A missing anchor is not invented: /emit on an unknown hash returns UNKNOWN_SEAM. The seam is an answer about the substrate, not a transport error.

Emission

Emission projects a traversal into an answer. The default mode constructs a song over the admitted graph; the direct mode retrieves along a forward index. The engine seals the result internally with a sigil and a structure digest.

The HTTP routes return the text projection and verdict. The full sealed result - traversal path, sigil, steps, and structure digest - is available through the Python engine, not the hosted JSON surface.

Derivation

Derivation reconstructs a justification between a source and a target. A candidate edge must pass quarantine, counterfactual perturbation, retrograde credit, and a monotonic gate before promotion. The HTTP route reports whether promotion occurred.

A true multi-premise join is not currently expressible in an emitted proof because each step carries one parent index. That is a named limitation, not an implied capability.

Determinism

No sampling and no temperature.
No floating point in the spatial path; fixed-point arithmetic is integer Q32.32.
Same input, state, and configuration produce the same invariant, trace, and seal.
Server calls are serialized so ordering is deterministic.

Three readings

Reading	Mechanic
`working_memory`	Residual strain carried by the manifold.
`staging_memory`	Candidate edges currently in quarantine.
`strict_mode`	True when the seam halt latch is not set. Alias: `grounding_guard`.

Next: Quickstart for the calls, or HTTP API for the contracts.

Start

Build

Reference