F · Algorithms

Each algorithm is stated against the formal framework of Section 6 and is an executable contract of the computation pipeline. The algorithms are versioned through the method version vector (Section 10.2); a change to any of them increments method_ver and is logged in the audit trail.

Algorithm 1. Layered observation-state computation

• Input: raw source records $r \in \mathcal{R}$; roster $\mathcal{I} \cup \mathcal{S}$; scale contract $\mathcal{S}$; source registry $\mathcal{K}$.
• procedure L1_ingest($\mathcal{R}$)
  • for each record $r$ do
    • classify key $(\mathrm{org}, \mathrm{source}, \mathrm{title})$;
    • stamp arrival time; validate schema against source profile
    • assign source state: present / degraded / absent (Section 6.2)
  • return raw records with source states
• procedure L2_derive($\mathrm{raw}$, $\mathcal{S}$)
  • classify missingness per factor into $P/Z/A/F$ (Algorithm 2)
  • apply scale contract per factor class (linear / heavy-tail / inverse / boolean)
  • aggregate factors to blocks by composition weights (Algorithm 3)
  • return derived indicator state $\xi(t)$ (Definition 6.1)
• procedure L3_publish($\xi(t)$, roster)
  • compute $\mathrm{FA}^{\mathrm{adj}}$, $\mathrm{RI}$ envelope, $\Theta$, $\Gamma$, $\Lambda$
  • apply settlement re-centering and presentation noise (Algorithms 5, 6)
  • return published layer values

Algorithm 2. Missing-value classification and two-level renormalization

• Input: factor values $v_{i,k}$; block weights $w_k$, $\sum_k w_k = 1$; status registry $\mathcal{M}$.
• procedure Classify($i$, $k$)
  • if unit not covered by the factor's definition then
    • return $P$ (true zero)
  • else if source state absent and no readable rank then
    • return $Z$ (numerical absence)
  • else if below printed cutoff, last readable rank available then
    • return $A$ (leaderboard floor)
  • else if source outage / schema failure then
    • return $F$ (technical unavailability)
• procedure Renormalize($i$)
  • $\mathcal{P} \gets \{ k : \text{state}(i,k) \in \{P, A, Z\text{-with-fill}\} \}$
  • $v_{i,k} \gets 0$ for $k$ in state $Z$ without fill, or floor value for $A$
  • $V_i \gets \sum_{k\in\mathcal{P}} w_k\, \hat v_{i,k} \;/\; \sum_{k\in\mathcal{P}} w_k$
  • $\mathrm{carry}(i,k) \gets v_{i,k}(t_{\text{last-valid}})$ for state $F$
  • register $(i, k, \text{state})$ in $\mathcal{M}$ with version stamp
  • return $V_i$ (projection onto present blocks, Prop. 6.4)

Algorithm 3. Fundamental-Anchor composition (V1)

• Input: normalized blocks $\mathrm{cap}, \mathrm{edge}, \mathrm{eco}, \mathrm{com} \in [0,1]$; V1 weights (Appendix B); roster.
• procedure Compose($\mathrm{cap}, \mathrm{edge}, \mathrm{eco}, \mathrm{com}$)
  • $\mathrm{cap}' \gets (0.55\,\mathrm{cap} + 0.05\,\mathrm{edge}) / 0.60$
  • $\mathrm{eco}' \gets (0.25\,\mathrm{eco} + 0.15\,\mathrm{com}) / 0.40$
  • $\mathrm{FA}_i \gets 100 \times \bigl(0.60\,\mathrm{cap}' + 0.40\,\mathrm{eco}'\bigr)$
  • $\mathrm{merge}$ per block from its factors by the composition map
  • return $\mathrm{FA}_i$
• procedure Adjust($\mathrm{FA}_i$, streaks, incidents)
  • $D_i \gets$ sustained-leadership value ((15)), capped at $D_{\mathrm{cap}}$
  • $R_i \gets$ real-harm value, capped at $R_{\mathrm{cap}}\mathrm{FA}_i$, official facts only
  • $\mathrm{FA}^{\mathrm{adj}}_i \gets \mathrm{FA}_i\,(1 + D_i) - R_i$
  • freeze $\mathrm{FA}^{\mathrm{adj}}_i(t_0)$ at settlement; immutable intraday
  • return $\mathrm{FA}^{\mathrm{adj}}_i(t_0)$

