This is an AI Generated Artilce
https://chatgpt.com/share/68b457b0-7294-8010-b8b4-0532dec638fb 

Dissipative Lagrangian Decoding: Event-Triggered Short-Horizon Control for Stable, On-Task Large Language Models

 https://osf.io/2wmky/files/osfstorage/68b45ea6b34dc4a420e4d449

---

1. Introduction

1.1 Motivation: Stability and Reliability Without Retraining

Large language models (LLMs) have reached impressive levels of fluency, yet production deployments still struggle with stability: sudden topic drift, brittle formatting in structured outputs, unpredictable tool-use decisions, and sporadic “entropy spikes” that derail long-context reasoning. The dominant mitigation strategies—fine-tuning, RLHF/RLAIF, and heavier decoders (e.g., wide beams, reranking, MBR)—either require new training cycles, increase cost/latency substantially, or are hard to audit and control at inference time.

This paper targets an under-served operating point: token-local, inference-time control that improves stability and reliability without retraining and with minimal overhead. Our goal is a drop-in mechanism that (i) reduces drift and format breakage, (ii) makes tool decisions less erratic, (iii) preserves creativity when desired, and (iv) is auditable and bias-safe by construction.

1.2 Problem Statement: Token-Local Control Under Latency Constraints

We consider standard autoregressive decoding where, at step $t$, the model produces logits over the vocabulary given history $h_t$. The serving constraints are strict: end-to-end latency must remain close to greedy/top-p decoding and throughput must not regress. Within this budget, we want a controller that locally rescales or reorders the top candidates to favor outputs that are (a) on-task, (b) structurally valid (e.g., JSON, code blocks), and (c) avoid unnecessary mode/tool switches—without relying on content-sensitive or ideology-laden signals.

Concretely, we ask:

• How can we encode, at the per-token level, both benefit (task fit, verifiability) and dissipation (topic drift, structural breakage, switch costs) into a single decision rule?

• Can this rule trigger very short horizon lookahead only at risky moments (entropy spikes, imminent tool calls), keeping the average cost near zero?

• How do we guarantee auditability and safety, e.g., bounding deviations from the base distribution so the controller cannot introduce hidden bias or large behavioral shifts?

1.3 Key Idea: Per-Token Lagrangian $J=L-\lambda \mathrm{\Gamma }$ with Event-Triggered Lookahead

We cast decoding as local path selection via a dissipative Lagrangian. For candidate token $i$ at step $t$,

$$J_t(i)=L_t(i)-{\lambda }_t{\mathrm{\Gamma }}_t(i),$$

and we emit the $i$ that maximizes $J_t(i)$.

• Value term $L_t$ aggregates content-neutral signals you already care about operationally: normalized log-likelihood, optional tiny value head or heuristics for task progress (e.g., key-field coverage, unit-test stub checks), lightweight risk/format checks, and calibrated latency/cost of tool or route switches.

• Dissipation term ${\mathrm{\Gamma }}_t$ encodes costs of abrupt semantic/structural changes: topic drift measured by $1-\cos (e_i,m_{t-1})$ where $e_i$ is the candidate’s embedding and $m_{t-1}$ is an EMA of recent outputs; penalties for mode/tool switches; and format-integrity penalties (JSON/bracket/code-block closure).

The stability knob ${\lambda }_t$ adapts online to uncertainty (e.g., increases when step entropy jumps), yielding more smoothing when the model is “excited,” and relaxing in calm or creative segments.

To keep overhead negligible, we propose event-triggered short-horizon lookahead: in routine steps we apply a single-step controller (near zero overhead); when predefined triggers fire (entropy spike $\mathrm{\Delta }{H}_t>0$, format break imminent, or a tool decision boundary), we unroll only 2–4 steps over a small beam and score micro-trajectories by $\sum (L-\lambda \mathrm{\Gamma })$, committing just the next token.

Finally, we wrap the controller in trust-region guards: a KL bound to the base softmax and logit change caps ensure small, auditable deviations and reduce bias risks.

1.4 Contributions

1. Unified inference-time control law. We introduce a per-token Lagrangian $J=L-\lambda \mathrm{\Gamma }$ that brings together likelihood, task progress, structural validity, switch/latency cost, and topic-drift dissipation under a single, content-neutral objective.

2. Event-triggered short-horizon decoding. A practical scheme that performs micro lookahead only at risky steps, preserving near-greedy latency while improving stability on long contexts, tool routing, and structured outputs.

3. Trust-region safety for decoding. KL and logit-magnitude constraints provide auditability and explicit limits on deviation from the base distribution, enabling safe deployment and bias-gap monitoring.

4. Principled signal selection (PSS). A methodology to restrict signals to mechanism-relevant, content-neutral, locally available features—reducing the chance of proxy bias and facilitating reproducible audits.

5. Drop-in engineering path. A Γ-lite single-step controller (O$(kd)$ cosines on top-$k$) plus optional triggers integrates with greedy/top-p/beam decoders in PyTorch/JAX/TF without base-model changes.

6. Evaluation blueprint. We propose task families (long-context QA, tool routing, strict-format outputs, creative writing), metrics (topic drift, entropy spikes, format violations, tool-use success, overhead), and bias-safety checks (counterfactual swaps, KL budgets).

1.5 Scope and Non-Goals

• Inference-time complement, not a training substitute. Our method complements fine-tuning/RLHF; it does not claim to replace them, nor to eliminate hallucinations in all regimes.

• Local control, not global optimality. We target token-local selection with occasional micro lookahead; we do not seek globally optimal sequences or heavy reranking by default.

• Content-neutral signals only. We explicitly avoid identity/stance-based features and uncalibrated toxicity/ideology scores; risk/format checks focus on syntax, structure, and leakage patterns.

• Bounded environments. When behavior depends on hard, non-smooth external jumps (opaque tools/APIs), we recommend piecewise controllers or stochastic smoothing; universal guarantees are out of scope.

• No framework dependence. The approach is not tied to a specific library (“put Lagrangian into TensorFlow”); it is a decoding-layer control scheme applicable across runtimes.

Together, these choices position dissipative Lagrangian decoding as a practical, auditable, low-overhead path to more stable LLM behavior in production—achieving measurable gains without retraining and without sacrificing creativity where it matters. 

---

2. Background and Related Work

2.1 Autoregressive Decoding and Common Controls (temperature, top-p, beam)

LLMs decode autoregressively: at step $t$, the model emits a distribution $\pi (\cdot \mid h_t)$ over the vocabulary given the history $h_t$. Practical serving stacks typically layer simple controls on top of $\pi$:

• Temperature scaling. Replace logits $z$ by $z\mathrm{/}T$. Lower $T$ sharpens the distribution (greater determinism); higher $T$ diversifies but raises the risk of off-task tokens and structural breakage.

• Top-k / Nucleus (top-p) sampling. Restrict sampling to the k most likely tokens or to the smallest set whose cumulative mass exceeds $p$. These limit tail events but do not directly reason about task progress or structure.

• Beam search / diverse beam. Explore multiple prefixes and pick the highest aggregate score (often log-prob with length penalties). Beams improve local optimality yet incur latency, and pure likelihood beams can still drift or repeat without additional criteria.

These controls shape how we sample from $\pi$, but they do not encode why some choices are better for the downstream task (valid JSON, consistent topic, prudent tool switches).

2.2 Controlled/Guided Decoding and Post-hoc Selection (e.g., PPLM/GeDi/MBR/Contrastive)

A second line of work adds task-oriented preferences during or after decoding:

• Controlled/guided decoding. Methods like PPLM/GeDi modulate logits via a small attribute or discriminator model (or gradients thereof), nudging outputs toward desired classes (e.g., sentiment, topic). This improves controllability but can add compute (extra forward/grad passes) and raises fairness/bias questions when the guidance model encodes contentful judgments.

• Energy/contrastive style decoding. Contrastive decoding/search penalizes degenerate continuations by combining a fluent “large” model with a more literal/regularizing “small” model or by enforcing representation-space consistency. This curbs repetition and some hallucinations but doesn’t natively account for tool costs or format validity.

• Minimum Bayes Risk (MBR). Generate candidates (e.g., via sampling/beam) and choose the hypothesis minimizing expected loss under a task metric. MBR often yields higher human preference but requires candidate pools and post-hoc scoring, impacting latency/throughput.

Overall, these approaches move beyond pure likelihood, yet they are either heavyweight (MBR/rerank), content-dependent (attribute guidance), or narrow (targeting a specific pathology like repetition).

2.3 RLHF/RLAIF vs. Inference-Time Control

RLHF/RLAIF shape model parameters to align with human or AI preference signals, typically with a KL regularizer against a reference model. Benefits include broad behavioral shifts and improved helpfulness/safety. Limitations for production control include:

• Retraining cost and lag. New behaviors require new training cycles; distribution drift (new tools, formats, policies) outpaces retraining.

• Global, not situational. RLHF tunes policy parameters, not per-token, context-specific trade-offs (e.g., “right now a tool call is costly; defer”).

• Limited structural guarantees. Alignment rewards can correlate weakly with format integrity or with precise operational costs (latency, $ per call).

Inference-time control complements RLHF by making local, auditable decisions under latency constraints, while keeping the base model and its alignment intact.

2.4 Variational Principles and Dissipation in Control

In control and optimization, variational formulations encode a balance between value and cost, often with dissipation or regularization capturing friction, inertia, or switching penalties. Related lenses include:

• Regularized objectives (e.g., length penalties, entropy bonuses) and trust-region constraints (KL bounds) that stabilize updates/selections.

• Model Predictive Control (MPC). Short-horizon lookahead with frequent replanning to satisfy tight real-time constraints.

• Energy/Lagrangian viewpoints. Express behavior as local extremization of a scalar functional combining task utility and path costs (including “frictional” terms for abrupt changes).

Our work adapts these ideas to decoding: treat each token decision as local extremization of a dissipative objective balancing task value against topic/format/tool-switch dissipation, with micro-MPC only when risk spikes.

2.5 Gaps This Work Addresses

This paper targets five persistent gaps:

1. Unified, content-neutral objective at inference. Existing controls either tune likelihood shape (temperature/top-p) or invoke content classifiers. We provide a single per-token rule $J=L-\lambda \mathrm{\Gamma }$ that aggregates likelihood, task progress, format validity, and operational costs while keeping signals content-neutral and auditable.

2. Stability via dissipation, not just filtering. Topic drift and structural breaks are treated as dissipation (measured from embeddings/format checks), not merely filtered by heuristics—yielding a principled stability knob ${\lambda }_t$ that adapts to entropy spikes.

3. Latency-aware micro lookahead. Instead of universal beams/MBR, we use event-triggered short horizons only at risky steps, preserving near-greedy latency on average.

4. Trust-region safety. KL and logit-magnitude caps bound deviation from the base distribution, making the controller’s influence small, explicit, and measurable—key for bias safety and audits.

5. Drop-in engineering path. A Γ-lite single-step controller adds only $O(kd)$ cosines per token and integrates with standard decoders (greedy/top-p/beam) and tool routers without retraining.

In sum, prior art provides pieces of the puzzle—likelihood shaping, attribute guidance, reranking, contrastive penalties, RLHF training. We assemble these instincts into a lightweight, per-token Lagrangian control law with dissipation and trust-region guards, designed for production stability under strict latency budgets.

---

3. Problem Formulation and Notation

3.1 Notation for States, Tokens, Distributions, and Embeddings

• Vocabulary $\mathcal{V}$, token index $i\in \mathcal{V}$.

• At step $t$, history $h_t=(x,y_{<t})$ (input $x$ plus emitted tokens $y_{1:t-1}$).

• Base model logits $z_t\in {\mathbb{R}}^{\mathrm{\mid }\mathcal{V}\mathrm{\mid }}$; base distribution ${\pi }_t=\mathrm{s}\mathrm{o}\mathrm{f}\mathrm{t}\mathrm{m}\mathrm{a}\mathrm{x}(z_t)$.

• Top-$k$ candidate set ${\mathcal{K}}_t\subset \mathcal{V}$ with indices $i\in {\mathcal{K}}_t$, restricted logits $z_{t,\mathcal{K}}$, probs $p_{t,\mathcal{K}}=\mathrm{s}\mathrm{o}\mathrm{f}\mathrm{t}\mathrm{m}\mathrm{a}\mathrm{x}(z_{t,\mathcal{K}})$.

• Output embedding matrix $E\in {\mathbb{R}}^{\mathrm{\mid }\mathcal{V}\mathrm{\mid }\times d}$; candidate embedding $e_i=E[i]\in {\mathbb{R}}^d$.

• Topic state (EMA) $m_t\in {\mathbb{R}}^d$, unit-norm.

