SSMT – Encoding SSMT: Kelvin, Lens, and Contrast (1.1–1.3)

The three irreversible steps: get to Kelvin, choose one lens, compute `e_T`

This is the core pipeline every SSMT stream must follow.
After you do this once, everyone downstream — ops, ML, audit, even another planet — is speaking the same thermal language.

1. Standardize to Kelvin (1.1)
Everything starts here. Temperature must first become Kelvin, with a safety floor.

to_kelvin(T_raw, unit):
    u = lower(unit)  # accept "C","c","celsius","F","fahrenheit","K","kelvin"
    if u in {"k","kelvin"}:
        T_K = T_raw
    elif u in {"c","celsius"}:
        T_K = T_raw + 273.15
    elif u in {"f","fahrenheit"}:
        T_K = (T_raw - 32) * 5/9 + 273.15
    else:
        raise "unknown unit"

    # Kelvin floor for numerical safety and domain sanity
    T_K = max(T_K, eps_TK)
    return T_K

Key points:

eps_TK > 0 (for example 1e-6) prevents divide-by-zero issues in low-temperature math and makes sure T_K never hits or crosses 0 K numerically.
Keep at least 0.01 K of precision internally.
Attach UTC timestamp and sensor identity outside this function. The conversion step is purely physical.

Why Kelvin first?

°C vs °F fights disappear immediately.
You can safely apply one global logic path to all sources.

After this step you are no longer “reading a building sensor.”
You are producing a physically grounded value in Kelvin, with a declared floor, that any downstream system can trust.

2. Pick exactly one lens and keep it fixed (1.2)
Now that you have T_K, you map it into a unitless contrast e_T.
That contrast is what everyone actually consumes.

You must choose one lens for the deployment, publish it, and not quietly change it mid-run.

Available lenses:

# Default (log lens; good across wide ranges, cross-fleet, cross-environment)
e_T := ln( T_K / T_ref )

# Linear (tight industrial / HVAC-style bands)
e_T := ( T_K - T_ref ) / DeltaT

# Beta (cold-dominant / cryogenic / near-freezing sensitivity)
e_T := ( T_ref / T_K ) - 1

# kBT (chemistry / reaction / per-mole energy framing)
e_T := (R*T_K)/E_unit - (R*T_ref)/E_unit

# Hybrid (piecewise: sensitive near nominal, robust at extremes)
if abs(T_K - T_ref) > tau:
    e_T := ln( T_K / T_ref )
else:
    e_T := ( T_K - T_ref ) / DeltaT

# qlog / quantum-safe log (near 0 K; stabilize the math close to absolute zero)
e_T := ln( (T_K/T_ref + alpha) / (1 + alpha) )

Where:

T_ref is your declared reference temperature in Kelvin.
DeltaT is your declared scale width in Kelvin.
E_unit is a chosen energy-per-mole scale.
tau is a temperature offset threshold (Kelvin) where you switch behavior in the hybrid lens.
alpha > 0 is a stabilizer constant for the qlog lens.
R is the gas constant (8.314462618 J/mol/K).

All lenses are:

monotone in T_K,
zero-centered at T_ref (e_T = 0 when T_K = T_ref),
unitless.

How to choose (practical intent):

Use linear if you’re running a controlled process window (for example ±25 K around nominal).
Use log if you’re comparing huge ranges (city vs desert vs Martian habitat).
Use beta if “too cold” is the life-limiting factor.
Use kBT if you speak in energy per mole (chemistry, bio, catalysis).
Use hybrid if you care about both “small drift near nominal” and “large deviation far away.”
Use qlog if you must stay numerically sane near cryogenic limits or other near-zero regimes.

Non-negotiable guardrails:

log, beta: require T_K > 0 and T_ref > 0
linear: require DeltaT > 0
kBT: require E_unit > 0
hybrid: require DeltaT > 0 and tau > 0
qlog: require T_ref > 0 and alpha > 0

Why “one lens per run” matters:

If you change lenses mid-run, e_T at 14:03 might mean something totally different than e_T at 14:07, and your audit trail is unusable.
A regulator, insurer, or mission controller needs to know what you meant by “0.8 of heat stress” at that time. That meaning comes from the lens, not from °C.

This is why every emitted record also includes the manifest_id.
That manifest freezes: lens choice, constants (T_ref, DeltaT, …), pivots, valid range, clamp values.

3. Compute the contrast e_T (1.3)
Now we actually generate the number that flows downstream.

encode_eT(
    T_K,
    lens,
    T_ref=None,
    DeltaT=None,
    E_unit=None,
    R=8.314462618,
    tau=None,
    alpha=None
):
    if lens == "linear":
        return (T_K - T_ref) / DeltaT

    if lens == "log":
        return ln(T_K / T_ref)

    if lens == "beta":
        return (T_ref / T_K) - 1

    if lens == "kBT":
        return (R*T_K)/E_unit - (R*T_ref)/E_unit

    if lens == "hybrid":
        if abs(T_K - T_ref) > tau:
            return ln(T_K / T_ref)
        else:
            return (T_K - T_ref) / DeltaT

    if lens == "qlog":
        return ln(((T_K / T_ref) + alpha) / (1 + alpha))

    raise "unknown lens"

Why e_T is the centerpiece:

It is unitless and portable.
It is zero-centric: e_T = 0 ↔ “at baseline.”
It is interpretable: positive means “hotter than baseline,” negative means “colder than baseline,” with slope/curvature defined by the chosen lens.
It is the one field (e_T) that every downstream consumer can understand the same way if they also know the manifest.

You can now:

alert on e_T,
compare two cities or two suits on Mars using e_T,
feed e_T into ML without worrying about °C vs °F,
attach e_T to fleet reporting without sharing raw sensor internals.

This is the heart of Shunyaya Symbolic Mathematical Temperature (SSMT):
temperature becomes a stable symbolic contrast, not a fragile local reading.

Navigation
Previous: SSMT – What Goes on the Wire (0E)
Next: SSMT – Making It Operational: Alignment Dials and Survival Bands (1.4–1.5)

Directory of Pages
SSMT – Table of Contents

The three irreversible steps: get to Kelvin, choose one lens, compute e_T

The three irreversible steps: get to Kelvin, choose one lens, compute `e_T`