Shunyaya Symbolic Mathematics — Regularization of alignment (2.17)

Abstract
Raw alignment series a(t) from real data often jitter near Zearo. We regularize in rapidity u = atanh(a) with total-variation (TV/fused-lasso) smoothing, then map back via tanh, preserving boundedness, numerical stability near edges, and compatibility with M2 operations.

🧮 Default policy — smooth in rapidity, then map back

Let

u_raw(t) = atanh( clamp(a(t), -1+eps, +1-eps) ),   eps = 1e-6

Compute {u_hat_t} as the minimizer of the 1-D fused-lasso objective

G(u_hat) = Σ_t (u_hat_t - u_raw_t)^2  +  lambda * Σ_t |u_hat_t - u_hat_{t-1}|,   lambda >= 0

Then map back

â_t = tanh(u_hat_t)
  • Why u-space? Near edges, atanh linearizes changes in a, so smoothing is well-conditioned and consistent with M2’s rapidity geometry.
  • Boundedness: â_t ∈ (-1, 1) automatically; clamp once if you must enforce closed bounds.

🧰 Alternative (legacy) — smooth directly in a-space

If u_raw cannot be computed:

F(â) = Σ_t (â_t - a_t)^2  +  lambda * Σ_t |â_t - â_{t-1}|

with optional box-constraint â_t ∈ [-1, +1]. Prefer the u-space policy when possible.

✅ Theorem — existence and uniqueness

For either formulation and any lambda >= 0, a unique minimizer exists.

Sketch
Quadratic fidelity term is strictly convex; TV term is convex; the sum is strictly convex ⇒ unique minimizer.

📎 Properties (default u-space policy)

  1. Boundedness preserved. â_t = tanh(u_hat_t) ∈ (-1, 1); a final clamp enforces [-1, +1] if needed.
  2. Limit behavior. lambda → 0 ⇒ u_hat_t → u_raw_t and â_t → a(t); lambda → +∞ ⇒ u_hat_t constant, â_t → tanh(mean(u_raw)).
  3. Reduced oscillation (bounded variation). TV penalizes jitter near Zearo but keeps genuine trends; â_t becomes piecewise-smooth.
  4. Compatibility. Works with all constructs using u = atanh(a) (operations, calculus, geometry) and respects the clamp policy.
  5. Collapse note. If raw a(t) ≡ +1 (idealized), the smoothed â_t remains at the +1 limit (numerically 1 - eps with finite eps), so classical collapse behavior is preserved.

🔍 Worked mini-example (u-space, qualitative)

Raw a: [ +0.9, +0.1, -0.2, +0.2, +0.8 ]
Compute u_raw = atanh(a) (after clamping if needed).

  • lambda = 0 → u_hat = u_raw → â = a (no smoothing).
  • lambda = 1 → mild smoothing in u; mapping back (illustrative)
    â ≈ [ +0.88, +0.28, +0.05, +0.28, +0.75 ] (spikes near 0 damped).
  • lambda = 10 → heavy smoothing; nearly constant
    â ≈ [ +0.60, +0.60, +0.60, +0.60, +0.60 ].
    (Exact values depend on solver; these show typical fused-lasso behavior.)

⚙️ Computation — practical choices

  • Batch (offline) exact: taut-string / Condat–Vu TV-denoising on {u_raw_t}.
  • Streaming (online) approximation: EMA in u + tiny-jump suppression:
u_hat_t = (1 - alpha)*u_hat_{t-1} + alpha*u_raw_t
if |u_hat_t - u_hat_{t-1}| < tau:  u_hat_t = u_hat_{t-1}   # soft threshold
â_t = tanh(u_hat_t)

Choose alpha ∈ (0,1) and small tau > 0. Declare both in the manifest.

🧾 Manifest fields (required)

reg.type   = "TV-u"           # default; or "TV-a" (legacy)
reg.lambda = <nonnegative>    # TV strength
reg.eps    = 1e-6             # clamp used to form u_raw
reg.solver = "taut-string"    # or "condat-vu", "online-ema"
reg.alpha  = <...>            # if streaming
reg.tau    = <...>            # if streaming

📣 Interpretation

Raw alignment is a noisy stability measurement. Regularizing in rapidity extracts a latent, smooth stability trajectory, filtering jitter near Zearo, keeping outputs bounded, and making downstream symbolic calculus and decisions reproducible and audit-ready.

✅ Takeaway

TV smoothing in u = atanh(a) yields a unique, bounded, low-oscillation alignment series that integrates seamlessly with M2 operations and symbolic calculus, while preserving collapse behavior (classical results via phi) and edge safety via clamping.

Navigation

Previous → Topology & continuity
Next → Vectors & matrices (symbolic lifts)

Disclaimer
Observation only. Reproducible math; domain claims require independent peer review. Defaults: gamma=1, mult_mode=M2, clamp_eps=1e-6, |a|<1.