SSMDE – Field-by-field walkthrough (1.7)

Exactly what each field means, how to compute it, and how to verify it

value — what happened (untouched)

Carry the factual magnitude or small struct exactly as produced.

# collapse parity (always holds)
phi((m,a)) = m

Rules

• No smoothing / rounding / rescaling
• No unit changes in-flight
• Byte-for-byte reproducible from the source

Examples

temperature_K         : 296.42
cash_collected_usd    : 18420.77
bearing_vibration_rms : 0.037
ai_model_score        : 0.912
heart_rr_interval_ms  : 782


align — how stable / how close to risk (bounded in (-1,+1))

Compute a bounded, replayable stability dial from a raw alignment signal.

# alignment pipeline (normative)
a_c   := clamp(a_raw, -1+eps_a, +1-eps_a)
u     := atanh(a_c)
U     += w * u
W     += w
align := tanh( U / max(W, eps_w) )

Knobs to publish (in the manifest)

eps_a := 1e-6
eps_w := 1e-12
w     := "uniform" | rule (e.g., w := |m|^gamma)

Expected properties

-1 < align < +1
batch == stream == merged-shards   # order-invariant fuse


band — a human / policy label derived from align

Turn the dial into duty-of-care using declared cutpoints.

# example cutpoints (declare in manifest)
A++      : align >= +0.80
A0       : -0.30 <= align < +0.80
A-       : -0.80 <= align < -0.30
CRITICAL : align < -0.80

What band communicates

• Immediate meaning (GREEN / AMBER / RED)
• Expected response (e.g., CRITICAL => human_response <= 10 minutes)

Rule

band := band_from_align(align, manifest_id)
# do not hand-label; always derive via the manifest


manifest_id — the rulebook anchor

Every record must point to the immutable policy that defined its meaning.

manifest_id := "PLANT_A_BEARING_SAFETY_v7"

A manifest declares

• Baseline/lens and math knobs (eps_a, eps_w, weight rule)
• Band cutpoints + escalation promises
• Any gates/filters used before banding

Versioning rule

# if policy changes, mint a new id
"PLANT_A_BEARING_SAFETY_v8"


stamp — proof of time, content, and order (recommended)

Bind the canonical subset to a digest and chain it to the previous one.

# canonical subset (hash exactly this)
canonical(record):
{
  "value":       <as-emitted>,
  "align":       <number>,
  "band":        <string-or-null>,
  "manifest_id": <string>
}

digest := sha256(bytes(canonical(record)))
stamp  := "SSMCLOCK1|" + utc_now() +
          "|theta=" + monotonic_marker() +
          "|sha256=" + digest +
          "|prev="  + prev_digest
prev_digest := digest

Verifier

expect := sha256(bytes(canonical(record)))
assert parse(stamp,"sha256") == expect
assert parse(stamp,"prev")   == last_digest
last_digest := expect


Quick acceptance checklist (copy-ready)

[ ] phi((m,a)) = m holds (value is untouched)
[ ] align computed via clamp → atanh → fuse → tanh and -1 < align < +1
[ ] band derived by manifest cutpoints (not freehand)
[ ] manifest_id resolves to an immutable manifest
[ ] stamp (if present) verifies digest parity and chain continuity


Navigation

Previous: SSMDE – Minimal Record Shape (1.6)
Next: SSMDE – Concrete examples (1.8)


Directory of Pages
SSMDE – Table of Contents