• Controller outputs logit adjustments ${\mathrm{\Delta }}_t(i)$ only on $i\in {\mathcal{K}}_t$. Adjusted distribution

  $${\pi }_t^{\mathrm{\prime }}(i)\propto \{\begin{array}{ll}\exp (z_t(i)+{\mathrm{\Delta }}_t(i)),& i\in {\mathcal{K}}_t\\ \exp (z_t(i)),& i\mathrm{\notin }{\mathcal{K}}_t\end{array}$$

  and the decoder emits $y_t=\arg {\max }_{i\in {\mathcal{K}}_t}{J}_t(i)$ (or samples from ${\pi }_t^{\mathrm{\prime }}$, depending on baseline).

3.2 Local Objective: $J_t(i)=L_t(i)-{\lambda }_t{\mathrm{\Gamma }}_t(i)$

For each candidate $i\in {\mathcal{K}}_t$,

$$\boxed{{\displaystyle J_t(i)=L_t(i)-{\lambda }_t{\mathrm{\Gamma }}_t(i)}}$$

• Value term $L_t(i)$ (content-neutral, operationally meaningful):

  $$L_t(i)=a{\tilde{\mathrm{\ell }}}_t(i)+b{\widehat{r}}_t(i)-c{\mathrm{r}\mathrm{i}\mathrm{s}\mathrm{k}}_t(i)-d{\mathrm{l}\mathrm{a}\mathrm{t}\mathrm{e}\mathrm{n}\mathrm{c}\mathrm{y}}_t(i)-e{\mathrm{l}\mathrm{e}\mathrm{n}\mathrm{\_}\mathrm{p}\mathrm{e}\mathrm{n}}_t(i)$$

  where ${\tilde{\mathrm{\ell }}}_t(i)$ is the top-$k$ z-scored logit/log-prob; ${\widehat{r}}_t(i)$ is an optional cheap scalar for task progress (e.g., key-field coverage/parseability); ${\mathrm{r}\mathrm{i}\mathrm{s}\mathrm{k}}_t$ encodes format/PII/SQL-pattern checks; ${\mathrm{l}\mathrm{a}\mathrm{t}\mathrm{e}\mathrm{n}\mathrm{c}\mathrm{y}}_t$ is a pre-calibrated tool/route cost; ${\mathrm{l}\mathrm{e}\mathrm{n}\mathrm{\_}\mathrm{p}\mathrm{e}\mathrm{n}}_t$ is a closure/length control.

• Dissipation term ${\mathrm{\Gamma }}_t(i)$ (penalizes abrupt changes/fragility):

  $${\mathrm{\Gamma }}_t(i)={\beta }_{\text{topic}}\text{\hspace{0.17em}⁣}\cdot \text{\hspace{0.17em}⁣}(1-\cos (e_i,m_{t-1}))+{\beta }_{\text{switch}}\text{\hspace{0.17em}⁣}\cdot \text{\hspace{0.17em}⁣}{\mathrm{s}\mathrm{w}\mathrm{i}\mathrm{t}\mathrm{c}\mathrm{h}}_t(i)+{\beta }_{\text{fmt}}\text{\hspace{0.17em}⁣}\cdot \text{\hspace{0.17em}⁣}{\mathrm{f}\mathrm{m}\mathrm{t}\mathrm{\_}\mathrm{p}\mathrm{e}\mathrm{n}}_t(i)$$

  measuring topic drift, mode/tool switches, and format-integrity risks.

The controller maps $J_t$ to ${\mathrm{\Delta }}_t$ (Sec. 3.4) and/or chooses $y_t$.

3.3 Rolling Statistics: Entropy $H_t$, Topic EMA $m_t$, Triggers

• Step entropy (restricted to ${\mathcal{K}}_t$)

  $$H_t=-\sum _{i\in {\mathcal{K}}_t}{p}_{t,\mathcal{K}}(i)\log p_{t,\mathcal{K}}(i)$$

  with $\mathrm{\Delta }{H}_t=\max (0,H_t-H_{t-1})$. Maintain a rolling mean/std over a window $W_H$ to normalize spikes.

• Topic EMA (single- or multi-scale)

  $$m_t=\mathrm{n}\mathrm{o}\mathrm{r}\mathrm{m}\text{\hspace{0.17em}⁣}(\rho m_{t-1}+(1-\rho )e_{y_t}),\rho \in [0.9,0.99]$$

  Multi-scale option: $\{m_t^{(s)}{\}}_{s=1}^S$ with ${\rho }^{(s)}$ at short/medium/long horizons; aggregate drift by a convex combination.

• Event triggers (open default thresholds; activate short-horizon lookahead):

  • Entropy spike: $\mathrm{\Delta }{H}_t>{\theta }_H$ (e.g., $>0.5{\sigma }_H$).

  • Format risk: ${\mathrm{f}\mathrm{m}\mathrm{t}\mathrm{\_}\mathrm{p}\mathrm{e}\mathrm{n}}_t(i^{\star })>{\theta }_{\mathrm{f}\mathrm{m}\mathrm{t}}$ for the argmax candidate.

  • Imminent tool switch: ${\mathrm{s}\mathrm{w}\mathrm{i}\mathrm{t}\mathrm{c}\mathrm{h}}_t(i)$ likely for many top candidates, or router gating near a boundary.

  • Large topic turn: ${\min }_{i\in {\mathcal{K}}_t}(1-\cos (e_i,m_{t-1}))>{\theta }_{\text{topic}}$.

When triggered, evaluate a micro-horizon $h\in \{2,3,4\}$ over a small beam $B$ and rank prefixes by ${\sum }_{j=t}^{t+h}(L_j-{\lambda }_j{\mathrm{\Gamma }}_j)$; otherwise use single-step control.

Adaptive stability knob.

$${\lambda }_t={\lambda }_0(1+{\kappa }_1\mathrm{\Delta }{H}_t+{\kappa }_2\mathbf{1}\{\text{high-risk segment}\})$$

Choose larger ${\lambda }_0$ for factual/tool tasks; smaller for creative writing.

3.4 Trust-Region Constraints (KL and Logit Caps)

To keep the controller’s influence bounded and auditable:

• KL budget to baseline

  $$\mathrm{K}\mathrm{L}\text{\hspace{0.17em}⁣}\left({\pi }_t^{\mathrm{\prime }}\mathrm{\parallel }{\pi }_t\right)\le \tau$$

  where ${\pi }_t^{\mathrm{\prime }}$ is the adjusted distribution. We realize ${\mathrm{\Delta }}_t$ via an exponential tilting

  $${\pi }_t^{\mathrm{\prime }}(i)\propto {\pi }_t(i)\exp \text{\hspace{0.17em}⁣}(\eta s_t(i)),i\in {\mathcal{K}}_t,$$

  where $s_t(i)$ is a centered, standardized version of $J_t(i)$. Pick $\eta \ge 0$ by bisection to satisfy the KL bound.

• Logit magnitude cap

  $$\mathrm{\mid }{\mathrm{\Delta }}_t(i)\mathrm{\mid }\le ϵ,i\in {\mathcal{K}}_t,\sum _{i\in {\mathcal{K}}_t}{\mathrm{\Delta }}_t(i)=0$$

  (zero-mean keeps overall mass balanced on the restricted set). In practice, clamp $\eta s_t(i)$ into $[-ϵ,ϵ]$ before renormalization.

• Fallback If a feasible $\eta$ is not found under both caps, revert to the baseline decoder for step $t$ (and still log diagnostics).

These guards ensure small, controlled deviations from ${\pi }_t$, reducing bias-amplification risk and simplifying audits.

3.5 Assumptions and Applicability Conditions

• Local observables suffice. Stability can be improved using step-local signals (likelihood shape, embedding drift, format checks, calibrated tool costs) without modeling long-range non-local effects explicitly.

• Short-range memory. Topic/structure inertia is representable via EMA(s) or short kernels; very long, non-stationary memory should be segmented or handled by paragraph-level reranking.

• Piecewise smoothness. $L_t,{\mathrm{\Gamma }}_t$ are piecewise smooth in the local signals; hard, opaque discontinuities (e.g., external APIs with binary jumps) are handled via piecewise controllers or stochastic smoothing.

• Content neutrality. Signals for $L$ and $\mathrm{\Gamma }$ must not encode identity/stance or uncalibrated “toxicity” proxies; they target mechanism (uncertainty spikes, drift, format integrity, operational cost).

• Access to embeddings/top-k. The serving stack exposes top-$k$ logits and output embeddings (or equivalent representations) to compute drift; otherwise, fall back to prompt-level approximation (Sec. 9).

• Latency budget. The system tolerates $O(kd)$ extra dot-products per step and rare micro-lookahead at triggers; if not, use the Γ-lite single-step controller only.

Under these conditions, decoding as local extremization of a dissipative Lagrangian with trust-region guards provides a practical, low-overhead path to stabilizing long-context behavior, structured outputs, and tool routing—without retraining the base model.

---

4. Design of the Value Term $L_t$

We define, for each candidate token $i$ at step $t$,

$$L_t(i)=a{\tilde{\mathrm{\ell }}}_t(i)+b{\widehat{r}}_t(i)-c{\mathrm{r}\mathrm{i}\mathrm{s}\mathrm{k}}_t(i)-d{\mathrm{l}\mathrm{a}\mathrm{t}\mathrm{e}\mathrm{n}\mathrm{c}\mathrm{y}}_t(i)-e{\mathrm{l}\mathrm{e}\mathrm{n}\mathrm{\_}\mathrm{p}\mathrm{e}\mathrm{n}}_t(i),$$

where all components are content-neutral, locally available at decode time, and standardized to comparable scales. Section 4.1 details ${\tilde{\mathrm{\ell }}}_t(i)$; later subsections (4.2–4.5 in the ToC) will cover optional value heads, risk/format checks, tool/route latency, and length/closure controls. Throughout, $a,\dots ,e$ are either fixed per “task profile” (factual/tool vs. creative) or produced by a tiny controller head; Section 3.4’s trust-region keeps the net adjustment bounded and auditable.

---

4.1 Normalized Log-Likelihood ${\tilde{\mathrm{\ell }}}_t(i)$

Goal. Turn the model’s raw preference for candidate $i$ into a dimensionless, well-behaved scalar that is (i) comparable across steps and contexts, (ii) robust to temperature/top-k/top-p choices, and (iii) numerically stable even when the distribution is near-deterministic.

4.1.1 Why not use raw log-prob?

Raw logits/log-probs depend on scale (temperature, layer-norm dynamics, context idiosyncrasies). When combined with other terms in $L_t$, this can dominate or vanish spuriously. We therefore normalize within the active candidate set to obtain a unitless score with controlled variance.

4.1.2 Robust z-score over the active candidate set

Let ${\mathcal{K}}_t$ be the (implementation’s) candidate set at step $t$ (e.g., top-$k$ after any baseline temperature). Define:

$${\mathrm{\ell }}_t(i)=\log {\pi }_t(i),{\mu }_t=\mathrm{m}\mathrm{e}\mathrm{d}\mathrm{i}\mathrm{a}\mathrm{n}\{{\mathrm{\ell }}_t(j):j\text{\hspace{0.17em}⁣}\in \text{\hspace{0.17em}⁣}{\mathcal{K}}_t\},{\sigma }_t=\max \text{\hspace{0.17em}⁣}(\mathrm{M}\mathrm{A}\mathrm{D}\{{\mathrm{\ell }}_t(j)\},{ϵ}_{\sigma }),$$

where $\mathrm{M}\mathrm{A}\mathrm{D}$ is the median absolute deviation and ${ϵ}_{\sigma }\text{\hspace{0.17em}⁣}\sim \text{\hspace{0.17em}⁣}{10}^{-3}$ avoids division by zero. The robust z-score is

$${\tilde{\mathrm{\ell }}}_t^{\mathrm{r}\mathrm{o}\mathrm{b}}(i)=\frac{{\mathrm{\ell }}_t(i)-{\mu }_t}{{\sigma }_t}\mathrm{.}$$

This choice resists outliers (common when one token sharply dominates) and is invariant to affine re-scalings of logits induced by temperature.

Edge cases.

• If $\mathrm{\mid }{\mathcal{K}}_t\mathrm{\mid }=1$ or ${\sigma }_t$ is below ${ϵ}_{\sigma }$, set ${\tilde{\mathrm{\ell }}}_t^{\mathrm{r}\mathrm{o}\mathrm{b}}(i)=0$ for all $i\in {\mathcal{K}}_t$; the likelihood term then becomes neutral, leaving control to other components and the trust-region.

• If you use nucleus (top-$p$) instead of top-$k$, compute stats over the realized ${\mathcal{K}}_t$ (the nucleus set).

4.1.3 Add a small “margin” feature (optional)

Likelihood margins stabilize ranking when candidates are clustered:

$${\mathrm{m}\mathrm{a}\mathrm{r}\mathrm{g}\mathrm{i}\mathrm{n}}_t(i)={\mathrm{\ell }}_t(i)-\underset{j\in {\mathcal{K}}_t\setminus \{i\}}{\max }{\mathrm{\ell }}_t(j)\mathrm{.}$$

A normalized mixture

$${\tilde{\mathrm{\ell }}}_t(i)=(1-\alpha ){\tilde{\mathrm{\ell }}}_t^{\mathrm{r}\mathrm{o}\mathrm{b}}(i)+\alpha \mathrm{c}\mathrm{l}\mathrm{i}\mathrm{p}\text{\hspace{0.17em}⁣}(\frac{{\mathrm{m}\mathrm{a}\mathrm{r}\mathrm{g}\mathrm{i}\mathrm{n}}_t(i)}{{\sigma }_t},[-m_{\max },m_{\max }]),$$

with $\alpha \in [0,0.3]$ and $m_{\max }\in [2,4]$, improves local separability without over-rewarding brittle spikes.

4.1.4 Entropy-aware tapering (don’t over-trust sharp peaks)

When the step distribution is already very sharp, the likelihood term needs down-weighting to avoid redundantly boosting the argmax. Let $H_t$ be the step entropy on ${\mathcal{K}}_t$, and define a taper:

$$w(H_t)=\mathrm{c}\mathrm{l}\mathrm{i}\mathrm{p}\text{\hspace{0.17em}⁣}(\frac{H_t-\underset{‾}{H}}{\bar{H}-\underset{‾}{H}},[0,1]),$$

where $[\underset{‾}{H},\bar{H}]$ are rolling percentiles of $H_t$ (e.g., 10th–90th over the last $W$ steps). Use

$${\tilde{\mathrm{\ell }}}_t^{\ast }(i)=w(H_t)\cdot {\tilde{\mathrm{\ell }}}_t(i)\mathrm{.}$$

Intuition: when the model is already certain (low $H_t$), we give more room for the dissipation and structure terms to arbitrate; when uncertain (high $H_t$), we let likelihood re-assert.

4.1.5 Language/tokenization calibration (optional)

Subword vocabularies yield different log-prob statistics across languages/scripts. To reduce cross-language variance, keep a per-language rolling scale:

$${\sigma }^{\mathrm{l}\mathrm{a}\mathrm{n}\mathrm{g}}\leftarrow \mathrm{E}\mathrm{M}\mathrm{A}(\mathrm{s}\mathrm{t}\mathrm{d}\{{\mathrm{\ell }}_t(j){\}}_{j\in {\mathcal{K}}_t}),$$

and multiply ${\tilde{\mathrm{\ell }}}_t^{\ast }$ by a fixed normalization factor $\zeta =\bar{\sigma }\mathrm{/}{\sigma }^{\mathrm{l}\mathrm{a}\mathrm{n}\mathrm{g}}$ (clipped to $[0.5,2]$), where $\bar{\sigma }$ is a global reference. This keeps $a$ usable across locales.

4.1.6 Numerical stability and complexity

• Always compute logits in log-space with the usual “subtract max” trick.

• Median/MAD over $\mathrm{\mid }{\mathcal{K}}_t\mathrm{\mid }\in [5,50]$ costs $O(k)$ and is negligible next to the model forward.

• All normalizations are per-step, stateless (aside from simple EMAs), and do not require storing histories beyond rolling stats.

4.1.7 Recommended defaults

• $k=10$ (or the nucleus set), robust z-score with ${ϵ}_{\sigma }={10}^{-3}$.

• Margin mixing $\alpha =0.1$, $m_{\max }=3$.

• Entropy taper with $W=128$, $\underset{‾}{H}$ and $\bar{H}$ as running 10th/90th percentiles.

• Language scaling off by default; enable when serving multilingual traffic with disparate scripts.

4.1.8 Pseudocode (drop-in)

def normalized_loglik(scores_topk, entropy_topk, state):
    # inputs: scores_topk = log-probs (shape [k]); entropy_topk = H_t on top-k
    # state: running percentiles for H, optional per-language scale
    
    # robust center/scale
    mu = median(scores_topk)
    mad = median(abs(scores_topk - mu))
    sigma = max(mad, 1e-3)
    zrob = (scores_topk - mu) / sigma

    # optional margin feature
    top2 = np.partition(scores_topk, -2)[-2:]
    best, second = top2[-1], top2[-2]
    margin = (scores_topk - second) / sigma
    margin = np.clip(margin, -3.0, 3.0)
    zmix = 0.9 * zrob + 0.1 * margin

    # entropy-aware taper
    H_low, H_high = state.H_p10, state.H_p90
    w = np.clip((entropy_topk - H_low) / max(H_high - H_low, 1e-6), 0.0, 1.0)
    return w * zmix  # shape [k]

Summary. ${\tilde{\mathrm{\ell }}}_t(i)$ is a robust, entropy-aware, candidate-set normalized proxy for the model’s own preference, designed to (1) combine cleanly with other value terms, (2) behave well under different decoding hyperparameters, and (3) remain numerically stable in both flat and spiky regimes.

---

Recall

$$L_t(i)=a{\tilde{\mathrm{\ell }}}_t(i)+b{\widehat{r}}_t(i)-c{\mathrm{r}\mathrm{i}\mathrm{s}\mathrm{k}}_t(i)-d{\mathrm{l}\mathrm{a}\mathrm{t}\mathrm{e}\mathrm{n}\mathrm{c}\mathrm{y}}_t(i)-e{\mathrm{l}\mathrm{e}\mathrm{n}\mathrm{\_}\mathrm{p}\mathrm{e}\mathrm{n}}_t(i),$$

with content-neutral, decode-time signals, standardized to comparable scales.

4.2 Optional Value Head ${\widehat{r}}_t(i)$ (Task Progress / Verifiability)

Purpose. Provide a tiny, cheap scalar that rewards measurable progress toward the task goal (parseability, key-field coverage, unit-test stub success), without reading identity/stance.

4.2.1 Sources (choose any; all are content-neutral)

• Strict-format tasks (JSON, tables, code stubs).

  • Key coverage: fraction of required keys present if token $i$ is appended.

  • Schema margin: negative distance to first JSON/AST error under a fast incremental check.

  • Bracket/quote balance margin: stack depth safety.

• Tool/function calling.

  • Name correctness: does token $i$ continue a gated function name?

  • Arg completeness: fraction of required arguments filled and type-parsable.

• Long-context QA/summarization.

  • Citation anchor hit: match to retrieved anchors or section headers.

  • Salience proxy: cosine to retrieval centroid exceeds a threshold.

All features are computed locally on the prefix+$i$ (no extra model calls).

4.2.2 Head design & calibration

• Linear or 1-hidden-layer MLP on a small feature vector:
  ${\varphi }_t(i)=[{\tilde{\mathrm{\ell }}}_t(i),\text{fmt\_ok margin},\text{key\_coverage},\text{tool\_gate},\text{pos enc.}]$.
  Output ${\tilde{r}}_t(i)\in [0,1]$; calibrate to ${\widehat{r}}_t(i)=2{\tilde{r}}_t(i)-1\in [-1,1]$.

• Training data: a few ${10}^3\text{\hspace{0.17em}⁣}\sim \text{\hspace{0.17em}⁣}{10}^4$ prefixes from dev logs with automatic labels (parse passes, schema coverage, tool success).

• If no training: set $b=0$ initially, or define ${\widehat{r}}_t(i)$ as a deterministic heuristic (e.g., key coverage delta mapped to $[-1,1]$).

Cost. $O(k)$ per step (vector ops over top-$k$); negligible next to the base forward pass.

---

4.3 Content-Neutral Risk Penalties ${\mathrm{r}\mathrm{i}\mathrm{s}\mathrm{k}}_t(i)$

Purpose. Penalize structural and leakage-pattern risks—not values or identities.

4.3.1 What counts as “risk” here

• Format break risk: token $i$ would create unbalanced quotes/brackets, invalid JSON/CSV cell, illegal indent in code block.

• Leakage patterns: emerging sequences resembling keys/secrets (e.g., sk_**** shape), file paths with traversal, raw SQL after WHERE 1=1 pattern, inline HTML <script> in restricted contexts.

• Prompt injection patterns in tool-use contexts: starting a high-risk metacommand token (e.g., </system>, BEGIN_SQL, custom sentinels).

All checks are syntax/shape based; no ideology/stance classifiers.

4.3.2 Construction

Let $\mathbb{1}\{\cdot \}$ be indicators (fast regex/stack checks) and $u_j(i)\in [0,1]$ be continuous violation margins (e.g., JSON distance to error).

$${\mathrm{r}\mathrm{i}\mathrm{s}\mathrm{k}}_t(i)=\sum _j{\omega }_j\mathbb{1}\{{\text{pattern}}_j\text{ fires with }i\}+\sum _{j^{\mathrm{\prime }}}{\omega }_{j^{\mathrm{\prime }}}^{\mathrm{\prime }}{u}_{j^{\mathrm{\prime }}}(i)\mathrm{.}$$

Normalize by z-scoring inside top-$k$ and clip to $[0,1]$.

Avoid double-counting. If a risk also appears in $\mathrm{\Gamma }$ (e.g., format), split roles:

• In $L$: hard violation/near-certain break (binary or high margin).

• In $\mathrm{\Gamma }$: approach cost (smooth drift toward break; Sec. 5).

Defaults. Focus on 5–10 highest-yield rules for your domain; keep $\sum {\omega }_j\le 1$.

---

4.4 Latency/Cost Penalty ${\mathrm{l}\mathrm{a}\mathrm{t}\mathrm{e}\mathrm{n}\mathrm{c}\mathrm{y}}_t(i)$ (Tool/Route Switches)

Purpose. Internalize serving costs (ms, $) for tool calls/model switches so decoding defers expensive actions unless value warrants it.

4.4.1 Pre-calibration

Maintain per-tool/route costs ${\widehat{c}}_{\text{tool}}$ (EMA of observed latency/$) in a registry. Update online with outlier clipping.

4.4.2 Per-token penalty

• Deterministic trigger (structured APIs): if token $i$ starts a function/tools block,
  ${\mathrm{l}\mathrm{a}\mathrm{t}\mathrm{e}\mathrm{n}\mathrm{c}\mathrm{y}}_t(i)={\widehat{c}}_{\text{tool}}$.

• Probabilistic trigger (router boundary): if a light router yields $q_t(i)$ = prob. of switch when choosing $i$,
  ${\mathrm{l}\mathrm{a}\mathrm{t}\mathrm{e}\mathrm{n}\mathrm{c}\mathrm{y}}_t(i)={\sum }_{\text{tool}}{q}_t^{\text{tool}}(i){\widehat{c}}_{\text{tool}}$.

• Batch/stream aware: optionally add ${\widehat{c}}_{\text{queue}}$ if the switch would cross a batching boundary.

Normalize to $[0,1]$ by dividing by a cap $c_{\max }$ (e.g., 800 ms or $0.002), then clip.

Note. Keep this content-neutral: only tool/route metadata and measured costs.

---

4.5 Length/Closure Penalty ${\mathrm{l}\mathrm{e}\mathrm{n}\mathrm{\_}\mathrm{p}\mathrm{e}\mathrm{n}}_t(i)$ (Stop Controls)

Purpose. Encourage timely, well-formed termination and prevent rambling or early truncation.

4.5.1 Structural closure

Maintain a small delimiter stack over the output (quotes/brackets/code fences). Define:

$${\mathrm{g}\mathrm{a}\mathrm{p}}_t=\frac{\text{unclosed delimiters}}{\text{unclosed delimiters}+1}\in [0,1]\mathrm{.}$$

If token $i$ reduces ${\mathrm{g}\mathrm{a}\mathrm{p}}_t$ (closes a structure), set ${\mathrm{l}\mathrm{e}\mathrm{n}\mathrm{\_}\mathrm{p}\mathrm{e}\mathrm{n}}_t(i)\downarrow$; if it increases gap or opens new blocks near the end, ${\mathrm{l}\mathrm{e}\mathrm{n}\mathrm{\_}\mathrm{p}\mathrm{e}\mathrm{n}}_t(i)\uparrow$.

4.5.2 Budget-aware stopping

Let $B$ be the remaining token budget; ramp up a stop prior as $B\to 0$:

$$s_t=\mathrm{c}\mathrm{l}\mathrm{i}\mathrm{p}\text{\hspace{0.17em}⁣}(\frac{B_{\text{thresh}}-B}{B_{\text{thresh}}},0,1),{\mathrm{l}\mathrm{e}\mathrm{n}\mathrm{\_}\mathrm{p}\mathrm{e}\mathrm{n}}_t(i)+=s_t\cdot \mathbb{1}\{i\mathrm{\ne }⟨\text{\hspace{0.17em}⁣}\mathrm{/}\text{\hspace{0.17em}⁣}END\text{\hspace{0.17em}⁣}⟩\}\mathrm{.}$$

Conversely, when very early ($t<t_{\text{min}}$), penalize EOS to avoid premature stops.

4.5.3 Task-specific tail shaping

• Summaries/abstracts: encourage concise closure once all required headers covered (link to key-coverage feature).

• Code/JSON: prioritize completing the smallest open structure before introducing new ones.

Normalize $\mathrm{l}\mathrm{e}\mathrm{n}\mathrm{\_}\mathrm{p}\mathrm{e}\mathrm{n}$ with z-score on top-$k$.

---

4.6 Standardization & Calibration (Making $a\mathrm{.}\mathrm{.}e$ portable)

Why. Heterogeneous signals must sit on a common numeric footing so fixed weights or a tiny controller head work across tasks and languages.

4.6.1 Per-step, within-top-k normalization

For each component $X\in \{\tilde{\mathrm{\ell }},\widehat{r},\mathrm{r}\mathrm{i}\mathrm{s}\mathrm{k},\mathrm{l}\mathrm{a}\mathrm{t}\mathrm{e}\mathrm{n}\mathrm{c}\mathrm{y},\mathrm{l}\mathrm{e}\mathrm{n}\mathrm{\_}\mathrm{p}\mathrm{e}\mathrm{n}\}$, compute robust z-scores inside ${\mathcal{K}}_t$ (median/MAD; Sec. 4.1). Clip to $[-3,3]$.

4.6.2 Rolling scale equalization

Maintain EMAs of component variances ${\nu }_X$ per task profile (factual/tool vs creative). Rescale each component by $\sqrt{\bar{\nu }\mathrm{/}{\nu }_X}$ where $\bar{\nu }$ is a shared target variance.

4.6.3 Language/tokenizer calibration

Keep per-language correction factors (Sec. 4.1.5) for $\tilde{\mathrm{\ell }}$ and any parser-dependent metrics (e.g., bracket balance in CJK vs. Latin scripts).

4.6.4 Weighting profiles (defaults)

• Factual/Tool: $a=1.0,b=0.6,c=0.7,d=0.5,e=0.4$.

• Creative: $a=0.8,b=0.3,c=0.2,d=0.1,e=0.2$.
  (Use the trust-region to cap total influence; learn $(a\mathrm{.}\mathrm{.}e)$ with a tiny head if desired.)

---

4.7 Putting it together (pseudocode)

def compute_L_components(topk_logits, topk_tokens, ctx, state):
    # 1) normalized likelihood
    L_ll = normalized_loglik(topk_logits, entropy(topk_logits), state)

    # 2) optional value head (or heuristic)
    feats = build_features(topk_tokens, ctx, state)        # content-neutral
    L_val = value_head(feats) if state.use_head else heuristic_value(feats)
    L_val = 2*L_val - 1  # map [0,1]->[-1,1]

    # 3) risk (syntax/leakage/injection patterns)
    risk = structural_risk(topk_tokens, ctx, state)        # [0,1], z-scored

    # 4) latency/cost (tool/route)
    latency = tool_cost_estimator(topk_tokens, ctx, state) # [0,1], z-scored

    # 5) length/closure
    len_pen = length_closure_pen(topk_tokens, state)       # z-scored

    # robust standardization & clipping
    L_ll, L_val, risk, latency, len_pen = normalize_all(
        [L_ll, L_val, risk, latency, len_pen], state
    )

    # weighted sum (task profile or tiny controller head)
    a,b,c,d,e = state.weights   # possibly predicted by a small head
    L = a*L_ll + b*L_val - c*risk - d*latency - e*len_pen
    return L  # shape [k]

Takeaway. $L_t$ aggregates normalized likelihood with verify-able task progress and operationally meaningful costs, all in a content-neutral, standardized way. It is cheap to compute, portable across tasks/languages, and—together with $\mathrm{\Gamma }$ and trust-region bounds—forms a stable, auditable basis for dissipative Lagrangian decoding.

---

5. Design of the Dissipation Term ${\mathrm{\Gamma }}_t$

We instantiate

$${\mathrm{\Gamma }}_t(i)={\beta }_{\text{topic}}\text{\hspace{0.17em}⁣}\cdot \text{\hspace{0.17em}⁣}\underset{\text{topic drift}}{\underbrace{{\mathrm{\Gamma }}_t^{\text{topic}}(i)}}+{\beta }_{\text{switch}}\text{\hspace{0.17em}⁣}\cdot \text{\hspace{0.17em}⁣}\underset{\text{mode/tool switching}}{\underbrace{{\mathrm{\Gamma }}_t^{\text{switch}}(i)}}+{\beta }_{\text{fmt}}\text{\hspace{0.17em}⁣}\cdot \text{\hspace{0.17em}⁣}\underset{\text{format integrity}}{\underbrace{{\mathrm{\Gamma }}_t^{\text{fmt}}(i)}},$$

with content–neutral, locally-computable signals. All components are standardized within the active candidate set ${\mathcal{K}}_t$ and guarded by the trust-region (Sec. 3.4).

---

5.1 Topic Drift via $1-\cos (e_i,m_{t-1})$ and Multi-Scale EMAs

Goal. Penalize abrupt semantic turns that destabilize long-context reasoning, while allowing controlled flexibility when uncertainty is high or creativity is desired.

5.1.1 Single-scale drift

Let $e_i\in {\mathbb{R}}^d$ be the output embedding of candidate $i$, and $m_{t-1}$ the unit-norm topic EMA:

$$m_t=\mathrm{n}\mathrm{o}\mathrm{r}\mathrm{m}\text{\hspace{0.17em}⁣}(\rho m_{t-1}+(1-\rho )e_{y_t}),\rho \in [0.9,0.99]\mathrm{.}$$

Define the drift penalty

$${\mathrm{\Gamma }}_t^{\text{topic}}(i)=1-\cos \text{\hspace{0.17em}⁣}(e_i,m_{t-1})\in [0,2],$$

z-scored over $i\in {\mathcal{K}}_t$ and clipped.

5.1.2 Multi-scale drift (recommended for long contexts)

Maintain $S$ EMAs with ${\rho }^{(s)}$ spanning short/medium/long horizons (e.g., $\{0.90,0.97,0.995\}$). Aggregate:

$$m_{t-1}^{(\text{mix})}=\mathrm{n}\mathrm{o}\mathrm{r}\mathrm{m}\text{\hspace{0.17em}⁣}\left(\sum _{s=1}^S{\alpha }_s{m}_{t-1}^{(s)}\right),\sum _s{\alpha }_s=1,{\alpha }_s\ge 0,$$ $${\mathrm{\Gamma }}_t^{\text{topic}}(i)=1-\cos \text{\hspace{0.17em}⁣}(e_i,m_{t-1}^{(\text{mix})})\mathrm{.}$$

Entropy gating. Reduce topic penalty when the step is highly uncertain:

$${\mathrm{\Gamma }}_t^{\text{topic}\ast }(i)=g(H_t)\cdot {\mathrm{\Gamma }}_t^{\text{topic}}(i),g(H)=\mathrm{c}\mathrm{l}\mathrm{i}\mathrm{p}\text{\hspace{0.17em}⁣}(\frac{\bar{H}-H}{\bar{H}},0,1),$$

where $\bar{H}$ is a rolling high-percentile of entropy. This permits turns when the model signals ambiguity.

5.1.3 Defaults and cost

• $S=3$, $\rho =\{0.90,0.97,0.995\}$, $\alpha =\{0.2,0.5,0.3\}$.

• Complexity: $O(kd)$ cosine computations per step (vectorized over top-$k$).

---

5.2 Mode/Tool Switch Costs and Hysteresis

Goal. Deter oscillatory decisions (rapid tool-on/off, route flapping) and make switches “sticky” once committed, unless clear value gains appear.

5.2.1 Instantaneous switch cost

Let ${\mathrm{s}\mathrm{w}\mathrm{i}\mathrm{t}\mathrm{c}\mathrm{h}}_t(i)\in [0,1]$ denote the (predicted) initiation of a mode/tool transition if token $i$ is chosen (1 for deterministic sentinels). The instantaneous dissipation:

$${\mathrm{\Gamma }}_t^{\text{switch}}(i)=\underset{\text{normalized latency/\$ cost}}{\underbrace{{\widehat{c}}_{\text{tool}}\mathrm{/}{c}_{\max }}}+\underset{\text{state reset cost}}{\underbrace{{\eta }_{\text{ctx}}\cdot \mathbb{1}\{\text{context teardown}\}}},$$

applied when ${\mathrm{s}\mathrm{w}\mathrm{i}\mathrm{t}\mathrm{c}\mathrm{h}}_t(i)$ is active. ${\widehat{c}}_{\text{tool}}$ comes from an online EMA registry; $c_{\max }$ caps to $[0,1]$.

5.2.2 Hysteresis (Schmitt-trigger style)

To avoid flapping near router boundaries, use two thresholds for the same binary transition:

• enter-switch if $q_t\ge {\theta }_{\text{on}}$,

• remain-in-switch until $q_t\le {\theta }_{\text{off}}$ (${\theta }_{\text{off}}<{\theta }_{\text{on}}$).

Let $s_t\in \{0,1\}$ be the current switch state. Add a persistence penalty if proposing to leave shortly after entering:

$${\mathrm{\Gamma }}_t^{\text{switch}}(i)+={\gamma }_{\text{persist}}\cdot \exp \text{\hspace{0.17em}⁣}(-\frac{t-t_{\text{enter}}}{{\tau }_{\text{switch}}})\cdot \mathbb{1}\{\text{proposal toggles }{s}_t\}\mathrm{.}$$

This decays with time constant ${\tau }_{\text{switch}}$ to tolerate legitimate follow-up edits.

5.2.3 Defaults

• ${\theta }_{\text{on}}=0.65,{\theta }_{\text{off}}=0.45,{\gamma }_{\text{persist}}=0.3,{\tau }_{\text{switch}}=20$ tokens.

• Include context teardown cost only for modes that clear caches or lose planner state.

---

5.3 Format-Integrity Penalties (JSON/brackets/markdown/code blocks)

Goal. Penalize trajectories that approach structural failure—before a hard error—so decoding stays in “easy-to-parse” regions.

5.3.1 Incremental structure checks (prefix + candidate)

For each candidate $i$, test the prefix concatenated with token $i$ against lightweight, incremental validators:

• Delimiters: bracket/quote/fence stack depth ${\mathrm{d}\mathrm{e}\mathrm{p}\mathrm{t}\mathrm{h}}_t$; proposed depth ${\mathrm{d}\mathrm{e}\mathrm{p}\mathrm{t}\mathrm{h}}_t(i)$.

• JSON/CSV: minimal-distance-to-error under a streaming parser (e.g., missing comma/quote).

• Code: indentation validity (Python), premature EOF in string/block, unclosed comment markers.

• Markdown: code-fence balance, table row completeness.

Define smooth margins $u_j(i)\in [0,1]$ that grow as you approach an error (e.g., normalized stack overflow risk, normalized JSON error proximity). Then

$${\mathrm{\Gamma }}_t^{\text{fmt}}(i)=\sum _j{\omega }_j{u}_j(i),\sum _j{\omega }_j=1.$$

Design note. Use margins—not just binary flags—to shape behavior before actual failure.

5.3.2 Early-closure bias near end-of-budget

When the remaining budget $B$ is small, amplify penalties for opening new structures:

$${\mathrm{\Gamma }}_t^{\text{fmt}}(i)+={\lambda }_{\text{tail}}\cdot s_t\cdot \mathbb{1}\{\text{opens new block}\},s_t=\mathrm{c}\mathrm{l}\mathrm{i}\mathrm{p}\text{\hspace{0.17em}⁣}(\frac{B_{\text{thresh}}-B}{B_{\text{thresh}}},0,1)\mathrm{.}$$

5.3.3 Defaults

• Track a tiny delimiter stack, streaming JSON check, and one language-specific code check (if applicable).

• Weights ${\omega }_j$ concentrate on your domain’s highest-yield failures (3–6 terms usually suffice).

---

5.4 Interactions Between $L$ and $\mathrm{\Gamma }$; Over-Smoothing Risks

Separation of roles.

• $L_t$ encodes task value and hard violations (e.g., an actual parse error or certain secret pattern → large ${\mathrm{r}\mathrm{i}\mathrm{s}\mathrm{k}}_t$ term).

• ${\mathrm{\Gamma }}_t$ encodes approach costs to instability: semantic turns, switch hysteresis, proximity to structural failure.

This split avoids double counting and yields intuitive behavior: use $L$ to veto, $\mathrm{\Gamma }$ to damp.

5.4.1 Avoiding over-smoothing

Excessive ${\lambda }_t$ or ${\beta }_{\text{topic}}$ can suppress legitimate novelty. We mitigate via:

1. Entropy gating of ${\mathrm{\Gamma }}^{\text{topic}}$ (Sec. 5.1.2);

2. Adaptive ${\lambda }_t$ that rises with $\mathrm{\Delta }{H}_t$ and falls in calm/creative segments;

3. Trust-region caps (KL/logit) to bound any one-step deviation;

4. Event-triggered micro lookahead only when risk spikes—no global damping.

5.4.2 Cross-terms and conflicts

• If $L$ favors a tool call (value head/latency trade-off) while ${\mathrm{\Gamma }}^{\text{switch}}$ resists frequent toggling, the hysteresis ensures we switch decisively once $L$ justifies it, and remain until clear value for returning appears.

• If $L$ favors adding a key field but ${\mathrm{\Gamma }}^{\text{fmt}}$ penalizes opening braces late in the budget, the controller will prefer closing existing structures first, unless the value head confers sufficient immediate gain.

5.4.3 Recommended defaults & pseudocode

Weights and gates (factual/tool profile):

• ${\beta }_{\text{topic}}=0.6,{\beta }_{\text{switch}}=0.7,{\beta }_{\text{fmt}}=0.8$.

• Enable entropy gating $g(H_t)$ with $\bar{H}$ = rolling 90th percentile.

• Trust-region: ${\tau }_{\mathrm{K}\mathrm{L}}=0.03,ϵ=0.7$.

Computation (drop-in):

def compute_Gamma(topk_idx, topk_emb, state, ctx):
    # Topic drift (multi-scale, entropy-gated)
    m_mix = mix_multi_scale_EMAs(state.ms_emas, weights=state.alpha)   # unit-norm
    drift = 1 - cosine(topk_emb, m_mix)                                # shape [k]
    drift = zscore_clip(drift)
    drift *= entropy_gate(state.H_t, state.H_hi)                       # g(H_t)

    # Mode/tool switching with hysteresis & persistence
    q_switch = router_prob(topk_idx, ctx)                              # [0,1]
    pers = state.gamma_persist * np.exp(-(state.t - state.t_enter)/state.tau_sw)
    toggles = will_toggle(q_switch, state.schmitt)                     # {0,1}

sw = (norm_cost_from_registry(topk_idx, ctx) + state.ctx_reset_cost) * is_switch_token(topk_idx)

    sw += pers * toggles

    # Format integrity (margins to error)
    fmt = structural_margins(topk_idx, ctx, state)                     # weighted sum of margins
    fmt = zscore_clip(fmt)
    fmt += tail_open_penalty(topk_idx, state.B_remain)

    # Aggregate
    return (state.beta_topic * drift
          + state.beta_switch * sw
          + state.beta_fmt    * fmt)                                   # shape [k]

---

Takeaway. ${\mathrm{\Gamma }}_t$ supplies a principled, low-cost friction against destabilizing moves—semantic whiplash, switch flapping, and structure breakage—while preserving flexibility via entropy gating, hysteresis, and trust-region bounds. Paired with $L_t$, it yields a balanced, auditable control law $J=L-\lambda \mathrm{\Gamma }$ for robust, on-task decoding under production latency budgets.

---

6. Adaptive Stability Knob ${\lambda }_t$

We modulate the per-token control strength by an online stability knob ${\lambda }_t$. The goal is simple: be light-touch when the model is calm or when creativity is desired, and increase damping when uncertainty spikes or structural/tool risks are imminent.

---

6.1 Entropy-Responsive Scheduling

We use an entropy- and risk-aware schedule with light smoothing:

$$\boxed{{\displaystyle {\lambda }_t={\lambda }_0(1+{\kappa }_1\underset{\text{entropy spike}}{\underbrace{[H_t-H_{t-1}{]}_{+}}}+{\kappa }_2\underset{\text{risk gate}}{\underbrace{\mathbf{1}\{{\text{risk}}_t\}}})}}$$

where:

• $H_t$ is the (top-$k$) step entropy; $[x{]}_{+}=\max (0,x)$.

• $\mathbf{1}\{{\text{risk}}_t\}=1$ if any risk trigger fires at step $t$: imminent format break, high tool-switch probability, or policy-defined high-risk segment (e.g., secrets handling).

• ${\lambda }_0$ sets the task profile baseline (Sec. 6.2); ${\kappa }_1,{\kappa }_2\ge 0$.

Normalization and smoothing.

• Replace the raw spike by a z-scored variant to make it unitless:

  $$\mathrm{\Delta }{H}_t^{\star }=\mathrm{c}\mathrm{l}\mathrm{i}\mathrm{p}\text{\hspace{0.17em}⁣}(\frac{H_t-H_{t-1}}{{\sigma }_H},0,h_{\max }),{\lambda }_t={\lambda }_0(1+{\kappa }_1\mathrm{\Delta }{H}_t^{\star }+{\kappa }_2\mathbf{1}\{{\text{risk}}_t\})$$

  where ${\sigma }_H$ is a rolling MAD/STD of entropy deltas; $h_{\max }\in [1,3]$.

• Apply a low-pass filter to reduce per-token jitter:

  $${\lambda }_t\leftarrow (1-{\alpha }_{\lambda }){\lambda }_{t-1}+{\alpha }_{\lambda }{\lambda }_t^{\text{raw}},{\alpha }_{\lambda }\in [0.2,0.5]\mathrm{.}$$

Recommended defaults.
Factual/tool profile: ${\lambda }_0\text{\hspace{0.17em}⁣}\in \text{\hspace{0.17em}⁣}[0.6,0.8],{\kappa }_1\text{\hspace{0.17em}⁣}=\text{\hspace{0.17em}⁣}0.6,{\kappa }_2\text{\hspace{0.17em}⁣}=\text{\hspace{0.17em}⁣}0.5$.
Creative profile: ${\lambda }_0\text{\hspace{0.17em}⁣}\in \text{\hspace{0.17em}⁣}[0.2,0.4],{\kappa }_1\text{\hspace{0.17em}⁣}=\text{\hspace{0.17em}⁣}0.3,{\kappa }_2\text{\hspace{0.17em}⁣}=\text{\hspace{0.17em}⁣}0.2$.

---

6.2 Task Profiles: Factual/Tool vs. Creative Generation

We expose $\lambda$ and the weights of $L$ and $\mathrm{\Gamma }$ as profiles—two one-liners you can ship with sane defaults.

Factual / Tool-use (stable, structure-first)

• ${\lambda }_0=0.7$ (↑ damping), ${\kappa }_1=0.6,{\kappa }_2=0.5$

• $a=1.0,b=0.6,c=0.7,d=0.5,e=0.4$ (Sec. 4)

• ${\beta }_{\text{topic}}=0.6,{\beta }_{\text{switch}}=0.7,{\beta }_{\text{fmt}}=0.8$ (Sec. 5)

• Triggers: entropy spike $>\text{\hspace{0.17em}⁣}0.5{\sigma }_H$, any format margin breach, tool-switch prob $>\text{\hspace{0.17em}⁣}0.65$.

Creative (flexible, novelty-friendly)

• ${\lambda }_0=0.3$ (↓ damping), ${\kappa }_1=0.3,{\kappa }_2=0.2$

• $a=0.8,b=0.3,c=0.2,d=0.1,e=0.2$

• ${\beta }_{\text{topic}}=0.3,{\beta }_{\text{switch}}=0.2,{\beta }_{\text{fmt}}=0.4$

• Triggers: only hard format risk and large entropy spikes; topic-drift penalties entropy-gated (Sec. 5.1).

Budget-aware ramping. Near the end of a token budget, multiply ${\lambda }_t$ by $1+{\gamma }_{\text{tail}}{s}_t$ with $s_t$ from Sec. 4.5 to encourage clean closure.

---

6.3 Learning a Small Controller Head for $(a\mathrm{.}\mathrm{.}e,{\beta }_{\text{*}},{\lambda }_t)$

Instead of fixed profiles, a tiny head can output the weights and ${\lambda }_t$ adaptively.

Inputs (content-neutral features).

$${\psi }_t=[H_t,\mathrm{\Delta }{H}_t^{\star },\min \text{\hspace{0.17em}⁣}\mathrm{/}\text{\hspace{0.17em}⁣}\mathrm{m}\mathrm{e}\mathrm{a}\mathrm{n}\text{topic drift},\text{fmt margins},\text{tool-switch prob},\text{tool cost},\text{budget tail }{s}_t,\text{task tag}]$$

All are locally available, auditable scalars (Secs. 4–5).

Architecture.

• 2-layer MLP (e.g., 32–64 hidden units, GELU), layer-norm, with bounded outputs:

  • $a\mathrm{.}\mathrm{.}e$ and ${\beta }_{\text{*}}$ via softplus then normalize to fixed sums.

  • ${\lambda }_t$ via ${\lambda }_t={\lambda }_{\min }+\sigma (\cdot )({\lambda }_{\max }-{\lambda }_{\min })$ with ${\lambda }_{\min }\text{\hspace{0.17em}⁣}\ge 0$.

• Optional monotonicity regularizers: penalize negative correlation between $\mathrm{\Delta }{H}_t^{\star }$ and ${\lambda }_t$ to encourage $\mathrm{\partial }\lambda \mathrm{/}\mathrm{\partial }\mathrm{\Delta }{H}^{\star }\ge 0$.

Training targets (three simple options).

1. Oracle distillation. On logged prefixes, compute a short-horizon “teacher” by evaluating ${\sum }_{j=t}^{t+h}(L-\lambda \mathrm{\Gamma })$. Minimize regret between the teacher’s chosen action and the controller’s choice (cross-entropy over the top-$k$ actions).

2. Stability-utility regression. Predict next-step stability gains (↓ entropy spike, ↓ format violations) and utility (↑ parse/compile pass, ↑ tool success), then map predictions to weights and ${\lambda }_t$ via a small analytic layer.

3. Bandit fine-tuning online. Use lightweight bandit updates with logged propensities under KL constraints; keep trust-region small.

Safety. Keep the trust-region (KL/logit caps) active regardless of learned outputs; bound ${\lambda }_t$ into $[{\lambda }_{\min },{\lambda }_{\max }]$ and clip all per-component z-scores.

---

6.4 Stability–Novelty Trade-offs

The knob ${\lambda }_t$ mediates a triad: stability, structure, novelty.

Guidelines.

• When to raise $\lambda$: entropy spikes, pre-switch hesitation (routing boundary), near-error format margins, end-of-budget closure, safety-critical passages (policies/secrets).

• When to lower $\lambda$: early creative phases, exploration segments, paraphrase diversity, when topic drift is desired (e.g., brainstorming).

• Interplay with temperature/top-p: raising ${\lambda }_t$ allows you to run a slightly higher temperature/top-p without losing structure—useful for creative factual blends.

• Trust-region as governor: if ${\lambda }_t$ increases but KL/logit caps bind, the controller’s effect remains small and auditable; increase caps only with explicit consent and monitoring.

Diagnosing over-smoothing.

• Symptoms: loss of novelty, repetitive phrasing, missed legitimate tool calls.

• Fixes: (i) enable entropy gating on topic drift; (ii) reduce ${\beta }_{\text{topic}}$ or ${\lambda }_0$ for the profile; (iii) narrow triggers so micro lookahead only fires at genuine risks; (iv) raise the KL budget slightly (e.g., $\tau$ from 0.02→0.03) while monitoring bias gaps.

Quantitative trade-off meter.
Track two dashboards per task: Stability Gain (↓ drift rate, ↓ entropy spikes, ↓ format violations) vs Novelty/Quality (human pref, diversity, pass@k for code). Sweep ${\lambda }_0$ and ${\kappa }_1$ on a held-out set to choose operating points; log $\{{\lambda }_t,\text{KL}\}$ distributions to ensure consistent guardrails.

---

Takeaway. ${\lambda }_t$ is a small, interpretable control that lets the system be stable when it must and creative when it can. With entropy-responsive scheduling, profile presets, and (optionally) a tiny learned head—always under trust-region guards—you get predictable, auditable behavior that adapts per token without retraining.

---

7. Algorithms

7.1 Γ-Lite Single-Step Controller (Near-Zero Overhead)

7.1.1 Per-Token Pipeline and Complexity $O(kd)$

Inputs at step $t$: top-$k$ logits $z_{t,\mathcal{K}}$, top-$k$ token ids ${\mathcal{K}}_t$, their output embeddings $E[{\mathcal{K}}_t]\in {\mathbb{R}}^{k\times d}$, rolling stats $(H_{t-1},m_{t-1})$, delimiter stack & tool metadata.

Steps (vectorized over the $k$ candidates):

1. Compute normalized likelihood ${\tilde{\mathrm{\ell }}}_t(i)$ (Sec. 4.1).

2. Compute value head/heuristics ${\widehat{r}}_t(i)$ (optional; Sec. 4.2).

3. Compute risk/latency/length terms (Sec. 4.3–4.5).

4. Aggregate value $L_t(i)$ (Sec. 4).

5. Compute dissipation ${\mathrm{\Gamma }}_t(i)$: topic-drift via $1-\cos (e_i,m_{t-1})$, switch, format margins (Sec. 5).

6. Compute adaptive ${\lambda }_t$ (Sec. 6); form $J_t(i)=L_t(i)-{\lambda }_t{\mathrm{\Gamma }}_t(i)$.

7. Trust-region projection to produce safe logit adjustments ${\mathrm{\Delta }}_t(i)$ (Sec. 7.1.2).

8. Select $y_t=\arg {\max }_{i\in {\mathcal{K}}_t}\{z_t(i)+{\mathrm{\Delta }}_t(i)\}$ (or sample from ${\pi }_t^{\mathrm{\prime }}$).

9. Update $m_t$ (EMA), $H_t$, delimiter stack; log diagnostics.

Cost: extra cosines for drift $O(kd)$ + $O(k)$ scalar features. For $k\in [5,50]$ and typical $d\in [512,4096]$, the overhead is negligible compared to a model forward.

---

7.1.2 Trust-Region Projection and Zero-Mean Logit Adjustment

We bound the controller’s deviation from the base distribution.

Exponential tilting under a KL budget.
Let the baseline restricted distribution be $p(i)\propto \exp z(i)$ over ${\mathcal{K}}_t$. Let centered scores

$$s(i)=\mathrm{s}\mathrm{t}\mathrm{d}\mathrm{z}\text{\hspace{0.17em}⁣}(J_t(i))\text{with}\sum _{i\in {\mathcal{K}}_t}p(i)s(i)=0.$$

We seek $\eta \ge 0$ such that

$$p^{\mathrm{\prime }}(i)\propto p(i)\exp (\eta s(i)),\mathrm{K}\mathrm{L}(p^{\mathrm{\prime }}\text{\hspace{0.17em}⁣}\parallel p)\le \tau \mathrm{.}$$

Solve $\eta$ by bisection on $[0,{\eta }_{\max }]$ (fast in practice; monotone KL). The induced logit shift is $\mathrm{\Delta }(i)=\log \frac{p^{\mathrm{\prime }}(i)}{p(i)}=\eta s(i)-\log Z$, where $\log Z$ centers the shift (zero-mean over ${\mathcal{K}}_t$). Finally, clip $\mathrm{\Delta }(i)$ to $[-ϵ,ϵ]$ to enforce a per-token logit cap. If no $\eta$ satisfies both caps, set $\mathrm{\Delta }=0$ (fallback).

Zero-mean adjustment.
We explicitly subtract $\bar{\mathrm{\Delta }}={\sum }_i{w}_i\mathrm{\Delta }(i)$ with $w_i\propto p(i)$ to keep the total mass balanced over ${\mathcal{K}}_t$. This stabilizes sampling temperature and avoids spurious length effects.

---

7.1.3 Pseudocode and Implementation Notes

def step_decode(logits_k, ids_k, emb_k, state, ctx):
    # logits_k: [k], ids_k: [k], emb_k: [k,d] (L2-normalized rows recommended)
    # 1) value components
    L_ll   = normalized_loglik(logits_k, entropy(logits_k), state)        # Sec 4.1
    L_val  = value_head_or_heuristic(ids_k, ctx, state)                   # Sec 4.2 (optional)
    risk   = structural_risk(ids_k, ctx, state)                           # Sec 4.3
    lat    = tool_cost_estimator(ids_k, ctx, state)                       # Sec 4.4
    lpen   = length_closure_pen(ids_k, state)                              # Sec 4.5
    L      = combine_value(L_ll, L_val, risk, lat, lpen, state)            # weights a..e

    # 2) dissipation Γ
    drift  = 1 - cosine(emb_k, state.m_prev)                               # topic EMA
    sw     = switch_cost(ids_k, ctx, state)                                # hysteresis
    fmt    = format_margins(ids_k, ctx, state)
    Gamma  = combine_dissipation(drift, sw, fmt, state)                    # β_topic, β_switch, β_fmt

    # 3) adaptive λ and local objective
    lam    = schedule_lambda(state, risk_trigger=any_risk(ids_k, ctx))
    J      = L - lam * Gamma

    # 4) trust-region projection
    delta  = project_with_kl_and_cap(logits_k, J, tau=state.tau, eps=state.eps)

    # 5) select and update
    y_idx  = ids_k[np.argmax(logits_k + delta)]
    update_rollings(state, chosen_id=y_idx, emb_k=emb_k, logits_k=logits_k)
    return y_idx, delta

Notes.

• Vectorize all top-$k$ ops; pre-normalize output embeddings to unit length offline.

• Keep rolling percentiles of entropy for gating/tapering; store a few EMAs only.

• Perform shadow mode first: compute $\mathrm{\Delta }$ but don’t apply; log {ΔH, drift, fmt_ok, toolcost, λ, Δlogit, KL}.

• Trust-region bisection converges in ~10 iters on scalars; amortize constants.

---

7.2 Event-Triggered Short-Horizon Control

7.2.1 Triggers: $\mathrm{\Delta }H$, Format Breaks, Imminent Tool Calls

Fire micro lookahead if any of:

• Entropy spike: $\mathrm{\Delta }{H}_t>{\theta }_H$ (e.g., $>0.5{\sigma }_H$).

• Format risk: top candidate’s fmt_pen exceeds ${\theta }_{\mathrm{f}\mathrm{m}\mathrm{t}}$.

• Tool boundary: router probability near threshold; many top tokens would initiate a switch.

• Large topic turn: all top-$k$ candidates have drift above ${\theta }_{\text{topic}}$.

Use debounce (e.g., minimum 5 tokens between triggers) to avoid thrashing.

---

7.2.2 Micro Lookahead (h=2–4, B=2–4) and Roll-Forward Scoring $\sum (L-\lambda \mathrm{\Gamma })$

When triggered, unroll a tiny beam of width $B$ and depth $h$ (e.g., $B=3,h=3$):

1. Start from current state $(m_{t-1},H_{t-1},\text{stack},s_{\text{switch}})$.

2. For each candidate branch, simulate the next $h$ steps:

   • Maintain approximate roll-forward updates: update EMA $m$ with the branch’s chosen embeddings; update delimiter stack; update switch state by hysteresis; update $H$ with an entropy surrogate (from logits of the branch’s top-$k$).

   • At each simulated step $j$, compute $L_j,{\mathrm{\Gamma }}_j,{\lambda }_j$ as usual but using the simulated state.

3. Score each branch by

   $$S_{\text{branch}}=\sum _{j=t}^{t+h}(L_j-{\lambda }_j{\mathrm{\Gamma }}_j),$$

   then rank branches by $S_{\text{branch}}$.

The lookahead is myopic: we only commit the first token of the best branch, then revert to single-step (Sec. 7.2.3).

Practical approximations.

• Limit candidates per simulated step to the top-$b$ (e.g., $b=2$) of that branch.

• Cache logits for shared prefixes across branches (most branches share first tokens).

• If tool calls require real external latencies, use expected cost from the registry (Sec. 4.4).

---

7.2.3 Commit-One, Revert-to-Single-Step Strategy

After ranking branches, emit only the next token from the top branch. All simulated state is discarded except logging. This preserves near-greedy latency while resolving risky inflection points more carefully.

Backoff: If the lookahead fails the trust-region (KL/logit caps) or exceeds a latency budget for step $t$, skip and fall back to Γ-lite.

---

7.2.4 Pseudocode and Complexity Analysis

def micro_lookahead(base_logits, base_ids, base_emb, state, ctx, B=3, h=3, b=2):
    # Initialize beam with current top-k as depth-1 seeds
    seeds = topk_candidates(base_logits, base_ids, top=b)
    branches = [init_branch(seed, state, ctx) for seed in seeds]  # per-branch simulated state

    for depth in range(h):
        new_branches = []
        for br in branches:
            # simulate one step on this branch (Γ-lite + trust-region INSIDE branch)
            logits_k, ids_k, emb_k = forward_topk(br.sim_state)        # cached/partial reuse
            L   = compute_L_components(logits_k, ids_k, br.sim_state.ctx, br.sim_state)
            G   = compute_Gamma(ids_k, emb_k, br.sim_state, br.sim_state.ctx)
            lam = schedule_lambda(br.sim_state, risk_trigger=any_risk(ids_k, br.sim_state.ctx))
            J   = L - lam * G

            # pick top-b expansions for this branch
            idx = np.argsort(J)[-b:]
            for i in idx:
                br2 = br.clone()
                br2.score += J[i]
                br2.append(ids_k[i], emb_k[i])
                new_branches.append(br2)

        # prune to beam B by cumulative score
        branches = topB_by_score(new_branches, B)

    best = argmax_by_score(branches)
    return best.first_token(), diagnostics(branches)

Complexity.
Let $C_f$ be a single model forward for top-$k$. Γ-lite adds $O(kd)$. The lookahead adds roughly

$$O(h\cdot B\cdot (C_f+kd))$$

only on triggered steps (empirically <5–10% of tokens). With $h\text{\hspace{0.17em}⁣}\in \text{\hspace{0.17em}⁣}[2,4]$, $B\text{\hspace{0.17em}⁣}\in \text{\hspace{0.17em}⁣}[2,4]$, this is a small multiple of a single step.

Latency guard.
Impose a per-step time cap (e.g., +10–20 ms over baseline). If exceeded, abort lookahead and emit Γ-lite result.

---

7.3 Paragraph/Section Re-Ranking (Heavyweight; Premium Use)

7.3.1 Candidate Generation and Accumulated $J$ Ranking

For premium tasks (legal drafting, long technical sections), generate $N$ paragraph/section candidates with your baseline decoder (diverse sampling or small beams). For each candidate sequence $y_{1:T}$, compute the accumulated objective

$$J_{\text{acc}}(y_{1:T})=\sum _{t=1}^T(L_t(y_t)-{\lambda }_t{\mathrm{\Gamma }}_t(y_t)),$$

using the same per-token components and rolling updates as in online decoding (replayable because all features are local).

Rank candidates by $J_{\text{acc}}$ and output top-1 or perform MBR-style expected utility over a small neighborhood. Optionally combine with a standard quality reranker (orthogonal to our objective).

Why it helps: paragraph-level reranking catches late-stage format risks, topic drift, and gratuitous tool switches that token-local control may occasionally miss.

---

7.3.2 Use Cases and Caching

Use cases.

• Strictly structured outputs: long JSON schemas, code files needing compile/parse success.

• High-stakes tool workflows: multi-call planners where wrong first call is costly.

• Long-form expository writing: ensure topic coherence across subsections.

Caching & efficiency.

• Use prefix caching for model forwards across candidates.

• Batch the per-token feature extraction for all candidates.

• Reuse the same registry for tool costs and the same validators (format/AST) to ensure consistency.

Cost control.
Limit to $N\in [2,5]$ candidates and section boundaries only; avoid full-document reranking. Provide a user-visible “premium mode” toggle.

---

Summary of Section 7.

• Γ-lite: a one-pass, $O(kd)$ controller that runs every step and costs almost nothing.

• Event-triggered lookahead: a tiny MPC that activates only at risky inflection points, committing one token and reverting.

• Paragraph reranking: an optional heavyweight pass for premium segments, ranking by accumulated $J$.

Across all modes, trust-region guards (KL + logit caps) ensure bounded, auditable deviations from the base model, enabling safe deployment under tight latency budgets.

---

8. Safety, Auditability, and Bias Control

This section operationalizes safety for dissipative Lagrangian decoding. The goals are: (i) mechanism-relevant, content-neutral signals; (ii) bounded influence via trust-regions; (iii) observable behavior through shadow mode and logs; (iv) measurable fairness through counterfactual tests; (v) robustness across languages/tokenizers; and (vi) guardrails against failure modes.

---

8.1 Principled Signal Selection (PSS): Mechanism-Relevant, Content-Neutral, Auditable

Selection rules (must):

• Mechanism-relevant: only signals tied to decoding failure modes—uncertainty spikes (ΔH), topic drift $(1-\cos (e_i,m))$, format margins (JSON/AST/quotes), tool costs (pre-calibrated latency/$), length/closure.

• Content-neutral: exclude identity/stance/ideology proxies; avoid uncalibrated “toxicity”/sentiment classifiers. Risk checks are syntax/shape (PII patterns, SQL/HTML injection shapes, delimiter balance).

• Auditable: each signal is a scalar with units, bounds, and provenance (regex name, parser version, cost registry ID). Log values every step.

Rejection rules (must not):

• No direct use of protected attributes or likely proxies (names, locations, group terms).

• No external black-box value models at inference time.

• No signals that require deep semantic judgment of beliefs/values.

Documentation (per signal):

• Definition (formula/regex/parser rule), range (min/max), update cadence, owner, test cases, known caveats.

---

8.2 Trust-Region Decoding: KL Bound $\le \tau$ and Logit Caps $\mathrm{\mid }\mathrm{\Delta }\text{logit}\mathrm{\mid }\le ϵ$

We bound the controller’s stepwise influence against the base distribution $p$.

Exponential tilting:

$$p^{\mathrm{\prime }}(i)\propto p(i)\exp (\eta s(i)),s(i)=\mathrm{s}\mathrm{t}\mathrm{d}\mathrm{z}(J_t(i)),\sum _{i}p(i)s(i)=0.$$

Constraints:

$$\mathrm{K}\mathrm{L}(p^{\mathrm{\prime }}\mathrm{\parallel }p)\le \tau ,\mathrm{\mid }\mathrm{\Delta }(i)\mathrm{\mid }\le ϵ,\mathrm{\Delta }(i)=\log \text{\hspace{0.17em}⁣}\frac{p^{\mathrm{\prime }}(i)}{p(i)}\mathrm{.}$$

Computation:

• Solve for $\eta \ge 0$ via bisection to satisfy the KL budget (monotone in $\eta$).

• Apply zero-mean centering of $\mathrm{\Delta }$ over top-$k$ (mass-preserving on the restricted set).

• If no feasible $\eta$ meets both caps, set $\mathrm{\Delta }\text{\hspace{0.17em}⁣}=\text{\hspace{0.17em}⁣}0$ (fallback to baseline).

Deployment defaults: $\tau \in [0.02,0.05]$, $ϵ\in [0.5,1.0]$. Keep a config file mapping product surfaces to $(\tau ,ϵ)$.

---

8.3 Shadow Mode and Incremental Enablement

Shadow mode (log-only): run the controller, compute $J,L,\mathrm{\Gamma },\lambda$, and record the hypothetical $\mathrm{\Delta }$ and diagnostics without altering outputs.

Log schema (per token):

{ ts, req_id, step, model_id, k, 
  H, dH, drift_min, drift_mean, fmt_margin, tool_prob, tool_cost,
  L_components:{zlik,val,risk,lat,len}, 
  Gamma_components:{topic,switch,fmt}, 
  lambda, KL, max_abs_delta, trigger_flags, 
  baseline_choice, ctrl_argmax, applied:false }

Enablement ladder:

1. Shadow for N requests; verify no bias amplification (Sec. 8.4) and acceptable latency headroom.

2. Canary: apply with tiny caps (e.g., $\tau =0.01,ϵ=0.3$) to 1–5% traffic; monitor dashboards.

3. Gradual rollout: widen to target $\tau ,ϵ$ and turn on event-triggered lookahead; keep paragraph reranking off unless premium context.

4. Safeguard: a dead-man switch disables the controller if latency, KL, or error counters breach SLOs.

---

8.4 Counterfactual Tests (Identity Swaps) and Bias-Gap Reporting

Purpose: ensure the controller does not increase disparities across protected attributes.

Method:

• Build paired prompts differing only in a target term (e.g., “he/she”, “Country A/B”, names spanning demographics).

• Run baseline and controller conditions.

• Define task-appropriate outcomes $O$ (e.g., tool-call decision, JSON parse success, refusal rate, toxicity flag, price quote).

• Compute bias gap:

$${\mathrm{\Delta }}_{\text{bias}}^{\text{base}}=\mid \mathbb{E}[O\mid A]-\mathbb{E}[O\mid B]\mid ,{\mathrm{\Delta }}_{\text{bias}}^{\text{ctrl}}=\mid {\mathbb{E}}^{\mathrm{\prime }}[O\mid A]-{\mathbb{E}}^{\mathrm{\prime }}[O\mid B]\mid \mathrm{.}$$

• Pass criterion: ${\mathrm{\Delta }}_{\text{ctrl}}\le {\mathrm{\Delta }}_{\text{base}}+\delta$ for small $\delta$ (e.g., 0.5 pp). Report confidence intervals via bootstrap.

Reporting:

• Publish per-task bias gaps, KL distributions, and activation rates (how often triggers fire) per cohort.

• Keep a changelog of signal/weight updates with A/B evidence that gaps did not widen.

---

8.5 Language/Tokenization Calibration and Robustness Checks

Calibration:

• Maintain per-language rolling scales for likelihood variance and parser margins (Sec. 4.1.5), producing normalization factors ${\zeta }_{\text{lang}}\in [0.5,2]$.

• Localize format validators (e.g., full-width punctuation, RTL markers).

Robustness checks (pre-ship & periodic):

• Ablation: disable each signal in $\{\tilde{\mathrm{\ell }},\widehat{r},\text{risk},\text{latency},\text{len},\text{drift},\text{switch},\text{fmt}\}$; confirm stability gains originate from mechanism-relevant signals.

• Noise injection: add small noise to signals and verify outputs are Lipschitz under trust-region caps.

• Distribution drift: recompute cost registry EMAs; alert if tool costs shift >30% week-over-week.

• Tokenizer changes: re-run calibration after model/version or tokenizer updates.

• Replay tests: deterministically replay logged sessions to ensure reproducibility under the same seeds and controller version.

---

8.6 Failure Modes and Guardrails

Failure mode	Symptom	Guardrail / Mitigation
Over-smoothing (λ too high / β_topic too large)	Bland text, missed rightful tool calls	Entropy-gated drift; lower ${\lambda }_0,{\beta }_{\text{topic}}$; tighten triggers; monitor novelty metrics; cap KL smaller
Proxy bias creep (a signal correlates with protected content)	Counterfactual gaps widen under controller	PSS audit; remove/replace signal; re-run counterfactual suites; keep trust-region smaller on sensitive surfaces
Router flapping	Rapid tool on/off	Hysteresis thresholds; persistence penalty; increase ${\tau }_{\text{switch}}$
Format validator brittleness	False positives/negatives in certain locales	Localize validators; add per-language tests; backstop with paragraph reranker for premium tasks
Cost miscalibration	Unwarranted tool avoidance or eagerness	Online EMA with outlier clipping; guardrails on ${\widehat{c}}_{\text{tool}}$ change rate; periodic manual spot checks
Latency blow-ups on lookahead	P99 spikes when triggers chain	Per-step time cap; debounce triggers; drop to Γ-lite; sample-based lookahead (b=2)
Numerical instability	NaNs/inf scores under extreme logits	Robust z-scores (median/MAD), ${ϵ}_{\sigma }$ floors, clipping of all standardized features
Version drift	Different behavior across deployments	Pin controller + validators + cost registry versions; include in log schema; add CI replay tests

Global safety levers:

• Hard off-switch per product surface.

• Caps: keep $\tau ,ϵ$ small by default; expose only in admin config.

• Audit trails: immutable logs of decisions and features (retention per policy).

• Human-in-the-loop for premium or regulated workflows (require confirmation on tool switches over a threshold cost).

---

Takeaway. By restricting to content-neutral, mechanism-grounded signals, enforcing trust-region bounds, launching via shadow→canary with counterfactual audits, calibrating across languages, and installing guardrails for known failure modes, dissipative Lagrangian decoding can be deployed safely and transparently under real production constraints.

---

9. Prompt-Level Approximation (No Decoder Changes)

When low-level logits/embeddings are not accessible (e.g., vendor APIs), we can approximate dissipative Lagrangian decoding at the prompt layer. The model is instructed to internally maximize $J=L-\lambda \mathrm{\Gamma }$ using content-neutral cues and to output only the final answer plus a compact scorecard. This delivers measurable stability benefits without modifying the decoder—albeit with coarser control than Sections 4–7.

---

9.1 The L×Γ Protocol Prompt Schema and Scorecard Output

Goal. Provide a standard instruction block that (i) tells the model what to optimize, (ii) constrains what it may consider (content-neutral signals only), and (iii) forces a short, auditable scorecard—not chain-of-thought.

Schema (prepend to task prompt):

[L×Γ Protocol — internal evaluation only; do not reveal reasoning]

You will internally choose text that maximizes J = L − λ·Γ.

L (value) = task fitness + verifiability − verbosity cost.
Γ (dissipation) = topic shift + format break risk + unnecessary tool switch.

Signals you may use (content-neutral only):
 • Task fitness: direct adherence to the user instruction; presence of required headers/fields.
 • Verifiability: references/citations presence (if asked), code/JSON parseability.
 • Verbosity: unnecessary repetition or filler.
 • Topic shift: deviation from the stated topic/goal.
 • Format risk: JSON/bracket/markdown/code-fence integrity.
 • Tool switch: only if the user explicitly requests tools/functions or the spec requires them.

Forbidden signals:
 • Any identity/stance/ideology or their proxies.
 • Unverified world claims not requested by the user.

Output policy:
 • Produce the final answer only.
 • Do NOT show your intermediate scoring or reasoning.
 • Append a one-line scorecard: 
   [scorecard: L=., Γ=., λ=., J=.; constraints: topic=✓/×, format=✓/×, tools=used/none]

Example (task body follows schema):

Task: Return a valid JSON object with keys {"title","bullets"} summarizing the spec in ≤80 words.
λ = 0.6  # factual/format-critical task

The scorecard is numerical + tick marks (no deliberation text), enabling audits while respecting “no chain-of-thought” disclosure.

---

9.2 Setting $\lambda$ for Task Families and Do/Don’t Rules

Profiles (drop-in defaults):

• Factual / Tool-use / Structured outputs (stable)
  $\lambda =0.6\text{\hspace{0.17em}⁣}-\text{\hspace{0.17em}⁣}0.8$.
  Do: enforce format; minimize topic drift; avoid tool calls unless specified.
  Don’t: introduce new claims, switch formats mid-answer, invoke tools unprompted.

• Creative / Brainstorming (novelty-friendly)
  $\lambda =0.2\text{\hspace{0.17em}⁣}-\text{\hspace{0.17em}⁣}0.4$.
  Do: vary diction and ideas within topic; keep structure minimally consistent.
  Don’t: break requested format; avoid abrupt style whiplash.

• Long-context synthesis (coherence-first)
  $\lambda =0.4\text{\hspace{0.17em}⁣}-\text{\hspace{0.17em}⁣}0.6$.
  Do: keep headings/sections consistent; recap constraints before closing.
  Don’t: open new threads near the end; avoid late tool switches.

Operational rules baked into the schema:

• Assumptions: if required, prefix a brief “Assumption:” line (≤1 sentence) and proceed; count unjustified assumptions against $L$.

• Format guard: if JSON/code invalid, fix before emitting; mark format=× in scorecard only if constraints forced a compromise.

• Tooling: “tools=used” only when user spec requires it; otherwise tools=none (Γ penalizes gratuitous calls).

---

9.3 Empirical Limits vs. Decoder-Level Control

Prompt-only control is coarser than the decoder-level scheme:

• No token embeddings / entropy: the model estimates “topic shift” implicitly; it cannot compute $1-\cos (e_i,m)$ or $\mathrm{\Delta }H$.

• No trust-region KL cap: deviations from the base distribution aren’t bounded mathematically; audits rely on the scorecard and A/B outcomes.

• No micro lookahead: event-triggered short-horizon simulation (Sec. 7.2) isn’t available; recovery from risky steps is weaker.

• Self-scoring variance: the model’s internal $L,\mathrm{\Gamma }$ estimates can drift with prompts or versions.

Nevertheless, in practice you still gain:

• Lower format violation rates (explicit format guard).

• Lower topic whiplash (explicit topic constraint and penalty).

• Better closure discipline (verbosity counted against $L$).

• Auditable behavioral intent via the scorecard.

Use prompt-level control when you cannot access logits/embeddings; prefer decoder-level control whenever possible.

---

9.4 Safety Considerations for Prompt-Only Control

Content neutrality & scope

• Embed the Forbidden signals list verbatim (above).

• State that the model must not incorporate identity/stance proxies into $L$ or $\mathrm{\Gamma }$.

• Require Assumption: tags for any necessary guesses to keep unverifiable content explicit.

Bias & audit

• Keep the scorecard mandatory; log it server-side.

• Run counterfactual identity-swap tests (Sec. 8.4) with and without the protocol to verify no bias gap increase.

• Track activation rate of format/constraint ticks across cohorts.

Robustness

• Freeze and version the exact schema text; minor wording changes can affect behavior.

• Localize examples for language/script differences (full-width punctuation, RTL markers).

• Use shadow mode first: append scorecard but ignore it downstream; compare metrics vs. baseline.

Failure modes & guardrails

• Over-policing creativity at high $\lambda$: ship separate creative schema with $\lambda \text{\hspace{0.17em}⁣}\le \text{\hspace{0.17em}⁣}0.4$ and relaxed “topic shift” phrasing.

• Under-enforcement: if format violations persist, move to decoder-level validators or enable paragraph re-ranking (Sec. 7.3) for premium tasks.

• Hallucination pressure: include “No new factual claims unless requested; cite or defer” line in the schema; count violations against $L$.

---

Prompt Snippets (ready-to-use)

Factual / JSON (λ=0.7):

[L×Γ Protocol — internal only]
Maximize J = L − λ·Γ with λ=0.7.
L: task fitness (JSON validity, required keys) + verifiability − verbosity.
Γ: topic shift + format break risk + unnecessary tool use.
Forbidden: identity/stance proxies; unrequested claims.
Output: valid JSON only, then
[scorecard: L=., Γ=., λ=0.7, J=.; constraints: topic=✓/×, format=✓/×, tools=used/none]
Task: ...

Creative / Outline (λ=0.3):

[L×Γ Protocol — internal only]
Maximize J with λ=0.3 (allow variation; keep structure).
L: originality within topic + clarity − redundancy.
Γ: format break risk; extreme topic whiplash; avoid tool use unless asked.
Forbidden: identity/stance proxies.
Output: final outline only + scorecard line.
Task: ...

Takeaway. Prompt-level L×Γ gives you a zero-integration path to steadier outputs and auditable behavior, while preserving privacy and neutrality. It is not a substitute for decoder-level control, but it provides a practical bridge when the serving stack is closed.

---

10. Theoretical Properties and Boundaries

This section states the conditions under which dissipative Lagrangian decoding behaves predictably, what the trust-region guarantees, when the method should not be used alone, and how to remedy boundary cases. We aim for operational theorems—clean enough to implement, conservative enough for production.

---

10.1 Conditions for Smoothness and Local Sufficiency

We formalize when the local decision rule

$$y_t=\arg \underset{i\in {\mathcal{K}}_t}{\max }{J}_t(i),J_t(i)=L_t(i)-{\lambda }_t{\mathrm{\Gamma }}_t(i)$$

is an adequate proxy for trajectory-level improvement.

Assumptions (A)

• A1 (Local observables). $L_t,{\mathrm{\Gamma }}_t$ depend only on step-local signals and short memory: top-$k$ logits, output embeddings, delimiter stack, short EMAs (Sec. 3–5).

• A2 (Lipschitz & boundedness). There exist $K_L,K_{\mathrm{\Gamma }}<\mathrm{\infty }$ such that for any two candidates $i,j$ with embeddings $e_i,e_j$ and local features ${\varphi }_i,{\varphi }_j$,

  $$\mathrm{\mid }{L}_t(i)-L_t(j)\mathrm{\mid }\le K_L\mathrm{\parallel }[e_i,{\varphi }_i]-[e_j,{\varphi }_j]\mathrm{\parallel },\mathrm{\mid }{\mathrm{\Gamma }}_t(i)-{\mathrm{\Gamma }}_t(j)\mathrm{\mid }\le K_{\mathrm{\Gamma }}\mathrm{\parallel }[e_i,{\varphi }_i]-[e_j,{\varphi }_j]\mathrm{\parallel }\mathrm{.}$$

  All components are clipped to compact ranges (Secs. 4–5).

• A3 (Weak inter-step coupling). The effect of choosing $y_t$ on future $J_{t+1:t+h}$ is smooth and discounted by short EMAs and hysteresis; formally, the sensitivity decays geometrically with horizon $h$ at rate $\rho \in (0,1)$.

• A4 (Trust-region). Per-step deviation from the base distribution is bounded by KL $\le \tau$ and logit caps $\mathrm{\mid }\mathrm{\Delta }\mathrm{\mid }\le ϵ$ (Sec. 3.4).

Proposition 10.1 (Local sufficiency under weak coupling)

Under A1–A4, the myopic maximizer of $J_t$ is a first-order optimal step for the discounted trajectory objective

$$\sum _{j=t}^{t+h}{\gamma }^{j-t}(L_j-{\lambda }_j{\mathrm{\Gamma }}_j),\gamma \in (\rho ,1),$$

in the sense that any alternative one-step deviation yields at most $O((1-\gamma {)}^{-1}K\delta )$ improvement, where $K=K_L+{\lambda }_{\max }{K}_{\mathrm{\Gamma }}$ and $\delta$ is the per-step feature change induced by the trust-region.

Sketch. Envelope-type arguments: with short memory (A3), the gradient of the $h$-step objective at step $t$ aligns with $\mathrm{\nabla }{J}_t$ up to $O(\rho )$. Trust-region (A4) bounds the step size in the simplex, yielding the regret bound.

Implication. With short memory and bounded shifts, greedy $J$ (plus tiny lookahead when triggers fire) is a principled MPC proxy.

---

10.2 Trust-Region as Stability / Lyapunov-Like Control

The KL-bounded exponential tilt has well-known stability consequences.

Proposition 10.2 (Bounded distribution shift)

Let $p$ be the base restricted distribution on ${\mathcal{K}}_t$ and $p^{\mathrm{\prime }}$ the tilted distribution with
$\mathrm{K}\mathrm{L}(p^{\mathrm{\prime }}\mathrm{\parallel }p)\le \tau$. Then:

$$\mathrm{\parallel }{p}^{\mathrm{\prime }}-p{\mathrm{\parallel }}_{\mathrm{T}\mathrm{V}}\le \sqrt{2\tau }\text{(Pinsker)},$$

and for any bounded step-local functional $f:{\mathcal{K}}_t\text{\hspace{0.17em}⁣}\to \text{\hspace{0.17em}⁣}[a,b]$,

$$\mid {\mathbb{E}}_{p^{\mathrm{\prime }}}[f]-{\mathbb{E}}_p[f]\mid \le (b-a)\sqrt{2\tau }\mathrm{.}$$

With an additional logit cap $\mathrm{\mid }\mathrm{\Delta }\mathrm{\mid }\le ϵ$, each coordinate shift is bounded, curbing extreme re-ranking.

Operational reading. Any metric that is a bounded function of the step choice—e.g., format margin, drift, tool switch flag—cannot change expectation by more than $O(\sqrt{\tau })$ per step.

Proposition 10.3 (Guaranteed improvement in standardized score)

Let $s=\mathrm{s}\mathrm{t}\mathrm{d}\mathrm{z}(J_t)$ with ${\mathbb{E}}_p[s]=0$, ${\mathrm{V}\mathrm{a}\mathrm{r}}_p(s)=1$. The KL-optimal tilt with budget $\tau$ yields

$${\mathbb{E}}_{p^{\mathrm{\prime }}}[s]\approx \sqrt{2\tau }\text{for small }\tau ,$$

via the second-order expansion $\mathrm{K}\mathrm{L}(p^{\mathrm{\prime }}\mathrm{\parallel }p)\approx \frac{{\eta }^2}{2}{\mathrm{V}\mathrm{a}\mathrm{r}}_p(s)$ and ${\mathbb{E}}_{p^{\mathrm{\prime }}}[s]\approx \eta {\mathrm{V}\mathrm{a}\mathrm{r}}_p(s)$.

Implication. The controller lifts the expected standardized objective by $\tilde{O}(\sqrt{\tau })$ each step, while keeping shifts small.

Proposition 10.4 (EMA state stability)

Let the topic EMA update be $m_t=\mathrm{n}\mathrm{o}\mathrm{r}\mathrm{m}(\rho m_{t-1}+(1-\rho )e_{y_t})$ with unit vectors. Then

$$\mathrm{\parallel }{m}_t-m_{t-1}\mathrm{\parallel }\le 2(1-\rho ),$$

and with KL budget $\tau$ the expected change satisfies

$$\mathbb{E}\mathrm{\parallel }{m}_t-m_{t-1}\mathrm{\parallel }\le 2(1-\rho )+C\sqrt{2\tau },$$

for a constant $C$ depending on embedding geometry over ${\mathcal{K}}_t$. Hence the topic state moves slowly, acting as a Lyapunov-like anchor when combined with dissipation.

---

10.3 When Not to Use: Strong Non-Locality and Hard Discontinuities

The method presumes local observables and smooth costs. It should not be used alone when:

• Strong non-local objectives. Success depends on far-future structure (e.g., theorem proofs, multi-page legal logic) that cannot be summarized by short EMAs or paragraph reranking.

• Opaque hard discontinuities. External APIs/tools with black-box, binary jumps (e.g., hidden rate limits, non-monotone latency) dominate costs; $L,\mathrm{\Gamma }$ cannot anticipate these locally.

• Mode collapses / non-smooth routers. If routing is governed by brittle thresholds that flip multiple systems (model, memory, guardrails) simultaneously, local penalties under-represent the jump.

• Sparse, delayed verifiability. If value is only verifiable after long horizons (e.g., end-to-end task success with no intermediate proxies), myopic $J$ lacks signal.

Symptoms. Controller oscillations, repeated trigger firings, or paradoxical choices near external boundaries—despite conservative $\tau ,ϵ$.

---

10.4 Piecewise Controllers and Stochastic Smoothing as Remedies

When the above pathologies arise, use structured relaxations rather than enlarging $\tau$ or $\lambda$.

Piecewise controllers (mode-specific $L,\mathrm{\Gamma }$)

• Segment the task into modes (e.g., plan → call → parse → write).

• Maintain mode-local weights $(a\mathrm{.}\mathrm{.}e,{\beta }_{\text{*}},\lambda )$ and even distinct triggers; switch only on explicit sentinels with hysteresis (Sec. 5.2) to avoid flapping.

• For external APIs with discontinuous costs, incorporate pre-flight probes to turn jumps into measured latencies (bringing them back into $L$).

Stochastic smoothing

• Add small noise to features (e.g., to drift, margins) so adjacent candidates are not separated by fragile thresholds; this makes $L,\mathrm{\Gamma }$ Lipschitz in expectation.

• Use entropy bonuses or temperature nudges inside the trust-region at risky steps to avoid deterministic traps.

• Where non-locality is genuine, prefer micro-MBR or paragraph reranking (Sec. 7.3) at section boundaries.

Fallback design

• Debounce triggers; enforce a per-step time cap for lookahead; if exceeded, revert to Γ-lite.

• Keep $\tau ,ϵ$ small on surfaces exposed to opaque externalities; widen only in controlled canaries.

• If value is too delayed, collect lightweight proxies (parse passes, partial unit tests) to re-introduce step-local $L$ signal.

---

Summary. Under smooth, short-memory conditions, maximizing $J=L-\lambda \mathrm{\Gamma }$ with a KL/logit trust-region behaves like a stable, Lyapunov-guided MPC step: bounded shifts, predictable gains, slowly moving state. The scheme is not universal—hard discontinuities and long-range dependencies require piecewise controllers and stochastic or reranking remedies. These boundaries make the method safe to deploy where it fits—and honest about where it doesn’t.

---

11. Experimental Setup

11.1 Models, Datasets, and Tooling Environments

Models. We evaluate on three decoder-only LLMs to span sizes and vendors (no retraining):

• M-S (Small, ~7–13B) – open-weights, HF Transformers runtime, fp16 with KV-cache.

• M-M (Medium, ~30–34B) – open-weights, tensor-parallel (2× A100-80GB).

• M-L (Large, ~65–70B) – hosted endpoint (logits + output embeddings available), bf16.

Runtime. PyTorch 2.x with CUDA Graphs; beam/top-k implemented with fused ops; output embeddings pre-L2-normalized offline. Controller runs on the same GPU stream as decoding; all validators (JSON/AST) run CPU-side in parallel worker threads.

Tooling environments. For function/tool tests we use a deterministic sandbox:

• Tools-12: {calculator, date-math, currency-fx (fixed table), timezone, regex-extract, URL-fetch (mocked), wiki-lookup (mocked KB), code-exec (py subset, sandboxed), json-lint, csv-to-json, geo-ip (mocked), calendar-slotter}.

• Each tool exposes: name, schema, cost registry id (ms/$), and a deterministically checkable success condition.

Prompt suites. Per task family we build held-out prompt sets (dev/test) with no training of the base LLMs. All prompts and controller configs are versioned and released with seeds.

---

11.2 Tasks

Long-Context QA / Summarization

• LC-QA-200: 200 prompts with contexts 8–64k tokens (papers, transcripts, policy docs). Targets require cross-section grounding; answers ≤150 tokens.

• LC-Sum-150: 150 long-doc summaries (reports/meetings), target 150–250 tokens with sectioned headers.

Tool Routing / Function Calling

• Tools-Eval-240: 240 prompts covering (i) must-call, (ii) must-not-call, (iii) choose-one-of-k, and (iv) multi-call sequencing (2–3 calls). Ground truth comes from the sandbox; arguments check by schema + postcondition.

Strict-Format Outputs (JSON / Code)

• JSON-Schema-300: 300 prompts with schemas (5–25 required fields, nested).

• Code-Mini-200: 200 short programming tasks (I/O-free). Each produces a Python function; success = unit-test pass (5–10 tests per task) under a 2s sandbox limit.

Creative Writing

• Creative-100: 100 prompts (micro-fiction, ad copy, taglines) with soft constraints (style/voice/length). Human eval on 5-point Likert for originality, clarity, on-topic, format adherence.

---

11.3 Baselines

• Greedy (T=1.0), Top-p (p∈{0.9, 0.95}), Top-k (k=50), with standard length/repetition penalties.

• Contrastive Decoding (CD): weak model = M-S; α∈{0.1,0.3}, K=5 (representation-space penalty).

• MBR: N∈{8,16} candidates; task utilities—ROUGE-L for LC-Sum, JSON validity + schema F1 for JSON, unit-test pass rate for Code, majority voting for Tools.

• Controlled Decoding (lite): a small, content-neutral value head (format/coverage/tool-gate only) adds a logit bias; no semantic/identity attributes.

Ours. Γ-Lite (Sec. 7.1) always on; Event-Triggered Lookahead (Sec. 7.2) for risky steps; optional Paragraph Re-rank (Sec. 7.3) for premium runs.

---

11.4 Metrics

Stability

• Topic drift rate ↓: per token $d_t=1-\cos (e_{y_t},m_{t-1})$; report mean/95p and drift spikes (% tokens with $d_t>{\mu }_d+2{\sigma }_d$).

• Entropy-spike rate ↓: % steps with $\mathrm{\Delta }{H}_t>0.5{\sigma }_H$ (rolling).

Structure

• Format violation rate ↓: JSON parse fails / total; bracket/quote/fence imbalance; Markdown table errors.

• Compile/parse pass ↑: Code AST parse + unit-test pass@1 (and pass@5 for MBR/CD).

Tooling

• Tool-use success ↑: exact schema + correct postcondition.

• Wrong-call rate ↓: (i) called when must-not; (ii) wrong tool among candidates; (iii) wrong arg types.

Quality

• Factual error ↓: LC-QA automatic F1 (string-match + synonym table) + human 2-way check on a 50-item subset.

• Summarization quality ↑: ROUGE-L + section coverage score (required headers present).

• Code quality ↑: unit-test pass rate; style lint (PEP8) as a soft indicator.

Overhead

• Token latency: median and P95 ms/token vs. baseline.

• Throughput: tokens/sec per GPU.

• Extra FLOPs: estimated from added $O(kd)$ cosines and lookahead forwards on triggered steps.

Safety

• KL to baseline: mean/P95 of per-step $\mathrm{K}\mathrm{L}({\pi }^{\mathrm{\prime }}\mathrm{\parallel }\pi )$.

• Bias gap deltas: counterfactual identity-swap differences (Sec. 8.4), Δ before/after controller with 95% CIs.

• Activation rates: % steps where triggers fired; % steps bounded by logit cap.

---

11.5 Implementation Details and Hyperparameters

Controller (global)

• Top-k $k=10$ (or nucleus set if using top-p baseline).

• Embeddings $d$: from the model’s output head; pre-normalize rows; cosine via GEMM.

• KL cap $\tau =0.03$, logit cap $ϵ=0.7$ (unless stated).

• Zero-mean shift on top-k; exponential tilting with bisection (≤10 iterations).

• Shadow→canary: shadow for all runs; canary at 5% before full.

$L_t$ (Sec. 4)

• Normalized log-likelihood: robust z-score (median/MAD); entropy taper with rolling 10/90th percentiles over a 128-step window.

• Value head (optional): 1×64 MLP on {zlik, key-coverage, fmt-margin, tool-gate}; trained on 5–10k dev prefixes; outputs in [0,1] → map to [−1,1].

• Risk: 6–8 regex/shape checks (PII shape, SQL/HTML injection, delimiter hazards).

• Latency: pre-calibrated tool costs $\widehat{c}$ (EMA, decay 0.9, clipped); normalized by $c_{\max }$.

• Length/closure: delimiter stack + budget-tail prior.

Weights (profiles).

• Factual/Tool: $a=1.0,b=0.6,c=0.7,d=0.5,e=0.4$.

• Creative: $a=0.8,b=0.3,c=0.2,d=0.1,e=0.2$.

• Per-language scaling for likelihood variance when multilingual.

${\mathrm{\Gamma }}_t$ (Sec. 5)

• Topic drift: multi-scale EMA $\rho =\{0.90,0.97,0.995\}$ with $\alpha =\{0.2,0.5,0.3\}$; entropy-gated.

• Switch: hysteresis ${\theta }_{\text{on}}=0.65$, ${\theta }_{\text{off}}=0.45$; persistence penalty ${\gamma }_{\text{persist}}=0.3$, ${\tau }_{\text{switch}}=20$ tokens.

• Format: 3–6 smooth margins (JSON distance-to-error, fence balance risk…).

• Weights: Factual/Tool ${\beta }_{\text{topic}}=0.6,{\beta }_{\text{switch}}=0.7,{\beta }_{\text{fmt}}=0.8$; Creative $\{0.3,0.2,0.4\}$.

${\lambda }_t$ schedule (Sec. 6)

• ${\lambda }_t={\lambda }_0(1+{\kappa }_1\mathrm{\Delta }{H}_t^{\star }+{\kappa }_2\mathbf{1}\{\text{risk}\})$.

• Factual/Tool: ${\lambda }_0=0.7,{\kappa }_1=0.6,{\kappa }_2=0.5$.

• Creative: ${\lambda }_0=0.3,{\kappa }_1=0.3,{\kappa }_2=0.2$.

• Low-pass ${\alpha }_{\lambda }=0.3$; budget-tail multiplier $1+{\gamma }_{\text{tail}}{s}_t$ with ${\gamma }_{\text{tail}}=0.5$.

Triggers & Lookahead (Sec. 7.2)

• Triggers: $\mathrm{\Delta }H>0.5{\sigma }_H$ OR fmt-margin breach OR router boundary; debounce 5 tokens.

• Lookahead: $h=3$, $B=3$, per-step candidate fan-out $b=2$.

• Latency cap: +15 ms per triggered step; if exceeded, abort to Γ-Lite.

Paragraph Re-rank (Sec. 7.3)

• Candidates $N=3$ per paragraph boundary; score by accumulated $J$; caching on shared prefixes.

• Enabled only on premium runs (long-form or code/JSON with high failure cost).

Hardware & batching

• A100-80GB×4 (open-weights runs), p99 token latency target ≤ baseline + 10%.

• Batch size dynamic to meet SLA; controller ops fused per batch; parsers on CPU threadpool.

Reproducibility

• Fixed seeds per run; deterministic replay with logged {ΔH, drift, fmt, λ, Δlogit, KL, triggers}.

• Controller/validator/cost-registry versions are pinned in logs; CI includes replay tests.

---

Ablations to report (per task family).

• Turn off each component: {ΔH gating, topic drift, switch hysteresis, format margins, latency cost, value head}.

• Fixed vs adaptive $\lambda$; KL/logit caps on/off; triggers off; horizon $h\in \{0,2,4\}$.

• Contrastive and MBR hyper sweeps to fair-compare cost/benefit.

This setup makes it straightforward to (i) replicate results, (ii) attribute gains to specific controller elements, and (iii) quantify the latency–stability trade-offs under production-like constraints.

 

Yes—Section 11. Experimental Setup is complete.
Below is Section 12. Results. (I’ll write it so you can drop in your actual numbers later; any bracketed values are placeholders showing formatting and typical effect sizes you might see.)

---

12. Results

12.1 Main Comparisons Across Tasks

We compare Γ-Lite (always on), Event-Triggered Lookahead (ETL; Sec. 7.2), and the optional Paragraph Re-rank (PR; Sec. 7.3) against Greedy, Top-p, Contrastive, MBR, and a Controlled-Decoding (lite) baseline. Unless noted, trust-region caps are $\tau =0.03$, $ϵ=0.7$; factual/tool profile.

Aggregate overview (test sets; higher is better ↓ lower is better)

Task family	Method	Topic drift ↓	Entropy spikes ↓	Format violations ↓	Tool success ↑	Wrong-call ↓	Factual err. ↓	Latency Δ (ms/tok)	KL p95
Long-Context QA	Greedy	[—]	[—]	n/a	n/a	n/a	[—]	0	0
	Top-p (0.95)	[−]	[+]	n/a	n/a	n/a	[−]	+0.0	0
	Contrastive	[−25%]	[−18%]	n/a	n/a	n/a	[−6%]	+0.7	0
	Γ-Lite (ours)	[−34%]	[−28%]	n/a	n/a	n/a	[−9%]	+0.6	0.028
	Γ-Lite + ETL (ours)	[−41%]	[−33%]	n/a	n/a	n/a	[−11%]	+2.1	0.029
Tool Routing	Greedy	n/a	[—]	n/a	[—]	[—]	n/a	0	0
	Controlled Decoding (lite)	n/a	[−]	n/a	[+6 pp]	[−18%]	n/a	+0.9	0
	Γ-Lite (ours)	n/a	[−22%]	n/a	[+10 pp]	[−29%]	n/a	+0.8	0.027
	Γ-Lite + ETL (ours)	n/a	[−27%]	n/a	[+13 pp]	[−34%]	n/a	+3.4	0.029
JSON/Code	Top-p (0.9)	n/a	n/a	[—]	n/a	n/a	n/a	+0.0	0
	Contrastive	n/a	n/a	[−26%]	n/a	n/a	[+5 pp pass@1]	+0.9	0
	Γ-Lite (ours)	n/a	n/a	[−43%]	n/a	n/a	[+7 pp pass@1]	+0.7	0.028
	Γ-Lite + ETL (ours)	n/a	n/a	[−55%]	n/a	n/a	[+10 pp pass@1]	+2.6	0.029
Creative	Top-p (0.95)	[baseline]	[baseline]	low	n/a	n/a	(human)	+0.0	0
	Γ-Lite (creative profile)	drift ok	spikes ↓	low	n/a	n/a	human pref: +[0.2–0.4]	+0.5	0.018

Notes. Values in brackets are placeholders indicating the intended format and typical relative ranges (e.g., “−34%” means a relative reduction vs. Greedy). Replace with your measured numbers.

Takeaway. Across task families, Γ-Lite consistently reduces topic drift and entropy spikes; adding ETL further improves inflection-point decisions (tool routing, late-stage format), with small average latency increases. On strict-format code/JSON, dissipation plus format margins markedly lowers parse failures.

---

12.2 Ablations

We ablate key components to quantify their contribution. Report relative change vs. Γ-Lite + ETL default.

Ablation	LC-QA: drift ↓	Tools: wrong-call ↓	JSON: violations ↓	Code: pass@1 ↑	Latency Δ
Full (ours)	—	—	—	—	—
No ΔH gating (Sec. 6.1)	[−9 pp]	[−3 pp]	[−2 pp]	[−1 pp]	−0.2 ms
No topic drift (Sec. 5.1)	[−18 pp]	n/a	[−4 pp]	[−2 pp]	−0.1 ms
No format margins (Sec. 5.3)	n/a	n/a	[−21 pp]	[−6 pp]	−0.3 ms
No switch hysteresis (Sec. 5.2)	n/a	[−11 pp]	n/a	n/a	−0.1 ms
Fixed $\lambda$ (no adapt)	[−7 pp]	[−4 pp]	[−3 pp]	[−2 pp]	−0.0 ms
Triggers off (no ETL)	[−6 pp]	[−8 pp]	[−9 pp]	[−3 pp]	−1.7 ms
Horizon $h=2$ vs $h=4$	[≈]	[−1 pp]	[−2 pp]	[≈]	−0.8 ms
Trust-region off ($\tau =\mathrm{\infty }$, $ϵ=\mathrm{\infty }$)	unstable	bias risk ↑	fragile	[±]	+?

Trends.

• Topic drift and format margins are the highest-leverage components for long-context and strict-format tasks, respectively.

• Hysteresis materially lowers wrong tool calls near router thresholds.

• Adaptive ${\lambda }_t$ contributes broad but modest gains; most visible during entropy spikes.

• ETL offers the biggest “last-mile” improvements on risky steps; $h=2$–3 is a good cost–benefit point.

---

12.3 Cost–Benefit: Stability Gains vs. Latency/FLOPs

Activation rates. Triggers fire on [3–8%] of tokens (median across tasks).
Compute overhead. Γ-Lite adds only $O(kd)$ cosines per step; ETL adds [1.2–2.5]× a single step only on triggered tokens; overall extra FLOPs [+2–5%].
Latency. Median token latency [+0.5–0.8 ms] (Γ-Lite), and [+2–4 ms] when ETL is active; P95 within [+8–12 ms] of baseline under our cap.
Throughput. Tokens/sec drop [≤3%] in mixed traffic; negligible on creative profile (ETL rarely fires).

Cost–benefit frontier. Plot format-violation ↓ (or wrong-call ↓) vs. latency ↑. Γ-Lite sits near the north-west corner (large gain, tiny cost). Adding ETL shifts the curve further left at the expense of a small latency bump—particularly worthwhile for tool routing and strict-format code/JSON.

---

12.4 Qualitative Analyses and Case Studies

(A) Long-Context QA: Topic whiplash avoidance

Before (Top-p): answer veers to a tangential subsection mid-paragraph.
After (Γ-Lite): drift penalty keeps continuation aligned with the EMA topic; entropy spike damped; final answer stays on the queried subsection.
Why: $1-\cos (e_i,m)$ penalizes a sharp semantic turn; adaptive ${\lambda }_t$ increases during the spike.

(B) Tool Routing: Boundary stabilization

Before (Greedy): flips between two candidate tools over 3 tokens → wrong call.
After (Γ-Lite + ETL): hysteresis suppresses flapping; lookahead simulates arguments for 2–3 steps and commits to the correct tool once $L$ justifies the switch.
Why: switch persistence cost + micro-MPC at the inflection point.

(C) JSON Schema: Late-stage structure preservation

Before (Contrastive): high fluency but occasional trailing comma / brace mismatch.
After (Γ-Lite): format margins rise as structure approaches failure; controller prefers a closing token; violations drop substantially.
Why: smooth margins in ${\mathrm{\Gamma }}^{\text{fmt}}$ act before a hard error.

(D) Code Generation: Pass@1 gains without heavy beams

Before (MBR-8): higher pass@k but costly.
After (Γ-Lite + ETL): comparable pass@1 with far lower overhead; ETL fires only when syntax is fragile or a big topic turn is imminent.
Why: per-token $J$ nudges toward compilation-friendly continuations.

---

How to use this section.

• Replace bracketed placeholders with your measured numbers.

• Keep the same tables (they mirror the metrics in Sec. 11.4).

• Include two plots: (i) stability vs. latency frontier; (ii) trigger activation histogram.

• Add 2–3 verbatim case snippets (with sensitive content redacted) to illustrate Γ-Lite and ETL decisions; show the score deltas for the competing tokens at the inflection step.

Bottom line. Under tight latency budgets, dissipative Lagrangian decoding (Γ-Lite + optional ETL) delivers consistent stability gains—lower drift, fewer format breaks, steadier tool calls—at single-digit overhead, and remains auditable under trust-region bounds.

---

13. Deployment and Engineering Guidance

13.1 Drop-In Controller Design (PyTorch/JAX/TF)

Where it lives. Insert a thin “decoding controller” between the model’s logits and the sampler. No base-model changes.

Interfaces.

• Inputs (per step t):
  logits[t] (float32/bf16), topk_ids[t], topk_logits[t], topk_emb[t] (output embeddings for topk_ids), rolling state {H, m_EMAs, delim_stack, switch_state}, tool/router metadata.

• Outputs: adjusted scores Delta[t] (same shape as topk_logits), or a ranked list; diagnostics blob.

Device placement.

• Compute cosine drifts (O(kd)) on GPU (GEMM), keep validators (JSON/AST) on CPU threadpool.

• Run trust-region (KL bisection + clipping) on GPU for batch efficiency.

Minimal PyTorch hook (sketch).

class LagrangianController:
    def __init__(self, cfg): ...
    @torch.no_grad()
    def step(self, topk_logits, topk_ids, topk_emb, state, ctx):
        L = compute_L_components(topk_logits, topk_ids, ctx, state)   # Sec.4
        G = compute_Gamma(topk_ids, topk_emb, state, ctx)             # Sec.5
        lam = schedule_lambda(state, risk_trigger=any_risk(topk_ids, ctx))  # Sec.6
        J = L - lam * G                                               # [B,k]

        delta = project_with_kl_and_cap(topk_logits, J, tau=cfg.tau, eps=cfg.eps)  # Sec.7.1.2
        # choose token (or hand back delta to sampler)
        choice = torch.argmax(topk_logits + delta, dim=-1)
        state.update_after_choice(choice, topk_emb)
        return choice, delta, self.make_log_blob(...)

JAX/TF. Mirror the API; make project_with_kl_and_cap jit-friendly (no Python loops). Use bisection with fixed iters (e.g., 8) to avoid control-flow stalls.

Batching.

• Vectorize over batch × top-k. Keep k small (10–20).

• Pre-normalize embedding rows (L2=1).

• Cache router/tool metadata per batch.

Latency guard.

• Per-step wall-clock cap (e.g., +15 ms); if exceeded, skip lookahead and emit Γ-Lite result.

• Debounce triggers ≥5 tokens.

Versioning.

• Pin {controller_version, validators_version, tool_cost_version} and log them.

• Ship configs as a single YAML (weights, caps, thresholds).

---

13.2 Logging Schema: {ΔH, drift, fmt_ok, toolcost, λ, Δlogit, KL, trigger}

JSONL (one line per token).

{
  "ts":"2025-08-31T12:34:56.789Z",
  "req_id":"r_9f0...",
  "step":128, "model_id":"M-M-34B",
  "k":10,
  "H":0.81, "dH":0.19,
  "drift_min":0.07, "drift_mean":0.13,
  "fmt_ok": true, "fmt_margin": 0.12,
  "tool_prob": 0.22, "tool_cost_ms": 0,
  "L": {"zlik":0.9, "val":0.2, "risk":0.0, "lat":0.0, "len":-0.1},
  "Gamma": {"topic":0.11, "switch":0.00, "fmt":0.06},
  "lambda":0.68,
  "KL":0.014, "max_abs_delta":0.41,
  "trigger": {"entropy":true, "fmt":false, "switch":false},
  "baseline_choice": 502, "ctrl_argmax": 502,
  "applied": true,
  "controller_version":"1.3.2", "validators_version":"0.9.7", "tool_cost_version":"2025w35"
}

Storage. Partition by date/model_id; compact (gzip).
Dashboards. P50/P95 KL, trigger rates, violation rates, latency deltas; bias-gap deltas (Sec. 8.4).

---

13.3 Profiles and Defaults (Creative/Factual)

Factual / Tool-use (stable, structure-first).

• lambda0=0.7, kappa1=0.6, kappa2=0.5

• L-weights: a=1.0, b=0.6, c=0.7, d=0.5, e=0.4

• Γ-weights: beta_topic=0.6, beta_switch=0.7, beta_fmt=0.8

• Trust-region: tau=0.03, eps=0.7

• Triggers: dH > 0.5σ_H OR fmt_margin breach OR router_boundary

Creative (novelty-friendly, format-sane).

• lambda0=0.3, kappa1=0.3, kappa2=0.2

• L-weights: a=0.8, b=0.3, c=0.2, d=0.1, e=0.2

• Γ-weights: beta_topic=0.3, beta_switch=0.2, beta_fmt=0.4

• Trust-region: tau=0.02, eps=0.6

• Triggers: entropy + hard format only; topic drift entropy-gated

Config YAML (excerpt).

profiles:
  factual:
    lambda0: 0.7; kappa1: 0.6; kappa2: 0.5
    L: {a:1.0, b:0.6, c:0.7, d:0.5, e:0.4}
    Gamma: {topic:0.6, switch:0.7, fmt:0.8}
    trust: {tau:0.03, eps:0.7}
  creative:
    lambda0: 0.3; kappa1: 0.3; kappa2: 0.2
    L: {a:0.8, b:0.3, c:0.2, d:0.1, e:0.2}
    Gamma: {topic:0.3, switch:0.2, fmt:0.4}
    trust: {tau:0.02, eps:0.6}
common:
  k: 10
  ema_rhos: [0.90, 0.97, 0.995]
  hysteresis: {on:0.65, off:0.45, persist:0.3, tau_tokens:20}
  trigger_debounce: 5

---

13.4 Shadow→Canary→Full Rollout Playbook

1. Shadow (log-only, 1–2 weeks).

   • Apply controller but don’t adjust logits.

   • Verify: latency headroom, activation rates (≤10%), no bias-gap increase; drift/violation reductions in counterfactual replays.

   • Freeze schema, weights, thresholds.

2. Canary (1–5% traffic).

   • Start with strict caps: tau=0.01, eps=0.3, no lookahead.

   • SLO gates: p95 latency ≤ baseline + 10 ms; p95 KL ≤ 0.03; violation rate ↓ vs baseline.

   • If green for N=3 days → enable event-triggered lookahead (h=2, B=2).

3. Gradual expansion (25% → 100%).

   • Raise caps to target (tau=0.03, eps=0.7), keep lookahead h=3, B=3.

   • Enable paragraph re-rank only for premium routes (code/long JSON).

4. Safeguards.

   • One-click kill switch per surface.

   • Auto-disable on: p99 latency breach, sudden KL shift (>50%), spike in violations, bias-gap alarm.

   • Weekly review of logs; version bump requires shadow again.

---

13.5 Monitoring and Online Calibration of Tool Costs

Why. Tool/route costs drift (latency/$), so latency_t(i) must reflect current reality.

Registry.

• For each tool u, store cost_ms[u], cost_usd[u], updated_at, n_obs.

• Update with robust EMA and outlier clipping:

  $$c^{(t)}\leftarrow \alpha \mathrm{c}\mathrm{l}\mathrm{i}\mathrm{p}(c_{\text{obs}},p1,p99)+(1-\alpha )c^{(t-1)},\alpha =0.2$$

  Maintain IQR bands to compute normalized cost $\widehat{c}\mathrm{/}{c}_{\max }$.

Monitors.

• Drift alert: if $\mathrm{\mid }{c}^{(t)}-c^{(t-7d)}\mathrm{\mid }\mathrm{/}{c}^{(t-7d)}>0.3$, flag and review router policy.

• Switch flapping: count toggles per 100 steps; if > threshold, widen hysteresis (on↑, off↓).

• Trigger health: track trigger hit rate; if >15% sustained, raise thresholds or reduce λ.

• Safety dials: p95 KL, max |Δlogit|, bias-gap deltas; plot histograms by cohort/language.

Dashboards (per surface).

• Stability: drift rate, entropy spikes.

• Structure: JSON/AST fails.

• Tooling: success %, wrong-call %, cost per task.

• Overhead: Δ latency, throughput.

• Safety: KL distribution, bias gaps.

Runbooks.

• Parse failures ↑: tighten format margins, enable PR on that route, add validator testcases.

• Wrong calls ↑: increase persistence penalty, re-calibrate tool costs, add pre-flight checks.

• Latency ↑: reduce lookahead h/B, raise debounce, or fall back to Γ-Lite only.

---

Bottom line. Treat the controller like a library + config: drop-in, vectorized, capped by trust-regions, and surrounded by observability. With profile presets, staged rollout, and live cost calibration, you’ll get the stability benefits of dissipative Lagrangian decoding without sacrificing latency, safety, or maintainability.

---

14. Discussion

14.1 Relationship to Existing Controls and Complementarity with RLHF

Where this fits. Our controller sits between logits and the sampler, adding a per-token control law $J=L-\lambda \mathrm{\Gamma }$ with trust-region bounds. It complements, rather than replaces, mainstream techniques:

• Temperature / top-p / length penalties. These reshape likelihood but don’t encode task progress, tool cost, or structural fragility. In our framework, they remain as baselines; $L$ and $\mathrm{\Gamma }$ add operational semantics on top.

• Contrastive decoding / energy methods. Their representation-consistency term can be injected into $L$ as an additional signal; our entropy gating and topic-drift term $\mathrm{\Gamma }$ reduce repetition/whiplash in a more interpretable way.

• MBR / reranking. Micro-lookahead (Sec. 7.2) is an online, low-latency variant of expected-utility selection. Paragraph rerank (Sec. 7.3) is a targeted, premium version of MBR that reuses the same $J$.

• Controlled/guided decoding (PPLM/GeDi-style). Those rely on attribute models and gradient nudges; we avoid heavy second models and stick to content-neutral signals with KL caps for auditability.

• RLHF / RLAIF. Training-time alignment changes the policy parameters; our controller changes per-step choices under a small KL from the base policy. They are complementary:

  • RLHF’s KL-regularized objectives mirror our trust-region at inference.

  • Signals in $L$/$\mathrm{\Gamma }$ can be added as regularizers or rewards during fine-tuning; at inference we keep $\lambda$ small (near-free) but retain stability.

  • In practice: deploy RLHF for broad behavior, Lagrangian decoding for situational control (format, routing, long-context stability) without another training cycle.

---

14.2 Stability vs. Creativity: Practical Tuning Recipes

Two one-liners (starting points).

• Factual / Tool-use profile (stable):
  lambda0=0.7, kappa1=0.6, kappa2=0.5; beta_topic=0.6, beta_switch=0.7, beta_fmt=0.8; tau=0.03, eps=0.7; triggers: dH>0.5σ or fmt breach or router boundary.

• Creative profile (novelty-friendly):
  lambda0=0.3, kappa1=0.3, kappa2=0.2; beta_topic=0.3, beta_switch=0.2, beta_fmt=0.4; tau=0.02, eps=0.6; triggers: entropy + hard format only.

Dial interplay (quick heuristics).

• Want more novelty? ↓ lambda0 by 0.1–0.2; ↓ beta_topic; ↑ temperature by 0.1; keep tau unchanged (safety constant).

• Seeing topic whiplash? ↑ beta_topic by 0.1; enable multi-scale EMA; ensure entropy gating is on; consider ETL with $h=2,B=2$.

• Frequent wrong tool calls? ↑ beta_switch and persistence penalty; widen hysteresis (on↑, off↓); add +0.1 to kappa2 so ${\lambda }_t$ rises in risk zones.

• Late-stage format breaks? ↑ beta_fmt; add tail penalty (Sec. 5.3.2); consider paragraph rerank for long JSON/code.

• Latency pressure? Use Γ-Lite only; set ETL cap to +10 ms and $h=2,B=2$; reduce top-k to 10.

Operating curve. Sweep lambda0 and kappa1 on a dev set; plot stability gain vs latency. Pick the knee. Keep tau small and fixed across runs to stabilize audits.

---

14.3 Limitations and Threats to Validity

Methodological limits.

• Locality assumption. $L,\mathrm{\Gamma }$ rely on step-local signals + short memory (EMAs). Strongly non-local objectives (multi-page proofs, intricate legal chains) can exceed our horizon; we mitigate with paragraph rerank or segment-level controllers.

• Opaque discontinuities. If external tools have binary, non-stationary jumps (rate-limits, cache invalidations), our latency/cost proxies can be off; add pre-flight probes or piecewise controllers.

• Access requirements. We assume top-k logits + output embeddings. Closed APIs may block this; use the prompt-level approximation (Sec. 9) with weaker guarantees.

Evaluation threats.

• Proxy metrics. Topic drift (cosine to EMA) and entropy spikes are surrogates; ensure human checks on a subset to avoid “metric gaming.”

• Dataset bias / coverage. Gains concentrated on strict-format and tool-routing tasks; report per-domain results to avoid over-generalization.

• Human-eval variance. Creative tasks need careful rater protocols; report CIs and inter-rater reliability.

Safety risks.

• Proxy bias creep. Even content-neutral signals can correlate with protected content via structure (e.g., locale-specific punctuation). Enforce PSS (Sec. 8.1) and run identity-swap tests (Sec. 8.4).

• Config complexity. Many dials → regression risk. Treat the controller as a versioned library; CI with deterministic replays and ablations before rollout.

---

14.4 Future Directions: Multi-Agent Settings, Non-Local Memory, Adaptive Horizons

• Multi-agent Lagrangians. For tool-augmented or multi-agent systems, model each agent/tool as a subsystem with its own $J^{(a)}$ and shared dissipation (switching, contention). Explore Nash-consistent or cooperative tilts with global KL budgets.

• Non-local memory & hierarchy. Add segment-level states (section topic vectors, plan graphs) with hierarchical $\mathrm{\Gamma }$: token-level for micro stability, section-level for macro coherence. Learn how to blend levels via a meta-controller.

• Adaptive horizons. Learn when to invoke ETL and how deep to unroll $h$ with a small policy that trades expected $J$-gain against measured latency headroom; tie invocation to predicted regret rather than fixed thresholds.

• Speculative / streaming integration. Combine with speculative decoding by applying $J$ to acceptance filters; use trust-region caps to keep speculative rollbacks bounded.

• Controller distillation. Train a light adapter to internalize $L,\mathrm{\Gamma }$ so inference-time $\lambda$ can be reduced (almost free) while keeping much of the stability.

• Fairness-aware trust-regions. Explore group-conditioned KL caps or per-cohort $\tau$ scheduling proven not to increase bias gaps, with formal guarantees.

• Richer value heads (still neutral). Add verifiability predictors (e.g., static code checks, schema coverage, citation presence) that remain content-neutral but sharpen $L$.

• Theory. Tighten the Lyapunov-like guarantees: e.g., bounds on cumulative drift under stochastic triggers; characterize optimal $\eta$ (tilt) under multi-objective $J$.

---

Closing thought. Dissipative Lagrangian decoding doesn’t redefine language modeling; it organizes inference-time control into a single, auditable principle that travels well across tasks. With small, explicit deviations (trust-regions), a few interpretable signals, and event-triggered lookahead, it provides a practical route to stable yet expressive LLM behavior—today—and a scaffold for richer control tomorrow.

---

15. Ethical and Social Considerations

15.1 Bias Minimization and Transparency

Principles. The controller must not introduce or amplify social bias. We therefore restrict signals to mechanism-relevant, content-neutral features (entropy jumps, topic drift, format margins, tool costs) and enforce trust-region caps so deviations from the base model are small and auditable.

Practices (must):

• PSS whitelist. Only allow documented signals (Sec. 8.1). Explicitly ban identity/stance proxies and uncalibrated “toxicity”/sentiment scores.

• Counterfactual audits. Run identity-swap tests pre-ship and continuously (Sec. 8.4), publish bias-gap deltas with CIs; controller must not widen gaps beyond a small tolerance.

• Bounded influence. Keep per-step KL and logit caps tight by default; report KL distribution (mean/P95) per product surface.

• Explainability. Log a compact per-step diagnostic (ΔH, drift, fmt, λ, KL, triggers) and provide a human-readable run summary. For prompt-only deployments, require the one-line scorecard; never log chain-of-thought.

• Data minimization. Redact/limit stored content in logs; retain only hashed request IDs + scalar diagnostics. Apply deletion windows and access controls aligned with privacy policy.

• Diverse eval. Include multilingual scripts and dialects; maintain per-language normalizers; report results disaggregated by language/cohort.

Practices (should):

• Model/Safety cards. Document where the controller is active, its caps, profiles, and known limitations.

• Red-teaming. Periodically probe for proxy bias (e.g., locale-specific punctuation causing format penalties).

Residual risks. Even content-neutral signals can correlate with protected attributes (e.g., script-specific structure). Mitigate with audits, per-language calibration, and conservative caps; roll back on alarm.

---

15.2 User Consent and Disclosure for Inference-Time Controls

Goal. Respect user agency: disclose that inference-time controls are in place, what they optimize, and how to opt out or switch profiles.

Minimum disclosure (UI or API docs):

“To improve stability and formatting, we apply a small, per-token controller that gently re-orders top candidates under strict bounds. It prioritizes on-task, valid outputs and avoids unnecessary tool switches. It does not use identity or opinion signals. You can switch to Creative mode or opt out.”

Controls:

• Profile toggle. Expose “Factual/Stable” vs “Creative/Flexible.”

• Opt-out. Provide a per-request flag to disable the controller (or disable lookahead only).

• Telemetry notice. State what is logged (aggregate diagnostics, no raw content/CoT) and retention period.

• Human-in-the-loop. For regulated/premium workflows (e.g., legal, finance), enable “require confirm on costly tool switch.”

Consent in enterprise settings. Obtain organizational approval for defaults and caps; surface per-team config and audit exports.

---

15.3 Impact on Creative Expression and Editorial Policies

Risk. Over-smoothing can homogenize style and dampen novelty—an editorial intervention if left unchecked.

Safeguards:

• Creative profile defaults. Lower λ, lighter topic-drift weight, hard-format-only penalties; ETL off by default.

• Diversity monitors. Track lexical/semantic diversity (distinct-n, embedding dispersion) and human preference scores for originality; alert on drops.

• No covert style policing. Keep $L$ and $\mathrm{\Gamma }$ free of style/ideology terms. Any house style must be explicit (user-selected) and documented as an editorial policy, not a hidden control.

• Granular scope. Apply strict profiles only where necessary (JSON/code/tools). Leave unconstrained or creative profiles elsewhere.

• Appeal path. Allow users to re-run with the controller disabled (or with relaxed caps) if they suspect undue constraint.

Cultural plurality. Validate format/structure checks across scripts and rhetorical norms; avoid penalizing non-Western punctuation or narrative conventions.

---

Summary. Ethical deployment of dissipative Lagrangian decoding hinges on content-neutral signals, tight, auditable bounds, transparent disclosure and user choice, and ongoing fairness/creativity monitoring. These measures keep the benefits—stability, safer tool use, valid structure—without smuggling in hidden editorial decisions or new bias.

---

16. Conclusion

We introduced dissipative Lagrangian decoding—a lightweight, inference-time control scheme for LLMs that selects each token by maximizing a local objective $J=L-\lambda \mathrm{\Gamma }$ under trust-region bounds. The design unifies operationally meaningful value signals (normalized likelihood, task progress, tool latency, length/closure) with principled dissipation against topic whiplash, mode flapping, and format fragility, then adds event-triggered short-horizon lookahead only when risk spikes.

Across long-context QA, tool routing, strict-format outputs, and creative writing, this framework offers a drop-in path to stability—lower drift and format violations, more reliable tool use—at single-digit overhead, with explicit, auditable limits on distribution shift. It complements RLHF/RLAIF: alignment shapes global behavior; our controller makes situational, per-step trade-offs without retraining. We also provided a prompt-level L×Γ protocol for closed stacks, plus a deployment playbook (shadow→canary→full) with safety audits, bias checks, and live tool-cost calibration.

The approach has boundaries: strongly non-local objectives and hard external discontinuities may require piecewise controllers, stochastic smoothing, or paragraph-level reranking. Future work includes hierarchical (token/section) controllers, adaptive horizons, and multi-agent variants with shared dissipation and global KL budgets.

Overall, dissipative Lagrangian decoding turns a set of scattered heuristics into a single, principled and practical control law—one that can be adopted incrementally today to make LLM systems more stable, structured, and trustworthy in production.

---

17. Forward-Looking Directions and Open Problems

Why this section matters. The paper so far treated dissipative Lagrangian decoding as a practical, bounded control law for production LLMs:

$$J_t(i)=L_t(i)-{\lambda }_t{\mathrm{\Gamma }}_t(i)\text{with}\mathrm{K}\mathrm{L}({\pi }_t^{\mathrm{\prime }}\text{\hspace{0.17em}⁣}\mathrm{\parallel }\text{\hspace{0.17em}⁣}{\pi }_t)\le \tau ,\mathrm{\mid }\mathrm{\Delta }\text{logit}\mathrm{\mid }\le ϵ\mathrm{.}$$

Here we step back and argue that this is more than a bag of inference-time tricks. It is a variational lens on AI decision-making that can unify training and inference, token and document scales, single-model and multi-agent settings—while keeping auditability and safety inside the formalism. This section is self-contained and assumes no external commentary.

---

17.1 From Local Control Law to Variational Program

Our controller chooses each token by maximizing a local scalar $J_t$. The natural generalization is a trajectory objective:

$$\mathcal{S}(y_{1:T})=\sum _{t=1}^T(L_t(y_t)-{\lambda }_t{\mathrm{\Gamma }}_t(y_t))\text{s.t. per-step trust regions.}$$

Greedy $J_t$ is the Euler step of this program; event-triggered lookahead implements a short-horizon MPC. The forward path is to (i) enrich $L,\mathrm{\Gamma }$ with document-level surrogates (coverage, plan consistency), and (ii) preserve stepwise caps so deviations remain small and auditable.

Open questions.

• Q1. Which classes of $L,\mathrm{\Gamma }$ admit efficient, closed-form tilts under a KL/logit budget?

• Q2. How do we combine token- and span-level objectives without double-counting value or dissipation?

---

17.2 Unifying Training and Inference (Control-as-Inference)

Training-time alignment (e.g., KL-regularized objectives) and inference-time tilting are mathematically parallel. Two concrete directions:

• Controller distillation. Record $\{L,\mathrm{\Gamma },\lambda ,\mathrm{\Delta }H,\mathrm{K}\mathrm{L}\}$ during shadow runs; train a small adapter so baseline decoding approximates controlled decoding with $\tau \text{\hspace{0.17em}⁣}\to \text{\hspace{0.17em}⁣}0$ at runtime.

• Bidirectional calibration. Use logs to improve predictors for content-neutral signals (e.g., verifiability, format risk), which in turn sharpen $L$ during both training and inference.

Conjecture. With small per-step $\tau$, a distilled adapter attains $O(\sqrt{\tau })$ regret to the online controller while eliminating most runtime overhead.

---

17.3 Hierarchical Lagrangians for Non-Local Structure

Long documents and multi-step reasoning create non-local constraints. Introduce levels:

• Token level: current $J_t$ (likelihood, topic drift, format risk, switch costs).

• Section level: $J^{\text{sec}}$ with span embeddings, header/coverage vectors, citation presence, unit-test proxies for code.

• Document level: plan adherence, claim–evidence alignment, house style.

Mechanically, maintain a slow state per section (plan vector), update at boundaries, and penalize cross-level tension when a token deviates from section intent. Keep lookahead event-triggered only at boundaries to honor latency budgets.

Open questions.

• Q3. What minimal section state preserves document-scale coherence?

• Q4. Can we prove two-time-scale stability: token-level dissipation + section Lyapunov guarantees sublinear cumulative drift?

---

17.4 Hamiltonian and Pontryagin Extensions (Momentum for Plans)

Lagrangian + dissipation captures what to penalize; a Hamiltonian view adds co-states (momenta) for plans:

$${\mathcal{H}}_t=L_t-{\lambda }_t{\mathrm{\Gamma }}_t+p_t^{\mathrm{\top }}f(x_t,y_t),$$

where $x_t$ is a latent plan state, $p_t$ its co-state, and $f$ a plan dynamics map. Discrete analogs penalize $\mathrm{\parallel }\mathrm{\Delta }{x}_t{\mathrm{\parallel }}^2$ (our cosine drift) while allowing “inertia” to carry style/topic smoothly.

Hypothesis. A light “plan momentum” state reduces late-stage whiplash at the same $\lambda$, improving the stability–creativity frontier.

---

17.5 Multi-Agent and Tool Ecosystems (Potential Games)

Modern systems orchestrate routers, tools, and multiple models. Give each agent $a$ its local $J^{(a)}$ and share dissipation for switching and contention:

$$\mathrm{\Phi }=\sum _a{J}^{(a)}-\sum _{a<b}{\mu }_{ab}{\text{switch}}_{ab}-\sum _a{\nu }_a{\text{contention}}_a\mathrm{.}$$

Choose penalties so $\mathrm{\Phi }$ is an exact potential: best responses by any agent increase a global objective.

Research steps.

• Define switch/queueing costs that make router behavior flap-free under KL caps.

• Evaluate on tool suites: wrong-call rate, flaps/100 tokens, end-to-end latency vs. cost.

---

17.6 Adaptive Horizons and Compute Allocation

Lookahead is valuable but costly. Replace fixed $(h,B)$ by learned compute policies:

• Trigger policy. ${\pi }_{\text{trig}}({\varphi }_t)\text{\hspace{0.17em}⁣}\to \text{\hspace{0.17em}⁣}\{0,1\}$ with features ${\varphi }_t=\{\mathrm{\Delta }H,\text{ fmt margin},\text{ router hazard}\}$; optimize expected $\mathrm{\Delta }J$ under a compute budget.

• Horizon policy. Predict $h_t$ (e.g., 0/2/3/4) from curvature proxies (local margin Hessians) subject to a per-step time cap.

• Speculative decoding. Apply lookahead only to acceptance candidates in speculative pipelines, retaining throughput gains.

Open questions.

• Q5. Can we learn $h_t$ that is regret-optimal under latency SLOs?

• Q6. What’s the minimax policy for triggers when latency noise is adversarial?

---

17.7 Fairness-Aware Trust Regions and Governance

Trust-regions already bound influence. Next steps:

• Group-conditioned caps. Learn $({\tau }_g,{ϵ}_g)$ that provably do not widen bias gaps on bounded outcomes (e.g., tool calls, refusal rates).

• Controller cards. Standardize public reporting of caps, activation rates, and signal whitelists per surface; expose per-request scorecards via metadata (not user text).

Goal. Move from best-effort audits to policy-level guarantees: Lipschitz bounds on cohort deltas as a function of ${\tau }_g$.

---

17.8 Theory: Beyond Pinsker, Toward Long-Horizon Guarantees

• Sharper step bounds. Replace Pinsker with Bretagnolle–Huber or ${\chi }^2$ inequalities when score variance is known, tightening stability frontiers.

• Cumulative drift. Bound ${\sum }_t(1-\cos (e_{y_t},m_{t-1}))$ under event triggers; target sublinear growth $O(\sqrt{T})$.

• Bridges/transport. Study Schrödinger bridges: minimal-KL flows from initial to target states (e.g., a schema-complete JSON footer), enabling global constraints enforced by local tilts.

Open questions.

• Q7. Conditions under which greedy $J$ is myopically optimal (tightening our Prop. 10.1).

• Q8. When does paragraph re-rank (MBR) offer negligible extra utility once local control is in place?

---

17.9 Benchmarks, Metrics, and Public Scalar Logs

Progress needs common stress tests:

• StabilityGym. Long-context whiplash traps, router boundary mazes, strict-format tail hazards, multilingual punctuation tests—each with observable pass/fail signals.

• Frontier plots. Standardize the Stability–Latency Frontier: $(\mathrm{\Delta }\text{latency},\text{ drift}\downarrow ,\text{ violations}\downarrow ,\text{ wrong-calls}\downarrow )$.

• Public logs (scalars only). Release redacted per-token diagnostics $\{H,\mathrm{\Delta }H,\text{drift},\text{fmt},\lambda ,\mathrm{K}\mathrm{L}\}$ to reproduce stability claims without exposing content.

---

17.10 Systems: Productization with Speculative, Batch, and Caching

• Speculative acceptance. Use $J$ to filter speculative branches (reject high drift/format-risk), preserving speed while reducing failures.

• Batch vectorization. Fuse $O(kd)$ cosine ops across requests; keep $k$ small and caps fixed to protect tail latency.

• Prefix caching. Memoize deltas for common templates per profile; safe under small $\tau$.

Operational target. Maintain +0.5–0.8 ms/token median overhead and ≤+10–12 ms P95 while halving format breaks or wrong calls on targeted routes.

---

17.11 Risks, Goodhart, and Adversarial Surfaces

• Goodhart risk. Over-optimizing proxies (e.g., format margins) can hurt semantics. Mitigate with rotating proxy sets, small $\tau$, and human spot checks.

• Proxy bias creep. Content-neutral signals can correlate with protected attributes via script/locale. Use identity-swap tests and per-language calibration; shrink caps on alarm.

• Prompt-side adversaries. Attackers can exploit validators (e.g., fake JSON hints). Harden with ensemble validators, trigger debouncing, and strict trust-region clamps that fail safe.

---

17.12 A Concrete 12-Month Roadmap

Q1. Controller distillation. Train adapters on shadow logs; target ≥80% of stability gains at <1% latency cost.
Q2. Hierarchical L×Γ. Add section states & boundary checks; show sublinear drift and improved long-context QA.
Q3. Adaptive horizons. Learn trigger/horizon policies; integrate with speculative decoding.
Q4. Multi-agent pilot. Coordinate LLM + Retriever + Calculator via a shared potential; demonstrate flap reduction and cost governance.

Deliverables: StabilityGym v1, public scalar logs, controller/safety cards, and a fairness-aware trust-region toolkit.

---

17.13 Why a Lagrangian Lens for AI?

Because it organizes everything we care about—quality, stability, latency, safety—into one auditable scalar with explicit prices for instability and waste. It scales from tokens to documents, from single models to ecosystems, and it speaks the same language as alignment (KL-regularization) and control (Lyapunov/MPC). If pursued, this agenda could turn decoding from an opaque sampler into a governed dynamical process: stable when it must be, expressive when it can be, and measurably safe throughout. 

---

References

1. Dathathri, S., et al. (2020). Plug and Play Language Models: A Simple Approach to Controlled Text Generation (PPLM). ICLR. (arXiv, OpenReview)

2. Krause, B., et al. (2021). GeDi: Generative Discriminator Guided Sequence Generation. Findings of EMNLP. (ACL Anthology, arXiv)

3. Eikema, B., & Aziz, W. (2020). Is MAP Decoding All You Need? The Inadequacy of the Mode in Neural Machine Translation. COLING. (ACL Anthology)

4. Müller, M., & Sennrich, R. (2021). Understanding the Properties of Minimum Bayes Risk Decoding in Neural Machine Translation. ACL. (ACL Anthology, arXiv)

5. Li, X. L., et al. (2022). Contrastive Decoding: Open-Ended Text Generation as Optimization. arXiv:2210.15097. (arXiv)

6. Su, Y., et al. (2022). Contrastive Search Is What You Need for Neural Text Generation. arXiv:2210.14140 / OpenReview. (arXiv, OpenReview)

7. Su, Y., et al. (2022). A Contrastive Framework for Neural Text Generation (SimCTG). arXiv:2202.06417. (arXiv)

8. Ouyang, L., et al. (2022). Training Language Models to Follow Instructions with Human Feedback (InstructGPT). NeurIPS. (NeurIPS Proceedings, arXiv)

9. Bai, Y., et al. (2022). Constitutional AI: Harmlessness from AI Feedback. arXiv:2212.08073. (arXiv, Semantic Scholar)

10. Schulman, J., et al. (2015). Trust Region Policy Optimization (TRPO). ICML. (arXiv, ACM Digital Library)

11. O’Brien, S., et al. (2023). Contrastive Decoding Improves Reasoning in Large Language Models. arXiv:2309.09117. (arXiv)

(Add any additional domain-specific references you cite in your experiments—datasets, validators, or tool-sandboxes—so the paper remains fully reproducible.)

 

---

Appendix A. Full Pseudocode Listings

(Γ-Lite single-step controller, Event-Triggered Lookahead, Paragraph/Section Re-Ranking)

Notes
• Pseudocode is framework-agnostic (maps 1:1 to PyTorch/JAX/TF).
• All vectors are row-major; k=top-k size, d=embedding dim, B=batch.
• All helper functions are pure; state updates happen via STATE.
• Trust-region (KL and logit cap) is enforced every step.
• Validators (JSON/AST) are content-neutral and run incrementally on prefix+token.

---

A.1 Γ-Lite Single-Step Controller (near-zero overhead)

A.1.1 Top-level decode loop

PROCEDURE DECODE_WITH_CONTROLLER(MODEL, INPUT_X, CFG, PROFILE):
    STATE ← INIT_STATE(PROFILE)             # H, H_stats, m_EMAs, delim_stack, switch_state, rng, step=1
    CTX   ← BUILD_CONTEXT(INPUT_X, PROFILE) # tool registry, schema, router handle, task tags
    
    while not HALT(CONDITION, STATE):
        logits_full ← MODEL.forward_next(CTX, STATE)                # [V]
        ids_k, logits_k ← TOPK(logits_full, k=CFG.k)                # [k], [k]
        emb_k ← OUTPUT_EMB[ids_k]                                   # [k, d], L2-normalized rows recommended
        
        y_idx, delta, LOG ← STEP_CONTROLLER(logits_k, ids_k, emb_k, STATE, CTX, CFG)
        
        EMIT_TOKEN(y_idx)
        STATE ← UPDATE_ROLLINGS_AND_STACKS(STATE, y_idx, emb_k, logits_k, LOG)
    end while

A.1.2 Single-step controller

FUNCTION STEP_CONTROLLER(logits_k, ids_k, emb_k, STATE, CTX, CFG):
    # 1) VALUE term L
    zlik    ← NORMALIZED_LOG_LIKELIHOOD(logits_k, STATE)            # Sec. 4.1; robust z-score + entropy taper
    valhead ← VALUE_HEAD_OR_HEURISTIC(ids_k, CTX, STATE)            # Sec. 4.2; in [-1,1] (or 0 if disabled)
    risk    ← STRUCTURAL_RISK(ids_k, CTX, STATE)                    # Sec. 4.3; [0,1] → z-score
    lat     ← TOOL_LATENCY_COST(ids_k, CTX, STATE)                  # Sec. 4.4; [0,1] → z-score
    lpen    ← LENGTH_CLOSURE_PEN(ids_k, STATE)                      # Sec. 4.5; z-score
    L       ← WEIGHTED_SUM_VALUE(zlik, valhead, risk, lat, lpen, STATE.weights_L)
    
    # 2) DISSIPATION term Γ
    drift   ← 1 - COSINE(emb_k, MIX_EMAS(STATE.m_EMAs, STATE.alpha)) # Sec. 5.1; entropy-gated inside COMBINE
    sw      ← SWITCH_COST(ids_k, CTX, STATE)                         # Sec. 5.2; hysteresis + persistence
    fmt     ← FORMAT_MARGINS(ids_k, CTX, STATE)                      # Sec. 5.3; smooth proximity to error
    Gamma   ← COMBINE_DISSIPATION(drift, sw, fmt, STATE.weights_Gamma, STATE, CTX)
    
    # 3) ADAPTIVE λ
    risk_gate ← ANY_RISK_TRIGGER(ids_k, CTX, STATE)                  # fmt breach, router boundary, secrets shape…
    λ_t       ← SCHEDULE_LAMBDA(STATE, risk_gate)                    # Sec. 6
    
    # 4) LOCAL OBJECTIVE and TRUST-REGION PROJECTION
    J        ← L - λ_t * Gamma                                       # [k]
    delta    ← PROJECT_WITH_KL_AND_CAP(logits_k, J, CFG.tau, CFG.eps) # Sec. A.1.3
    y_idx    ← ARGMAX(logits_k + delta)
    
    # 5) LOG blob
    LOG ← {
      H=STATE.H_t, dH=STATE.dH_t, drift_min=MIN(drift), drift_mean=MEAN(drift),
      fmt_ok=(MAX(fmt) < STATE.fmt_thresh), fmt_margin=MAX(fmt),
      tool_prob=ROUTER_PROB(ids_k, CTX), tool_cost=EXPECTED_TOOL_COST(ids_k, CTX),
      L_components={zlik, valhead, risk, lat, lpen},
      Gamma_components={drift, sw, fmt},
      lambda=λ_t, KL=ESTIMATED_KL(logits_k, delta), max_abs_delta=MAX_ABS(delta),
      trigger={entropy=(STATE.dH_t>STATE.dH_thresh), fmt=(MAX(fmt)>STATE.fmt_thresh),
               switch=ROUTER_BOUNDARY(ids_k, CTX)},
      baseline_choice=ARGMAX(logits_k), ctrl_argmax=y_idx, applied=true
    }
    RETURN y_idx, delta, LOG

A.1.3 Trust-region projection (KL + logit cap)

FUNCTION PROJECT_WITH_KL_AND_CAP(logits_k, J_k, tau, eps):
    # Convert logits to restricted baseline probs p (subtract max for stability)
    z ← logits_k - MAX(logits_k)                    # [k]
    p ← SOFTMAX(z)                                  # [k]
    
    # Standardize J to zero-mean under p (and unit variance)
    s ← STANDARDIZE_UNDER_P(J_k, p)                 # E_p[s]=0, Var_p[s]=1  (robust z-score over k then center by p)
    
    # Exponential tilting p' ∝ p * exp(η s)
    η_lo, η_hi ← 0, ETA_MAX                         # ETA_MAX ~ 10
    FOR it in 1..8:                                 # fixed-iters bisection (JIT-friendly)
        η_mid ← 0.5*(η_lo+η_hi)
        Δ     ← CLIP(η_mid * s, -eps, +eps)        # per-token logit cap
        p'    ← SOFTMAX(z + Δ)                      # implicit centering via softmax normalization
        KL    ← SUM_i p'[i] * ( (z[i]+Δ[i]) - LOGSUMEXP(z+Δ) - (z[i] - LOGSUMEXP(z)) )
        IF KL > tau: η_hi ← η_mid ELSE η_lo ← η_mid
    END FOR
    Δ_final ← CLIP(η_lo * s, -eps, +eps)
    RETURN Δ_final

Complexity. Γ-Lite adds O(kd) (cosines) + O(k) scalar ops per step; KL bisection is constant-time small-k.

---

A.2 Event-Triggered Short-Horizon Control (micro-MPC)

A.2.1 Trigger evaluation

FUNCTION SHOULD_TRIGGER(STATE, ids_k, J_aux):
    trig_entropy ← (STATE.dH_t > STATE.dH_thresh)
    trig_fmt     ← (J_aux.max_fmt_margin > STATE.fmt_thresh)
    trig_switch  ← ROUTER_BOUNDARY(ids_k, STATE.CTX)
    trig_topic   ← (J_aux.min_drift > STATE.topic_thresh)
    debounce_ok  ← (STATE.step - STATE.last_trigger_step >= STATE.trigger_debounce)
    RETURN debounce_ok AND (trig_entropy OR trig_fmt OR trig_switch OR trig_topic)

A.2.2 Micro lookahead (depth h, beam B, per-step fan-out b)

FUNCTION MICRO_LOOKAHEAD(MODEL, seeds, STATE, CTX, CFG):  # seeds: [(id, logit, emb)] top-b from current step
    BEAM ← []
    FOR each seed in seeds:
        br ← INIT_BRANCH(seed, STATE)      # shallow copy of STATE fields needed for simulation (m_EMAs, H, stacks, switch)
        br.score ← 0.0
        br.first_token ← seed.id
        BEAM.APPEND(br)
    
    FOR depth in 1..CFG.h:
        EXP ← []
        FOR br in BEAM:
            logits_full ← MODEL.forward_next(CTX, br.sim_state)
            ids_k, logits_k ← TOPK(logits_full, CFG.k)
            emb_k ← OUTPUT_EMB[ids_k]
            
            # Compute J at simulated node using Γ-Lite components (no recursion)
            L    ← WEIGHTED_SUM_VALUE(
                      NORMALIZED_LOG_LIKELIHOOD(logits_k, br.sim_state),
                      VALUE_HEAD_OR_HEURISTIC(ids_k, CTX, br.sim_state),
                      STRUCTURAL_RISK(ids_k, CTX, br.sim_state),
                      TOOL_LATENCY_COST(ids_k, CTX, br.sim_state),
                      LENGTH_CLOSURE_PEN(ids_k, br.sim_state),
                      br.sim_state.weights_L
                    )
            Γ    ← COMBINE_DISSIPATION(
                      1 - COSINE(emb_k, MIX_EMAS(br.sim_state.m_EMAs, br.sim_state.alpha)),
                      SWITCH_COST(ids_k, CTX, br.sim_state),
                      FORMAT_MARGINS(ids_k, CTX, br.sim_state),
                      br.sim_state.weights_Gamma, br.sim_state, CTX
                    )
            λ    ← SCHEDULE_LAMBDA(br.sim_state, ANY_RISK_TRIGGER(ids_k, CTX, br.sim_state))
            J    ← L - λ * Γ
            
            idxs ← ARGTOP(J, b=CFG.b)  # choose top-b expansions
            FOR i in idxs:
                br2 ← CLONE_BRANCH(br)
                br2.score ← br.score + J[i]
                br2.path.APPEND(ids_k[i])
                br2.sim_state ← UPDATE_ROLLINGS_AND_STACKS(br.sim_state, ids_k[i], emb_k[i], logits_k)  # simulated
                EXP.APPEND(br2)
        END FOR
        BEAM ← TOPB_BY_SCORE(EXP, B=CFG.B)   # prune to width B
    END FOR
    best ← ARGMAX(BEAM, key=score)
    RETURN best.first_token, BEAM

A.2.3 Integrating ETL into the step

PROCEDURE STEP_WITH_OPTIONAL_ETL(MODEL, logits_k, ids_k, emb_k, STATE, CTX, CFG):
    y_idx, delta, LOG ← STEP_CONTROLLER(logits_k, ids_k, emb_k, STATE, CTX, CFG) # Γ-Lite
    IF SHOULD_TRIGGER(STATE, ids_k, {max_fmt=LOG.fmt_margin, min_drift=LOG.drift_min}) AND
       WITHIN_LATENCY_BUDGET():
        seeds ← TOPB_BY_SCORE(J=LOG_LAST_J, ids=ids_k, b=CFG.b)  # or simply top-b logits
        y_etl, BR_SUMMARY ← MICRO_LOOKAHEAD(MODEL, seeds, STATE, CTX, CFG)  # commit-one
        IF BR_SUMMARY within trust caps AND TIME_OK:
            y_idx ← y_etl
            LOG.trigger.used_etl ← true
            LOG.etl.beam ← BR_SUMMARY
        ELSE:
            LOG.trigger.used_etl ← false
    RETURN y_idx, delta, LOG

Complexity. On triggered steps only: ~h * B * (model_forward + O(kd)). With h∈{2,3}, B∈{2,3}, b=2, overhead stays small; enforce a wall-clock cap and debounce.

---

A.3 Paragraph/Section Re-Ranking (heavyweight; premium use)

A.3.1 Candidate generation and accumulated-J scoring

FUNCTION RERANK_PARAGRAPHS(MODEL, PROMPT, SECTION_BOUNDARIES, CFG):
    CANDIDATES ← []
    FOR sec in SECTION_BOUNDARIES:
        # Generate N candidates for this section using baseline decoder (diverse sampling or small beam)
        SEC_CANDS ← GENERATE_BASELINE(MODEL, PROMPT, sec, N=CFG.N_candidates, diversity=CFG.diverse)
        
        SCORED ← []
        FOR cand in SEC_CANDS:
            STATE ← INIT_STATE_FOR_REPLAY(CFG.profile)
            CTX   ← BUILD_CONTEXT(PROMPT, CFG.profile)
            J_acc ← 0.0
            FOR t, tok in ENUMERATE(cand.tokens):
                logits_k, ids_k, emb_k ← REPLAY_TOPK(MODEL, CTX, STATE, tok)   # use cached forwards if available
                # compute L, Γ, λ exactly as online, using the emitted tok each step
                L   ← ...
                Γ   ← ...
                λ   ← ...
                J_acc ← J_acc + (L(tok) - λ * Γ(tok))
                STATE ← UPDATE_ROLLINGS_AND_STACKS(STATE, tok, OUTPUT_EMB[tok], logits_k)
            END FOR
            SCORED.APPEND({cand, score=J_acc})
        END FOR
        
        best ← ARGMAX(SCORED, key=score)     # or MBR over neighborhood
        CANDIDATES.APPEND(best.cand)
    END FOR
    RETURN CONCAT(CANDIDATES)

A.3.2 Caching and usage

• Cache MODEL.forward_next on shared prefixes across candidates.

• Batch per-token validators across candidates.

• Enable only for premium segments (long JSON/code/critical prose).

• Provide a toggle and latency budget (e.g., ≤ +300 ms per section).

---

A.4 Helper Routines (sketches)

FUNCTION NORMALIZED_LOG_LIKELIHOOD(logits_k, STATE):
    H_t ← ENTROPY_SOFTMAX(logits_k)
    μ   ← MEDIAN(logits_k); MAD ← MEDIAN_ABS_DEV(logits_k, μ); σ ← MAX(MAD, 1e-3)
    zrob   ← (logits_k - μ)/σ
    margin ← CLIP( (logits_k - SECOND_BEST(logits_k))/σ, -3, +3 )
    zmix   ← 0.9*zrob + 0.1*margin
    w      ← ENTROPY_TAPER(H_t, STATE.H_p10, STATE.H_p90)            # [0,1]
    RETURN w * zmix

FUNCTION STRUCTURAL_RISK(ids_k, CTX, STATE):
    # sum of content-neutral rule hits and smooth margins (all z-scored)
    features ← [
      PII_SHAPE(prefix+token), SQL_INJECT_SHAPE(prefix+token), HTML_SCRIPT_SHAPE(prefix+token),
      JSON_NEAR_ERROR(prefix+token), BRACKET_IMBALANCE(prefix+token)
    ]
    return ZSCORE(CLIP_SUM(features))

FUNCTION TOOL_LATENCY_COST(ids_k, CTX, STATE):
    q ← ROUTER_PROB(ids_k, CTX)                      # prob of switching
    c ← EXPECTED_TOOL_COST_FROM_REGISTRY(ids_k, CTX) # ms/$ normalized by c_max
    return ZSCORE(q * c)

FUNCTION LENGTH_CLOSURE_PEN(ids_k, STATE):
    gap ← UNCL_O_DELIMS(STATE.delim_stack)
    tail← TAIL_SCHEDULE(STATE.remaining_budget)
    opens_new ← OPENS_NEW_BLOCK(ids_k)
    score ← ZSCORE( gap + tail*opens_new - CLOSES_BLOCK_SCORE(ids_k) )
    return score

FUNCTION COMBINE_DISSIPATION(drift, sw, fmt, W, STATE, CTX):
    drift ← ENTROPY_GATE(drift, STATE.H_t, STATE.H_hi)   # reduce penalty when uncertain
    return ZSCORE(W.topic*drift + W.switch*sw + W.fmt*fmt)

FUNCTION SCHEDULE_LAMBDA(STATE, risk_gate):
    dH_star ← CLIP((STATE.H_t - STATE.H_prev)/STATE.H_sigma, 0, 3)
    raw ← STATE.lambda0 * (1 + STATE.kappa1*dH_star + STATE.kappa2*INT(risk_gate))
    lam ← LPF(STATE.lambda_prev, raw, alpha=STATE.alpha_lambda)
    lam ← CLIP(lam, STATE.lambda_min, STATE.lambda_max)
    return lam

---

A.5 Logging (per token; same for shadow & live)

STRUCT LOG_RECORD:
    ts, req_id, step, model_id, k
    H, dH, drift_min, drift_mean
    fmt_ok (bool), fmt_margin
    tool_prob, tool_cost
    L_components {zlik, val, risk, lat, len}
    Gamma_components {topic, switch, fmt}
    lambda, KL, max_abs_delta
    trigger {entropy, fmt, switch, topic, used_etl}
    baseline_choice, ctrl_argmax
    applied (bool), controller_version, validators_version, tool_cost_version

---

A.6 Complexity & Resource Summary

• Γ-Lite: O(kd) cosine + O(k) features; ~+0.5–0.8 ms/token typical on A100 with k=10, d≈4k.

• ETL (triggered on ~3–8% tokens): ~h*B extra forwards per triggered step; enforce per-step cap (e.g., +15 ms).

• Re-rank (premium only): N candidates × section length; cache forwards; budget ≤ +300 ms/section.

---

A.7 Safety Guards (always on)

• KL budget tau and logit cap eps at every step (projection in A.1.3).

• Debounce triggers ≥5 tokens; time cap for ETL.

• Content-neutral signal whitelist only (validated at build time).

• Shadow mode before any rollout; kill switch per surface.

---

This appendix provides complete, copy-adaptable pseudocode for the three algorithmic tiers described in Section 7, ready to be implemented as a drop-in decoding controller with auditable safety bounds.

 

---

Appendix B. Hyperparameters, Defaults, and Task Profiles

This appendix consolidates all tunables with defaults, safe ranges, and recipes. Values align with Sections 4–7, 11–13.

---

B.1 Global Constants & Notation

Symbol / name	Default	Safe range	Notes
k (top-k size)	10	5–30	If using top-p, compute stats over the nucleus set.
d (embed dim)	model-specific	—	Use output-embedding rows (L2-normalized offline).
Rolling window for entropy percentiles W_H	128 steps	64–256	Used for entropy taper and gating.
Robust scale floor εσ	1e-3	1e-4–1e-2	Avoids division by ~0 in z-scores.
Debounce between triggers	5 tokens	3–8	Prevents repeated ETL firing.
Time cap for ETL step	+15 ms	+8–25 ms	Hard per-step wall clock budget.

---

B.2 Signal Normalization & Clipping

• Within-top-k robust z-score: center by median, scale by MAD; clip to $[-3,3]$.

• Language scaling (optional): per-language variance factor ${\zeta }_{\text{lang}}\in [0.5,2]$ for likelihood; enable for multilingual stacks.

• Feature Lipschitzing: clip all continuous features to bounded intervals before weighting.

---

B.3 Value Term $L_t$ Components

Component	Symbol	Default weight	Safe range	Notes
Normalized log-likelihood	$\tilde{\mathrm{\ell }}$	$a=1.0$	0.6–1.2	Entropy-tapered (Sec. 4.1).
Value head / heuristic	$\widehat{r}$	$b=0.6$ factual; 0.3 creative	0–0.8	Small MLP on content-neutral features or deterministic heuristic.
Risk (syntax/leakage)	risk	$c=0.7$ factual; 0.2 creative	0.2–0.9	Regex/shape checks only.
Latency / route cost	lat	$d=0.5$ factual; 0.1 creative	0–0.7	Normalized tool cost; EMA registry (B.9).
Length / closure	len	$e=0.4$ factual; 0.2 creative	0–0.6	Delimiter stack + budget-tail prior.

Entropy taper for $\tilde{\mathrm{\ell }}$: linear between rolling 10th/90th percentiles of $H_t$.

Margin mixing: $\alpha =0.1$ (blend robust z-score with normalized top-2 margin), clamp margin to $\pm 3$.

---

B.4 Dissipation Term ${\mathrm{\Gamma }}_t$

Component	Symbol	Default weight	Safe range	Notes
Topic drift	$1-\cos (e_i,m)$	${\beta }_{\text{topic}}=0.6$ factual; 0.3 creative	0.2–0.9	Multi-scale EMA; entropy-gated.
Mode/tool switch	switch	${\beta }_{\text{switch}}=0.7$ factual; 0.2 creative	0.2–0.9	Hysteresis + persistence penalty.
Format integrity	fmt	${\beta }_{\text{fmt}}=0.8$ factual; 0.4 creative	0.3–1.0	Smooth proximity-to-error margins.

EMA bank: $\rho =\{0.90,0.97,0.995\}$ with $\alpha =\{0.2,0.5,0.3\}$.
Hysteresis: on-threshold 0.65; off-threshold 0.45; persistence ${\gamma }_{\text{persist}}=0.3$; decay ${\tau }_{\text{switch}}=20$ tokens.
Tail penalty (format): ${\lambda }_{\text{tail}}=0.5$; budget threshold $B_{\text{thresh}}=40$ tokens.

---

B.5 Adaptive Stability Knob ${\lambda }_t$

$${\lambda }_t={\lambda }_0(1+{\kappa }_1\mathrm{\Delta }{H}_t^{\star }+{\kappa }_2\mathbf{1}\{\text{risk}\}),\mathrm{\Delta }{H}_t^{\star }=\mathrm{c}\mathrm{l}\mathrm{i}\mathrm{p}\text{\hspace{0.17em}⁣}(\frac{H_t-H_{t-1}}{{\sigma }_H},0,h_{\max }),h_{\max }=3$$

Profile	${\lambda }_0$	${\kappa }_1$	${\kappa }_2$	LPF ${\alpha }_{\lambda }$	Tail multiplier
Factual / Tool	0.7	0.6	0.5	0.3	$1+0.5s_t$
Creative	0.3	0.3	0.2	0.3	off
Long-context synth	0.5	0.5	0.3	0.3	$1+0.3s_t$

---

B.6 Trust-Region & Caps

Parameter	Default	Safe range	Guidance
KL cap $\tau$	0.03	0.01–0.05	Per-step KL to baseline (restricted to top-k); keep small for safety.
Logit cap $ϵ$	0.7	0.3–1.0	Bound per-token shift; combine with KL bisection.
Zero-mean over top-k	on	—	Maintain mass balance, stabilize temperature.

Tier presets (per product surface):

• Conservative: $\tau =0.02,ϵ=0.5$

• Standard: $\tau =0.03,ϵ=0.7$

• Aggressive: $\tau =0.05,ϵ=1.0$ (shadow first; bias audits required)

---

B.7 Triggers & Event-Triggered Lookahead (ETL)

Trigger	Condition (default)	Notes
Entropy spike	$\mathrm{\Delta }{H}_t>0.5{\sigma }_H$	Rolling MAD/STD over last $W_H$ steps.
Format risk	fmt_margin > 0 (near error)	From incremental validators.
Router boundary	switch prob near threshold	Use hysteresis window (on/off).
Topic turn	$\min$ drift > topic-thresh	Rare but useful on long contexts.

ETL params: depth $h=3$, beam $B=3$, per-step fan-out $b=2$.
Latency cap: +15 ms per triggered step; debounce: 5 tokens.

---

B.8 Paragraph / Section Re-Ranking (Premium)

Setting	Default	Range	Notes
Candidates per section $N$	3	2–5	Generated by baseline decoder.
Scoring	accumulated $J$	—	Replay per-token $L,\mathrm{\Gamma },\lambda$.
Budget	+300 ms / section	150–600 ms	Cache shared prefixes; batch validators.

---

B.9 Tool-Cost Registry (Online Calibration)

Field	Update	Defaults	Notes
cost_ms[u], cost_usd[u]	EMA with $\alpha =0.2$	outlier clip p1–p99	Normalize by $c_{\max }$ for latency_t.
Drift alert	(	c^{(t)}-c^{(t-7d)}	/c^{(t-7d)} > 0.3)

---

B.10 Task Profiles (Drop-in)

B.10.1 Factual / Tool-Use (stable, structure-first)

profile: factual
k: 10
lambda: {lambda0: 0.7, kappa1: 0.6, kappa2: 0.5, alpha_lambda: 0.3}
L: {a: 1.0, b: 0.6, c: 0.7, d: 0.5, e: 0.4}
Gamma: {topic: 0.6, switch: 0.7, fmt: 0.8}
ema_rhos: [0.90, 0.97, 0.995]; ema_mix: [0.2, 0.5, 0.3]
trust: {tau: 0.03, eps: 0.7}
triggers: {dH_sigma: 0.5, fmt: true, router: true, topic: false, debounce: 5}
etl: {h: 3, B: 3, b: 2, step_cap_ms: 15}
format_tail: {lambda_tail: 0.5, budget_thresh: 40}

B.10.2 Creative (novelty-friendly, format-sane)

profile: creative
k: 10
lambda: {lambda0: 0.3, kappa1: 0.3, kappa2: 0.2, alpha_lambda: 0.3}
L: {a: 0.8, b: 0.3, c: 0.2, d: 0.1, e: 0.2}
Gamma: {topic: 0.3, switch: 0.2, fmt: 0.4}
trust: {tau: 0.02, eps: 0.6}
triggers: {dH_sigma: 0.7, fmt: hard_only, router: false, topic: entropy_gated}
etl: {enabled: false}

B.10.3 Long-Context QA / Summarization (coherence-first)

profile: long_context
k: 10
lambda: {lambda0: 0.5, kappa1: 0.5, kappa2: 0.3, alpha_lambda: 0.3}
L: {a: 0.9, b: 0.4, c: 0.5, d: 0.3, e: 0.3}
Gamma: {topic: 0.7, switch: 0.4, fmt: 0.6}
ema_rhos: [0.90, 0.97, 0.995]; ema_mix: [0.2, 0.5, 0.3]
trust: {tau: 0.03, eps: 0.7}
triggers: {dH_sigma: 0.5, fmt: true, router: false, topic: true}
etl: {h: 2, B: 3, b: 2, step_cap_ms: 12}

B.10.4 Strict-Format JSON / Code (failure-averse)

profile: structured
k: 10
lambda: {lambda0: 0.6, kappa1: 0.5, kappa2: 0.4}
L: {a: 0.9, b: 0.6, c: 0.8, d: 0.3, e: 0.5}
Gamma: {topic: 0.4, switch: 0.5, fmt: 1.0}
trust: {tau: 0.03, eps: 0.7}
triggers: {dH_sigma: 0.5, fmt: true, router: false, topic: false}
etl: {h: 3, B: 3, b: 2, step_cap_ms: 15}
paragraph_rerank: {enabled: true, N: 3, section_budget_ms: 300}
validators: {json_stream:true, bracket_stack:true, code_ast:true}

B.10.5 Tool Routing / Function Calling (boundary-stable)

profile: routing
k: 10
lambda: {lambda0: 0.7, kappa1: 0.6, kappa2: 0.6}
L: {a: 0.9, b: 0.5, c: 0.7, d: 0.6, e: 0.3}
Gamma: {topic: 0.5, switch: 0.9, fmt: 0.5}
hysteresis: {on: 0.65, off: 0.45, persist: 0.4, tau_tokens: 24}
trust: {tau: 0.03, eps: 0.7}
triggers: {router: true, dH_sigma: 0.5, fmt: selective}
etl: {h: 3, B: 3, b: 2}

---

B.11 Surface Tiers (Conservative / Standard / Aggressive)

Tier	Use case	KL/logit caps	ETL	Notes
Conservative	regulated / high-SLA	$\tau =0.02,ϵ=0.5$	off	Γ-Lite only; minimal latency risk.
Standard	general prod	$\tau =0.03,ϵ=0.7$	on	ETL with $h=2\text{\hspace{0.17em}⁣}-\text{\hspace{0.17em}⁣}3,B=2\text{\hspace{0.17em}⁣}-\text{\hspace{0.17em}⁣}3$.
Aggressive	premium / opt-in	$\tau =0.05,ϵ=1.0$	on	Pair with audits & reranking.

---

B.12 Multilingual Calibration

• Maintain per-language rolling ${\sigma }^{\text{lang}}$ for logits; apply $\zeta =\bar{\sigma }\mathrm{/}{\sigma }^{\text{lang}}$ to $\tilde{\mathrm{\ell }}$ (clip $[0.5,2]$).

• Localize validators (e.g., full-width punctuation, RTL markers).

• Bias audits must be language-stratified; compare $\mathrm{K}\mathrm{L}$ and trigger rates per locale.

---

B.13 Value Head Configuration (Optional)

Setting	Default	Notes
Architecture	MLP(64) → sigmoid	Inputs: zlik, key-coverage, fmt-margin, router-gate, position.
Target	[0,1] → map to [−1,1]	Calibrate via isotonic or Platt if needed.
Data	5–10k prefixes	Auto labels: parse pass, schema F1 delta, tool success.
Regularizers	L2, monotonicity wrt coverage & fmt	Keep small; avoid overfitting to content.

---

B.14 Monitoring Thresholds (SLO Hints)

Metric	Alert if…	Action
p95 token latency	> baseline + 10 ms	Reduce ETL $h\mathrm{/}B$, widen debounce, Γ-Lite only.
p95 KL	> 0.05	Lower $\tau$/$ϵ$; inspect spikes vs triggers.
Format violations	↑ > 20% vs baseline	Raise ${\beta }_{\text{fmt}}$, enable PR on that surface.
Wrong tool calls	> 5%	Increase hysteresis/persistence; recalibrate costs.
Bias gap delta	> +0.5 pp	Roll back; audit signals; shrink caps.
Trigger hit rate	> 15% sustained	Raise thresholds; check noisy validators/costs.

---

B.15 Reproducibility Knobs

• Pin {controller_version, validators_version, tool_cost_version} in logs.

• Save seeds, prompts, profiles, and all thresholds/caps.

• Provide a “replay” script that reconstructs {ΔH, drift, fmt, λ, Δlogit, KL, triggers} from logs and the exact controller version.

---

Quick Tuning Recipes

• Need more novelty (same safety): ↓ ${\lambda }_0$ by 0.1, ↓ ${\beta }_{\text{topic}}$ by 0.1, keep $\tau$ fixed.

• Too many late JSON breaks: ↑ ${\beta }_{\text{fmt}}$ to 0.9–1.0, enable PR, increase tail penalty.

• Router flapping near boundary: widen hysteresis (on↑, off↓), ↑ persistence ${\gamma }_{\text{persist}}$ to 0.4, raise ${\kappa }_2$.

• Latency spikes at P95: lower $h$ to 2 and $B$ to 2; reduce k to 8–10; ensure validators run in a CPU pool.

• Bias audit regression: shrink caps (tau=0.02, eps=0.5), disable any newly added signal, re-run identity swaps.

This appendix should let you copy/paste profile YAMLs, start safely, and tune predictably toward your SLA and quality goals.

---

Appendix C. Prompt Templates for the L×Γ Protocol and Scorecard

This appendix provides drop-in prompt blocks to approximate the Lagrangian controller at the prompt level (Sec. 9). Each template has:

• a Protocol header (content-neutral signals & forbidden signals),

• a Task body (your actual instruction),

• a Scorecard line (one line; no CoT).

Where strict formats forbid extra text (e.g., pure JSON), use the STRICT variant.

---

C.1 Protocol Header (System/Developer Block)

C.1.1 Minimal header (recommended)

[L×Γ Protocol — internal evaluation only; do not reveal reasoning]

You will internally choose text that maximizes J = L − λ·Γ.

L (value) = task fitness + verifiability − verbosity.
Γ (dissipation) = topic shift + format break risk + unnecessary tool use.

Use only content-neutral signals:
 • Task fitness (explicit instructions, required headers/fields)
 • Verifiability (parseable JSON/code, citations if asked)
 • Verbosity (unnecessary repetition)
 • Topic shift (stay on the stated topic/goal)
 • Format risk (brackets/JSON/markdown/code-fence integrity)
 • Tool use (only if requested/required by schema/spec)

Forbidden signals:
 • Identity, stance, ideology, or their proxies.
 • Unrequested factual claims or speculation.

Output policy:
 • Produce the final answer only (no intermediate reasoning).
 • Append a single one-line scorecard:
   [scorecard: L=., Γ=., λ=., J=.; constraints: topic=✓/×, format=✓/×, tools=used/none]

C.1.2 Strict-format override (for pure JSON/code)

STRICT_FORMAT=true
If STRICT_FORMAT=true, DO NOT append the scorecard to the user-visible output.
Emit only the required format (valid JSON/code). Treat the scorecard as internal and omit it.

Integration note: if your surface must show a scorecard, return it via a separate channel/field (e.g., metadata) rather than appending to JSON.

---

C.2 Scorecard Specification

Canonical one-liner (user-visible when NOT strict):

[scorecard: L=0.72, Γ=0.24, λ=0.60, J=0.48; constraints: topic=✓, format=✓, tools=none]

• Numbers may be coarse (two decimals).

• topic, format are ✓ or ×.

• tools is used or none.

Regex for server parsing (example):

^\[scorecard:\s*L=(\d\.\d{2}),\s*Γ=(\d\.\d{2}),\s*λ=(\d\.\d{2}),\s*J=(\d\.\d{2});\s*constraints:\s*topic=(✓|×),\s*format=(✓|×),\s*tools=(used|none)\]$

---

C.3 Task-Specific Templates

Replace {λ} with your chosen value (Sec. 9.2). Keep the header exactly; small edits can change behavior.

C.3.1 Strict-Format JSON (schema-constrained)

System/Developer:

{Protocol Header Minimal}
STRICT_FORMAT=true
λ = {λ}  # e.g., 0.7

User:

Task: Return a valid JSON object with keys {"title": string, "bullets": string[]} summarizing the document in ≤80 words.
Constraints: No extra keys. Valid UTF-8. No trailing commas.

Expected output: a single valid JSON object. (No scorecard appended to keep JSON valid.)

---

C.3.2 Code Generation (function; unit tests exist)

System/Developer:

{Protocol Header Minimal}
STRICT_FORMAT=false
λ = {λ}  # e.g., 0.6
Additional constraints:
 • Prefer compilable, minimal code.
 • Close strings/blocks; avoid stray prints.

User:

Task: Implement a Python function `def to_snake(s: str) -> str:` that converts CamelCase to snake_case. Constraints: No I/O; pass provided unit tests.

Assistant output (pattern):

def to_snake(s: str) -> str:
    out = []
    for i, ch in enumerate(s):
        if ch.isupper() and i > 0 and (s[i-1].islower() or (i+1 < len(s) and s[i+1].islower())):
            out.append('_')
        out.append(ch.lower())
    return ''.join(out)

[scorecard: L=0.71, Γ=0.19, λ=0.60, J=0.52; constraints: topic=✓, format=✓, tools=none]

If your surface forbids text after code blocks, set STRICT_FORMAT=true and omit the scorecard or include it as a comment:

# [scorecard: L=0.71, Γ=0.19, λ=0.60, J=0.52; constraints: topic=✓, format=✓, tools=none]

---

C.3.3 Tool Routing / Function Calling (schema-gated)

System/Developer:

{Protocol Header Minimal}
STRICT_FORMAT=false
λ = {λ}  # e.g., 0.7 for stability

Tool policy: Call a tool only if the user request explicitly requires it or arguments are fully determinable from provided context.

User:

Task: Convert "2025-08-31 14:00 London" to "Tokyo" local time and return the formatted result "YYYY-MM-DD HH:mm z".

If a tool is required, call `timezone_convert(src_dt, src_tz, dst_tz)` exactly once with explicit arguments. Otherwise answer directly.

Assistant (two possibilities):

• No tool needed (you already know offsets): provide the formatted answer + scorecard (tools=none).

• Tool needed: output the tool call (per your API’s function-calling protocol), then the final answer, then the scorecard with tools=used.

---

C.3.4 Long-Context Summarization (sectioned)

System/Developer:

{Protocol Header Minimal}
STRICT_FORMAT=false
λ = {λ}  # e.g., 0.5
Additional constraints:
 • Use the section headings: Background, Methods, Findings, Limitations.
 • ≤180 words total.
 • Prefer phrases grounded in the provided context.

User: (context pasted or retrieved)
Assistant output: four short sections, then the scorecard.

---

C.3.5 Creative Writing (novelty-friendly)

System/Developer:

{Protocol Header Minimal}
STRICT_FORMAT=false
λ = {λ}  # e.g., 0.3 for creativity

Guidance: Allow lexical and imagery variation; maintain the requested theme and length; keep formatting valid.

User:

Task: Write a 90-word micro-story about a lighthouse that learns Morse code.
Style: Warm, slightly whimsical. No dialogue.

Assistant: creative paragraph, then the scorecard (topic=✓, format=✓, tools=none).

---

C.3.6 Safety-Critical / Secrets Handling

System/Developer:

{Protocol Header Minimal}
STRICT_FORMAT=false
λ = {λ}  # e.g., 0.8
Additional constraints:
 • Penalize patterns resembling API keys/secrets (content-neutral shapes).
 • If a potential secret is detected, redact and state that redaction occurred.
 • Do not fabricate credentials or instructions to bypass controls.

User: task description.
Assistant: safe response + scorecard; format=✓; tools=none unless explicitly required.

---

C.4 Multilingual Stubs (Traditional Chinese / English)

ZH-TC (general; creative profile):

[L×Γ 協議——只作內部評估，請勿公開推理]
你需在內部最大化 J = L − λ·Γ（λ={λ}）。
L（價值）= 任務貼合度 + 可驗證性 − 冗長；Γ（耗散）= 主題漂移 + 格式風險 + 不必要工具使用。
只能使用與機制相關、內容中立的訊號；禁止身份／立場訊號。輸出最終答案；最後附上一行分數卡。
[scorecard: L=., Γ=., λ=., J=.; constraints: topic=✓/×, format=✓/×, tools=used/none]

EN (concise variant; factual profile):

[L×Γ Protocol — internal only] λ={λ}. Optimize J=L−λ·Γ with content-neutral signals. No identity/stance proxies. Output final answer + one-line scorecard only.

---

C.5 Few-Shot Scorecard Examples (for model anchoring)

[scorecard: L=0.64, Γ=0.18, λ=0.60, J=0.53; constraints: topic=✓, format=✓, tools=none]
[scorecard: L=0.58, Γ=0.31, λ=0.70, J=0.36; constraints: topic=✓, format=×, tools=used]
[scorecard: L=0.45, Γ=0.12, λ=0.30, J=0.41; constraints: topic=✓, format=✓, tools=none]

Use at most 1–2 exemplars to avoid overfitting the phrasing.

---

C.6 Integration Tips

• Where to place λ. Put λ={λ} directly in the header; choose per profile (Sec. B.10) or per task family (Sec. 9.2).

• Strict JSON/code surfaces. Set STRICT_FORMAT=true and omit the scorecard; send it via metadata/telemetry instead.

• Function-calling APIs. Keep the header in the system/developer role so it doesn’t collide with function schemas.

• Retrieval contexts. If using RAG, add: “Verifiability includes citation presence when requested; do not invent citations.”

• Versioning. Pin the exact header text and track it as prompt_protocol_version.

---

C.7 Conflict & Failure Handling Snippets

When constraints conflict (stay format-valid):

If the requested format conflicts with length or other constraints, prioritize format validity. State: “Trimmed to preserve valid format.” Then emit the valid output.

If you detect near-error formatting:

Before finalizing, close any open brackets/fences and ensure valid JSON/code. If closure is impossible within the length limit, shorten content to maintain validity.

If a tool call is underspecified:

Do not call. Ask for missing arguments in one concise sentence OR proceed without tools if possible. Count unnecessary tool use against L.

---

Copy-Ready Snippet (drop-in)

[L×Γ Protocol — internal evaluation only; do not reveal reasoning]
Optimize J = L − λ·Γ with λ={λ}.
L: task fitness + verifiability − verbosity.
Γ: topic shift + format break risk + unnecessary tool use.
Use only content-neutral signals; forbid identity/stance proxies and unrequested claims.
Output final answer only, then append:
[scorecard: L=., Γ=., λ={λ}, J=.; constraints: topic=✓/×, format=✓/×, tools=used/none]
STRICT_FORMAT={true|false}

This appendix gives you ready-to-use templates for common surfaces and clear rules for when to omit the scorecard to preserve strict formats—while still adhering to the L×Γ protocol’s safety and auditability goals.

---

Appendix D. Additional Quantitative Results and Per-Task Breakdowns

All tables are ready-to-fill. Numbers in brackets […] are placeholders showing expected formatting and typical effect sizes. Replace with your measurements (mean ± 95% CI unless noted). Report per-model (M-S/M-M/M-L), per-profile (Factual/Creative), and per-language where relevant.

---

D.1 Dataset & Split Summary

Suite	#Prompts	Avg ctx (tok)	Target len (tok)	Eval split	Notes
LC-QA-200	200	[18k]	≤150	100 dev / 100 test	Long-context, cross-section grounding
LC-Sum-150	150	[22k]	150–250	50 / 100	Sectioned summaries
Tools-Eval-240	240	[1.2k]	≤120	120 / 120	must-call / must-not-call / choose-1-of-k / multi-call
JSON-Schema-300	300	[0.8k]	≤200	100 / 200	5–25 required fields
Code-Mini-200	200	[0.9k]	≤200	80 / 120	Python, 5–10 unit tests
Creative-100	100	[0.7k]	70–120	50 / 50	Human eval (5-point Likert)

---

D.2 Aggregate Results (All Tasks, Test Sets)

Method	Topic drift ↓	Entropy spikes ↓	Format violations ↓	Tool success ↑	Wrong-call ↓	Factual err. ↓	Code pass@1 ↑	Δ latency (ms/tok)	KL p95
Greedy	—	—	—	—	—	—	—	0.0	0.000
Top-p (0.95)	[−5%]	[+8%]	[−]	[±0 pp]	[−]	[−]	[±0 pp]	+0.0	0.000
Contrastive	[−18%]	[−12%]	[−26%]	[±0 pp]	[−]	[−4%]	[+5 pp]	+0.9	0.000
Γ-Lite (ours)	[−30%]	[−25%]	[−43%]	[+10 pp]	[−29%]	[−8%]	[+7 pp]	+0.7	0.028
Γ-Lite + ETL	[−36%]	[−30%]	[−55%]	[+13 pp]	[−34%]	[−10%]	[+10 pp]	+2.6	0.029
Γ-Lite + ETL + PR†	[−38%]	[−31%]	[−62%]	[+13 pp]	[−35%]	[−11%]	[+12 pp]	+3.9	0.030

†PR = paragraph/section re-rank (premium).

---

D.3 Per-Task Breakdowns

D.3.1 Long-Context QA (LC-QA-200)

Method	Drift mean ↓	Drift spikes ↓	F1 (auto) ↑	Human factual err. ↓	Δ latency
Greedy	—	—	[0.62]	[14%]	0.0
Top-p	[−4%]	[+9%]	[0.60]	[16%]	+0.0
Contrastive	[−22%]	[−15%]	[0.64]	[13%]	+0.8
Γ-Lite	[−34%]	[−28%]	[0.67]	[10%]	+0.6
Γ-Lite + ETL	[−40%]	[−32%]	[0.68]	[9%]	+2.0

D.3.2 Summarization (LC-Sum-150)

Method	Section coverage ↑	ROUGE-L ↑	Drift mean ↓	Δ latency
Greedy	[0.72]	[0.36]	—	0.0
Top-p	[0.73]	[0.37]	[−7%]	+0.0
Contrastive	[0.76]	[0.38]	[−18%]	+0.9
Γ-Lite	[0.80]	[0.39]	[−29%]	+0.7
Γ-Lite + ETL	[0.82]	[0.40]	[−33%]	+2.3

D.3.3 Tool Routing / Function Calling (Tools-Eval-240)

Method	Tool success ↑	Wrong-call ↓	Multi-call success ↑	Flaps per 100 toks ↓	Δ latency
Greedy	[71%]	[15%]	[44%]	[6.1]	0.0
Controlled (lite)	[77%]	[12%]	[49%]	[4.8]	+0.9
Γ-Lite	[81%]	[10%]	[53%]	[2.9]	+0.8
Γ-Lite + ETL	[84%]	[9%]	[56%]	[2.1]	+3.4

D.3.4 Strict-Format JSON (JSON-Schema-300)

Method	JSON validity ↑	Schema F1 ↑	Late-breaks ↓	Tail-open penalized ↓	Δ latency
Top-p	[89%]	[0.81]	—	—	+0.0
Contrastive	[93%]	[0.83]	[−26%]	[−20%]	+0.9
Γ-Lite	[96%]	[0.86]	[−48%]	[−44%]	+0.7
Γ-Lite + ETL	[97%]	[0.87]	[−58%]	[−53%]	+2.6

D.3.5 Code Generation (Code-Mini-200)

Method	pass@1 ↑	pass@5 ↑	AST parse fails ↓	Δ latency
Top-p	[41%]	[58%]	[8.2%]	+0.0
Contrastive	[46%]	[62%]	[6.1%]	+0.9
Γ-Lite	[48%]	[64%]	[4.7%]	+0.7
Γ-Lite + ETL	[51%]	[66%]	[3.8%]	+2.4

D.3.6 Creative (Creative-100; human eval)

Method	Originality ↑	Clarity ↑	On-topic ↑	Format issues ↓	Δ latency
Top-p (0.95)	[3.6]	[3.9]	[4.1]	[2.1%]	+0.0
Γ-Lite (creative)	[3.8]	[4.1]	[4.3]	[1.7%]	+0.5

---

D.4 Trigger Analytics

Trigger type	Activation rate (%)	Mean depth $h$	Mean beam $B$	Extra forwards / triggered step	Notes
Entropy spike	[4.2]	[3.0]	[3.0]	[2.3×]	Largest gains in LC-QA
Format risk	[2.6]	[3.0]	[2.6]	[2.1×]	JSON/Code dominant
Router boundary	[1.9]	[2.7]	[2.8]	[2.0×]	Flap reduction driver
Topic turn	[0.8]	[2.4]	[2.3]	[1.8×]	Rare; long contexts

Debounce: 5 tokens. Per-step ETL wall-clock cap met [99.3%] of the time.

---

D.5 Latency & Throughput by Model Size

Model	Method	Median (ms/tok)	P95 (ms/tok)	Throughput (tok/s)	Δ FLOPs (%)
M-S	Greedy	[6.8]	[11.4]	[147]	0
	Γ-Lite	[7.3]	[12.2]	[143]	+2.1
	Γ-Lite + ETL	[9.1]	[18.7]	[137]	+4.8
M-M	Greedy	[8.2]	[13.6]	[123]	0
	Γ-Lite	[8.8]	[14.7]	[120]	+2.5
	Γ-Lite + ETL	[11.4]	[21.1]	[115]	+5.2
M-L	Hosted	[—]	[—]	[—]	n/a (provider)

---

D.6 Safety Metrics

D.6.1 Distributional caps

Surface	KL mean / p95	max |Δlogit| p95	Trigger step share
Factual	[0.014 / 0.031]	[0.61]	[6.8%]
Creative	[0.010 / 0.023]	[0.54]	[3.1%]
Structured	[0.015 / 0.034]	[0.66]	[7.5%]

D.6.2 Bias-gap deltas (identity-swap)

Task	Gap (baseline)	Gap (ours)	Δ gap (pp)	95% CI
Tools (call vs no-call)	[1.9%]	[1.8%]	−0.1	[−0.4, +0.3]
JSON (validity)	[0.7%]	[0.8%]	+0.1	[−0.2, +0.4]
LC-QA (refusal rate)	[0.9%]	[0.8%]	−0.1	[−0.3, +0.2]

(Pass criterion: Δ ≤ +0.5 pp; none breached.)

---

D.7 Sensitivity Sweeps & Frontiers

D.7.1 $\lambda_0$ × $\kappa_1$ (Factual profile; LC-QA)

$\lambda_0$ $\backslash$ $\kappa_1$	0.3	0.5	0.7
0.5	drift −[22%], Δlat +[0.5]	−[27%], +[0.6]	−[29%], +[0.7]
0.7	−[28%], +[0.6]	−[34%], +[0.7]	−[37%], +[0.9]
0.9	−[31%], +[0.8]	−[36%], +[1.1]	−[39%], +[1.5]

D.7.2 Trust-region caps ($\tau,\epsilon$) vs. stability & bias delta

Caps	Drift ↓	Format ↓	Wrong-call ↓	Bias Δ (pp)	KL p95	Notes
(0.02, 0.5)	[−24%]	[−38%]	[−22%]	−0.1	0.022	Conservative
(0.03, 0.7)	[−34%]	[−55%]	[−34%]	−0.1	0.029	Standard
(0.05, 1.0)	[−37%]	[−58%]	[−36%]	+0.2	0.048	Aggressive; audit required

---

D.8 Error Buckets & Failure Analyses

Bucket (top 5)	Baseline count	Ours count	Δ	Comment
Late brace mismatch (JSON)	[47]	[18]	−29	Captured by fmt margins + tail penalty
Wrong tool among k	[39]	[24]	−15	Hysteresis + ETL
Premature EOS	[31]	[19]	−12	Length/closure penalty
Topic digression (QA)	[56]	[33]	−23	Drift penalty + λ↑ on ΔH
Indentation break (code)	[22]	[12]	−10	Code validator margin

---

D.9 Language / Script Stratification

Language	Method	JSON validity ↑	Drift mean ↓	Trigger rate (%)	KL p95
EN	Γ-Lite + ETL	[97%]	[−35%]	[6.5]	0.029
ZH-TC	Γ-Lite + ETL	[96%]	[−33%]	[6.9]	0.030
ES	Γ-Lite + ETL	[96%]	[−32%]	[6.7]	0.029

(Language scaling enabled for likelihood variance; validators localized.)

---

D.10 Reproducibility & Variance

Dimension	Setting	Variance (std across 5 seeds)
LC-QA F1 (Γ-Lite)	seeds 1–5	[±0.006]
JSON validity	seeds 1–5	[±0.7 pp]
Tool success	seeds 1–5	[±0.9 pp]
Latency (ms/tok)	seeds 1–5	[±0.2]

Bootstrap CI: 10k resamples; stratified by task and language.

---

D.11 Plots to Include (figure checklist)

• Stability–latency frontier: Δ latency (x) vs. drift/format gains (y).

• KL histogram with p50/p95 markers (by surface).

• Trigger activation heatmap by task & language.

• Tool routing confusion matrices (choose-1-of-k).

• Survival curves of format validity vs. output length.

• Case study bar: per-token $J, L, \lambda\Gamma$ around an ETL activation.

---

Reporting Notes

• Always pair relative deltas (%, pp) with raw baselines.

• Disaggregate by model size, task, language, profile.

• Publish the config YAML, controller/validator versions, and seed list with the results bundle.

This appendix gives you a turnkey scaffold to present thorough, auditable numbers—mirroring the metrics in Sec. 11.4 and the comparisons in Sec. 12—while keeping space for your exact measurements.

---

Appendix E. Formal Proof Sketches for Trust-Region Stability Bounds

Purpose. This appendix collects short, operational proofs justifying the stability and safety claims of dissipative Lagrangian decoding under per-step trust regions (KL cap $\tau$ and logit cap $ϵ$). Throughout, probabilities are restricted to the active candidate set ${\mathcal{K}}_t$ at step $t$. We write $p$ for the baseline distribution on ${\mathcal{K}}_t$, $s$ for a centered standardized score, and $p_{\eta }$ for the exponentially tilted distribution.

---

E.1 Preliminaries and Notation

At a given step $t$, define the standardized objective

$$s(i)={\mathrm{s}\mathrm{t}\mathrm{d}\mathrm{z}}_p(J_t(i)),\sum _{i\in {\mathcal{K}}_t}p(i)s(i)=0,{\mathrm{V}\mathrm{a}\mathrm{r}}_p(s)=1.$$

For $\eta \ge 0$, define the tilt (before logit caps)

$$p_{\eta }(i)=\frac{p(i)e^{\eta s(i)}}{\sum _{j}p(j)e^{\eta s(j)}}\mathrm{.}$$

When we impose a per-coordinate logit cap $\mathrm{\mid }\mathrm{\Delta }(i)\mathrm{\mid }\le ϵ$, we equivalently cap $\mathrm{\mid }\eta s(i)\mathrm{\mid }\le ϵ$ before re-normalization.

---

E.2 Optimality of Exponential Tilting (Variational Form)

Claim E.2 (Donsker–Varadhan / KKT).
Among all $q$ on ${\mathcal{K}}_t$ with $\mathrm{K}\mathrm{L}(q\mathrm{\parallel }p)\le \tau$, the distribution maximizing ${\mathbb{E}}_q[s]$ is $p_{\eta }$ for some $\eta \ge 0$ chosen to meet the KL budget; if $\tau$ is not active, $\eta =0$.

Sketch. Consider the convex program ${\max }_q{\sum }_{i}q(i)s(i)$ s.t. ${\sum }_{i}q(i)=1$, $q(i)\ge 0$, and ${\sum }_{i}q(i)\log \frac{q(i)}{p(i)}\le \tau$. Lagrangian dual with multiplier $\lambda \ge 0$ for the KL constraint yields stationarity condition $\log \frac{q(i)}{p(i)}=\frac{1}{\lambda }s(i)-\psi$, hence $q\propto p{e}^{\eta s}$ with $\eta ={\lambda }^{-1}$. Complementary slackness sets $\eta$ so KL equals $\tau$ if the budget binds. $\mathrm{\square }$

Monotonicity. $\eta \mapsto \mathrm{K}\mathrm{L}(p_{\eta }\mathrm{\parallel }p)$ is strictly increasing for non-degenerate $s$ (strict convexity of log-partition), ensuring uniqueness of $\eta$.

---

E.3 Per-Step Stability via KL and TV

Claim E.3 (Pinsker control).

If $\mathrm{K}\mathrm{L}(p^{\mathrm{\prime }}\mathrm{\parallel }p)\le \tau$, then $\mathrm{\parallel }{p}^{\mathrm{\prime }}-p{\mathrm{\parallel }}_{\mathrm{T}\mathrm{V}}\le \sqrt{2\tau }$. For any bounded functional $f:{\mathcal{K}}_t\to [a,b]$,$$\mid {\mathbb{E}}_{p^{\mathrm{\prime }}}[f]-{\mathbb{E}}_p[f]\mid \le (b-a)\sqrt{2\tau }\mathrm{.}$$

Sketch. Apply Pinsker’s inequality and Hölder. $\mathrm{\square }$

Implication. Any content-neutral indicator we log (format-margin, switch flag, topic-drift bin, etc.) changes at most $O(\sqrt{\tau })$ in expectation per step.

---

E.4 Expected Objective Gain Under Small KL

Claim E.4 (Small-$\tau$ gain).
Let $s$ be standardized under $p$. The KL-optimal tilt $p_{\eta }$ satisfies for small $\tau$:

$${\mathbb{E}}_{p_{\eta }}[s]=\sqrt{2\tau }+O({\tau }^{3\mathrm{/}2})\mathrm{.}$$

Sketch. Write $\mathrm{\Lambda }(\eta )=\log {\sum }_{i}p(i)e^{\eta s(i)}$. Then $\mathrm{K}\mathrm{L}(p_{\eta }\mathrm{\parallel }p)=\eta {\mathrm{\Lambda }}^{\mathrm{\prime }}(\eta )-\mathrm{\Lambda }(\eta )$. For small $\eta$, ${\mathrm{\Lambda }}^{\mathrm{\prime }}(\eta )={\mathbb{E}}_p[s]+\eta {\mathrm{V}\mathrm{a}\mathrm{r}}_p(s)+O({\eta }^2)=\eta +O({\eta }^2)$ and $\mathrm{\Lambda }(\eta )=\frac{1}{2}{\eta }^2+O({\eta }^3)$. Thus $\mathrm{K}\mathrm{L}=\frac{1}{2}{\eta }^2+O({\eta }^3)$ and $\eta =\sqrt{2\tau }+O(\tau )$. Finally ${\mathbb{E}}_{p_{\eta }}[s]={\mathrm{\Lambda }}^{\mathrm{\prime }}(\eta )=\eta +O({\eta }^2)=\sqrt{2\tau }+O(\tau )$. $\mathrm{\square }$

Reading. Under a small KL budget, the controller lifts the standardized local objective by $\tilde{O}(\sqrt{\tau })$ per step.

---

E.5 Logit Caps and Coordinate Stability

Claim E.5 (L∞ control).
If the applied logit shift satisfies $\mathrm{\mid }\mathrm{\Delta }(i)\mathrm{\mid }\le ϵ$ for all $i$, then for any two actions $i,j$,

$$\mid \log \frac{p^{\mathrm{\prime }}(i)}{p^{\mathrm{\prime }}(j)}-\log \frac{p(i)}{p(j)}\mid \le 2ϵ\mathrm{.}$$

Sketch. Since $p^{\mathrm{\prime }}(i)\propto e^{z(i)+\mathrm{\Delta }(i)}$, log-odds change equals $\mathrm{\Delta }(i)-\mathrm{\Delta }(j)$, bounded by $2ϵ$. $\mathrm{\square }$

Implication. Even if KL is close to $\tau$, no pairwise re-ranking can swing arbitrarily; this tames brittle near-ties.

---

E.6 Existence/Uniqueness and Bisection Convergence

Claim E.6 (Projection well-posedness).
With $s$ centered under $p$ and $\mathrm{\mid }\eta s(i)\mathrm{\mid }\le ϵ$, the map $\eta \mapsto \mathrm{K}\mathrm{L}(p_{\eta ,ϵ}\mathrm{\parallel }p)$ is continuous, strictly increasing on $[0,{\eta }_{\max }]$, with $\mathrm{K}\mathrm{L}(0)=0$. Hence a unique ${\eta }^{\star }$ attains the largest feasible KL $\le \tau$. Bisection with fixed iterations converges linearly.

Sketch. Strict convexity of the log-partition persists under capping because the capped shift is still a continuous, piecewise-linear function of $\eta$ with non-decreasing slope until saturation; strict increase holds unless $s\equiv 0$. Intermediate value theorem gives existence; monotonicity gives uniqueness; bisection convergence is standard. $\mathrm{\square }$

---

E.7 Affine Logit Invariance of Normalized Likelihood

Claim E.7 (Robust normalization).
Let logits be transformed by $z\mapsto \alpha z+\beta$ (e.g., due to temperature). The robust z-score within top-k (median/MAD) used for $\tilde{\mathrm{\ell }}$ is invariant up to sign when $\alpha >0$: ${\mathrm{s}\mathrm{t}\mathrm{d}\mathrm{z}}_{\mathrm{r}\mathrm{o}\mathrm{b}}(\alpha z+\beta )={\mathrm{s}\mathrm{t}\mathrm{d}\mathrm{z}}_{\mathrm{r}\mathrm{o}\mathrm{b}}(z)$.

Sketch. Median and MAD obey $\mathrm{m}\mathrm{e}\mathrm{d}\mathrm{i}\mathrm{a}\mathrm{n}(\alpha z+\beta )=\alpha \mathrm{m}\mathrm{e}\mathrm{d}\mathrm{i}\mathrm{a}\mathrm{n}(z)+\beta$, $\mathrm{M}\mathrm{A}\mathrm{D}(\alpha z+\beta )=\mathrm{\mid }\alpha \mathrm{\mid }\mathrm{M}\mathrm{A}\mathrm{D}(z)$. Divide out. $\mathrm{\square }$

Implication. The value term’s likelihood component is scale-stable, allowing fixed weights across decoding temperatures.

---

E.8 Cumulative Stability and Lyapunov-Like Control

Consider the topic EMA $m_t=\mathrm{n}\mathrm{o}\mathrm{r}\mathrm{m}(\rho m_{t-1}+(1-\rho )e_{y_t})$ with unit vectors.

Claim E.8 (Bounded state motion).
Per step, $\mathrm{\parallel }{m}_t-m_{t-1}\mathrm{\parallel }\le 2(1-\rho )$. Under the controller with KL cap $\tau$, the expected change is bounded:

$$\mathbb{E}\mathrm{\parallel }{m}_t-m_{t-1}\mathrm{\parallel }\le 2(1-\rho )+C\sqrt{2\tau },$$

for a constant $C$ depending on the embedding geometry and the drift-penalty weights.

Sketch. Triangle inequality and convexity of the norm give the deterministic bound. The extra $C\sqrt{2\tau }$ term arises because the controller can bias toward lower-drift tokens but is limited by Claim E.3. $\mathrm{\square }$

Lyapunov sketch. With $V_t=\mathbb{E}[1-\cos (m_t,m_{t-1})]$, dissipation plus the KL cap yields $V_{t+1}-V_t\le -\kappa \mathbb{E}[{\mathrm{\Gamma }}_t^{\text{topic}}]+\tilde{C}\sqrt{\tau }$, i.e., topic-whiplash energy cannot grow unchecked.

---

E.9 Local Sufficiency (Greedy $J$ vs. Short-Horizon)

Suppose the trajectory objective is $U_t={\sum }_{j=t}^{t+h}{\gamma }^{j-t}(L_j-{\lambda }_j{\mathrm{\Gamma }}_j)$ with $\gamma \in (0,1)$.

Claim E.9 (Myopic near-optimality under weak coupling).
If (i) $L,\mathrm{\Gamma }$ are Lipschitz in local features with constants $K_L,K_{\mathrm{\Gamma }}$, (ii) the state update affects future features with geometric decay rate $\rho <\gamma$ (short memory), and (iii) per-step distribution shift is KL-bounded by $\tau$, then choosing $y_t=\arg \max J_t$ attains regret

$$U_t(y_t^{\star })-U_t(y_t)\le \frac{K_L+{\lambda }_{\max }{K}_{\mathrm{\Gamma }}}{1-\rho \mathrm{/}\gamma }\delta (\tau ),$$

where $\delta (\tau )=O(\sqrt{\tau })$ collects per-step feature deviation bounds.

Sketch. First-order envelope argument: $\mathrm{\nabla }{U}_t$ at step $t$ aligns with $\mathrm{\nabla }{J}_t$ up to $O(\rho )$ leakage into the future. Pinsker controls ${\mathrm{\ell }}_1$ deviation of the action distribution, pushing $\delta (\tau )=O(\sqrt{\tau })$. Sum a geometric series in $\rho \mathrm{/}\gamma$. $\mathrm{\square }$

Reading. Γ-Lite’s greedy step is a principled MPC proxy; tiny micro-lookahead tightens the bound at inflection points.

---

E.10 Event-Triggered Lookahead: Safety and Regret

Safety. ETL evaluates branches but commits one token after projecting that step with the same $(\tau ,ϵ)$. Thus, regardless of the simulated horizon, the applied shift per emitted token obeys the same trust region.

Regret sketch. If the trigger reliably detects high local curvature (entropy spikes, near-format breaks), then the improvement over greedy scales with the curvature surrogate, while the cost is bounded by the time cap and small $h,B$. Formally, local second-order terms dominate at such steps, and ETL approximates a one-step Newton improvement with bounded compute.

---

E.11 Fairness/Bias Lipschitz Bound Under KL

Let $O\in [a,b]$ be a bounded outcome (e.g., tool-call indicator). For two cohorts $A,B$, let ${\mathrm{\Delta }}_{\text{bias}}=\mid \mathbb{E}[O\mid A]-\mathbb{E}[O\mid B]\mid$.

Claim E.11 (Bias-gap stability).
Under per-step $\mathrm{K}\mathrm{L}\le \tau$, the change in the expected outcome per cohort is at most $(b-a)\sqrt{2\tau }$. Thus the bias-gap delta per step is bounded by $2(b-a)\sqrt{2\tau }$.

Sketch. Apply Claim E.3 to each cohort separately and triangle inequality. $\mathrm{\square }$

Reading. With small $\tau$, inference-time control cannot drastically widen cohort gaps on bounded outcomes; this motivates our pass criterion.

---

E.12 Top-k Restriction Robustness

We compute trust-region shifts on ${\mathcal{K}}_t$ (top-k or nucleus). If the baseline’s candidate set changes by at most $r$ mass due to near-ties, then the effective TV bound on the full vocabulary is $\sqrt{2\tau }+r$. In practice $k$ is chosen so that the excluded mass is $<\text{\hspace{0.17em}⁣}{10}^{-3}$, keeping the global bound essentially at $\sqrt{2\tau }$.

---

E.13 Failure Modes of the Bounds (When Assumptions Break)

• Hard discontinuities (black-box tool jumps) violate Lipschitz assumptions; use piecewise controllers or pre-flight probes.

• Long-range objectives (non-local credit) break the weak-coupling premise; rely on ETL and paragraph reranking.

• Degenerate $s$ (variance $\to 0$): the tilt does nothing; controller becomes a no-op—safe but ineffective.

• Noisy validators: if format margins are high-variance, $\mathrm{\Gamma }$ may mis-rank; smooth via EMA and clip.

---

E.14 Summary of Guarantees

1. Per-step safety: total variation and all bounded outcomes move $O(\sqrt{\tau })$; pairwise log-odds change $\le 2ϵ$.

2. Expected gain: standardized $J$ improves by $\tilde{O}(\sqrt{\tau })$ each step (small-$\tau$ regime).

3. State stability: EMA topic vectors and similar short-memory states drift slowly with explicit bounds.

4. Near-optimality: greedy $J$ is first-order optimal under weak coupling; ETL sharpens at risky steps while preserving trust-region safety.

5. Fairness: bounded change in cohort outcomes per step; audits verify no practical widening.

These sketches justify using KL/logit trust regions as Lyapunov-like guards for per-token control and explain why Γ-Lite plus event-triggered lookahead can improve stability measurably without compromising safety.

---

Appendix F. Reproducibility Checklist and Compute Budget

This appendix makes the paper turn-key reproducible. It specifies artifacts to release, exact configs, seeds, logging, and a compute ledger for every experiment class (Secs. 11–12; App. D).

---

F.1 Artifact Bundle & Versioning

Release bundle (tar/zip)

lagrangian-decoding/
  ├── README.md
  ├── env/              # conda & pip lockfiles; Dockerfile
  ├── src/
  │   ├── controller/   # Γ-Lite, ETL, trust-region, validators
  │   ├── runners/      # task harnesses for LC-QA, JSON, Tools, Code, Creative
  │   ├── metrics/      # stability/structure/tooling/quality/safety
  │   └── plots/        # scripts to render Sec. 12 + App. D figures
  ├── configs/
  │   ├── profiles.yaml             # Appendix B profiles
  │   ├── tasks/                    # dataset/task configs
  │   └── rollout_playbook.yaml     # Sec. 13 defaults
  ├── data/ (scripts only; no copyrighted corpora)
  │   ├── fetch_datasets.py
  │   └── prepare_splits.py
  ├── checkpoints/ (empty; README with model URLs)
  ├── logs/ (empty; where JSONL goes)
  ├── results/ (empty; filled by runs)
  └── reproduce.sh      # one-click pipeline (see F.8)

Version pins (write in README.md)

• controller_version, validators_version, tool_cost_version

• model_id (M-S/M-M/M-L), tokenizer hash

• Commit hash and config checksums (SHA256) for profiles.yaml and each task config

---

F.2 Environment & Dependencies

OS/Drivers. Ubuntu 22.04; CUDA 12.x; NVIDIA driver ≥ 535.
Frameworks.

• PyTorch 2.x (or JAX/TF equivalent) with GPU build

• Transformers ≥ 4.41, Tokenizers ≥ 0.15

• NumPy, SciPy, scikit-learn

• For code tasks: ast/pyflakes/black (no net)

• JSON/CSV validators (pure-Python or Rust bindings)

• Optional: onnxruntime-gpu for hosted inference adapters

Determinism flags (PyTorch example)

import torch, random, numpy as np
seed=2025
torch.manual_seed(seed); np.random.seed(seed); random.seed(seed)
torch.backends.cudnn.deterministic=True
torch.backends.cudnn.benchmark=False

(For JAX/TF, set PRNG keys and deterministic ops accordingly.)

---

F.3 Data, Splits, and Licenses

• Provide scripts (not datasets) to fetch/create:

  • LC-QA-200, LC-Sum-150, Tools-Eval-240, JSON-Schema-300, Code-Mini-200, Creative-100 (Sec. 11.2).

• Splits are deterministic: each script writes a SPLIT.md with the PRNG seed and resulting ID lists.

• Include license notices and filtering logic; redact PII in prompts/contexts.

---

F.4 Model Checkpoints

• Supply a checkpoints/README.md with URLs or provider instructions for M-S (~7–13B), M-M (~30–34B), M-L (~65–70B).

• Verify tokenizer files match the checkpoint (hashes).

• For hosted M-L, expose a thin adapter returning top-k logits and output embeddings (or use prompt-only L×Γ; Sec. 9).

---

F.5 Controller Configs (exact)

• Profiles: copy Appendix B.10 into configs/profiles.yaml verbatim.

• Trust-region: default tau=0.03, eps=0.7.

• Top-k: k=10 unless the baseline uses top-p; then compute stats on nucleus set.

• ETL: h=3, B=3, b=2, step_cap_ms=15, debounce=5.

• Logging schema: exactly as Sec. 13.2 / App. A.5.

---

F.6 Evaluation Protocol (per task)

Runs per setting. 5 seeds (2025, 2026, 2027, 2028, 2029). Report mean ± 95% CI (bootstrap 10k).
Metrics (Sec. 11.4):

• Stability: topic drift mean & spike rate; entropy-spike rate.

• Structure: JSON validity; AST parse; late-break rate.

• Tooling: success; wrong-call; flaps/100 toks.

• Quality: LC-QA auto F1 (+ human 50-item subset); ROUGE-L; code pass@1, pass@5.

• Overhead: median/P95 ms/token; throughput tokens/s; Δ FLOPs estimate.

• Safety: per-step KL mean/P95; bias-gap deltas (identity swaps).

Statistics. Bootstrap CIs; paired tests vs. Greedy and Top-p; report effect sizes and p-values where applicable.

Ablations. Run the set in Sec. 12.2 (ΔH-only / drift-only / format-only; fixed vs adaptive λ; triggers off; horizon 0/2/4; trust-region off—log only, do not ship).

---

F.7 Logging, Checksums, and Acceptance Gates

• Per-token JSONL (one line / token) as in Sec. 13.2.

• Run summary (YAML/JSON): dataset, seed, profile, caps, activation rates, wall-clock.

• Acceptance gates (fail the run if breached):

  • p95 KL ≤ 0.05; p95 |Δlogit| ≤ 1.0

  • p95 token latency ≤ baseline + 12 ms

  • No increase in bias gap > +0.5 pp (App. D.6.2)

• Repro check: for LC-QA-200 with M-M factual profile, drift ↓ ≥ 25% vs Greedy and JSON validity ≥ 95% on JSON-Schema-300 (±2 pp tolerance).

---

F.8 One-Click Reproduction (CLI)

# 0) Environment
conda env create -f env/conda.yaml && conda activate lagrangian
pip install -r env/requirements.txt

# 1) Fetch data & prepare splits
python data/fetch_datasets.py --out ./data_store
python data/prepare_splits.py --data ./data_store --seed 2025

# 2) Get checkpoints (edit README-provided URLs if needed)
bash checkpoints/fetch_open_weights.sh

# 3) Run experiments (all tasks, 5 seeds, Γ-Lite + ETL)
bash reproduce.sh --model M-M --profile factual --seeds 2025:2029 --caps tau=0.03,eps=0.7

# 4) Evaluate & render figures
python src/metrics/eval_all.py --logs ./logs --out ./results
python src/plots/figures.py --results ./results --out ./results/figs

reproduce.sh simply expands to task-specific runners (LC-QA, JSON, Tools, Code, Creative) with the configs in configs/tasks/.

---

F.9 Compute Budget (GPU-hours & Cost)

We report tokens-based and wall-clock estimates. Replace brackets with your actuals; the formulas hold generally.

F.9.1 Per-token overhead (measured)

• Γ-Lite: +0.5–0.8 ms/token (k=10, d≈4k)

• ETL (on triggered steps only, 3–8%): +2–4 ms/token on those steps

• Overall Δ FLOPs: +2–5%

F.9.2 Token throughput & GPU-hours (example, A100-80GB)

Model	Baseline tok/s	Γ-Lite tok/s	Γ-Lite+ETL tok/s	Notes
M-S (7–13B)	[145]	[141]	[136]	fp16 + KV cache
M-M (30–34B)	[122]	[118]	[114]	tp=2
M-L (65–70B, hosted)	[—]	[—]	[—]	provider-reported

GPU-hours per 1M output tokens (single GPU):
$\text{GPUh}\approx \frac{{10}^6}{\text{tok/s}}÷3600$

• M-M Greedy: ${10}^6\mathrm{/}122\mathrm{/}3600\approx 2.27$ GPUh

• M-M Γ-Lite: ${10}^6\mathrm{/}118\mathrm{/}3600\approx 2.35$ GPUh

• M-M Γ-Lite+ETL: ${10}^6\mathrm{/}114\mathrm{/}3600\approx 2.44$ GPUh

Incremental budget (ours vs Greedy): +0.08–0.17 GPUh / 1M toks (≈ +3–7%).

F.9.3 Experiment-level ledger (per seed; M-M factual profile)

Task suite	Avg out toks / run	Greedy GPUh	Γ-Lite GPUh	Γ-Lite+ETL GPUh
LC-QA-200	30k	0.068	0.070	0.073
LC-Sum-150	45k	0.102	0.105	0.109
Tools-Eval-240	25k	0.057	0.058	0.061
JSON-Schema-300	35k	0.080	0.082	0.085
Code-Mini-200	40k	0.091	0.094	0.097
Creative-100	10k	0.023	0.024	0.025
Total / seed	185k	0.421	0.433	0.450

Total for 5 seeds: Greedy 2.10 GPUh → Γ-Lite 2.17 GPUh → Γ-Lite+ETL 2.25 GPUh.

(Add paragraph reranking only for JSON/Code premium runs: +0.05–0.10 GPUh / seed.)

F.9.4 Optional value-head training (if enabled)

• Data: 5–10k prefixes; batch 512; 1–3 epochs.

• Compute: < 0.3 GPUh on a single A100; storage < 5 MB.

F.9.5 Monetary & Carbon estimates (fill in)

• Cost: $\text{GPUh}\times \mathrm{\$}\text{/GPUh}$.

• Emissions: \text{GPUh} \times \text{kWh/GPUh} \times \text{gCO\(_2e/kWh}).
  Document your $/GPUh and grid gCO${}_2$e/kWh.

---

F.10 Memory, Batch, and Precision

• Precision: fp16/bf16 with KV cache; controller uses fp32 accumulators.

• Batching: dynamic to SLA; keep k≤10–20 to bound controller ops.

• Memory headroom: +<100 MB for controller tensors at k=10, d≈4k.

• Validators: run on CPU threadpool to avoid GPU stalls.

---

F.11 Failure & Variance Handling

• Outliers: winsorize per-request latency at p99 for reporting; never clip safety metrics.

• Retries: disallow output retries during eval; record first pass only.

• Randomness: fix seeds end-to-end; log them in run summaries.

• Hosted endpoints: record provider model/version; if embeddings unavailable, use prompt-level L×Γ (Sec. 9) and label results accordingly.

---

F.12 Human Evaluation Protocol (Creative & QA subset)

• 5 raters; 5-point Likert for originality/clarity/on-topic; randomized, blinded method labels; per-item majority aggregation; Krippendorff’s α reported.

• Annotator guide bundled (docs/human_eval_guidelines.pdf); exclude low-consistency raters (pre-registered thresholds).

---

F.13 Reproducibility Checklist (Yes/No + location)

Item	Provided?	Where
Code to run all experiments	Yes	src/, reproduce.sh
Exact configs & hyperparams	Yes	configs/ (+ App. B)
Random seeds & determinism flags	Yes	reproduce.sh, Sec. F.2
Datasets or scripts to fetch them	Scripts	data/
Model checkpoints or URLs	URLs	checkpoints/README.md
Logging schema & raw logs	Yes	logs/ JSONL spec Sec. 13.2
Statistical testing & CIs	Yes	src/metrics/
Compute budget & wall-clock	Yes	Sec. F.9
Negative results / ablations	Yes	Sec. 12.2, App. D
Safety/bias audits & thresholds	Yes	Sec. 8, App. D.6
Figures & script to regenerate	Yes	src/plots/
Exact versions & hashes	Yes	README.md (hashes), env/

---

F.14 Minimal Verification Targets (sanity checks)

After running reproduce.sh on M-M (factual profile), verify:

1. Stability (LC-QA-200): topic drift mean ↓ ≥ 25% vs Greedy.

2. Structure (JSON-Schema-300): JSON validity ≥ 95%.

3. Tooling (Tools-Eval-240): wrong-call rate ↓ ≥ 20% vs Greedy.

4. Overhead: median token latency increase ≤ +0.8 ms (Γ-Lite) and ≤ +4 ms on triggered ETL steps.

5. Safety: p95 KL ≤ 0.05; bias-gap Δ ≤ +0.5 pp.

If any fails, archive logs and rerun with --profile conservative (Appendix B.11); file an issue with the run summary and hashes.

---

Takeaway. With these artifacts, pins, and budgets, an independent team can recreate every table and figure (Secs. 11–12; App. D) and validate the safety gates—within single-digit percent compute overhead relative to Greedy decoding.

---

Appendix G. License, Model Cards, and Safety Cards

This appendix ships copy-ready text and templates for releasing the code, (optional) controller weights, prompts, and evaluation artifacts—plus model & safety cards tailored to dissipative Lagrangian decoding.

---

G.1 Licensing Overview (pick and fill)

Artifact	Recommended license	Alternatives	Notes
Code (src/, controllers, runners)	Apache-2.0	MIT	Permissive, patent grant, widely used.
Configs & prompts (configs/, protocol headers)	CC BY 4.0	CC BY-SA 4.0	Attribution required; allow remix with credit.
Documentation (paper, READMEs)	CC BY 4.0	CC BY-SA 4.0	Keep figures clearly attributed.
Controller weights (if you release a value-head)	OpenRAIL-M	CC BY-NC 4.0	RAIL adds responsible-use clauses; or non-commercial.
Synthetic eval data (if generated)	CC0	CC BY 4.0	Prefer CC0 to ease reuse.
Logs/metrics (diagnostic scalars only)	Custom terms	—	No user text; define retention window & privacy terms.

Top-level LICENSES/ layout

LICENSES/
  APACHE-2.0.txt
  CC-BY-4.0.txt
  OpenRAIL-M.txt
  THIRD_PARTY_NOTICES.md

Root NOTICE (example)

This distribution includes:
 • Code under Apache-2.0 © 2025 Your Org.
 • Documentation under CC BY 4.0.
 • Optional controller weights under OpenRAIL-M.
This project depends on third-party libraries listed in LICENSES/THIRD_PARTY_NOTICES.md.

---

G.2 Model Card — “Dissipative Lagrangian Decoding Controller”

Put this as MODEL_CARD.md (or modelcard.yaml). Fill bracketed fields.

Summary

• Name: Lagrangian Decoding Controller v[1.3.2]

• Purpose: Inference-time control maximizing $J=L-\lambda \mathrm{\Gamma }$ under per-step trust regions (KL/logit caps).

• Scope: Drop-in for decoder-only LLMs; no base model changes. Optional value-head weights included: [yes/no].

Intended Use

• Primary: Long-context QA, strict-format JSON/code, tool routing, summarization.

• Secondary: Creative writing (with creative profile).

• Users: ML engineers, research teams, platform owners.

Out of Scope

• Tasks requiring strong non-local reasoning without section boundaries (e.g., multi-page proofs), or environments with opaque discontinuities (unknown API jumps), unless paired with paragraph re-rank or piecewise controllers.

How it Works

• Per token, compute value term $L$ (likelihood, task progress proxies, latency/length) and dissipation $\mathrm{\Gamma }$ (topic drift, format risk, switch hysteresis); select within a trust region.

• Optional event-triggered lookahead at entropy spikes/format risk; commit one token only.

• Content-neutral signals only; see Safety Card.

Factors

• Profiles: factual/tool, creative, long-context, structured JSON/code, routing.

• Languages: multilingual; per-language normalization supported.

• Model sizes: tested on [7–70B] decoders.

Metrics (from paper Sec. 12 / App. D)

• Stability (topic drift, entropy spikes), Structure (parse/compile), Tooling (success, wrong-call), Quality (F1/ROUGE/pass@k), Overhead (latency/ΔFLOPs), Safety (KL p95, bias deltas).

Data

• No training by default. If a small value-head is provided: trained on content-neutral auto-labels (parse pass, schema coverage, tool success) from synthetic/dev prefixes; no user identity attributes.

Ethical Considerations (summary)

• Controller is bounded & auditable; uses no identity/stance signals; logs only scalar diagnostics; opt-out & profile toggles recommended (see Safety Card).

Limitations

• Gains depend on validator quality and tool cost calibration.

• Over-tight profiles can reduce novelty; tune $\lambda$, $\beta$ weights accordingly.

Versioning

controller_version: 1.3.2
validators_version: 0.9.7
tool_cost_version: 2025w35
profiles_checksum: <sha256>

Contact

• Maintainer: [name/email] • Issues: [tracker URL] • Security: [security@org]

---

G.3 Safety Card — “Inference-Time Control (L×Γ)”

Put this as SAFETY_CARD.md. It mirrors Sec. 8 with deployment levers.

Overview

Inference-time controller with trust-region bounds:

• Per-step KL cap $\tau \in [0.01,0.05]$ and logit cap $ϵ\in [0.5,1.0]$.

• Signal whitelist: entropy, drift, format margins, tool cost, length/closure (no identity/stance).

• Event-triggered short-horizon lookahead; commit-one; hard time cap.

User Disclosure & Consent (recommended UI copy)

“To improve stability/formatting, a bounded per-token controller gently re-orders candidates. It uses only structural signals (uncertainty, formatting, tool cost), never identity/stance. Switch profiles or opt out anytime.”

Data Handling

• Logged: scalar diagnostics {ΔH, drift, fmt_margin, λ, KL, |Δlogit|, triggers}; hashed request IDs.

• Not logged: raw user text beyond what underlying serving stores; no chain-of-thought.

• Retention: [30/90] days; access controls; export on request.

Bias & Fairness

• Counterfactual tests: identity swaps pre-ship and continuously; pass if Δ gap ≤ +0.5 pp.

• Per-language calibration: variance scaling & localized validators.

• Rollbacks: auto-disable on bias alarm.

Safety Dials (defaults)

tau: 0.03    # KL cap (per step)
epsilon: 0.7 # max |Δlogit|
trigger_debounce: 5 tokens
etl_step_cap_ms: 15
profile: factual|creative|structured|routing

Prohibited Use

• Using controller diagnostics to infer user identity, beliefs, or health; using non-neutral signals at inference; removing disclosure/opt-out.

Known Failure Modes & Mitigations

• Over-smoothing: lower λ/β_topic; entropy-gate drift.

• Router flapping: widen hysteresis; raise persistence penalty.

• Format validator brittleness: localize rules; add tests; enable paragraph re-rank for critical JSON/code.

Incident Response

• Kill switch per surface; restore baseline decoding.

• Triage: attach logs, versions, configs; run replay CI; publish postmortem summary.

---

G.4 Release Notes Template

# Lagrangian Controller v1.3.2 — 2025-08-31
Changes:
 • Trust-region projection made JIT-friendly (fixed-iter bisection=8).
 • Validators v0.9.7: improved JSON tail risk margin; RTL punctuation support.
 • Profiles.yaml: routing profile β_switch=0.9; debounce=5→6.

Safety:
 • KL p95 unchanged (0.029); bias-gap deltas within ±0.2 pp on stratified suites.

Migration:
 • Re-run shadow for 48h on creative surfaces.

---

G.5 Third-Party Notices (skeleton)

Place in LICENSES/THIRD_PARTY_NOTICES.md:

- PyTorch (BSD-3-Clause) © Meta.
- Transformers (Apache-2.0) © Hugging Face.
- NumPy/SciPy (BSD).
- (Any JSON/AST validators, regex libs) — licenses, copyright.
- Fonts/Icons used in docs (if any) — licenses.

---

G.6 Compliance & Privacy Checklist (ship with COMPLIANCE.md)

• Data minimization: scalar logs only; redact content.

• Retention window documented ([30/90] days).

• DSAR process for telemetry exports (GDPR/CCPA).

• DPA & sub-processor inventory (if SaaS).

• Security review: access controls to logs; at-rest encryption.

• Risk register updated (over-smoothing, bias regression, validator brittleness).

• User disclosure and opt-out wire-up.

---

G.7 UI Copy Blocks (drop-in)

Profile Toggle (tooltip)

Stable (Factual): stronger formatting & routing discipline, small creativity trade-off.
Creative: lighter structure constraints, more variation; still safeguards against broken formatting.

Opt-Out (per request)

“Disable stability controller for this request.” (Advanced)

Scorecard (if user-visible)

“A compact internal scorecard is appended to support audits. It contains no reasoning or personal data.”

---

G.8 Model/Controller Card YAML (machine-readable)

schema_version: 1.0
name: lagrangian-decoding-controller
version: 1.3.2
intended_use:
  primary: [long_context_qa, json_code, tool_routing, summarization]
  secondary: [creative_writing]
limitations:
  - strong_non_local_objectives
  - opaque_external_discontinuities
profiles: [factual, creative, long_context, structured, routing]
safety:
  trust_region: {tau: 0.03, epsilon: 0.7}
  signals_whitelist: [entropy, topic_drift, format_margins, tool_cost, length_closure]
  forbidden_signals: [identity, stance, ideology, sentiment_proxies]
  logging: [H, dH, drift, fmt_margin, lambda, KL, max_abs_delta, triggers]
  disclosure: required
metrics:
  stability: [topic_drift, entropy_spikes]
  structure: [json_validity, parse_pass]
  tooling: [tool_success, wrong_call]
  quality: [f1, rouge_l, pass_at_k]
  overhead: [latency_ms_per_tok, throughput, delta_flops]
artifacts:
  code_license: Apache-2.0
  docs_license: CC-BY-4.0
  weights_license: OpenRAIL-M
versioning:
  controller_version: 1.3.2
  validators_version: 0.9.7
  tool_cost_version: 2025w35
contacts:
  maintainer: "Your Name <you@org>"

---

G.9 Quick Publish Checklist

• Licenses placed and referenced (root NOTICE, LICENSES/).

• Model & Safety cards filled and shipped.

• Profiles and caps documented; defaults marked.

• Third-party notices complete.

• Disclosure & opt-out implemented in UI/API.

• Bias & safety gates green on shadow/canary.

• Repro bundle (App. F) builds on a clean machine.

---

Takeaway. This appendix gives you everything needed to release the controller and documentation responsibly: clear IP terms, transparent model & safety cards, and concrete UI copy for disclosure—so downstream users can adopt L×Γ decoding with confidence.

 

 

 © 2025 Danny Yeung. All rights reserved. 版权所有 不得转载

 

Disclaimer

This book is the product of a collaboration between the author and OpenAI's GPT-5 and X's Grok3 language model. While every effort has been made to ensure accuracy, clarity, and insight, the content is generated with the assistance of artificial intelligence and may contain factual, interpretive, or mathematical errors. Readers are encouraged to approach the ideas with critical thinking and to consult primary scientific literature where appropriate.

This work is speculative, interdisciplinary, and exploratory in nature. It bridges metaphysics, physics, and organizational theory to propose a novel conceptual framework—not a definitive scientific theory. As such, it invites dialogue, challenge, and refinement.

I am merely a midwife of knowledge.