Reading the Edges

A tree has a trunk, and a reader knows what to do with it. Start at the top, follow a branch down, and each step narrows toward a leaf. Remove a branch and the rest survives. The structure tells you where to begin and which way to travel. The Realis corpus is a constraint network. Its documents connect through dependencies, where one condition gates another and the failure of an upstream condition changes what a downstream evaluation means. No single document sits beneath all the others the way a trunk sits beneath its branches. A reader who arrives looking for the trunk will not find one. More than that, the search for a trunk is itself what obscures the structure. While a reader hunts for the thing at the bottom that everything rests on, the dependencies that actually govern movement stay invisible, because they do not run top to bottom. They run from condition to evaluation, across the network, in the direction a failure would travel. The instinct to find a hierarchy is the first thing that sends a reader off course, and it misleads precisely because it looks like the responsible thing to do. What governs movement through this corpus is not depth. It is the edge: the dependency that connects an upstream condition to a downstream evaluation that relies on it. Reading the corpus means reading its edges. This page is how.

When one condition depends on another, the link between them is an edge. The edge runs from the upstream condition to the downstream evaluation that needs it. Authority depends on formation. Verification depends on trace. A correction landing depends on the pathway staying continuous. Each of those sentences names an edge. The edge carries the information a reader needs, because the same upstream failure can mean two entirely different things downstream depending on the edge type. Knowing which document sits upstream of which is not enough. The reader has to know what the upstream failure does to the thing downstream of it. That is the difference between a result worth inspecting and a result that should never have been produced.

When an upstream condition fails, ask what the failure did to the downstream object of evaluation. Did it remove the object, or corrupt it? Removal and corruption are not degrees of the same failure. They are different relationships between an upstream condition and the evaluation that depends on it. One takes away the thing the downstream evaluation was supposed to read. The other leaves something to read and makes it the wrong thing. The downstream symptoms differ, the danger differs, and the correct response differs. The whole of traversal reduces to recognizing which one a reader faces. There is a third move, and it sits one level up from the edge itself. Sometimes the right reading is that this surface should not be entered at all, because the conditions for correction to land are already gone. That move belongs to selection rather than to a single edge, and it is treated in its own section below.

When the upstream condition fails across a validity edge, the downstream evaluation has nothing to run on. No decision state has formed, no signal has arrived, no reference exists. The evaluation either cannot run, or runs and returns nothing a reader can interpret. A validity-edge failure announces itself. The evaluation halts or returns an absence that a competent reader recognizes as absence rather than as a result. The failure is legible at the moment it occurs. The corpus instances this where formation fails beneath the Structural Authority Gate. When no formation rule resolves under load, no decision state forms, and the gate has no formed authority to evaluate. The gate may emit a procedural output anyway, but the authority state it was meant to read does not exist. The reading is to halt at the upstream finding. There is no downstream result to inspect, trust, or correct, because the object the downstream evaluation needed was never present.

When the upstream condition fails across a correctness edge, the downstream evaluation still has an object to run on. The object is the wrong one, or it carries inputs the system has misidentified. The evaluation runs to completion and returns a result that has the form of a valid output and none of its standing. A correctness-edge failure conceals itself. The output reads as ordinary. Nothing in the result signals that the input was corrupt, because the result is structurally well formed. It passes inspection, because inspection examines the output and the output looks like every other passing output. The corruption surfaces later, if it surfaces at all, when the result drives a consequence that does not match the reality it was supposed to describe. The corpus instances this where authority sits upstream of where the record places it. A decision state exists and authority inputs exist, so the gate runs, but it runs on authority the system has mislabeled, and its return points at the wrong actor. The reading is to correct the upstream input first, then re-run the downstream evaluation, and to treat any result produced before the correction as pointed at the wrong object regardless of how clean it looks.

A surface admits structural intervention only where reality contact survives, meaning the declared function is still coupled to observable outcomes through a traceable, verifiable, consequentially bound pathway. Where a valid decision state can still form, where verification still binds to consequence, where custody attaches to identifiable actors, and where pathways stay continuous, the surface admits entry. Where any of those conditions has failed, the surface is disqualified rather than merely lower-ranked. This is the move that runs against instinct. When an institution fails loudly, the pull is to enter where the failure is loudest, because the stakes read as highest there. Reality contact is not distributed that way. Institutions in advanced cascade have usually lost reality contact before the failure became loud enough to draw attention. By the time the urgency signal dominates, the conditions for correction to land are already gone, and effort spent there is absorbed without producing correction. The selection operates on surfaces, not on whole institutions. A single institution often carries surfaces at very different levels of reality contact: one reporting function that still binds decisions to evidence, another function within the same walls that has drifted into declarative mode. The reading is to find the surface that still admits entry, which is frequently a quiet one, and to re-route there rather than to the loud one that no longer passes the gate.

In a hierarchy, where to start is settled by the structure: begin at the top. A network has no top, so the entry point depends on where the reader already enters. A safety engineer tends to enter through standards. A lawyer enters through authority. An educator enters through memory continuity. An AI researcher enters through correction capacity. None of these is the wrong door, and none is more central than the others. What the reader is actually entering on is an edge. Authority depends on conditions that memory continuity preserves, so a reader who enters at authority is one edge away from memory. Correction depends on authority, so a reader who enters at correction is one edge away from both. The doors differ, and the structure reached through any of them is the same, because the dependencies are real and they connect the same way regardless of which one a reader noticed first. This is why the corpus can be entered by concept rather than by sequence, and why there is no single reading order to recover. The order is supplied by the edges, once the reader starts reading them.

Facing any surface, read the selection question first: does this surface still keep reality contact? If it does not, re-route to one that does. There is no value in reading the internal edges of a surface that cannot be corrected. On an admissible surface, read each dependency by its edge type. Where an upstream failure removes the downstream object, halt, because no downstream result exists to interpret. Where an upstream failure corrupts the downstream object, correct the upstream input first, then re-evaluate, and discard any result produced before the correction even when it reads as clean. That is the whole of it. Selection decides whether to enter. Edge type decides what an upstream failure did. The reading is diagnostic throughout. This page names how to read what a reader faces. It does not prescribe what to build once the reading is done, because that decision belongs to the person inside the outcome, and no reading can make it for them.