SSMT – Bounded Dials, Hysteresis Memory, and Gentle Safety Near the Edge (3.4–3.6)

Why SSMT replaces brittle freeze/boil cutoffs with smooth, replayable risk dials.

3.4 Why bounded alignments (and safe pooling)
We don’t want raw numbers to explode or dominate. We want clean, bounded “how bad is it” dials that can be averaged safely across sensors, rooms, or subsystems.

Alignment channel (optional):
a_T := tanh(c_T * e_T)
a_T := clamp_a(a_T, eps_a)
• c_T > 0 controls sharpness.
• clamp_a(a_T, eps_a) enforces |a_T| <= 1 - eps_a, usually with eps_a = 1e-6.

What this gives you:

  • a_T always lives in (-1,+1).
  • Large spikes in e_T can’t blow up dashboards or ML.
  • You can compare different assets fairly because the dial is bounded.

Now suppose you have multiple sensors (array/fleet pooling). You want one “fleet dial” that respects all of them without letting one outlier dominate.

Use rapidity pooling (safe, associative, order-invariant):

  1. Transform each bounded dial with atanh() (rapidity).
  2. Take a weighted mean in that space.
  3. Map back with tanh().

In ASCII:

U := sum_i ( w_i * atanh(a_i) )
W := max( sum_i w_i , eps_w )
a_pool := tanh( U / W )

• w_i are weights like confidence or health; default is all 1.
• eps_w is a tiny positive guard like 1e-12 so you never divide by 0.
• Output a_pool still lives in (-1,+1).
• Associativity means you can group sensors arbitrarily (per room, per rack, per wing, then per site) and get the same final result.

So:

  • a_T is a “how hard are we pushing the limit?” dial.
  • a_pool is “how hard is the group pushing the limit?” in a mathematically safe and replayable way.

This is perfect for fleet dashboards, SLAs, safety control, and ML priors.

3.5 Phase proximity and soft hysteresis (why it is gentler and safer)
Legacy logic:
“If temperature <= 0 °C, freeze alert. Else no alert.”
That logic flickers like crazy near the boundary. It also ignores how far into danger you are.

SSMT logic replaces that with continuous, signed depth.

Single-pivot phase dial (one critical point like freezing, warp point, gel point, human danger band):

d_m := (T_K - T_m) / DeltaT_m
a_phase := tanh( c_m * d_m )

• T_m is the pivot (e.g. 273.15 K for freezing water).
• DeltaT_m > 0 is the softness width (“how wide is the danger band?”).
• c_m > 0 is sharpness.

Interpretation:

  • a_phase ≈ -1 means “well below pivot” (solid / too cold / brittle).
  • a_phase ≈ +1 means “well above pivot” (liquid / soft / safe side).
  • Sign tells you which side you’re on.
  • Magnitude tells you how deep you are into that side.

Multi-pivot fused dial (if you care about multiple transitions, e.g. freezing AND boiling, or gel point AND warp point):

  1. Normalize each pivot i into a dimensionless contrast:
    z_i := c_m_i * (T_K - T_m_i) / DeltaT_m_i
  2. Optionally weight each pivot by importance (w_i > 0).
  3. Combine them in a stable way:
    W := max( sum_i w_i , eps_w )
    z_bar := (1 / W) * sum_i( w_i * z_i )
  4. Bound it:
    a_phase_fused := tanh(z_bar)
    a_phase_fused := clamp_a(a_phase_fused, eps_a)

Key rule: emit either a_phase (single pivot) OR a_phase_fused (multi), not both.
You also carry tags like "water", "propellant", "skin_safety_band" so downstream systems know what that dial actually corresponds to.

Now: hysteresis. Even if you’re hovering around T_m, you don’t want “safe / risk / safe / risk / safe / risk” spam every few seconds.

SSMT gives you Q_phase, a soft memory:

p_side := 0.5 * (1 + tanh( k_side * (T_K - T_m) ))
Q_phase := rho * Q_prev + (1 - rho) * clip(p_side, 0, 1)

• k_side > 0 controls how sharply you flip sides.
• rho in (0,1) controls memory — higher rho means you require longer dwell before saying “we truly switched state.”
• Q_phase stays in [0,1]. Near 0 = cold side, near 1 = hot side.
• You alert off Q_phase, not off raw temperature, so flicker drops dramatically.

Result:

  • You get a smooth dial of “how dangerous is this band and on which side are we?”
  • You get a debounced memory of which side you’ve effectively been on.
  • Operators (or ML) can now act on stability, not on noise.

This is hugely important for cryo storage, human exposure safety, structural fatigue, mission survivability, etc.

3.6 Keeping it simple (anti over-engineering guardrails)
SSMT is designed so teams can start tiny and only grow if they truly need it.

Recommended path:

Step 1 — S1 (Lite)
Emit only:

  • e_T (the unitless contrast around T_ref)
  • manifest_id
  • health flags like range_ok

No phase dial. No alignment dial. No pooling.
This already kills °C/°F confusion and gives you portable thresholds like “hot anomaly if e_T >= +0.8”.

Step 2 — S2 (freeze / survival matters)
Add:

  • a_phase (or a_phase_fused)
  • Q_phase

Now you have a clean survivability dial and flicker-resistant alerts near critical pivots (freeze, gel, warp, human safety band).

Step 3 — S3 (fleet / ML / gating)
Add:

  • a_T (bounded alignment dial from contrast)
  • pooling rules (rapidity mean with weights)
  • gating lane g_t if you want environment-driven throttles
  • optional validation hooks (datasets, thresholds, dwell times)

Only go to S3 if you truly need pooled dashboards, ML priors, or automated gating.

The principle:
You never rewrite S1 streams. You only add fields in a way that is replayable and formally declared in the manifest.
Policy, audit, ML, insurance, safety — everyone can reason about the same symbolic language.

Navigation
Previous: SSMT – Why SSMT Works in the Real World: Zero Drama, Safety Dials, Fleet Control (3.1–3.3)
Next: SSMT – Validation, Human/Machine Boundaries, and Practical Limits (3.7–3.11)

Directory of Pages
SSMT – Table of Contents