stratum atlas
Model DocsCorrelation and Effects
M23

Effects Propagation Model

Given a verified shock, who carries it - directly, by co-exposure, and downstream - and how far the documented links actually reach.

Assumptions

Everything the model believes, stated before the math. If you do not buy one of these, do not buy the output.

  1. Propagation walks documented links only (node, queue request, sponsor); similarity or proximity never creates a path.
  2. Direct subjects are the target or carry the shocked object. Co-exposed means exactly one hop from a direct subject through a named mechanism; deeper hops are not claimed.
  3. Downstream subjects are load asks routed through affected nodes, per the corpus convention that asks bind via node_id.
  4. Capacity sums describe exposure, not impact. The magnitude of the effect is UNKNOWN unless a scenario model re-runs; this model never prints an estimated loss.
  5. Direction (ADVERSE / BENEFICIAL) comes from the verified shock input; the model never invents direction.
  6. Subjects with missing linkage cannot be reached or cleared - independence is never asserted.

Derivation

The input is a verified typed shock: event id, target kind (project / node / sponsor / queue_request), target id, and direction. The walk then classifies every reachable subject:

  • Direct: the target itself, and every project carrying the shocked object (a project on the shocked node, sponsored by the shocked sponsor, or holding the shocked queue request).
  • Co-exposed: exactly one named-mechanism hop from a direct subject - shares a node, queue request or sponsor with one. The mechanism is printed on every subject (via list).
  • Downstream: load asks routed through any node carried by a direct or co-exposed subject.

Exposure is deduplicated across layers: one subject appearing on several layers counts once. Capacity sums per class are descriptive exposure:

A co-exposed capacity sum crossing 1,000 MW trips a printed review threshold. Non-propagated subjects - those whose missing node or queue linkage means the walk can neither reach nor clear them - are counted with the reason printed.

Identification strategy

Why the estimate supports the claimed meaning - and where the model refuses to claim more than the data carries.

  • Reach is identified by the graph, not by narrative: a subject appears only with the documented mechanism that reaches it (the via list), so every name on the list is auditable to a link.
  • The one-hop limit on co-exposure is an identification boundary, not a convenience: beyond one hop, shared-mechanism exposure cannot be distinguished from general market linkage without extra assumptions the model refuses to make.
  • Magnitude is deliberately not identified here: converting an exposure structure into a loss requires a distribution shift, which is the Scenario Engine's (M12) job. This model says who is exposed and how much capacity sits in each class; it does not say how bad the shock is.
  • Direction is taken from the verified shock, never inferred from outcomes - the model cannot turn a neutral event into an adverse one on its own.

Inputs and outputs

Reads

Verified typed shock
event_id + target kind/id + direction; verification happens before the run
Frozen typed graph
The shared correlation substrate: documented links only
Load asks
Load requests collection; asks bind via node_id (corpus convention)

Writes

  • Direct, co-exposed and downstream subjects, each with its mechanism (via list)
  • Capacity sums per class (descriptive exposure, never loss estimates)
  • Magnitude: UNKNOWN with the reason (a distribution shift requires an m12 scenario re-run)
  • Unique exposure count; threshold crossings; non-propagated count with reason
  • Direction as given by the shock input

Calibration and gate evidence

Validation design

  • Gates at seal (8 m23-specific): shock on a shared node finds direct subjects; co-exposed subjects named with mechanisms; direction comes from the shock, never invented; magnitude is an honest UNKNOWN with reason; unique exposure dedupes layers; determinism (identical input hash on re-run); audit row written; an unknown target propagates to nobody.

Evidence on record

  • Smoke 27/27 at seal (8 m23 gates incl. determinism, audit row, unknown-target-propagates-to-nobody); capabilities 73/73; acceptance 12/12; slice 46/46; hardening 74/74; tsc clean.
  • Standing caveat: no OpenAI key in the build box; adapter paths unexercised.

Gates at seal

  • smoke 27/27 at seal (8 m23 gates incl. determinism, audit row, unknown-target-propagates-to-nobody)
  • capabilities 73/73; acceptance 12/12; slice 46/46; hardening 74/74; tsc clean
  • standing caveat: no OpenAI key in the build box; adapter paths unexercised

Failure modes

The ways this model declines, degrades or goes UNKNOWN - and what it prints when it does.

  • Unknown target (not in the graph): propagates to nobody - direct and co-exposed lists are empty, and this is gated.
  • Subject with missing node/queue linkage: counted in non-propagated with the reason printed; it is neither reached nor cleared.
  • Load ask with no node binding: cannot be classified downstream and is not forced into the class.
  • Capacity missing on a record: that subject's capacity is UNKNOWN ('capacity missing on record'); the class sum treats it as zero and the class sum is badged INFERRED.

Sensitivity

  • The one-hop co-exposure boundary defines the answer's reach; extending it would require the interaction assumptions the model declines.
  • Downstream classification rests on the asks-bind-via-node_id convention; books whose asks bind differently would need that convention re-ruled before the downstream class means anything.
  • The 1,000 MW review threshold is policy: it flags big co-exposed sums for human review and does not change the arithmetic.

Iron rules

Capacity sums are descriptive exposure, never loss estimates; effect magnitude is an explicit UNKNOWN pending an m12 scenario re-run.

A missing link is never independence.

Source and audit

Written from the sealed model source. Every run is recorded - model version, frozen inputs, input hash, timestamp. There is no unrecorded model execution.