Algorithm 4. Real-time-influence renewal update

• Input: event stream; residual map $r(\cdot)$; half-life map $T_{1/2}(\cdot)$.
• for each event $e$ at time $t_e$ do
  • $r_{\text{new}} \gets A_e\, 2^{-0}$ (full value)
  • if $r(\mathrm{key}) \le r_{\text{new}}$ then
    • (renewal rule)
    • void residual of the same primary key
    • insert $r_{\text{new}}$ with start $t_e$
    • append to the renewal log (deterministic replay ledger)
  • else
    • keep existing pulse; log the rejected event
• for each active pulse do
  • $\rho_e \gets (\text{now} - t_e)/T_{1/2}(e)$; value $\gets A_e\, 2^{-\rho_e}$
• $\mathrm{RI}_i(t) \gets \sum_{\text{active } e} A_e\, 2^{-(t-t_e)/T_{1/2}(e)}$
• $\mathrm{H}_i(t) \gets \sum_{\text{active } e} |A_e|\, 2^{-(t-t_e)/T_{1/2}(e)}$
• return $\mathrm{RI}_i(t)$, $\mathrm{H}_i(t)$ (Prop. 6.14)

Algorithm 5. Settlement and centering

• Input: fresh $\mathrm{FA}^{\mathrm{adj}}_i(t_0)$ recomputed from settled slow data ((14)), $\mathrm{RI}_i$, roster $\mathcal{I}$.
• $t \gets$ window close (UTC 04:00–07:00, 16:00–19:00)
• procedure Settle
  • $\overline{\mathrm{RI}} \gets \frac{1}{|\mathcal{I}|}\sum_{j\in\mathcal{I}}\mathrm{RI}_j(t)$
  • for $i \in \mathcal{I}$ do
    • $\Theta_i(t) \gets \mathrm{FA}^{\mathrm{adj}}_i(t_0) + k_{\mathrm{ri}}\bigl(\mathrm{RI}_i(t) - \overline{\mathrm{RI}}\bigr) + \mathrm{BR}_i(t)$
  • (exact conservation: $\sum\Theta_i = \sum\mathrm{FA}^{\mathrm{adj}}_i$ (Prop. 6.9))
  • freeze $\mathrm{FA}^{\mathrm{adj}}_i(t_0)$ as the new anchor (slow anchor, not the closing line)
  • write settlement record; increment flagship_ver
  • return $\Theta_i(t)$, frozen $\mathrm{FA}^{\mathrm{adj}}_i(t_0)$

Algorithm 6. Presentation-layer nominal dual-value process

• Input: actual line $\Theta_i(t)$; display parameters (Table 22).
• procedure Nominalize($\Theta_i(t)$)
  • $x \gets 0$ (display-noise stock, hash-seeded per unit)
  • for each publish tick do
    • $x \gets x\cdot (1 - 2^{-1/15}) + \mathcal{N}(0,\sigma_0^2)$ (discrete OU, zero mean)
    • with prob. $0.15\%$ per minute: jump $x \gets x \pm U(3,5)\,\sigma$
    • $x \gets \mathrm{clip}(x,\ \pm 75\,\mathrm{bps})$
    • if inside taper window: $\tau$ min to close then
      • $x \gets x\cdot (1 - \tau/N_{\mathrm{taper}})$ (force to zero at close)
    • $\widetilde{\Theta}_i(t) \gets \Theta_i(t) + x + \mathcal{N}(0,\sigma_j^2)$
  • return $\widetilde{\Theta}_i(t)$; at close $\widetilde{\Theta} \equiv \Theta$ (Prop. 6.17)

Algorithm 7. Dual-track audit and replay

• Input: production trace; replay engine; keys.
• procedure Audit(window $W$)
  • recompute all outputs from raw inputs over $W$ (replay path)
  • compare replay vs. production at each published tick
  • check $\mathrm{H}_i(t) \ge |\mathrm{RI}_i(t)|$ over $W$ (Prop. 6.14)
  • check conservation $|\sum\Theta_i - \sum\mathrm{FA}^{\mathrm{adj}}_i| \le \epsilon$ at each settlement
  • verify renewal-log determinism (re-run key events)
  • return audit verdict + exception list
• procedure Reconcile(exception list)
  • for each exception do
    • classify: display noise / source swap / model change / operator error
    • if source-related: trigger Algorithm 8
    • emit correction record; increment decision_ver

Algorithm 8. Circuit breaker and source-swap migration

• Input: source state; factor weights $w_s$; alert threshold.
• procedure Monitor($k \in \mathcal{K}$)
  • if health(k) below threshold for $2$ consecutive windows then
    • degrade source $k$: drop its observations, re-normalize over survivors
    • assert $|\hat v - \hat v_{\mathrm{out}}| \le w_k/(1-w_k)$ (Prop. 6.1)
    • mark factor state $F$ (technical unavailability), carry forward (Section 6.2)
  • if $\Delta_k >$ alert threshold on recovery then
    • record discrepancy; report to reconcile (Algorithm 7)
  • return circuit state; update source_ver

Algorithm 9. Dynamic membership inclusion

• Input: universe $\mathcal{U}$; observation-layer completeness $c_u$; threshold $c^*$.
• procedure Review($u \in \mathcal{U}$)
  • compute $c_u$ = fraction of required factors observed over last $N$ windows
  • if $u \in \mathcal{S}$ and $c_u \ge c^*$ for $2$ consecutive reviews then
    • move $u$ to $\mathcal{I}$; apply Prop. 3.1 check
    • if a normalization extreme changes: disclose revaluation, no backcast
  • else if $u \in \mathcal{I}$ and $c_u < c^*$ for $2$ consecutive reviews then
    • move $u$ to $\mathcal{S}$; re-run centering on the new $\mathcal{I}$
  • return roster; increment roster_ver

Algorithm 10. BR-01 bridge transition

• Input: mechanical-change gap $G_{\mathrm{mech}}$; horizon $H$; path $\varphi(t)$.
• procedure Transition
  • if $G_{\mathrm{mech}} = 0$ then
    • return (no bridge; Prop. 6.19(d))
  • $\mathrm{BR}(0) \gets -G_{\mathrm{mech}}$
  • $I^{\mathrm{pub}}(0) \gets I^{+} + \mathrm{BR}(0) = I^{-} + \Delta_{\mathrm{fund}}$ (value preserved)
  • for $t \in (0, H]$ do
    • $\mathrm{BR}(t) \gets -G_{\mathrm{mech}}\,\varphi(t)$, $\varphi(0)=1$, $\varphi(H)=0$
    • $I^{\mathrm{pub}}(t) \gets I^{+} + \mathrm{BR}(t)$
  • $\mathrm{BR}(t) \gets 0$ for $t > H$; bridge never deposits into $\mathrm{FA}$, never enters $\mathrm{RI}$
  • return published path; increment method_ver

Algorithm 11. Weight-sensitivity analysis

• Input: frozen V1 weights $\beta$; factor uncertainty model $\Theta_{\mathrm{unc}}$; $M$ draws.
• procedure Analyze
  • for $m = 1, \dots, M$ do
    • $\beta_m \gets \beta \cdot (1 + \varepsilon_m)$, $\varepsilon_m \sim$ bounded noise per block
    • recompute all $\mathrm{FA}$, $\Theta$; record full board ranking $\pi_m$
    • for each adjacent pair $(i,j)$ do
      • $r_{ij} \gets$ smallest relative perturbation reversing the ordering (Appendix D.4)
  • report: min adjacent $r_{ij}$; distribution of rank changes; extreme-bounds band
  • return sensitivity report (Section 8.7)

Together, Algorithms 1–11 cover the full pipeline from raw observation to published value, with the verification and governance loops designed to keep the pipeline auditable. The version-vector bookkeeping (Section 10.2) tags every algorithm run, so that a state change can in principle be replayed from the recorded inputs.

Back to contents  |  ← E · Proof Corpus  |  G · FA Snapshot →