https://osf.io/yaz5u/files/osfstorage/68cdecc75ecb719a6a413f46
https://chatgpt.com/share/68cdf2bf-bf2c-8010-9ba9-3b271dedc944

Belt Theory for AGI — A Mini-Textbook

Preface

This mini-textbook was written to make one simple idea operational for both physicists and AGI engineers:

If a process has two complementary traces, you should model it on a ribbon (a “belt”), not a line.
On that ribbon, the edge-to-edge phase gap equals the sum of a surface flux and a framing (twist) term.
This identity is the working engine behind the book—in physics and in AGI.

We’ll call the physics statement the Framed Belt Holonomy Law (FBHL) and its semantic/algorithmic counterpart the Semantic Belt Holonomy Law (SBHL). Everything else—operators, algorithms, controllers, and benchmarks—exists to estimate, preserve, or steer those quantities.

Who this book is for

AGI/ML practitioners who want concrete metrics, losses, and control knobs that improve safety, planning, and style control without ad-hoc heuristics.
Physicists/applied mathematicians who want a lean, surface-based formulation that explains why “ribbons” (two boundaries) are inevitable whenever we care about gauge phases, geometric responses, or exchange effects.

What problem Belt Theory solves

Line-based formalisms often drop invariants that only live on a surface (e.g., framed linking, twist quantization, surface-ordered curvature). The belt/ribbon model restores those invariants and makes them computable. For AGI, it becomes a practical dimensional-reduction and control framework: collapse rich trajectories into a 2D ribbon where flux and twist can be measured and regulated.

Core claims (the spine you can build on)

Two boundaries are canonical. Any “do/observe,” “intent/generation,” or “forward/back” process naturally yields two traces; a minimal belt is the correct domain.
FBHL (physics): the difference of boundary holonomies equals the ribbon’s integrated curvature plus a framing phase proportional to twist.
SBHL (semantics): phase gap = meaning flux + style twist—a directly usable identity for training and inference control.
Ribbon collapse is sufficient on large patches. High-dimensional dynamics often admit a faithful 2D reduction that preserves the invariants we care about; extend to slabs or networks only when diagnostics say so.

Technical remark (for researchers): Readers familiar with SMFT/“pre/post collapse” traditions will recognize the two boundaries as that pre-/post-projection pair. We keep the main text neutral and self-contained; historical mappings appear in sidebars.

What you can do with this book

Training: use Two-Boundary Loss, Flux Regularization, Twist Steering to learn models that are robust to prompt shifts and preserve style on demand.
Inference control: deploy flux-spike safety gates (detect agenda shifts/prompt injection), twist dials (tune creativity/voice), and belt tiling for plan repair.
Evaluation: run three reproducible benchmarks— $4\pi$ periodicity, width-scaling of framing phase, and a belt-Faraday test—for regression and ablation.

How to read this book (two tracks)

Engineer track (fastest path): Ch. 1 → Ch. 10–11 (Ribbon Collapse Model & visuals) → Ch. 13 (SBHL identity) → Ch. 15–18 (metrics, losses, controllers, RAG) → Ch. 24–27 (software & benchmarks).
Physics track (rigor path): Ch. 1–6 (belt calculus & framing) → Ch. 7–9 (surface ordering & FBHL) → Ch. 28 (mini-cases) → Ch. 31–32 (limits).

Prerequisites

Multivariable calculus and basic differential geometry (forms/curvature at the level of a short primer).
For AGI sections, standard ML literacy (embeddings/logits/optimizers) and basic linear algebra.

What this book is not

Not a general treatise on quantum field theory or cognition.
Not a survey of historical schools; we keep terminology neutral and only add contextual remarks where they sharpen engineering choices.

Reproducibility & software

All core identities are paired with pseudocode, error notes, and unit-style tests. Benchmarks specify target curves/tolerances. A minimal reference API (metrics, losses, controllers) is provided so you can port to your stack.

Conventions and notation

Ribbons/belts are denoted $\mathcal{B}$ ; boundaries $\Gamma_+$ and $\Gamma_-$ .
Curvature/flux integrals live on $\mathcal{B}$ ; twist $\mathrm{Tw}$ is computed from a framing field along the belt.
“Phase” means a gauge-invariant edge quantity (physics) or a principal semantic phase (semantics), specified per chapter.
We mark formal proof sketches with ▶ and provide complete checks when short; longer ones go to the appendices.

Roadmap (what comes next)

Part II–III build the belt calculus and derive FBHL.
Part IV introduces the Ribbon Collapse Model—the hinge from physics to AGI.
Part V–VII deliver SBHL, metrics/losses/controllers, and composition rules for planning and tool use.
Parts VIII–X scale to multi-agent belts, software, benchmarks, and case studies.
Parts XI & Appendices cover limits, open problems, and full computational references.

Acknowledgments. This synthesis stands on standard geometric tools and recent clarity around two-boundary worldsheets. The goal here is pragmatic: make the invariants visible, computable, and steerable—so both labs and production systems can benefit.

Part I — Orientation (engineers first, math-ready)

Ch. 1 Why Belts, Not Lines

Motivation: hidden style drift, prompt injection, planning detours; why a 2-boundary worldsheet is the minimal carrier of the right invariants.
Running example reused across the book (a code-assistant task).
Preview of the belt identity: edge–edge phase gap = surface flux + framing twist.

Ch. 2 Symbols & Conventions (One-Page Cheat Sheet)

Domain $\mathcal{B}$ ; edges $\Gamma_\pm$ ; width $w$ ; framing angle $\phi$ ; twist $\mathrm{Tw}$ .
Orientation/sign rules that prevent “minus-sign hell.”

Ch. 3 Ten-Page Mathematical Primer

Curves/surfaces, frames, connections/curvature.
What we fully prove vs. what we sketch (and why).

Part II — Belt Calculus (operators you can code)

Ch. 4 The Belt Domain and Operators

Local metric $g=\mathrm{diag}((1-\kappa n)^2,1)$ ; belt-grad/div/curl/ $\Delta$ .
Thin-ribbon regime $\kappa w\!\ll\!1$ : error terms and stability bounds (sketch proof).

Ch. 5 Two-Boundary Stokes & Gauss

“Upper–minus–lower” circulation/flux on $\mathcal{B}$ ; partition proof using classical Stokes + Jacobian (sketch).

Ch. 6 Framing, Twist, Writhe, Linking

Belt form of $\mathrm{Lk}=\mathrm{Tw}+\mathrm{Wr}$ ; when specialization fails (sketch).
Why a single line loses the framing invariant → belts are inevitable.

Part III — Gauge Geometry on Belts (core mechanism)

Ch. 7 Connections, Curvature, Surface Ordering

Path vs. surface exponentials; refinement limit on annuli; gauge covariance (lemmas, sketches).

Ch. 8 Framed Belt Holonomy Law (FBHL)

\mathrm{Hol}(\Gamma_+)\,\mathrm{Hol}(\Gamma_-)^{-1} =\mathcal{P}\exp\!\iint_{\mathcal{B}}F \;\times\; e^{i\alpha\,\mathrm{Tw}}.

Consistency checks: thin limit; composition; framing quantization.
Derivation from non-Abelian Stokes + framing phase accounting (sketch).

Ch. 9 Physical Consequences

Theorem: Geometric/adiabatic forces = variational response of belt holonomy (worked statement).
Theorem: Exchange/statistics phases = framed belt linking; $4\pi$ periodicity tests.

Part IV — Ribbon Collapse Model (the hinge to AGI)

Ch. 10 Why Collapse Reduces to a 2D Belt

Principle of two projections → two edges; completeness conditions for a valid belt patch (sketch).
When to extend: slabs (time-phase), networks (branch/merge), membranes (higher forms).
Technical remark (SMFT/Hetu–Luoshu): pre/post collapse as a canonical two-boundary reduction; belts remain complete for this patch.

Ch. 11 Visual Grammar of Ribbons

Ribbon vs. volume vs. network; invariants that survive projection.
Engineering payoff: stable metrics, faster training, stronger safety gates.

Part V — Semantic Belt Holonomy (SBHL): the AGI bridge

Ch. 12 Semantic States, Connections, Curvature

U(1)/U(k) & mixed-state (Uhlmann) options; estimator choices and gauge covariance (sketch).

Ch. 13 SBHL: “Phase Gap = Meaning Flux + Style Twist”

\oint_{\Gamma_+}\!\mathcal{A}_s\;-\;\oint_{\Gamma_-}\!\mathcal{A}_s =\iint_{\mathcal{B}}\!\mathcal{F}_s\;+\;\alpha\,\mathrm{Tw}.

Scalar invariants: $\arg\det$ , trace/character, principal eigenphase.
Semantic Faraday law: $\partial_t \mathcal{F}_s$ induces edge-gap EMF → cognitive work.
Toy experiments: A/B paraphrase loop; twist quantization; curvature pump.

Ch. 14 (Remark) Hetu–Luoshu as Pre/Post Templates

Side-note for researchers: 10-node pre-field (Hetu) supporting a 9-mode trace (Luoshu); belts as the measurement surface for that patch.

Part VI — Metrics, Losses, and Online Control (AGI-ready)

Ch. 15 Engineer Metrics

Phase-gap, flux, twist, width scaling; reparameterization/gauge invariance (sketch).
Calibration protocols and acceptance bands.

Ch. 16 Training Objectives

Two-Boundary Loss (TBL), Flux Regularization (FR), Twist Steering (TS); differentiable estimators for U(1)/U(k); gradient recipes & pitfalls.

Ch. 17 Controllers at Inference

Safety gate (flux-spike abort), creativity dial (twist stepping), plan repair via belt tiling.
Local stability/Lyapunov-style bound (sketch).

Ch. 18 Memory & Retrieval Belts (RAG)

Retrieval path vs. generation path as $\Gamma_-,\Gamma_+$ ; flux-threshold routing; de-dup & hallucination checks.

Part VII — Tool Use, Planning, and Composition

Ch. 19 Planning as Belt Tiling

Subgoals/tools induce tiles on $\mathcal{B}$ ; composition law & error accumulation (sketch).

Ch. 20 Program Synthesis & Self-Repair

Compilation/binding as twist; unit tests as edge checks; loop until flux $<\tau$ .

Ch. 21 Multi-Turn Dialogue & Style Control

Part VIII — Multi-Agent Belt Networks

Ch. 22 Junctions and Cobordisms (Pair-of-Pants)

Merging/splitting channels; junction conservation law under smooth gluing (sketch).

Ch. 23 Consensus & Negotiation Protocols

Phase-agreement dynamics; spectral-radius condition ⇒ consensus (sketch).

Part IX — Computation, Software, and Benchmarks

Ch. 24 Discrete Surface-Ordering Algorithms

Annular meshes, quadrature, ordering; complexity & numerical stability; error vs. curvature (sketch).

Ch. 25 Estimating the Semantic Connection from Models

From embeddings/logits/hidden states (U(1)/U(k)/Uhlmann); bias/consistency under mild assumptions (sketch).

Ch. 26 Benchmarks & Evaluation

Three suites: $4\pi$ periodicity; width-scaling law; belt-Faraday test.
Expected curves/tolerances; reproducibility checklist + logs schema.

Ch. 27 Reference Implementation

Minimal APIs for metrics, losses, controllers; audit logging format.

Part X — Case Studies

Ch. 28 Physics Mini-Cases

Dirac belt trick; framed Wilsons; Uhlmann/Berry geometric force as holonomy variation (worked).

Ch. 29 Soft-Matter & Robotics

DNA supercoiling; ribbon robots; EM “upper–minus–lower” sensing (sim plans).

Ch. 30 AGI Systems in the Wild

Prompt injection detection via flux spikes; controllable style dials via twist steps; planning/repair via tiling.

Part XI — Limits & Open Problems

Ch. 31 Beyond Thin Belts

Large-width corrections; defects; stochastic belts; non-annular topologies.

Ch. 32 Higher-Form & Back-Reaction Effects

When membranes/volumes are required; coupling belts to collapse processes (outline).

Appendices

App. A Notation & Orientation Diagrams — ready-to-print cheat sheets.
App. B Proof Sketches — Two-Boundary Stokes/Gauss; FBHL derivation; framing quantization (with [BH] margin tags).
App. C Computational Reference — meshes, quadrature, error tables, complexity.
App. D Exercises & Mini-Projects (30) — solutions outline; unit tests for invariants.
App. E Quick-Start One-Pager — all core equations on a single page.

Part I — Orientation (engineers first, math-ready)

Chapter 1 — Why Belts, Not Lines

1.1 The engineering problem this fixes

Modern agents trip over three recurring issues:

Hidden style drift. A model keeps solving the task but its voice/format slides unnoticed (e.g., from concise TypeScript to chatty pseudo-code). Line-based metrics catch token-level mismatch, not the geometric source of the drift.
Prompt injection / agenda hijack. A single stray instruction bends the generation path away from the intended plan; you need a surface to measure how much “semantic flux” pierced your guardrails.
Planning detours. Multi-step tools or subgoals add small local deviations that accumulate into a globally wrong answer; “distance along a line” underestimates accumulated curvature.

Core insight. Whenever a process naturally has two complementary traces—e.g., intent vs. generation; plan vs. execution; forward vs. backward (Schwinger–Keldysh)—the minimal geometric carrier of the invariants you care about is not a line but a two-boundary worldsheet (a ribbon, or “belt”). On that belt live (i) the curvature flux you must integrate (for response/forces) and (ii) a framing/twist term you will lose if you collapse to a single line. In standard quantum/open-system geometry this two-boundary belt is not an extra axiom; it’s forced by the formalism (SK doubling + mixed-state parallel transport / Uhlmann).

1.2 Running example (used throughout the book)

Task. A code-assistant must convert a short Python function into a strict TypeScript implementation with identical algorithmics and lower-casing of all identifiers. The product must pass a hidden unit test.

Two traces we log each run (per mini-batch):

Upper edge, $\Gamma_+$ — the generation path: the actual sequence of latent states/edits/choices that produced the final TypeScript.
Lower edge, $\Gamma_-$ — the intent path: a deterministic “shadow” run compiled from the spec (typed signature, target style rules, test oracle stubs), i.e., what the model should have done if it were perfectly steered.

Ribbon $\mathcal{B}$ . We tile a narrow annulus between $\Gamma_-$ and $\Gamma_+$ . Over this belt we estimate a semantic connection (U(1)/U(k) or Uhlmann) from model internals (e.g., normalized hidden trajectories), then compute:

Phase gap $\Delta\phi = \oint_{\Gamma_+}\mathcal{A} - \oint_{\Gamma_-}\mathcal{A}$
Curvature flux $\iint_{\mathcal{B}} \mathcal{F}$
Framing twist $\mathrm{Tw}$ from the belt’s framing field (a continuous “style axis” along the edges)

Empirically, prompt-injection pushes flux spikes, style drift shows up as quantized twist steps, and detours accumulate as belt area, all before failures appear in tokens. In later chapters we formalize these readouts into losses (train-time) and controllers (inference-time). The “two edges + framing” construction mirrors the SK double-boundary ribbon used to define well-posed holonomies; compressing to a single unframed line erases the framing term.

1.3 What a “belt” is (one-paragraph definition)

A belt for a closed control loop $\gamma$ is a smooth immersed ribbon $\mathcal{B}(\gamma)\subset \Theta\times\mathrm{SK}$ whose boundary is the two SK-lifted edges $\partial\mathcal{B}=\Gamma_+\sqcup\Gamma_-$ . Its belt holonomy is the surface-ordered exponential of the pulled-back curvature, $\mathcal{H}[\mathcal{B}]=\mathcal{P}\exp\!\iint_{\mathcal{B}} F$ . In the thin-belt limit, a framing (nowhere-vanishing normal field along the boundary) survives and contributes a finite, gauge-covariant phase (“framing anomaly”). Result: two boundaries + framing are minimal and inevitable for capturing the invariants.

1.4 The belt identity (preview)

Throughout the book we use the following working law (physics: FBHL; semantics: SBHL):

\boxed{\quad \underbrace{\oint_{\Gamma_+}\!\mathcal{A}-\oint_{\Gamma_-}\!\mathcal{A}}_{\text{edge–edge phase gap}} \;=\; \underbrace{\iint_{\mathcal{B}}\!\mathcal{F}}_{\text{surface curvature flux}} \;+\; \underbrace{\alpha\,\mathrm{Tw}}_{\text{framing / twist term}} \quad}

The left side is the measurable gap between two boundary holonomies (upper minus lower).
The first term on the right is the integrated curvature (Berry/Uhlmann or non-Abelian analogue), which governs geometric forces via first variation.
The second term is the framing (twist) contribution, the piece you lose on a single unframed line but which is physically/operationally real (e.g., shows up as exchange/statistics or style quantization).

Why this matters to you.

For safety, $\partial_t \mathcal{F}$ acts like a semantic Faraday law: sudden flux induces an “EMF” along the edges—a reliable early-warning for agenda shifts (injection).
For style control, $\mathrm{Tw}$ is a clean knob: stepping twist by $2\pi$ yields predictable, quantized style/format changes without wrecking content.
For planning, the belt area and flux budget accumulate small local deviations into a global invariant.

1.5 Why a line is not enough (and never will be, in this setting)

Two independent arguments show that compressing to a single trace loses essential, gauge-covariant information:

Geometric argument. Even as the width $w\to 0$ , ordered-exponential calculus over the surface retains a finite framing contribution proportional to $\mathrm{Tw}$ . This term cannot be reconstructed from a single unframed path integral.
Topological argument. In Berry–Chern / Chern–Simons-type sectors, properly defined loop observables are framing-dependent; the cure is to use framed ribbons (two nearby boundaries). The SK belt is exactly that framed regularization.

Hence the two-boundary belt is minimal: remove the second edge or the framing and you discard genuine, observable phase.

1.6 A 60-second recipe (what you’ll actually implement in Chs. 10–18)

Log two traces per run: an intent surrogate $\Gamma_-$ and the generation $\Gamma_+$ .
Tile a belt $\mathcal{B}$ between them (thin annulus; stable framing).
Estimate a connection $\mathcal{A}$ from model states (U(1)/U(k)/Uhlmann) and compute
$\Delta\phi,\ \iint_{\mathcal{B}}\mathcal{F},\ \mathrm{Tw}$ .
Act on them:
- Train with Two-Boundary Loss + Flux Regularization + Twist Steering.
- Infer with flux-spike safety gates, twist dials for style, and belt-tiling for plan repair.
  This operationalizes the identity above and directly follows from the two-boundary calculus developed in Parts II–V.

1.7 Where we’re headed

Part II–III builds the calculus and proves existence/minimality, variation ⇒ force, and exchange = framed linking. Expect short, focused lemmas—no exotic postulates.
Part IV introduces the Ribbon Collapse Model as the hinge from physics to AGI (why 2D suffices on large patches).
Part V–VII turn the belt identity into metrics, losses, and controllers you can ship.

One-line takeaway.
If your system has two traces, promote your model from a line to a belt. On that belt, phase-gap = flux + twist is the invariant that makes safety, style, and planning measurable and steerable.

Chapter 2 — Symbols & Conventions (One-Page Cheat Sheet)

A. Belt geometry

Belt / ribbon: $\mathcal{B}$ — a smooth annulus (two-boundary worldsheet).
Edges (boundaries): $\Gamma_+$ (upper), $\Gamma_-$ (lower).
- Engineering reading: $\Gamma_+$ = generation path, $\Gamma_-$ = intent/spec path (but any two complementary traces work).
Centerline: $C(s)$ (optional), parameter $s\in[0,1]$ with $s=0\sim1$ identified (closed loop).
Width: $w(s)>0$ — geodesic separation between edges (thin-belt regime: $\max_s \kappa(s) w(s)\ll 1$ ).

Local coordinates on $\mathcal{B}$ : $(s,n)$ with $s\in[0,1]$ along the edge/centerline and $n\in[0,w(s)]$ across the belt (from $\Gamma_-$ to $\Gamma_+$ ).
Area form: $dS = J(s,n)\, ds\, dn$ . In the thin limit, $J\approx 1$ .

B. Orientation & sign rules (anti “minus-sign hell”)

Surface orientation: choose $(s,n)$ so that the ordered basis $(\partial_s,\partial_n)$ gives the positive orientation on $\mathcal{B}$ .
Boundary orientation (Stokes-consistent):
$\partial \mathcal{B} = \Gamma_{+}\;-\;\Gamma_{-}.$
That is, the upper edge $\Gamma_+$ inherits the forward $s$ -orientation; the lower edge $\Gamma_-$ inherits the reverse orientation.
Mnemonic: upper minus lower.
Stokes on a belt:
$\oint_{\Gamma_+}\!\mathcal{A}\;-\;\oint_{\Gamma_-}\!\mathcal{A}\;=\;\iint_{\mathcal{B}}\!\mathcal{F}.$
Normal direction: $+n$ always points from $\Gamma_-$ to $\Gamma_+$ . (This fixes the sign of twist and the area form.)

C. Gauge geometry (physics/semantics both)

Connection (1-form): $\mathcal{A}$ on $\mathcal{B}$ (U(1) or U(k); mixed-state/Uhlmann optional).
Curvature (2-form): $\mathcal{F} = d\mathcal{A} + \mathcal{A}\wedge \mathcal{A}$ .
Edge holonomies: $\mathrm{Hol}(\Gamma_\pm) = \mathcal{P}\exp\!\oint_{\Gamma_\pm}\mathcal{A}$ .
Phase gap (edge–edge): $\Delta\phi := \oint_{\Gamma_+}\mathcal{A} - \oint_{\Gamma_-}\mathcal{A}$ (use arg det/trace/character as appropriate).
Gauge transforms: $\mathcal{A}\mapsto g^{-1}\mathcal{A}g+g^{-1}dg$ ; choose invariants accordingly (e.g., $\arg\det$ , projected Abelian components).

D. Framing, angle, and twist

Tangent: $T(s)=\dot{C}(s)/\|\dot{C}(s)\|$ .
Framing vector: $U(s)$ — a nowhere-vanishing unit vector field along the edge/centerline, orthogonal to $T(s)$ (picks the belt’s “span” direction).
Framing angle: $\phi(s)$ — orientation of $U(s)$ in a chosen transverse plane (or style axis in the semantic reading).
Twist:
- Angle form (thin-belt): $\displaystyle \mathrm{Tw}=\frac{1}{2\pi}\oint \frac{d\phi}{ds}\,ds$ .
- White’s formula: $\displaystyle \mathrm{Tw}=\frac{1}{2\pi}\oint (T\times U)\cdot \frac{dU}{ds}\,ds$ .
Link–twist–writhe (if using a spatial embedding): $\mathrm{Lk}=\mathrm{Tw}+\mathrm{Wr}$ .
Framing coefficient: $\alpha$ — domain-specific constant multiplying $\mathrm{Tw}$ in the belt identity (fixed later by sector; treat as known at use-time).

E. The belt identity (stated, not proved here)

\boxed{\quad \Delta\phi\;=\;\iint_{\mathcal{B}}\mathcal{F}\;+\;\alpha\,\mathrm{Tw} \quad}

Read as: edge–edge phase gap $=$ surface curvature flux $+$ framing/twist term.

Physics track: framed holonomy difference on a two-boundary worldsheet.
AGI track: “meaning flux + style twist” controls safety/style/planning.

F. Discrete implementation notes (for code)

Sampling: discretize $s$ into $K$ points per edge; tile $\mathcal{B}$ with $K\times M$ quads ordered first in $n$ (lower→upper), then in $s$ .
Surface ordering: multiply cell exponentials in that fixed order; keep orientation consistent with the Stokes sign.
Twist (discrete): unwrap $\phi(s_k)$ to avoid $2\pi$ jumps, then finite-difference and sum; or use the White formula with normalized vectors to reduce drift.
Stability: thin-belt guard $\max_s \kappa w<\varepsilon$ (e.g., $<0.2$ ) for reliable first-order geometry.
Numerical gauge: in U(k), compute $\arg\det$ or use a principal-angle projection to U(1) for the phase-gap scalar.

G. Quick pitfalls & cures

Wrong boundary sign: if $\oint_{\Gamma_+}\mathcal{A}+\oint_{\Gamma_-}\mathcal{A}$ appears, you flipped the lower edge orientation—fix to upper minus lower.
Twist drift: always unwrap $\phi$ ; prefer White’s formula for robustness.
Gauge leakage: compare scalars (trace/character/arg det) or fix a reference frame; log both raw and invariant versions for audits.
Width creep: if $w$ grows, expect curvature-ordering errors; either retile (more $M$ ) or switch to a slab/network model.

H. Symbol glossary

$\mathcal{B}$ belt/ribbon worldsheet • $\Gamma_\pm$ edges (upper/lower) • $s$ edge parameter • $n$ transverse coord • $w$ width
$C$ centerline • $T$ tangent • $U$ framing vector • $\phi$ framing angle • $\mathrm{Tw}$ twist (dimensionless)
$\mathcal{A}$ connection 1-form • $\mathcal{F}$ curvature 2-form • $\Delta\phi$ edge–edge phase gap • $\alpha$ framing coefficient

One-liner: Use upper minus lower for boundary integrals, lower→upper for the transverse ordering, and compute phase-gap = flux + $\alpha$ ·twist.

Chapter 3 — Ten-Page Mathematical Primer

Goal: fix notation and the exact math objects we use—curves, surfaces, frames, connections, curvature, surface-ordered exponentials—so later results (FBHL/SBHL, metrics, controllers) are unambiguous.

3.1 Curves and Surfaces (with the belt in mind)

Channel manifold. Work on a smooth manifold $\Theta$ (the “control/context” space).
Closed loop. A $C^1$ closed control loop $\gamma:S^1\to\Theta$ , unit-speed when convenient.
SK doubling (two boundaries). Schwinger–Keldysh induces two oriented time branches, giving a canonical lift $\gamma_\pm:S^1\to \Theta\times\mathrm{SK}$ . This is the source of our two boundaries.
Belt / ribbon. A belt $\mathcal{B}(\gamma)\subset\Theta\times\mathrm{SK}$ is a smooth, compact, oriented, immersed annulus with boundary
$\partial\mathcal{B}=\Gamma_+\sqcup\Gamma_-, \quad \Gamma_\pm=\gamma_\pm(S^1).$
A canonical construction uses the geodesic-normal ribbon with a chosen framing field (below).
Orientation convention. We adopt Stokes-consistent signs: $\partial\mathcal{B}=\Gamma_+ - \Gamma_-$ . This “upper minus lower” rule is used everywhere later.

Why this matters. All belt integrals, signs, and surface orders inherit from these choices; it prevents “minus-sign hell” in Chapters 4–9.

3.2 Frames, Framing Angle, and Twist

Tangent & normal. Let $T(s)=\dot{\gamma}(s)/\|\dot{\gamma}(s)\|$ . A framing field along $\gamma$ is a smooth, nowhere-vanishing $U(s)\in T_\gamma\Theta$ with $\langle U(s),T(s)\rangle=0$ .
Framing angle. In a chosen transverse plane, $U$ has angle $\phi(s)$ .
Twist (thin-belt).
$\mathrm{Tw}=\frac{1}{2\pi}\oint \frac{d\phi}{ds}\,ds \quad\text{(or White’s vector formula)}.$
Link–twist–writhe (spatial embeddings). $\mathrm{Lk}=\mathrm{Tw}+\mathrm{Wr}$ . Belts inherit framed boundaries, hence self-link (framing) will appear in phases later.

Takeaway. The framing datum survives the thin-belt limit and contributes a finite, gauge-covariant phase; a single unframed line cannot encode it.

3.3 Differential Forms and Two-Boundary Stokes

Connection 1-form $\mathcal{A}$ and curvature 2-form $\mathcal{F}=d\mathcal{A}+\mathcal{A}\wedge\mathcal{A}$ .
Two-boundary Stokes (schematic).
$\oint_{\Gamma_+}\!\mathcal{A}-\oint_{\Gamma_-}\!\mathcal{A} \;=\;\iint_{\mathcal{B}}\!\mathcal{F},$
with the orientation convention above. This identity is the Abelian warm-up to belt holonomy. (We use it as a mnemonic; the full non-Abelian statement uses surface ordering below.)

3.4 Connections, Uhlmann Transport, and Belt Holonomy

Purification bundle. Over the density-operator manifold, use the Uhlmann connection $A$ ; its curvature $F=dA+A\wedge A$ . Pull back to $\Theta\times\mathrm{SK}$ via the process map.
Surface-ordered exponential (Non-Abelian Stokes). For a belt $\mathcal{B}$ :
$\mathcal{H}[\mathcal{B}] = \mathcal{P}\exp\!\iint_{\mathcal{B}} F,\qquad W[\mathcal{B}] = \mathrm{Tr}\,\mathcal{H}[\mathcal{B}],$
which is gauge-covariant; class functions (e.g., $\arg W$ ) are gauge-invariant and reparametrization-independent.

Minimality. With SK + Uhlmann, a two-boundary ribbon is forced by the formalism; compressing to a single unframed line generally loses the finite framing phase.

3.5 Thin-Ribbon Regime and Local Coordinates

Local chart $(s,n)$ with $s\in S^1$ along the edge/centerline and $n\in[-w/2,w/2]$ transverse (lower $\to$ upper).
Metric (first order). In geodesic-normal coordinates, $g\approx\mathrm{diag}((1-\kappa n)^2,\,1)$ ; thin-belt regime requires $\max_s \kappa(s)w \ll 1$ .
Area form. $dS=J(s,n)\,ds\,dn$ , with $J=1+O(\kappa n)$ .

We’ll use this only to state stability/error terms for discrete surface ordering and twist estimators (Ch. 4). (Sketch-level only in this chapter.)

3.6 Surface-Ordered Exponentials: Variation Formula

For a smooth family of belts $\{\mathcal{B}_\epsilon\}$ with moving boundary, define

\Phi(\epsilon)=\arg \mathrm{Tr}\,\mathcal{H}[\mathcal{B}_\epsilon].

Using Duhamel/Volterra calculus for surface order plus Cartan’s identity for the Lie derivative, one obtains the first-variation structure used later to connect geometric forces to holonomy. Full details are carried in the proof of Theorem B (Chapter 9 / Appx. A).

3.7 What We Mean by “Framing Survives”

Let $( \gamma, U )$ be a framed loop generating geodesic-normal belts of thickness $\varepsilon$ . Then

\lim_{\varepsilon\downarrow 0}\arg\,\mathrm{Tr}\,\mathcal{H}[\mathcal{B}_\varepsilon]

exists and depends on the rotation class of $U$ —i.e., on the twist—yielding a finite framing (self-link) contribution. Therefore, two boundaries + framing are minimal and inevitable; a single unframed line generically drops an observable. (Thin-belt lemma.)

3.8 Exchange/Statistics as Framed Linking (Preview)

Given two belts $\mathcal{B}_1,\mathcal{B}_2$ with framed boundaries, define the framed belt linking as the sum of Gauss linkings over all boundary components (with inherited framings). In Berry–Chern/Chern–Simons-type sectors, the exchange unitary acquires a phase proportional to this framed linking; $4\pi$ periodicity shows up crisply in interferometry. (We work this out in the case studies and in Appx. E.)

3.9 Gauge Covariance and Reparametrization Independence

Under a gauge transform $g$ , $A\mapsto g^{-1}Ag+g^{-1}dg$ , $F\mapsto g^{-1}Fg$ , hence
$\mathcal{H}[\mathcal{B}]\mapsto g(\Gamma_+)^{-1}\,\mathcal{H}[\mathcal{B}]\,g(\Gamma_-)$ .
Any class function (e.g., $\mathrm{Tr}$ , $\arg\det$ , characters) is invariant, and since $F$ is a 2-form, reparametrizations of edges/interior leave $\mathcal{H}$ unchanged. We rely on this when defining scalar phase gaps and when discretizing surfaces.

3.10 Non-Abelian Stokes (Working Statement)

We adopt the surface form (ordered exponential over $\mathcal{B}$ ) as the definition of belt holonomy, equivalent to line-ordered forms when the surface is admissible and the usual hypotheses hold. This choice is the right one for computation (mesh/quadrature) and for proving variation formulas. (Full statements and admissibility criteria appear with the proofs.)

3.11 Semantic Read (for later SBHL)

Everything above ports to the “semantic” setting by:

Picking a semantic connection $\mathcal{A}_s$ (U(1)/U(k)/Uhlmann estimator).
Defining the phase gap $\Delta\phi = \oint_{\Gamma_+}\mathcal{A}_s - \oint_{\Gamma_-}\mathcal{A}_s$ .
Logging flux $\iint_{\mathcal{B}}\mathcal{F}_s$ and twist $\mathrm{Tw}$ as engineer metrics.
This will become SBHL: phase gap = meaning flux + style twist (Ch. 13).

3.12 What We Fully Prove vs. What We Sketch (and Why)

Fully proved later (physics-rigor chapters & appendices):

Existence & minimality of belts (Theorem A): SK forces two boundaries; holonomy is gauge-covariant; thin-belt framing survives ⇒ single unframed line is insufficient. (Chs. 7–8, proofs in §4/Appx.)
Geometric/adiabatic forces = first variation of belt holonomy (Theorem B): full Duhamel/Volterra + Cartan calculus. (Ch. 9, Appx. A)
Exchange/statistics = framed belt linking (Theorem C): framed-Wilson analysis; $4\pi$ checks. (Ch. 9, Appx. E)

Sketched in this book (engineer-level suffices):

Thin-belt metric model and first-order coordinate invariance/stability (used for discretization bounds).
Discrete surface ordering convergence on annuli; error terms vs. curvature and mesh.
Semantic connection existence along $C^1$ paths and gauge covariance (SBHL bridge).
These are treated as sketch proofs because (i) they follow standard differential-geometric arguments, (ii) full generality adds length not needed for implementation, and (iii) we provide unit tests/benchmarks that validate them empirically for engineering purposes.

Minimal takeaway

You now have the exact geometric toolbox we’ll use:

Belts $\mathcal{B}$ with two boundaries $\Gamma_\pm$ ,
Framing $U,\phi,\mathrm{Tw}$ ,
Connection/curvature $A,F$ with surface-ordered holonomy $\mathcal{H}[\mathcal{B}]$ ,
The knowledge that framing survives and gauge covariance is clean.

Chapters 4–6 turn this primer into code: operators, two-boundary Stokes, framing/twist; Chapters 7–9 derive the core laws we’ll build the AGI stack on.

Chapter 4 — The Belt Domain and Operators

Goal: fix the local metric on a ribbon and give explicit, code-ready formulas for grad/div/curl/Δ with thin-belt error notes and stability guards.

4.1 Geometry of a belt (local chart and metric)

Let the centerline be a $C^2$ closed loop $C(s)$ (unit speed), with curvature $\kappa(s)$ . Construct the geodesic-normal ribbon by offsetting along a framing field $U(s)\perp \dot C(s)$ a signed distance $n\in[0,w(s)]$ from the lower to the upper edge. Use local coordinates $(s,n)$ with orientation $(\partial_s,\partial_n)$ and lower→upper taken as $+n$ .

In this chart (first order in thickness), the induced ribbon metric is

g=\mathrm{diag}\!\big((1-\kappa n)^2,\,1\big),\quad \sqrt{|g|}=(1-\kappa n),\quad g^{ss}=(1-\kappa n)^{-2},\ g^{nn}=1.

This follows from the standard geodesic-normal construction for the belt (existence as smooth immersed ribbon; SK lift gives the two boundaries).

Validity domain (thin-belt): require $\max_s |\kappa(s)|\,w(s)\ll 1$ so the chart is non-singular and Jacobian $1-\kappa n>0$ . Higher-order terms are $O(\kappa' n)+O(\kappa^2 n^2)$ .

4.2 Differential operators on the ribbon

Below, scalar fields $f$ , vector fields $V=V^s\partial_s+V^n\partial_n$ . We use the coordinate basis and the metric above.

Gradient

\nabla f=\big(g^{ss}\partial_s f\big)\,\partial_s+\big(g^{nn}\partial_n f\big)\,\partial_n =\frac{\partial_s f}{(1-\kappa n)^2}\,\partial_s+\partial_n f\,\partial_n.

Divergence $(\nabla\!\cdot V = \nabla_i V^i)$

\nabla\!\cdot V =\frac{1}{\sqrt{|g|}}\partial_i\!\big(\sqrt{|g|}\,V^i\big) =\frac{1}{1-\kappa n}\Big[\partial_s\!\big((1-\kappa n)V^s\big)+\partial_n\!\big((1-\kappa n)V^n\big)\Big].

Curl / vorticity (2D scalar)

Let $V^\flat$ be the 1-form with components $V_s=g_{ss}V^s=(1-\kappa n)^2V^s$ , $V_n=V^n$ . The scalar curl is

\operatorname{curl}V = {*}d(V^\flat) = \frac{1}{\sqrt{|g|}}\big(\partial_s V_n-\partial_n V_s\big) = \frac{1}{1-\kappa n}\Big[\partial_s V^n-\partial_n\!\big((1-\kappa n)^2 V^s\big)\Big].

Laplace–Beltrami on scalars

\Delta f=\nabla\!\cdot(\nabla f) =\frac{1}{1-\kappa n}\left[ \partial_s\!\Big(\frac{1}{1-\kappa n}\,\partial_s f\Big) +\partial_n\!\big((1-\kappa n)\,\partial_n f\big) \right].

These formulas are the thin-belt specializations of standard Riemannian identities with the geodesic-normal metric; they are the operators used in our surface-ordered calculus and stability estimates for the belt holonomy.

4.3 Discrete versions (for code)

Mesh. Sample $s$ at $K$ points per edge; tile $\mathcal{B}$ by $K\times M$ quads ordered first in $n$ (lower→upper), then in $s$ . Use $\sqrt{|g|}=(1-\kappa n)$ for quadrature weights.

Finite differences.

$\partial_s f \approx (f_{k+1,m}-f_{k-1,m})/(2\Delta s)$ on a periodic grid; $\partial_n f \approx (f_{k,m+1}-f_{k,m-1})/(2\Delta n)$ .
Implement $\nabla\!\cdot V$ as the conservative form $(1/\sqrt{|g|})\,\nabla\cdot(\sqrt{|g|}V)$ to preserve Stokes consistency with upper–minus–lower orientation used later for belt Stokes and holonomy.
For curl, assemble $V_s=(1-\kappa n)^2V^s$ first, then apply the difference stencil in the formula above.

Sanity tests.

Constant $f\Rightarrow \nabla f=0,\ \Delta f=0$ .
Constant $V$ tangent to edges with $V^n=0\Rightarrow \operatorname{curl}V= -\frac{1}{1-\kappa n}\partial_n((1-\kappa n)^2V^s)$ (captures curvature-induced twist).
Discrete Stokes: $\sum_{\text{cells}} \mathcal{F}\,\Delta S \approx \oint_{\Gamma_+}\!\mathcal{A}-\oint_{\Gamma_-}\!\mathcal{A}$ .

4.4 Thin-ribbon regime: error terms & stability (sketch)

Assumptions. $|\kappa|w\le \varepsilon\ll1$ , $|\kappa'|w^2\ll1$ , fields $C^2$ in $(s,n)$ .

Metric & Jacobian errors. True area factor is $J=1-\kappa n+O(\kappa' n^2+\kappa^2 n^2)$ ; using $J\approx1-\kappa n$ induces $O(\varepsilon^2)$ relative error in surface integrals. Sketch: Taylor expand the exponential map in the geodesic-normal construction; compute $g_{ss}$ and $\sqrt{|g|}$ to second order.

Operator consistency.

$\nabla\!\cdot$ in conservative form is first-order accurate in $n$ and second-order in $s$ with centered stencils; residual $O(\varepsilon\,\Delta s^2+\varepsilon\,\Delta n)$ .
$\Delta$ incurs an additional $\partial_n\kappa$ coupling; truncation is $O(\varepsilon\,\Delta s^2+\varepsilon\,\Delta n + \varepsilon^2)$ .

Stability guard. Enforce $\max |\kappa| w < 0.2$ and choose $M$ such that $\Delta n \le w/8$ ; this keeps Jacobian positivity and controls surface-ordering error in holonomy beyond which commutator nesting dominates. Rationale: bounded by the admissible-homotopy/curvature support arguments used in the belt holonomy stability discussion.

Why this is enough. The full belt framework (existence/minimality; gauge covariance; variation → force) rests on the geodesic-normal ribbon and non-Abelian Stokes—both independent of discretization—and only requires these first-order geometric controls for reproducible numerics.

4.5 Quick reference (copy into code)

Metric: $g_{ss}=(1-\kappa n)^2$ , $g_{nn}=1$ , $\sqrt{|g|}=1-\kappa n$ .
Grad: $\big(\partial_s f/(1-\kappa n)^2,\ \partial_n f\big)$ .
Div: $\frac{1}{1-\kappa n}\big[\partial_s((1-\kappa n)V^s)+\partial_n((1-\kappa n)V^n)\big]$ .
Curl: $\frac{1}{1-\kappa n}\big[\partial_s V^n-\partial_n((1-\kappa n)^2V^s)\big]$ .
Laplacian: $\Delta f=\frac{1}{1-\kappa n}\!\left[\partial_s\!\big(\frac{1}{1-\kappa n}\partial_s f\big)+\partial_n\!\big((1-\kappa n)\partial_n f\big)\right]$ .
Orientation: boundary = upper minus lower.

These are the operators we’ll use to: (i) state two-boundary Stokes cleanly, (ii) implement surface ordering for belt holonomy, and (iii) quantify thin-belt stability in later algorithms.

Chapter 5 — Two-Boundary Stokes & Gauss

Goal: express Stokes/Gauss on a ribbon $\mathcal{B}$ with two boundaries $\Gamma_\pm$ and fix the upper–minus–lower convention. We also give a partition proof (via classical Stokes + Jacobian) so you can trust the signs and the discretization.

5.1 Setup and orientation

Belt / ribbon: $\mathcal{B}\subset\Theta\times \mathrm{SK}$ is a smooth immersed annulus with boundary
$\partial\mathcal{B}=\Gamma_+\;\sqcup\;\Gamma_- , \quad\text{with the Stokes-consistent sign } \partial\mathcal{B}=\Gamma_+ - \Gamma_- .$
(This is the SK two-branch lift with inherited orientations.)
Local chart: use $(s,n)$ with $s$ along the edge and $n\in[0,w(s)]$ from $\Gamma_-$ (at $n=0$ ) to $\Gamma_+$ (at $n=w$ ).
Metric from Ch. 4: $g=\mathrm{diag}((1-\kappa n)^2,1)$ , area form $dS=(1-\kappa n)\,ds\,dn$ . (We’ll only need that Jacobian once.)
Key fact: Using forms, reparametrizations/Jacobians cancel for surface integrals because curvature is a 2-form (this will justify our discrete formulas too).

5.2 Two-Boundary Stokes (circulation = flux)

Let $\mathcal{A}=A_s\,ds + A_n\,dn$ be a smooth 1-form on $\mathcal{B}$ , with curvature 2-form

d\mathcal{A}=\big(\partial_s A_n - \partial_n A_s\big)\,ds\wedge dn .

Theorem (two-boundary Stokes).

\boxed{\;\;\oint_{\Gamma_+}\!\mathcal{A}\;-\;\oint_{\Gamma_-}\!\mathcal{A} \;=\;\iint_{\mathcal{B}} d\mathcal{A}\;=\;\iint_{\mathcal{B}}\big(\partial_s A_n-\partial_n A_s\big)\,ds\,dn\;\;}

The left side is upper minus lower because $\partial\mathcal{B}=\Gamma_+ - \Gamma_-$ .
This is the Abelian warm-up of the non-Abelian (surface-ordered) version used for belt holonomy; there, the 2-form nature again ensures parametrization independence.

Partition proof (sketch). Tile $\mathcal{B}$ into thin rectangles $R_{k,m}=[s_k,s_{k+1}]\times[n_m,n_{m+1}]$ . Apply classical Stokes on each $R_{k,m}$ :
$\displaystyle \oint_{\partial R_{k,m}}\!\!\mathcal{A}=\iint_{R_{k,m}} d\mathcal{A}.$
Sum over all tiles. Internal edges cancel telescopically, leaving only the two belt boundaries; the sum of the right-hand sides gives the surface integral. Jacobian factors do not appear in the form version (and cancel in the non-Abelian derivation), which is why this identity is coordinate-robust.

5.3 Two-Boundary Gauss (divergence = normal flux)

Let $V=V^s\partial_s+V^n\partial_n$ be a smooth vector field on $\mathcal{B}$ . With the ribbon metric from Ch. 4, the divergence is

\nabla\!\cdot V =\frac{1}{1-\kappa n}\left[\partial_s\!\big((1-\kappa n)V^s\big)+\partial_n\!\big((1-\kappa n)V^n\big)\right].

Divergence theorem on a belt.

\boxed{\;\;\iint_{\mathcal{B}} (\nabla\!\cdot V)\,(1-\kappa n)\,ds\,dn =\;\oint_{\Gamma_+}\!\!\langle V,\nu\rangle\,dl\;-\;\oint_{\Gamma_-}\!\!\langle V,\nu\rangle\,dl\;\;}

where $\nu=\pm\,\partial_n$ is the outward unit normal along the boundary within the surface, and $dl=(1-\kappa n)\,ds$ is the boundary line element. At $\Gamma_+$ (upper edge) the outward normal is $+\partial_n$ ; at $\Gamma_-$ it is $-\partial_n$ (pointing into the hole), yielding upper minus lower again.

Partition proof (sketch). Tile $\mathcal{B}$ into rectangles and apply the planar divergence theorem in $(s,n)$ coordinates with area element $(1-\kappa n)\,ds\,dn$ . Fluxes across internal faces cancel; the only survivors are the normal fluxes across $n=w(s)$ and $n=0$ , which appear with opposite signs once you account for outward normals and the boundary line Jacobian $dl=(1-\kappa n)\,ds$ . (Same Jacobian-cancellation logic as above guarantees coordinate consistency.)

5.4 Discrete formulas (drop-in)

On a $K\times M$ mesh (periodic in $s$ ), with cells ordered first in $n$ (lower→upper):

Stokes (circulation vs flux):
$\sum_{m,k}\Big(\partial_s A_n-\partial_n A_s\Big)_{k,m}\,\Delta s\,\Delta n \;\approx\; \sum_k A_s(s_k,w)\,\Delta s\;-\;\sum_k A_s(s_k,0)\,\Delta s .$
(1-forms don’t need Jacobian weights; keep upper minus lower.)
Gauss (div vs normal flux):
$\sum_{m,k}(\nabla\!\cdot V)_{k,m}\,(1-\kappa n_{m})\,\Delta s\,\Delta n \;\approx\; \sum_k V^n(s_k,w)\,(1-\kappa w)\,\Delta s \;-\; \sum_k V^n(s_k,0)\,(1-0)\,\Delta s .$
Sanity tests: constant $V$ tangential to edges ⇒ net flux $=0$ ; constant $f$ ⇒ $\nabla f=0$ , $\Delta f=0$ . (Also verify discrete Stokes by summing cell fluxes vs boundary circulations.)

These discretizations align with the belt holonomy calculus (surface ordering on an annulus) and inherit the gauge/parametrization robustness of the 2-form statement.

5.5 Why this is the right abstraction (physics link)

The non-Abelian, gauge-geometric version replaces $d\mathcal{A}$ by the curvature $\mathcal{F}=d\mathcal{A}+\mathcal{A}\wedge\mathcal{A}$ and the line integrals by edge holonomies—still with upper minus lower—yielding the belt holonomy used throughout the paper. Because $\mathcal{F}$ is a 2-form, the holonomy is gauge-covariant and reparametrization-independent, and in the thin-belt limit a framing term survives, which a single line would miss.

One-liner

On a ribbon, Stokes and Gauss are literally “upper minus lower.” Prove it once with tile-by-tile Stokes + the Jacobian, then reuse it everywhere—from discrete code to non-Abelian belt holonomy.

Chapter 6 — Framing, Twist, Writhe, Linking

Goal: relate framing on a ribbon to topological link invariants and show why a single line cannot carry the needed data. We state the belt form of the Călugăreanu–White identity and connect it to framed belt linking used later for exchange/statistics.

6.1 From framed curves to belt invariants

A framed belt is a smooth immersed annulus $\mathcal{B}\subset \Theta\times\mathrm{SK}$ with two boundary components $\Gamma_\pm$ and a nowhere-vanishing normal (framing) field $U$ along the core loop $\gamma$ . In the thin-belt construction, $\Gamma_\pm$ are small offsets of $\gamma$ along $U$ . The framing datum survives as the belt thickness $\varepsilon\to 0$ ; it contributes a finite, gauge-covariant phase that cannot be reconstructed from a single unframed line.

6.2 The Călugăreanu–White identity (belt form)

For a closed, embedded core curve $\gamma\subset\mathbb{R}^3$ with a smooth framing $U$ that spans a ribbon, the self-linking number $\mathrm{SL}$ of either boundary component relative to the other satisfies the classical identity:

\boxed{\ \mathrm{SL}(\gamma;U)\;=\;\mathrm{Wr}(\gamma)\;+\;\mathrm{Tw}(\gamma;U)\ }

Writhe $\mathrm{Wr}(\gamma)$ : geometric (global) bending & coiling of $\gamma$ (Gauss double integral).
Twist $\mathrm{Tw}(\gamma;U)$ : integrated rotation of the framing $U$ along $\gamma$ (e.g., $\frac{1}{2\pi}\oint \frac{d\phi}{ds}\,ds$ ).

Belt specialization. Each SK belt has two framed boundary curves that are $\varepsilon$ -offsets of $\gamma$ . The paper records this as “ $\mathrm{SL} = \mathrm{Wr} + \mathrm{Tw}$ ” and uses it to account for the framing (self-link) contributions that persist in the thin-belt limit.

6.3 Framed belt linking (mutual linking between two belts)

Given two framed belts $\mathcal{B}_1,\mathcal{B}_2$ with boundaries $\Gamma_{1,\pm}$ , $\Gamma_{2,\pm}$ , define the framed belt linking

\mathrm{Lk}_{\text{belt}}(\mathcal{B}_1,\mathcal{B}_2) \;=\;\sum_{\sigma,\tau\in\{+,-\}} \mathrm{Lk}(\Gamma_{1,\sigma},\Gamma_{2,\tau}) .

In the SK thin-ribbon setup, each $\Gamma_{i,\pm}$ is a small framed offset of the core loop $\gamma_i$ , so the pairwise linkings equal the core linking, yielding

\mathrm{Lk}_{\text{belt}}(\mathcal{B}_1,\mathcal{B}_2)=4\,\mathrm{Lk}(\gamma_1,\gamma_2) \quad\text{(for consistent SK orientations).}

Self-link terms (from each belt separately) produce the framing anomaly offsets. This is exactly the quantity that controls the exchange/statistics phase in the topological/adiabatic sectors derived later.

6.4 Why a single line loses framing ⇒ belts are inevitable

Two complementary arguments:

Geometric (thin-belt) limit. The surface-ordered exponential over the belt yields a finite limit as thickness $\varepsilon\to 0$ that depends on the rotation class of $U$ (twist). The area term vanishes with $\varepsilon$ , but ordered-exponential structure retains a finite framing contribution; hence different framings over the same $\gamma$ lead to different phases. A single unframed curve cannot encode this.
Topological (Wilson framing). In Berry–Chern/Chern–Simons–type sectors, loop observables are framing-dependent; the standard cure is to frame the loop by a narrow ribbon. SK ribbonization is precisely that cure, supplying the self-link term that an unframed line misses. Conclusion: two boundaries + framing are the minimal gauge-covariant carrier.

6.5 Computation (engineer playbook)

A. Linking number (Gauss integral). For two closed piecewise-smooth curves $\alpha,\beta\subset\mathbb{R}^3$ ,

\mathrm{Lk}(\alpha,\beta)=\frac{1}{4\pi}\iint \frac{(\dot\alpha(s)\times \dot\beta(t))\cdot(\alpha(s)-\beta(t))} {\|\alpha(s)-\beta(t)\|^3}\,ds\,dt .

B. Writhe of $\gamma$ : same Gauss integral with $\alpha=\beta=\gamma$ taken in a principal-value sense (or by standard discretized approximations).

C. Twist: either angle-accumulation $\frac{1}{2\pi}\oint d\phi/ds\,ds$ or White’s vector formula

\mathrm{Tw}=\frac{1}{2\pi}\oint (T\times U)\cdot \frac{dU}{ds}\,ds .

D. Belt form.

Compute $\mathrm{Tw}(\gamma;U)$ from the framing along the core.
Compute $\mathrm{Wr}(\gamma)$ from the centerline geometry.
Then $\mathrm{SL}=\mathrm{Wr}+\mathrm{Tw}$ gives the self-link of the belt boundary; assemble $\mathrm{Lk}_{\text{belt}}$ for pairs of belts from the four boundary combinations. These self-/mutual-link integers feed the framing anomaly and the exchange phase.

E. Sanity checks.

Reverse belt orientation ⇒ $\mathrm{Lk}_{\text{belt}}$ changes sign consistently on both sides of the exchange law (Ch. 9).
Change framing by $+1$ twist ⇒ $\mathrm{SL}\mapsto \mathrm{SL}+1$ and only adds a constant phase offset; mutual phases (between distinct belts) are unaffected.

6.6 Where specialization fails (sketch)

The identity and belt reductions above rely on smoothness, orientability, and embeddedness. Pitfalls:

Non-orientable span (Möbius-like strip). A Möbius band has one boundary and no globally consistent normal field $U$ ; belt assumptions fail (we require two boundaries and an orientable annulus), so $\mathrm{SL}=\mathrm{Wr}+\mathrm{Tw}$ in this form is inapplicable. The SK belt is explicitly orientable with two edges.
Self-intersections / non-embedded centerline. If $\gamma$ is not an embedded $C^2$ loop (e.g., has cusps or crossings), the Gauss integrals need rectifiable-chain techniques; $\mathrm{Wr}$ and even $\mathrm{Lk}$ may become ill-defined without extra care. The paper’s belt construction assumes a smooth immersed ribbon with finite area.
Open ribbons (endpoints). For open curves, $\mathrm{SL}=\mathrm{Wr}+\mathrm{Tw}$ requires endpoint framing conventions (or closing by a reference arc). Our book focuses on closed belts; open cases are postponed to the computational appendix.
Large width / leaving thin regime. If $\kappa w\not\ll 1$ , the geodesic-normal chart and thin-belt limit estimates degrade; discrete surface ordering acquires higher commutator corrections that spoil clean separation of $\mathrm{Wr}$ and $\mathrm{Tw}$ . Use slab/net generalizations (Part IV). (Thin-belt minimality is what underwrites “line is insufficient.”)

6.7 Why this chapter matters downstream

Physics link (Ch. 9): exchange/statistics phase $U_{\mathrm{ex}}$ equals $\exp\{i\,\lambda\,\mathrm{Lk}_{\text{belt}}\}$ up to local terms; self-link pieces are exactly the framing anomaly.
Core minimality claim (Ch. 7–8): finite framing persists in the thin limit; hence belts are inevitable once SK + mixed-state transport are present.

One-liner

A ribbon’s boundary self-link splits as writhe + twist, and mutual phases ride on framed belt linking; both depend on framing that a single unframed line cannot carry—hence the belt.

Chapter 7 — Connections, Curvature, Surface Ordering

Goal: formalize belt holonomy as a surface-ordered exponential on an annulus, relate it to line-ordered forms, prove gauge covariance and reparametrization independence, and state the refinement limit on annuli (why your discrete surface product converges).

7.1 Setting and objects

Bundle & connection. Work in the purification principal bundle over the density-operator manifold; take the (possibly non-Abelian) Uhlmann connection $A$ with curvature $F=dA+A\wedge A$ . Pull back to $\Theta\times \mathrm{SK}$ by the process map.
Belt. A belt $\mathcal{B}\subset \Theta\times\mathrm{SK}$ is a smooth immersed annulus with boundary $\partial\mathcal{B}=\Gamma_+\sqcup\Gamma_-$ (the SK-lifted edges).

Definition 7.1 (Belt holonomy).

\mathcal{H}[\mathcal{B}]\;:=\;\mathcal{P}\exp\!\iint_{\mathcal{B}}F, \qquad W[\mathcal{B}]\;:=\;\mathrm{Tr}\,\mathcal{H}[\mathcal{B}] .

We adopt the surface form as the definition (the non-Abelian Stokes theorem relates it to line-ordered boundary data when applicable).

7.2 Path vs. surface exponentials (what equals what)

Lemma 7.2 (Non-Abelian Stokes—operational form).
If a (piecewise smooth) surface $\mathcal{B}$ bounds a closed contour $\partial\mathcal{B}$ , then the line-ordered holonomy around $\partial\mathcal{B}$ is represented by the surface-ordered exponential of $F$ over $\mathcal{B}$ . We take $\mathcal{H}[\mathcal{B}]$ as primary; when Stokes applies, it coincides with the boundary object. Sketch. Standard non-Abelian Stokes on the pulled-back bundle; the draft records this choice and uses it for all variation formulas.

Remark (flat vs. curved sectors).
For flat $F$ on a 3-chain spanning two admissibly homotopic belts $\mathcal{B}_0,\mathcal{B}_1$ with the same framed boundary, their holonomies are boundary-conjugate so any class function agrees: $W[\mathcal{B}_0]=W[\mathcal{B}_1]$ . In general, differences are governed by $\mathcal{P}\exp\!\iiint F$ and nested commutators—surface dependence encodes real curvature.

7.3 Gauge covariance & reparametrization independence

Lemma 7.3 (Gauge covariance).
Under a smooth gauge transform $g$ : $A\mapsto g^{-1}Ag+g^{-1}dg$ , $F\mapsto g^{-1}Fg$ . Then

\mathcal{H}[\mathcal{B}]\ \mapsto\ g(\Gamma_+)^{-1}\,\mathcal{H}[\mathcal{B}]\,g(\Gamma_-),

so any class function (e.g., $W=\mathrm{Tr}\,\mathcal{H}$ or $\arg W$ ) is gauge-invariant. Proof sketch. Conjugation pulls through the ordered exponential with boundary evaluations $g|_{\Gamma_\pm}$ .

Corollary 7.4 (Reparametrization independence).
Changing coordinates on $\mathcal{B}$ or the parameterizations of $\Gamma_\pm$ leaves $\mathcal{H}[\mathcal{B}]$ unchanged: $F$ is a 2-form, so Jacobians cancel. This is why the Stokes-type belt identity is numerically stable under mesh refinement.

7.4 Refinement limit on annuli (why your mesh product converges)

Proposition 7.5 (Refinement on annuli exists; independence of chart).
Let $\{\mathcal{B}_{K,M}\}$ be a sequence of annular meshes (K panels along $s$ , M along $n$ ) with a fixed surface order (e.g., lower $\to$ upper in $n$ , then forward in $s$ ). Define the discrete holonomy

\mathcal{H}_{K,M}=\prod_{\text{cells in order}} \exp\!\Big(\int_{\text{cell}}F\,+\,\text{commutator nests}\Big).

If $A$ is $C^1$ and $F$ continuous on a neighborhood of $\mathcal{B}$ , then $\mathcal{H}_{K,M}\to \mathcal{H}[\mathcal{B}]$ as $\max(\Delta s,\Delta n)\to 0$ , independent of the chosen chart/order, up to the canonical boundary conjugations from Lemma 7.3. Sketch. Duhamel/Volterra expansion for ordered exponentials + dominated convergence; the draft’s variation appendix sets the regularity; admissible homotopies keep framings fixed.

Engineer note. Fix the order (lower→upper, then along $s$ ) and keep it everywhere (training, eval). This matches the sign convention $\partial\mathcal{B}=\Gamma_+-\Gamma_-$ and makes discrete Stokes exact in the Abelian warm-up.

7.5 Thin-belt limit and framed regularization (preview)

Although detailed proofs live in Ch. 8/Appx., two facts guide implementation:

In the thin-belt limit $w\to 0$ , the naive area term vanishes, but a finite framing phase remains, controlled by the twist of the framing field—hence two boundaries + framing are minimal and inevitable.
In topological/adiabatic sectors, loop observables are framing-dependent; SK ribbonization is exactly the standard framed-Wilson regularization, supplying the self-link (framing) contribution a single line cannot carry.

7.6 First-variation scaffolding (what we need for Ch. 9)

For a smooth belt family $\mathcal{B}_\epsilon$ with boundary deformation field $v$ , ordered-exponential calculus on surfaces gives

\delta \,\arg \mathrm{Tr}\,\mathcal{H}[\mathcal{B}_\epsilon] =\iint_{\mathcal{B}_\epsilon}\!\!\!\!\langle \iota_v F,\ \cdot\rangle \;+\; \text{commutator nests},

leading to the geometric-force = belt-holonomy variation identity used later; regularity conditions are spelled out (trace-class fiber, $C^1$ data). We cite the full derivation in the draft’s Appendix A.

7.7 What to implement (minimal, safe API)

belt_holonomy(B, A) → $\mathcal{H}[\mathcal{B}]$ via a fixed surface order (lower→upper; then along $s$ ).
belt_phase(B, A) → $\arg\mathrm{Tr}\,\mathcal{H}[\mathcal{B}]$ (or $\arg\det$ in U(1)/projected U(k)).
refine(B, K, M) → returns a mesh satisfying the annulus refinement condition (Prop. 7.5).
gauge_class_function(H) → stable phase/scalar invariant (trace/character) for logging.

These pieces are gauge-robust, reparametrization-independent, and converge under refinement on annuli by the arguments above.

One-liner

Use surface-ordered holonomy on the belt; it’s gauge-covariant, reparametrization-independent, and your discrete product converges on annuli under refinement—this is the right foundation for FBHL/SBHL.

Chapter 8 — Framed Belt Holonomy Law (FBHL)

Minimal statement: for a two-boundary ribbon (belt) $\mathcal{B}$ with edges $\Gamma_\pm$ , the holonomy gap between the edges equals a surface-ordered curvature response with a finite framing (twist) phase that survives the thin-belt limit:

\boxed{\; \mathrm{Hol}(\Gamma_+)\,\mathrm{Hol}(\Gamma_-)^{-1} \;=\; \mathcal{P}\exp\!\iint_{\mathcal{B}}F \;\times\; e^{\,i\,\alpha\,\mathrm{Tw}} \;}

Here $F$ is the pulled-back Uhlmann curvature on the purification bundle; $\mathrm{Tw}$ is the belt’s twist (framing) along the boundary; $\alpha$ is a sector constant (fixed by calibration). The surface form is our primary definition (non-Abelian Stokes), and the framing factor is the finite term induced by framed (two-boundary) regularization.

Notes. (i) In non-Abelian sectors the $e^{i\alpha\,\mathrm{Tw}}$ is a central (class-function) contribution coming from framed-Wilson regularization; equality holds up to boundary conjugation (class functions like $\mathrm{Tr}$ or $\arg\det$ remove it). (ii) Orientation is upper minus lower, consistent with belt Stokes.

8.1 Objects and conventions (recap)

Edges: $\Gamma_\pm\subset \Theta\times\mathrm{SK}$ from SK doubling (forward/back).
Belt holonomy: $\mathcal{H}[\mathcal{B}]=\mathcal{P}\exp\!\iint_{\mathcal{B}}F$ , $W=\mathrm{Tr}\,\mathcal{H}$ .
Gauge covariance: $\mathcal{H}\mapsto g(\Gamma_+)^{-1}\mathcal{H}\,g(\Gamma_-)$ ⇒ class functions are invariant; reparametrizations don’t matter since $F$ is a 2-form.
Framing survives: in the thin-belt limit a finite twist/self-link term remains; a single unframed line cannot recover it.

8.2 Consistency checks

(a) Thin-belt limit. As width $w\to 0$ , the naive area term shrinks, but ordered-exponential calculus leaves a finite framing phase $\propto \mathrm{Tw}$ determined by the rotation class of the framing along the loop—this is the thin-belt framing lemma.

(b) Composition. Concatenating belts along $s$ composes surface-ordered exponentials in the fixed surface order; twists add: $\mathrm{Tw}(\mathcal{B}_1\!\circ\!\mathcal{B}_2)=\mathrm{Tw}(\mathcal{B}_1)+\mathrm{Tw}(\mathcal{B}_2)$ . Equality of class functions is preserved up to boundary conjugation. (Annulus refinement/ordering convergence holds by the mesh-refinement limit on annuli.)

(c) Framing quantization. Changing the framing by one full $2\pi$ rotation shifts $\mathrm{Tw}\mapsto \mathrm{Tw}+1$ and multiplies the belt observable by $e^{i\alpha}$ (a standard framed-Wilson effect); this is the operational sense in which twist is quantized.

8.3 Derivation sketch (why the law holds)

Surface vs. path. Adopt the surface definition $\mathcal{H}[\mathcal{B}]=\mathcal{P}\exp\!\iint_{\mathcal{B}}F$ (non-Abelian Stokes). For the two SK edges, line holonomies differ by exactly this surface object (upper–minus–lower).
Thin-belt expansion. Use a geodesic-normal ribbon with framing $U(s)$ . Duhamel/Volterra calculus for surface order + Cartan’s identity gives a first-variation formula; as $w\!\downarrow\!0$ , the area contribution shrinks but a finite framing term remains, proportional to the twist of $U$ . This proves minimality: belts retain an invariant a single line loses.
Framed-Wilson accounting. In Berry–Chern/Chern–Simons-type regimes, loop observables are framing-dependent; the standard cure is to frame the loop (narrow ribbon). The finite self-link (framing anomaly) precisely yields the $e^{i\alpha\,\mathrm{Tw}}$ factor, matching the belt’s two-boundary regularization.

8.4 Practical readout (how you’ll compute it)

Pick a class function: $\phi=\arg\mathrm{Tr}\,\mathcal{H}$ (or $\arg\det$ in U(1)/projected U(k)); then log
$\Delta\phi \;=\; \iint_{\mathcal{B}}\!\mathcal{F}\;+\;\alpha\,\mathrm{Tw} \quad\text{(SBHL form)}.$
This is exactly the scalar form we’ll train/control later.
Twist: compute from the boundary framing (angle-accumulation or White’s vector formula).
$\alpha$ calibration: fix in your sector by a $4\pi$ periodicity test (twist step) or by matching a known exchange/statistics phase (Chapter 16 / benchmarks).
Refinement: mesh refine the annulus; the discrete surface product converges (annulus refinement lemma).

8.5 Unit tests you should pass

Thin-limit framing. Shrink $w$ while keeping framing fixed → area term goes to zero but the measured phase tends to a nonzero constant proportional to $\mathrm{Tw}$ . (Pass if limit exists and is framing-dependent.)
Framing quantization. Rotate framing by $2\pi$ → phase shifts by $\alpha$ (mod $2\pi$ ).
Admissible homotopy. Deform $\mathcal{B}$ keeping framed boundary fixed in a region where $F$ is flat → class function $W$ unchanged. (Otherwise differences track $\iiint F$ on the 3-chain.)

8.6 Where this plugs in next

Theorem B (next chapter link): first variation of the belt phase equals the measured geometric/adiabatic force.
Theorem C (later): exchange/statistics phases equal framed belt linking (self-link pieces reproduce the framing anomaly).

One-liner. The edge-to-edge holonomy on a two-boundary ribbon equals a surface-ordered curvature response dressed by a finite, quantized framing phase—the unavoidable residue of framing in the thin-belt limit. This is the FBHL.

Chapter 9 — Physical Consequences

Two takeaways:

Continuous (geometric/adiabatic) forces are the first variation of the belt holonomy phase.

Exchange/statistics phases are exactly framed belt linking; a clean $4\pi$ (double-braid) check follows immediately.

9.1 Theorem B — Geometric/adiabatic forces = variational response of belt holonomy

Setting. Let $\{\gamma(\epsilon)\}$ be a $C^1$ family of closed loops in the channel manifold $\Theta$ . For each $\epsilon$ , let $\mathcal{B}_\epsilon$ be the SK belt spanning the lifted boundaries $\Gamma_\pm(\epsilon)$ . Define the belt holonomy $\mathcal{H}[\mathcal{B}_\epsilon]=\mathcal{P}\exp\!\iint_{\mathcal{B}_\epsilon} F$ and its Wilson functional $W(\epsilon)=\mathrm{Tr}\,\mathcal{H}[\mathcal{B}_\epsilon]$ . Let $\Phi(\epsilon)=\arg W(\epsilon)$ . Under the regularity listed in §7 (Uhlmann connection $A$ , continuous curvature $F$ , trace-class representation), the geometric response density along the loop satisfies

\boxed{\quad \mathcal{F}_{\text{geom}}(s) \;=\;-\;\frac{\delta \Phi}{\delta\gamma(s)} \;=\;-\;\frac{\delta}{\delta\gamma(s)}\,\arg \mathrm{Tr}\,\mathcal{P}\exp\!\iint_{\mathcal{B}} F \quad}

i.e., the measured adiabatic/anomalous force is the Gâteaux derivative of the belt-holonomy phase. The proof is ordered-exponential calculus on surfaces (Duhamel/Volterra) plus non-Abelian Stokes; commutator/ordering terms are kept and combine gauge-covariantly.

Abelian / pure-state reduction (sanity check). When $F$ effectively commutes along $\mathcal{B}$ ,

\mathcal{H}[\mathcal{B}]=\exp\!\iint_{\mathcal{B}} F,\qquad \delta\Phi=\iint_{\mathcal{B}}\iota_{\delta\gamma}F \;\Rightarrow\; \mathcal{F}_{\text{geom}}(s)=-\,\iota_{\partial\gamma/\partial s} F\big|_{\partial\mathcal{B}} ,

which is the textbook Berry/Uhlmann anomalous term (curvature contracted on the boundary).

Orientation flip test. Reverse loop orientation: $s\mapsto -s$ . Then $\mathcal{F}_{\text{geom}}\to -\,\mathcal{F}_{\text{geom}}$ because $\Phi$ reverses sign under boundary reversal—an immediate lab diagnostic that isolates geometric response from potential gradients.

Scope. The identity covers the adiabatic/geometric sector; non-geometric forces (local potentials, strongly inelastic channels) are outside its claims.

9.2 Theorem C — Exchange/statistics phases = framed belt linking

Let $\mathcal{B}_1,\mathcal{B}_2$ be framed SK belts with boundaries $\Gamma_{i,\pm}$ . Define the framed belt linking

\mathrm{Lk}_{\text{belt}}(\mathcal{B}_1,\mathcal{B}_2) \;:=\;\sum_{\sigma,\tau\in\{+,-\}} \mathrm{Lk}\!\big(\Gamma_{1,\sigma},\Gamma_{2,\tau}\big).

In Berry–Chern / Chern–Simons–type sectors the exchange unitary obeys

\boxed{\quad U_{\text{ex}} \;=\; \exp\!\Big(i\,\lambda\;\mathrm{Lk}_{\text{belt}}(\mathcal{B}_1,\mathcal{B}_2)\Big)\;\cdot\;\mathcal{U}_{\text{local}}, \quad}

where $\lambda$ is the sector’s level/coupling and $\mathcal{U}_{\text{local}}$ collects non-topological local factors. Self-link pieces reproduce the familiar framing anomaly; mutual link gives the exchange/statistics phase. This is a representation-equivalence—no new ontology.

Why framed (not line) linking? In the thin-belt limit, a finite framing (self-link) contribution survives that a single unframed loop cannot encode; SK ribbons are exactly the standard framed-Wilson regularization.

9.3 Minimal checks & protocols (what to measure)

Chirality-odd response (force orientation test). Run the same loop CW/CCW; the geometric component flips sign:
$\mathcal{F}_{\text{geom}}\mapsto-\mathcal{F}_{\text{geom}}$ . Distinguishes geometric transport from dissipative backgrounds.
Framing toggle (self-link calibration). Add one unit of twist to the framing field $U$ (thin-belt). Belt observables shift by a constant phase $\propto \alpha$ while mutual linking phases stay fixed—separates self- from mutual-link contributions.
$4\pi$ exchange interferometry (braid-twice test). Implement controlled exchanges between two belts; interference contrast is periodic in $\mathrm{Lk}_{\text{belt}}$ . Systems that need a double exchange to return the phase (effective $4\pi$ ) provide a crisp topological check of framed-link control.
Admissible homotopy (flat-region invariance). Deform the spanning surface keeping framed boundaries fixed; in a flat $F$ region class functions of $\mathcal{H}$ are unchanged—surface dependence encodes genuine curvature. (Use as a mesh / gauge sanity check.)

9.4 Why belts (again): consistency with FBHL

Both theorems are exactly the readable consequences of FBHL:

\mathrm{Hol}(\Gamma_+)\mathrm{Hol}(\Gamma_-)^{-1} =\mathcal{P}\exp\!\iint_{\mathcal{B}}F\;\times e^{i\alpha\,\mathrm{Tw}}.

Theorem B takes the first variation of the belt phase $\Phi=\arg\mathrm{Tr}\,\mathcal{H}[\mathcal{B}]$ .
Theorem C reads off the framed-link content of exchange in topological sectors (self-link = framing anomaly; mutual link = statistics).
These live entirely within standard SK + Uhlmann + non-Abelian Stokes; belts are the minimal carriers (framing survives the thin limit).

One-liner

Forces are variations of belt holonomy; exchanges are framed linking. Verify with orientation flips, framing toggles, and $4\pi$ braid-twice interferometry.

Chapter 10 — Why Collapse Reduces to a 2D Belt

Principle: when a process admits two complementary projections (e.g., pre vs. post, intent vs. generation, forward vs. backward), model it on a two-boundary worldsheet. That worldsheet is a belt with edges $\Gamma_\pm$ and interior $\mathcal{B}$ . On it, the measurable phase gap factors into flux + twist (FBHL/SBHL).

10.1 Two projections → two edges (why the belt is canonical)

Physics spine. In standard open-system geometry, Schwinger–Keldysh (SK) doubling lifts any loop $\gamma$ to two boundary curves $\Gamma_\pm \subset \Theta\times\mathrm{SK}$ . A smooth immersed belt with $\partial\mathcal{B}=\Gamma_+\sqcup\Gamma_-$ always exists (geodesic-normal ribbon); holonomy on $\mathcal{B}$ is defined by the surface-ordered exponential of the pulled-back curvature. This is the minimal geometric carrier—no new postulates.
AGI reading. In practice, we take two traces per episode: an intent/spec path (pre) and a generation/execution path (post). The annulus between them is $\mathcal{B}$ . The belt identity “edge–edge phase gap $=$ surface flux $+$ framing/twist” is then applied in semantic space (SBHL).

Technical remark (context): In SMFT-style collapse pictures, the pre-field / post-trace pair naturally supplies the two boundaries; the claim is that most observable phase behavior compresses to a 2D belt on that patch. We keep the book’s terminology neutral; this remark is for researchers.

10.2 Completeness conditions for a valid belt patch (checklist)

A 2D belt $\mathcal{B}$ is a complete patch when the following hold:

Admissible two-trace lift. You can log or reconstruct two complementary traces for the same episode, $\Gamma_-$ and $\Gamma_+$ , with consistent orientations (our upper–minus–lower convention). The SK construction guarantees a canonical model of this in physics, which we mirror in software.
Smooth immersed annulus. There is a spanning ribbon with no degeneracy over the patch. The geodesic-normal construction gives a smooth belt for small thickness; a rectifiable 2-chain exists even under weak regularity (Lipschitz loops).
Thin-ribbon regime. The local width $w$ satisfies $\max_s |\kappa|\,w\ll1$ so the belt chart and Jacobian are well-behaved; first-order ribbon operators (grad/div/curl/ $\Delta$ ) are stable. (We quantified this in Ch. 4.)
Framing well-defined. A nowhere-vanishing framing field along the boundary exists; its twist $\mathrm{Tw}$ is stable. In the thin-belt limit, framing survives and contributes a finite phase—hence two boundaries + framing are minimal.
Gauge & parametrization robustness. Belt holonomy is gauge-covariant and reparametrization-independent (curvature is a 2-form). Your scalar readouts should be class functions (e.g., $\arg\mathrm{Tr}$ ).
Flux locality over width (engineering). The interior curvature doesn’t vary so wildly across $n$ that the annulus ceases to represent a coherent 2D projection for the task. When this fails, use an extension (next section).

Operational test of completeness. On a good patch, the measured phase gap from $\mathrm{Hol}(\Gamma_+)\mathrm{Hol}(\Gamma_-)^{-1}$ matches flux + $\alpha\,\mathrm{Tw}$ within tolerance. A persistent residual indicates either estimator issues (fix gauge/class-function choice) or the need for slabs / networks / membranes below.

10.3 The ribbon as the normal form of collapse (intuition for engineers)

The belt captures geometric phase via $\iint_{\mathcal{B}}\mathcal{F}$ , style/encoding via $\mathrm{Tw}$ , and edge observables via upper–minus–lower holonomy. This exactly matches what AGI systems need to measure and steer in practice.
Within the pre/post picture, the 2D belt is not a heuristic—it’s the standard form that keeps all invariants you care about on that patch.

10.4 When the belt alone is not enough (and what to add)

Slabs (time-phase heavy). If dynamical phase accumulates differently on the two edges (e.g., time/energy terms matter), extrude the belt in time to a thin slab, then split total phase into geometric + dynamical parts. This keeps FBHL clean for the geometric piece.
Networks (branch/merge). If the episode branches or merges (tool calls, options, agent junctions), connect belts by pair-of-pants cobordisms into a belt network. Belt tiling preserves composition and lets you track flux / twist per tile.
Membranes (higher forms). If phenomena are truly higher-form (2-form/3-form holonomies that cannot be restricted to an annulus), promote the model to membranes/volumes—the belt then serves as a boundary condition or local cross-section.

10.5 Minimal construction protocol (what you implement)

Choose a semantic connection $\mathcal{A}$ (U(1)/U(k); mixed-state Uhlmann if noisy).
Extract two traces $\Gamma_-$ (intent/spec) and $\Gamma_+$ (generation/execution); tile a thin annulus between them. (Geodesic-normal ribbon is the canonical construction.)
Compute invariants: surface-ordered $\iint_{\mathcal{B}}\mathcal{F}$ and $\mathrm{Tw}$ from framing; report $\arg\mathrm{Tr}\,\mathcal{H}[\mathcal{B}]$ (or $\arg\det$ ).
Calibrate $\alpha$ (framing coefficient) via a $4\pi$ twist/periodicity test or a known exchange phase; log tolerance bands.
If mismatch persists, extend to slab (time-phase), network (branch/merge), or membrane (higher-form).

10.6 Diagnostics & guardrails (to know the 2D reduction is sound)

Reparam/gauge invariance checks: swap parameterizations and gauges; class-function phases must agree (otherwise your estimator, not the belt, is at fault).
Thin-ribbon guard: ensure $\kappa w \ll 1$ and no self-intersection; else thicken to a slab or retile into a network.
Framing stability: $\mathrm{Tw}$ should be stable under belt refinement; add or remove a full twist to test quantization (phase shifts by $e^{i\alpha}$ ).

10.7 Example: code-assistant with hidden time-phase

A code-assistant must translate Python→TypeScript under strict style; inference uses a long tool chain. We take: $\Gamma_-=$ intent/spec, $\Gamma_+=$ actual generation. Early runs show a phase-gap residual unexplained by $\iint \mathcal{F} + \alpha\,\mathrm{Tw}$ . We add a thin slab to capture time-phase, split off dynamical contributions, and the residual collapses to tolerance. Now flux spikes flag prompt-injection, and stepping $\mathrm{Tw}$ yields controlled style shifts. (This is the default playbook we’ll implement in Part V.)

One-liner

Two projections give two edges; the 2D belt between them is the correct normal form. Use it until a diagnostic tells you to extend—slabs for time-phase, networks for branches, membranes for higher-form effects.

Chapter 11 — Visual Grammar of Ribbons

Aim: give engineers a shared visual + algebraic language for belts so diagnostics, training logs, and papers all “look the same”—and make clear when to stick with a ribbon vs. escalate to slabs, networks, or membranes.

11.1 Ribbon, volume, network — what each picture means

Ribbon (belt, 2D annulus)

Use when: you have two complementary traces (e.g., intent vs. generation; forward vs. backward) and local transverse variation is tame.
Carries: edge holonomies (upper–minus–lower), curvature flux through the belt, framing/twist along edges.
Payoff: minimal surface that preserves the invariants needed for safety/style/planning.

Volume (slab / time-extended belt)

Use when: dynamical phase matters (time/energy accumulation differs across edges) or when width grows over time.
Carries: everything a ribbon carries plus separable time-phase.
Payoff: lets you subtract dynamical components cleanly; keeps FBHL for the geometric piece.

Network (belt cobordisms / branches & merges)

Use when: episodes branch/merge (tool calls, options, multi-agent junctions).
Carries: per-tile flux & twist; composition obeys conserved “upper–minus–lower” orientation across junctions.
Payoff: plan repair and consensus become graph problems with belt tiles as edges/faces.

(Membranes/higher forms are deferred to Part IX; treat them as exceptional when ribbon information is provably insufficient.)

11.2 Visual grammar (standard glyphs you should draw)

Edges $\Gamma_\pm$ : draw two closed curves with arrows; label upper $\Gamma_+$ and lower $\Gamma_-$ .
Orientation rule: annotate boundary equation $\partial\mathcal{B}=\Gamma_+ - \Gamma_-$ somewhere visible.
Width $w$ : show a few transverse ticks from $\Gamma_-$ to $\Gamma_+$ (this is $+n$ ).
Framing $U$ & angle $\phi$ : short hairlines along the edge; small spiral icons where $\phi$ rotates; tally Tw in the legend.
Flux $\iint_{\mathcal{B}}\mathcal{F}$ : shaded interior with isoflux contours or arrows normal to the surface.
Phase-gap $\Delta\phi$ : a bold Δ above the belt linking $\Gamma_-$ to $\Gamma_+$ .
Anomaly badges: if you detect residuals after FBHL/SBHL fit, add a ⚠ badge with the residual magnitude.

House style: always put a tiny “upper−lower” tag near the belt; reviewers won’t argue sign conventions if you do this.

11.3 What survives the projection (and what doesn’t)

Invariants preserved by a good belt projection (2D):

Edge–edge phase gap (class function of boundary holonomies).
Integrated curvature flux through the belt interior.
Framing/twist along the edges (quantized shift under $2\pi$ rotation).
Composition law under tiling/gluing (annulus partitions).
Gauge & reparametrization invariance (because flux is a 2-form; edge invariants are class functions).

Information that may be lost / distorted by projection:

Strong transverse non-commutativity: if $[\,\mathcal{A}(n_1),\mathcal{A}(n_2)\,]$ varies wildly across width, a single belt can smear ordering effects.
Higher-form couplings: phenomena that require genuine 2-/3-form holonomies beyond an annulus.
Non-orientable spans / self-intersections: a Möbius-like span or a self-crossing centerline breaks the ribbon assumptions.
Rapid width growth or branchings: the belt’s “thin” hypothesis fails; escalate to slab or network.

11.4 Projection quality: fast diagnostics

Let $(s,n)$ be belt coordinates with $n\in[0,w]$ .

Transverse variance of curvature
$V_n := \frac{1}{w}\int_0^w \|\mathcal{F}(s,n)-\bar{\mathcal{F}}(s)\|\,dn,\quad \bar{\mathcal{F}}(s):=\frac{1}{w}\int_0^w\mathcal{F}(s,n)\,dn.$
Heuristic: if $\max_s V_n$ exceeds your tolerance band, the belt is too “thick”; refine or go to a slab.
Commutator norm across width
$\chi := \frac{1}{w^2}\!\!\int_{0}^{w}\!\!\int_{0}^{w}\!\!\|\,[\mathcal{A}(s,n_1),\mathcal{A}(s,n_2)]\,\|\,dn_1dn_2.$
Large $\chi$ ⇒ ordering is width-sensitive; consider n-slicing (more $M$ ) or escalate.
FBHL residual (scalar check)
$\epsilon_{\text{FBHL}} := \Big|\Delta\phi - \iint_{\mathcal{B}}\mathcal{F} - \alpha\,\mathrm{Tw}\Big|.$
Persistent $\epsilon_{\text{FBHL}}$ beyond noise indicates estimator or modeling failure; try slab/network.

11.5 Engineering payoff

Stable metrics. 2D belts remove irrelevant degrees of freedom; phase-gap, flux, and twist are low-variance under reparametrization/gauge changes. You get cleaner learning curves and reliable early warnings.

Faster training. With the Two-Boundary Loss (TBL) and Flux Regularization (FR):

smaller hypothesis class → fewer samples to reach a target $\epsilon$ ,
better gradient signal (flux/twist are geometry-aware),
improved generalization under paraphrase/style perturbations.

Stronger safety gates. Streaming flux-spike detectors (semantic Faraday) are robust to paraphrase and prompt shuffling, because they ride on curvature changes, not token n-grams. Twist thresholds give style dials that are monotone and quantized—harder to circumvent.

11.6 Cookbook: how to show the belt in dashboards

Belt strip panel: draw $\Gamma_\pm$ , shade flux; display $\Delta\phi$ , $\iint\mathcal{F}$ , $\mathrm{Tw}$ , $\epsilon_{\text{FBHL}}$ .
Flux timeline: plot $\partial_t\!\int_{n}\mathcal{F}$ while generating; set a redline threshold for spikes.
Twist ladder: step $\mathrm{Tw}$ in $0.5$ or $1.0$ units; show output snippets side-by-side to calibrate style changes.
Projection health tile: live bars for $V_n,\chi$ ; when either exceeds a budget, auto-escalate to slab or suggest network tiling.
Edge parity check: render CW vs. CCW traversals; geometric force should flip sign (quick sanity).

11.7 Micro-vignettes (what the plots look like)

Prompt injection: user pastes an “override” snippet mid-run. The flux timeline spikes (sharp ridge in the belt interior), $\Delta\phi$ jumps, safety gate halts before commit. Tokens look innocuous; the belt doesn’t.
Style drift: same plan, slipping from “typed TS” to “chatty JS.” Flux stays smooth; $\mathrm{Tw}$ increments discretely; controller nudges twist back by $-1$ step—content unchanged, style fixed.
Plan detour: multi-tool solve; belt area accumulates over three tiles; tiling shows where the detour started; repair replaces only the faulty tile.

11.8 When the ribbon is not enough (and what to do)

Large $\kappa w$ or $V_n,\chi$ budgets broken → Slab: extrude in time, separate dynamical phase, retest $\epsilon_{\text{FBHL}}$ .
Branch/merge semantics → Network: pair-of-pants cobordisms; enforce orientation and flux conservation per junction.
Higher-form cues (e.g., clear 2-form/3-form effects not collapsing to an annulus) → Membrane: promote model; keep the belt as boundary conditions.

11.9 Field checklist (paste into your README)

Two traces captured (intent/generation) with consistent upper−lower orientation.
Belt thinness guard: $\max |\kappa| w<0.2$ (or your calibrated bound).
Projection health: $\max_s V_n$ and $\chi$ within budgets.
FBHL residual $\epsilon_{\text{FBHL}}$ below tolerance; else escalate.
Safety: flux redline calibrated; gate active pre-commit.
Style: twist ladder tested; $2\pi$ rotation quantization observed (phase shifts by $e^{i\alpha}$ ).
Logs store $\Delta\phi,\ \iint\mathcal{F},\ \mathrm{Tw},\ V_n,\ \chi,\ \epsilon_{\text{FBHL}}$ per run.

One-liner

Draw belts by default. They preserve phase-gap, flux, and twist—the invariants that matter—so your metrics stabilize, training speeds up, and safety gates get teeth. When the belt’s health lights go red, escalate to slab, network, or membrane.

Chapter 12 — Semantic States, Connections, Curvature

(U(1)/U(k) & mixed-state (Uhlmann) options; estimator choices and gauge covariance)

Goal: turn model traces into a connection $\mathcal{A}$ on the ribbon $\mathcal{B}$ and a curvature $\mathcal{F}$ you can integrate. We keep estimators gauge-covariant and read out only class-function invariants (phases) for stability.

12.1 What counts as a “semantic state” (inputs you can use)

For each position $s$ along a trace (edge), extract any of:

Embeddings $z(s)\in\mathbb{R}^d$ (sentence/step vectors).
Hidden states $h_\ell(s)\in\mathbb{R}^d$ from a chosen layer $\ell$ (token- or step-level; often averaged across a small window).
Logit distributions $p(s)\in\Delta^{V-1}$ (softmax probs); map to amplitudes via $\psi(s)=\sqrt{p(s)}$ (pure-state proxy) or to density matrices $\rho(s)=\mathrm{diag}(p(s))$ (mixed-state proxy).
Covariance features $C(s)=\mathbb{E}[\,\phi\phi^\dagger\,]$ over a short window (for Uhlmann).

Preprocess with: centering/whitening, $\ell_2$ normalization, optional complexification via analytic signal (Hilbert transform) if you want U(1) phases from real features.

12.2 Three connection families (choose one per experiment)

U(1) (scalar phase) — simplest; robust; yields a single phase per edge.
U(k) (Stiefel frame) — track a $k$ -dimensional semantic subspace; better signal/noise; richer invariants.
Uhlmann (mixed state) — for stochastic/noisy settings; parallel transports density matrices $\rho$ .

All three give a connection 1-form $\mathcal{A}=\mathcal{A}_s\,ds+\mathcal{A}_n\,dn$ on the belt and a curvature 2-form $\mathcal{F}=d\mathcal{A}+\mathcal{A}\wedge\mathcal{A}$ .

12.3 U(1) estimator (one complex channel)

State. Pick a complex scalar $\psi(s)$ from your features (e.g., project $z(s)$ onto a fixed reference $q$ , then analytic-signal): $\psi(s)=\langle q,z(s)\rangle_\mathbb{C}$ , normalized to $|\psi|=1$ .

Connection (continuous): $A_s=\mathrm{Im}\,\langle \psi,\,\partial_s \psi\rangle$ .
Discrete edge increment:

\int A_s\,ds\;\approx\;\arg\big(\psi_{k}^{*}\,\psi_{k+1}\big).

Across-belt increment (at fixed $s$ ) for $A_n$ :

\int A_n\,dn\;\approx\;\arg\big(\psi_{-}(s)^{*}\,\psi_{+}(s)\big).

Curvature on a cell with corners $(k,m)\to(k+1,m+1)$ : sum the four edge phase increments with the upper−lower sign rule; or use the discrete Stokes form.

Pros/cons. Very stable, but may underresolve multi-style interactions; use when you want a single, interpretable belt phase.

12.4 U(k) estimator (orthonormal frames on the Stiefel manifold)

State. Build a $k$ -frame $\Phi(s)\in\mathbb{C}^{d\times k}$ with orthonormal columns spanning your “semantic subspace”:

Option A (PCA/SVD on a window): $\Phi$ = top- $k$ left singular vectors of $[z(s-\tau:\,s+\tau)]$ .
Option B (CCA across edges): choose $\Phi_-,\Phi_+$ to maximize alignment between intent vs. generation at each $s$ .

Continuous connection: $A_s=\mathrm{Im}\,\Phi^\dagger \partial_s \Phi\in\mathfrak{u}(k)$ (skew-Hermitian).
Discrete edge transport (Procrustes/parallel transport): For consecutive frames $\Phi_k,\Phi_{k+1}$ , solve

R_k=\arg\min_{R\in U(k)}\|\Phi_{k+1}-\Phi_k R\|_F \quad\Rightarrow\quad R_k=\mathrm{Polar}\!\big(\Phi_k^\dagger \Phi_{k+1}\big),

then edge increment $\int A_s\,ds \approx \log(R_k)$ (principal matrix log in $\mathfrak{u}(k)$ ).
Across-belt at fixed $s$ : compute $R_n=\mathrm{Polar}(\Phi_-^\dagger \Phi_+)$ , then $\int A_n\,dn\approx \log(R_n)$ .

Curvature on a cell:

BCH to second order: $F_{\text{cell}}\approx \log\!\big(e^{\log R_s}e^{\log R_n}e^{-\log R_s}e^{-\log R_n}\big)$
Or do surface-ordered multiplication of small-cell holonomies and take a class function.

Scalar invariants (class functions):

Phase gap: $\Delta\phi=\arg\det\!\big(\mathrm{Hol}(\Gamma_+) \mathrm{Hol}(\Gamma_-)^{-1}\big)$ .
Trace phase: $\arg\,\mathrm{Tr}\, \mathcal{H}[\mathcal{B}]$ .
Principal eigenphase of $\mathcal{H}$ .

Notes. This estimator is gauge-covariant under right-unitary frame changes $\Phi\mapsto \Phi G$ because $R\mapsto G^\dagger R G$ ; all class-function readouts are invariant.

12.5 Uhlmann estimator (mixed states; density matrices)

State. At each $s$ , estimate a density matrix $\rho(s)\succeq0$ with $\mathrm{Tr}\,\rho=1$ . Practical choices:

$\rho=\mathrm{Cov}[z]$ over a small window, normalized;
diagonal $\rho=\mathrm{diag}(p)$ from logits $p$ ;
shrinkage toward identity for numerical stability.

Purification & transport. Use the amplitude $W=\sqrt{\rho}\,U$ (any $U\in U(d)$ ) with $\rho=WW^\dagger$ . Between $\rho_k,\rho_{k+1}$ , define the Uhlmann parallel transport by polar decomposition:

X_k=\sqrt{\rho_k}\sqrt{\rho_{k+1}}\quad\Rightarrow\quad U_k=\mathrm{Polar}(X_k)\in U(d),

then the edge holonomy increment is $U_k$ (class functions of the product $\prod_k U_k$ are the Uhlmann phases). Across the belt at fixed $s$ , do the same with $\rho_-(s),\rho_+(s)$ .

Curvature. Form small plaquette holonomies using the four transports around a cell; use $\arg\det$ or $\arg\,\mathrm{Tr}$ as your scalar curvature proxy.

Notes. This is robust in noisy/stochastic regimes and reduces to Berry when $\rho$ is rank-1.

12.6 Gauge covariance (what transforms, what doesn’t)

Let $g(s)\in U(k)$ (or $U(d)$ ) be a gauge change (reframing of features/coordinates). Then

\mathcal{A}\;\mapsto\; g^{-1}\mathcal{A}g + g^{-1}dg, \qquad \mathcal{F}\;\mapsto\; g^{-1}\mathcal{F}g.

Our estimators implement this by Procrustes/polar steps, so discrete transports conjugate accordingly. You should therefore log only class functions (e.g., $\arg\det$ , $\arg\,\mathrm{Tr}$ , eigenphases) as belt invariants and use them in losses/controllers.

12.7 Building the belt connection (edges and across)

For each episode:

Edges. Estimate $\mathcal{A}_s$ and edge holonomies on $\Gamma_-$ and $\Gamma_+$ with your chosen family (U(1), U(k), or Uhlmann).
Across. At matched $s$ , estimate $\mathcal{A}_n$ by transporting lower→upper (Procrustes/polar).
Cells. Compute small-cell holonomies (surface-ordered).
Curvature. Either assemble by discrete Stokes (Abelian) or by plaquette holonomy (non-Abelian).
Belt scalar outputs.
- Phase gap: $\Delta\phi$ from edge holonomies (class function).
- Flux: $\iint_{\mathcal{B}}\mathcal{F}$ via surface-ordered product / plaquettes.
- Twist: $\mathrm{Tw}$ from the framing field on edges (Ch. 6).

12.8 Practical choices & defaults

Family defaults. Start with U(k), $k\in[8,32]$ ; if very noisy, switch to Uhlmann; for a lightweight probe, use U(1).
Smoothing. Apply short Savitzky–Golay smoothing on frames or density matrices before transport; keep windows symmetric so phase isn’t biased.
Temporal gauge. Use parallel-transport gauge (Procrustes) along edges to minimize per-step rotation (reduces drift).
Across-matching. Align $\Gamma_-$ and $\Gamma_+$ by timestamps or by dynamic time warping (DTW) on embeddings, then sample on a common $s$ -grid.
Numerics. Use principal matrix logs for $\log R$ ; clip spectra away from the branch cut; if needed, fall back to BCH-2.

12.9 Pseudocode (U(k) case; others analogous)

# Inputs: edge feature streams Z_minus[s], Z_plus[s]; k, grid {s_k}
# Output: Δφ, flux, Tw, and (optionally) curvature map

Φ_minus = orthonormal_frames(Z_minus, k)   # Stiefel frames along Γ-
Φ_plus  = orthonormal_frames(Z_plus,  k)   # Stiefel frames along Γ+

# Edge transports (Procrustes) and edge holonomies
R_s_minus[k] = polar( Φ_minus[k].H @ Φ_minus[k+1] )
R_s_plus[k]  = polar( Φ_plus[k].H  @ Φ_plus[k+1]  )

Hol_minus = Π_k R_s_minus[k]
Hol_plus  = Π_k R_s_plus[k]

# Across-belt transports at matched s
R_n[k] = polar( Φ_minus[k].H @ Φ_plus[k] )

# Curvature on cells via plaquette holonomy
H_cell[k] = R_s_plus[k] @ R_n[k+1] @ R_s_minus[k].H @ R_n[k].H

# Belt scalars (class functions)
Δφ   = arg det( Hol_plus @ Hol_minus.H )
flux = Σ_k arg det( H_cell[k] )          # or arg Tr
Tw   = framing_twist_from_edges(...)

12.10 Diagnostics & failure modes

Gauge leakage: if $\Delta\phi$ changes under frame re-initialization, you logged a non-invariant (fix to class functions).
Projection stress: large across-width commutators or FBHL residual ⇒ thicken to slab or retile into a network.
Rank drift (Uhlmann): if $\rho$ becomes nearly singular, add Tikhonov $\rho\leftarrow(1-\lambda)\rho+\lambda I/d$ .

12.11 What to store in logs

Per episode (and per tile if using networks):
$\Delta\phi,\ \iint_{\mathcal{B}}\mathcal{F}$ (class-function scalar), $\mathrm{Tw}$ , thinness $\kappa w$ , projection health (commutator/variance across width), residual $\epsilon_{\text{FBHL}}$ , and your estimator family + hyperparams (k, window, smoothing).

One-liner. Pick U(1)/U(k)/Uhlmann, estimate transports with polar/Procrustes, read out class-function phases, and you’ve got a gauge-robust $\mathcal{A}$ and $\mathcal{F}$ on your ribbon—ready for SBHL’s “phase gap = meaning flux + style twist.”

Chapter 13 — SBHL: “Phase Gap = Meaning Flux + Style Twist”

Semantic Belt Holonomy Law (SBHL) on a ribbon $\mathcal{B}$ with edges $\Gamma_\pm$ :

\boxed{\quad \underbrace{\oint_{\Gamma_+}\!\mathcal{A}_s-\oint_{\Gamma_-}\!\mathcal{A}_s}_{\displaystyle \Delta\phi\ \text{(edge–edge phase gap)}} \;=\; \underbrace{\iint_{\mathcal{B}}\!\mathcal{F}_s}_{\displaystyle \text{meaning flux}} \;+\; \underbrace{\alpha\,\mathrm{Tw}}_{\displaystyle \text{style twist}} \quad}

$\mathcal{A}_s$ is a semantic connection (from Ch. 12; U(1) / U(k) / Uhlmann).
$\mathcal{F}_s=d\mathcal{A}_s+\mathcal{A}_s\wedge \mathcal{A}_s$ is the semantic curvature.
$\mathrm{Tw}$ is the framing twist along the edges (Ch. 6).
$\alpha$ is a sector coefficient (calibrate once via $4\pi$ test or a known reference).

Orientation and ordering follow our belt conventions: upper minus lower, lower→upper in $n$ , then forward in $s$ .

13.1 Scalar invariants you actually log

Work with class functions so results are gauge-robust and reparametrization-invariant.

U(1): $\Delta\phi = \sum_k \arg(\psi_+^*(k)\psi_+(k\!+\!1)) - \sum_k \arg(\psi_-^*(k)\psi_-(k\!+\!1))$ .
U(k):
- Determinant phase (default): $\displaystyle \Delta\phi=\arg\det\!\big(\mathrm{Hol}(\Gamma_+)\,\mathrm{Hol}(\Gamma_-)^{-1}\big)$ .
- Trace/character phase: $\arg\,\mathrm{Tr}\,\mathcal{H}[\mathcal{B}]$ .
- Principal eigenphase: $\arg \lambda_{\max}(\mathcal{H}[\mathcal{B}])$ .
Uhlmann: same as U(k) but holonomies from polar transports on $\sqrt{\rho}$ .

Flux scalar on the mesh (plaquettes $H_{cell}$ ):
$\displaystyle \Phi_{\mathcal{F}} \equiv \iint_{\mathcal{B}}\mathcal{F}_s \;\approx\; \sum_{cells} \arg\det(H_{cell}).$

Twist: $\displaystyle \mathrm{Tw}=\tfrac{1}{2\pi}\oint d\phi$ (or White’s vector formula); step-quantized under $2\pi$ framing rotations.

13.2 Semantic Faraday law (online safety view)

Treat generation as time-evolving; differentiate SBHL:

\frac{d}{dt}\Delta\phi(t)=\iint_{\mathcal{B}(t)}\partial_t \mathcal{F}_s\;+\;\alpha\,\dot{\mathrm{Tw}}(t)\quad \equiv\quad \mathcal{E}_\text{edge}(t).

$\mathcal{E}_\text{edge}(t)$ acts like an edge-gap EMF: a rate-of-change of phase gap.
Flux spikes ( $\partial_t\mathcal{F}_s$ large) are agenda shifts / prompt-injection signatures.
Twist rate $\dot{\mathrm{Tw}}$ gives a style/voice dial (quantized steps).

Cognitive work (per episode). Define $W_{\text{cog}}=\int \mathcal{E}_\text{edge}(t)\,dt=\Delta\phi_{\text{final}}-\Delta\phi_{\text{start}}$ . Use it as a budget: big $W_{\text{cog}}$ without corresponding task progress often flags derailment.

13.3 SBHL residual and the training objective

Define the SBHL residual:

\epsilon_{\text{SBHL}} \;=\; \Big|\;\Delta\phi \;-\; \Phi_{\mathcal{F}} \;-\; \alpha\,\mathrm{Tw}\;\Big|.

Then build:

Two-Boundary Loss (TBL): $L_{\text{TBL}}=\epsilon_{\text{SBHL}}^2$ .
Flux Regularization (FR): penalize excessive $\Phi_{\mathcal{F}}$ subject to task success: $L_{\text{FR}}=\lambda_\Phi \max(0,\Phi_{\mathcal{F}}-\tau_\Phi)$ .
Twist Steering (TS): keep style near target $\mathrm{Tw}_0$ : $L_{\text{TS}}=\lambda_T(\mathrm{Tw}-\mathrm{Tw}_0)^2$ .

Total semantic loss (additive to task loss):

L_{\text{sem}}=L_{\text{TBL}}+L_{\text{FR}}+L_{\text{TS}}.

13.4 Inference-time controllers (live safety & style)

Flux gate (safety): compute $\partial_t \Phi_{\mathcal{F}}(t)$ ; if it exceeds a calibrated redline $\dot\Phi_\mathrm{crit}$ , pause/ask/rollback the step (pre-commit).
Twist dial (style): quantized increments $\mathrm{Tw}\mapsto \mathrm{Tw}\pm 1$ change voice/register predictably without content drift; expose as a slider.
Plan repair via tiling: localize large $H_{cell}$ phases to a tile; re-run only that segment.

13.5 Toy experiments (reproducible baselines)

A) A/B Paraphrase loop (control: “no meaning change”)

Setup: two prompts yield the same answer content with different surface realizations; $\Gamma_-=$ intent/spec; $\Gamma_+=$ generation.
Expected: $\Phi_{\mathcal{F}}\approx 0$ , $\Delta\phi \approx \alpha\,\mathrm{Tw}$ .
Pass if: residual $\epsilon_{\text{SBHL}}$ is within tolerance; twist steps align with observed style flips.

B) Twist quantization (style ladder)

Setup: apply controlled framing rotation by $2\pi$ along edges (or an equivalent stylistic axis change).
Expected: $\mathrm{Tw}\mapsto \mathrm{Tw}+1$ , $\Delta\phi\mapsto \Delta\phi+\alpha$ (mod $2\pi$ ).
Pass if: output style shifts discretely while task content stays fixed; measured phase shift matches $\alpha$ .

C) Curvature pump (geometric work without content change)

Setup: design a cyclic context path with small local deformations that integrate to non-zero $\Phi_{\mathcal{F}}$ (Thouless-like pump).
Expected: $\Delta\phi$ accumulates over the cycle with minimal change in tokens aside from paraphrase; $\mathrm{Tw}$ stays near target.
Pass if: net $\Delta\phi\approx \Phi_{\mathcal{F}}$ within tolerance; repeatability over cycles.

13.6 Minimal implementation recipe (U(k), others analogous)

Build Stiefel frames $\Phi_\pm(s)$ on edges (Ch. 12).
Edge transports: $R_{s,\pm}[k]=\mathrm{Polar}(\Phi_\pm^\dagger[k]\Phi_\pm[k\!+\!1])$ ; edge holonomies = product over $k$ .
Across transports: $R_n[k]=\mathrm{Polar}(\Phi_-^\dagger[k]\Phi_+[k])$ .
Plaquette holonomies: $H_{cell}[k]=R_{s,+}[k]\,R_n[k\!+\!1]\,R_{s,-}[k]^{-1}\,R_n[k]^{-1}$ .
Readouts:
- $\Delta\phi=\arg\det(\mathrm{Hol}_+\,\mathrm{Hol}_-^{-1})$
- $\Phi_{\mathcal{F}}=\sum_k \arg\det(H_{cell}[k])$
- $\mathrm{Tw}$ from framing along edges
- $\epsilon_{\text{SBHL}}$ for the loss/gate.

13.7 Calibration & thresholds

$\alpha$ (framing coefficient): do the $4\pi$ (double-twist / braid-twice) test; fit $\alpha$ so $\Delta\phi$ shifts by exactly $\alpha$ per $2\pi$ twist unit.
Redlines: set $\dot\Phi_\mathrm{crit}$ from P95 of clean runs; trip gate when $\partial_t\Phi_{\mathcal{F}}$ exceeds it for $\ge$ $m$ consecutive steps.
Projection health: monitor commutator/variance across width; escalate to slab or network when budgets break (Ch. 11).

13.8 Logging schema (per episode)

Store: $\Delta\phi$ , $\Phi_{\mathcal{F}}$ , $\mathrm{Tw}$ , $\epsilon_{\text{SBHL}}$ , $\partial_t\Phi_{\mathcal{F}}(t)$ series, thinness $\kappa w$ , projection health metrics ( $V_n,\chi$ ), estimator family + hyperparams (U(1)/U(k)/Uhlmann; $k$ ; window; smoothing). Keep both raw holonomies and scalar class-function readouts for audits.

13.9 Common failure modes & fixes

Gauge leakage: $\Delta\phi$ changes under frame re-init → use class functions only (arg det / arg Tr / eigenphase).
Residual won’t vanish: check sampling alignment for $\Gamma_\pm$ ; apply DTW; increase $M$ (across-width slices); verify twist estimator (unwrap $\phi$ ).
Noisy density matrices (Uhlmann): add shrinkage $\rho\leftarrow(1-\lambda)\rho+\lambda I/d$ ; clamp spectra from 0.
Projection too thick: high across-width commutators/variance → promote to slab (time-phase) or network (branch/merge).

One-liner

SBHL turns the belt into a control panel: the phase gap splits into meaning flux (safety signal) and style twist (voice dial). Measure them, minimize the residual, and your AGI’s behavior becomes steerable, auditable, and robust.

Chapter 14 — (Remark) Hetu–Luoshu as Pre/Post Templates

Side note for researchers: view Hetu as a 10-node pre-field (pre-collapse attractor lattice) and Luoshu as a 9-mode post-trace (collapse geometry). On any local patch that respects this pre/post split, the belt is the correct 2D measurement surface: two edges for the two projections; interior flux and edge twist capture the invariants.

14.1 Pre vs. Post in SMFT terms (what the numbers “are”)

Luoshu (9 modes) = minimal collapse trace manifold: a closed, quantized cycle of entropy-consuming attention events (Ô-trace) with nine distinguishable modal peaks; empirically plausible as a universal “nine-state” loop in discrete semantic dynamics.
Hetu (10 nodes) = pre-collapse attractor lattice: five symmetric sum-11 pairs $(1\!-\!6),(2\!-\!7),(3\!-\!8),(4\!-\!9),(5\!-\!10)$ furnishing anti-phase anchoring for trace formation. Node 10 functions as an entropy cap (non-trace stabilizer), explaining why it appears in Hetu but not in Luoshu.
Dynamic closure (field ⇄ trace): collapse events leave residual entropy gradients that rewrite the pre-field; the field then biases future traces—i.e., a coupled semantic thermodynamic loop rather than a one-way “origin→manifestation.”

14.2 Why the belt is the right measurement surface

Two projections → two edges. Pre (field template) and post (trace) give two complementary traces $\Gamma_-,\Gamma_+$ . The annulus between them is the belt $\mathcal B$ . Report edge–edge phase as a class function of $\mathrm{Hol}(\Gamma_+)\mathrm{Hol}(\Gamma_-)^{-1}$ .
Completeness (on the patch). On H–L patches that satisfy the thin-ribbon and smoothness assumptions, SBHL gives
$\Delta\phi=\iint_{\mathcal B}\mathcal F_s+\alpha\,\mathrm{Tw},$
i.e., meaning flux + style twist account for the measurable phase gap. This is the SMFT ↔ Belt dictionary specialized to pre/post collapse.

14.3 Minimal encoding of “9 from 10”

Support logic. A 10-node pre-field is the minimal closed pairing structure that can support a 9-mode self-closing trace (Luoshu). Intuition: nine distributed modal channels plus one global entropy anchor (node 10) ensure a low-dissipation loop; graph-theoretically, 10 is the smallest set admitting a perfect anti-phase matching under the sum-11 constraint.
Roles of 5 and 10. 5 = post-collapse pivot (trace center); 10 = containment rim / entropy ceiling that never appears as a trace state but stabilizes the field. This pair $(5,10)$ acts as a structural “vortex axis.”

14.4 Reading H–L on a belt (without naming it in the book)

Treat the upper edge as the post trace (your actual generation/execution) and the lower edge as the pre template (intent/spec, or reconstructed field cues). Compute
$\Delta\phi=\arg\det(\mathrm{Hol}_+\mathrm{Hol}_-^{-1})$ , the flux $\sum \arg\det H_{\text{cell}}$ , and twist $\mathrm{Tw}$ from the framing. If $\Delta\phi\approx \Phi_{\mathcal F}+\alpha\,\mathrm{Tw}$ within tolerance, the patch behaves “H–L-like.”
Many reported “∞-shaped” trace orders (e.g., $1\!\to\!6\!\to\!7\!\to\!2\!\to\!9\!\to\!4\!\to\!3\!\to\!8\!\to\!1$ ) appear as low-dissipation loops embedded in the belt; the belt’s flux map makes the corridor visible.

14.5 When the local H–L belt is not enough

Open breathing / low node counts: four-phase “breathing” without closure ⇒ escalate to eight-node attractor systems (八卦) or tile a network of belts for branch/merge.
Heavy time-phase: split dynamical vs geometric by adding a thin slab; SBHL continues to hold for the geometric piece.

14.6 Quick research probes (drop-in)

9-mode closure test. Extract a post trace on the upper edge; does a 9-state clustering recover a closed belt loop with small SBHL residual? (Pass ⇒ Luoshu-like.)
Entropy cap probe. Perturb the pre-field; does an effective “10th” latent state act only as a boundary/ceiling (affecting flux but never appearing as a trace node)? (Pass ⇒ Hetu-like.)
Rewrite hysteresis. After repeated cycles, does the pre-field estimate shift in ways predicted by collapse-induced field plasticity? (Pass ⇒ field⇄trace coupling.)

Bottom line for researchers. Read H–L as a pre/post template pair: 10-node field supporting a 9-mode trace. On that patch, a two-boundary belt is the minimal, gauge-robust surface to measure “phase gap = meaning flux + style twist.” Use it as an internal model even if the book never names Hetu or Luoshu.

Ch. 15 — Engineer Metrics

This chapter defines the belt scalars you will actually compute and log, proves (or sketches) their key invariances, and gives calibration protocols with acceptance bands ready for deployment.

15.1 Core scalars (what to measure)

Let ℬ be a belt with edges Γ±, connection 1-form A on ℬ, curvature 2-form F = dA + A∧A, and framing angle φ(s) along the edge frame. Use class functions so readouts are gauge-robust and reparameterization-invariant.

(a) Phase-gap (edge–edge)
For U(1): Δφ := ∮Γ+ A − ∮Γ− A.
For U(k): Δφ := arg det (Hol(Γ+) Hol(Γ−)⁻¹). The spectrum/characters are also admissible. Gauge covariance implies class-function scalars are invariant.

(b) Flux (surface)
Φ_F := class-function phase of the surface-ordered exponential on ℬ, implemented discretely as a product of plaquette holonomies (ordered lower→upper across width):
Φ_F ≈ Σ_cells arg det(H_cell). This realizes Stokes on a belt: “upper minus lower” at the boundary equals interior flux.

(c) Twist (framing)
Tw := (1/2π)∮ dφ(s) (unwrap φ)
= (1/2π)∮ (u×t)·(du/ds) ds (White’s vector formula).
This is the standard belt twist entering Lk = Tw + Wr and the framing phase in FBHL.

(d) Width & thinness
Let w(s) be geodesic separation between edges; define thinness ε := max_s κ(s)·w(s). In the thin-belt regime (ε≪1) discretization errors and non-commutation corrections are controlled.

Belt identity (for residual checks).
Throughout the book we use the framed belt identity (FBHL):
Δφ = Φ_F + α·Tw (class-function scalars), used here to define a residual r_FBHL := Δφ − (Φ_F + α·Tw) that should be small on valid belts.

15.2 Discrete estimators (how to compute)

Edge holonomies. Build orthonormal frames Φ±[k] along each edge and transport by polar/Procrustes:
R_s,±[k] = Polar(Φ±[k+1]ᵀ Φ±[k]); Hol(Γ±) = ∏_k R_s,±[k].
Across-width transports R_n[k] = Polar(Φ−[k]ᵀ Φ+[k]) close the plaquettes.

Plaquette holonomies (curvature cells).
H_cell[k] = R_s,+[k] · R_n[k+1] · R_s,−[k]⁻¹ · R_n[k]⁻¹,
then Φ_F = Σ_k arg det(H_cell[k]). This is Stokes-on-a-belt in code.

Twist estimator.
Tw = (1/2π) Σ_k unwrap(φ[k+1] − φ[k]) or use White’s formula for robustness to drift.

Numerical guardrails.
Use class functions (arg det / arg Tr / principal eigenphase); enforce thinness ε ≤ 0.2; keep orientation “upper minus lower.”

15.3 Invariance properties (why these are safe)

Reparameterization. Because F is a 2-form and the belt holonomy is a surface-ordered exponential, Φ_F and any class-function Δφ are invariant under smooth reparameterizations of edges or interior; discretizations inherit this when cell ordering respects the belt orientation (lower→upper across width). Sketch: pullback by reparameterization preserves ∫∫F and conjugates holonomies; class functions remove conjugation.

Gauge covariance. Under g: A↦g⁻¹Ag + g⁻¹dg, we have Hol(Γ±)↦g(Γ±(0))⁻¹ Hol(Γ±) g(Γ±(0)) and ℋ[ℬ]↦g(Γ+)⁻¹ ℋ[ℬ] g(Γ−); class functions (arg det, characters) are invariant. Tw is geometric and independent of gauge.

Framing survival (thin-belt). In ε→0, the framing phase persists while pure area terms vanish—hence belts (two boundaries + framing) are minimal; single lines drop this observable.

15.4 Width-scaling diagnostics

In the thin regime, first-order theory gives
Δφ(w) = w·⟨n⋅F⋅t⟩ + α·Tw + O(w²).
Thus linear Δφ–w scaling (slope set by averaged curvature component) is expected for fixed Tw. Use it both to (i) validate thinness and (ii) calibrate flux units. Acceptance: linear fit R²≥0.95 and relative curvature of the fit ≤5% over your working w-range. (Escalate to a slab model if violated.)

15.5 Calibration protocols

(A) Framing coefficient α (twist quantization / 4π test).
Perform a controlled ±2π twist (one full twist unit) while keeping curvature nearly constant. Fit α so Δφ shifts by exactly α per twist unit. Cross-check by a “braid twice” (4π) or double-twist experiment to verify periodicity and absence of spurious flux. Log before/after Δφ, Tw, and r_FBHL. Pass if |Δφ − (Φ_F + α·Tw)| ≤ τ_twist (e.g., ≤1°).

(B) Flux scale (curvature wedge).
Use a belt spanning a region with known curvature (synthetic or analytic). With Tw≈0, verify Δφ ≈ Φ_F. Fit any scalar normalization implicit in your estimator (e.g., units/step). Pass if relative error ≤ τ_flux (e.g., ≤2%) and r_FBHL statistics are centered with MAD ≤ τ_res.

(C) Gauge & reparameterization stability.
Resample edges (different arc-length parametrizations) and re-initialize frames; recompute Δφ, Φ_F, Tw. Acceptance: coefficient of variation ≤ τ_inv (e.g., 0.5%) across runs. If violated, you are logging non-invariant quantities—switch to class functions.

(D) Thinness health & commutators.
Track ε and across-width commutators (or variance) of A. If ε↑ or commutators exceed budget, promote to a slab or retile more densely. Redline: trigger a safety gate when dΦ_F/dt exceeds the P95 of clean runs for K consecutive steps.

15.6 Acceptance bands (defaults)

Twist calibration: |Δφ − (Φ_F + α·Tw)| ≤ 1° after fitting α; repeatability within 0.5°.
Flux calibration: relative error ≤2% on reference belts; residual MAD ≤0.5°.
Invariance: Δφ, Φ_F stable within 0.5% under gauge/frame re-inits and resampling.
Width-scaling: linear fit R²≥0.95, curvature of fit ≤5% over operational w.
Thinness: ε≤0.2 in production; otherwise escalate model (slab/network).

15.7 Engineer checklist (log these every run)

Δφ (class-function), Φ_F (plaquette sum), Tw (unwrapped/White), r_FBHL, thinness ε, across-width commutator/variance, estimator family & hyper-params (U(1)/U(k)/Uhlmann, window, smoothing). These fields support audits and gates downstream.

What you now have: invariant scalars (Δφ, Φ_F, Tw), robust estimators, and pass/fail bands tied to the belt identity and width physics. Next, Ch. 16 turns them into losses (Two-Boundary Loss, Flux Regularization, Twist Steering) with gradients and training recipes.

Ch. 16 — Training Objectives

We turn the Chapter-15 metrics into trainable losses for models that expose (or let us estimate) belt transports. The chapter is self-contained and stays in standard gauge/differential-geometry language.

Setup. A model with parameters $\theta$ induces discrete transports on a belt $\mathcal{B}$ :

edge transports $U_{s,\pm}[k](\theta)\in \mathrm{U}(k)$ along $\Gamma_\pm$ ,
across-width transports $U_{n}[k](\theta)\in \mathrm{U}(k)$ between edges,
plaquette holonomies $H_{\square}[k]=U_{s,+}[k]\,U_{n}[k\!+\!1]\;U_{s,-}[k]^{-1}\,U_{n}[k]^{-1}$ .
Class-function readouts:

\Delta\phi \;=\; \arg\det\!\Big(\!\prod_k U_{s,+}[k]\;\Big(\prod_k U_{s,-}[k]\Big)^{-1}\!\Big),\quad \Phi_F \;=\; \sum_k \arg\det H_{\square}[k],\quad \mathrm{Tw} \;=\; \frac{1}{2\pi}\sum_k \operatorname{unwrap}(\phi_{k+1}-\phi_k).

The framed belt identity (FBHL) predicts $\Delta\phi \approx \Phi_F + \alpha\,\mathrm{Tw}$ in the thin-belt regime.

16.1 The objective family

(A) Two-Boundary Loss (TBL)

TBL enforces boundary consistency and—optionally—targets a desired edge gap.

Physics-consistency TBL

\mathcal{L}_{\text{TBL-cons}} \;=\; \rho\!\left(\Delta\phi - \Phi_F - \alpha\,\mathrm{Tw}\right),

where $\rho$ is a robust penalty (Huber or wrapped-angle L2 on $\mathbb{S}^1$ ).

Goal-tracking TBL (optional)

\mathcal{L}_{\text{TBL-goal}} \;=\; \rho\!\left(\Delta\phi - \Delta\phi^\star\right),

with $\Delta\phi^\star$ supplied by supervision, planning, or control.

Use either or both: $\mathcal{L}_{\text{TBL}} = w_c\,\mathcal{L}_{\text{TBL-cons}} + w_g\,\mathcal{L}_{\text{TBL-goal}}.$

(B) Flux Regularization (FR)

FR suppresses spurious interior curvature and stabilizes non-Abelian commutators.

\mathcal{L}_{\text{FR}} \;=\; \lambda_F \sum_k \big\|\log H_{\square}[k]\big\|_F^2 \;+\; \lambda_{\nabla}\!\sum_{k\sim k'} \big\|\log H_{\square}[k]-\log H_{\square}[k']\big\|_F^2 \;+\; \lambda_{\text{unit}}\!\sum_{e}\!\big\|U_e^\dagger U_e - I\big\|_F^2.

Here $e$ ranges over all edge/width transports; the last term softly projects numerics back to $\mathrm{U}(k)$ .

(C) Twist Steering (TS)

TS makes style/orientation controllable and smooth.

\mathcal{L}_{\text{TS}} \;=\; \mu_1\,\rho\!\left(\mathrm{Tw}-\mathrm{Tw}^\star\right) \;+\; \mu_2 \sum_k \big(\Delta \mathrm{twist}[k]\big)^2 \;+\; \mu_q\,\min_{m\in\mathbb{Z}} \rho\!\left(\mathrm{Tw}-m\right),

where $\Delta \mathrm{twist}[k]$ is a discrete second difference of the framing angle (smoothness), and the quantization term (weight $\mu_q$ ) gently prefers integer twist units when desired.

Total loss.

\mathcal{L}_{\text{total}} \;=\; w_{\text{TBL}}\,\mathcal{L}_{\text{TBL}} \;+\; w_{\text{FR}}\,\mathcal{L}_{\text{FR}} \;+\; w_{\text{TS}}\,\mathcal{L}_{\text{TS}}.

16.2 Differentiable estimators (U(1) and U(k))

We give gradients for class functions so they’re gauge-safe.

U(1) case

Write edge integrals discretely: $U_{s,\pm}[k]=e^{i a_{s,\pm}[k]}$ , $H_{\square}[k]=e^{i f[k]}$ . Then

\Delta\phi \;=\; \sum_k \big(a_{s,+}[k]-a_{s,-}[k]\big), \quad \Phi_F \;=\; \sum_k f[k].

If parameters $\theta$ control $a$ and $f$ ,

\frac{\partial \Delta\phi}{\partial \theta} = \sum_k\bigg(\frac{\partial a_{s,+}[k]}{\partial \theta} - \frac{\partial a_{s,-}[k]}{\partial \theta}\bigg), \quad \frac{\partial \Phi_F}{\partial \theta} = \sum_k \frac{\partial f[k]}{\partial \theta}.

For twist with unwrapped angles $\phi_k$ ,

\frac{\partial \mathrm{Tw}}{\partial \theta} = \frac{1}{2\pi}\sum_k \frac{\partial }{\partial \theta}\big(\phi_{k+1}-\phi_k\big),

treating the integer jump from unwrap as stop-gradient (see pitfalls).

U(k) case

Let $U\in \mathrm{U}(k)$ and define $\varphi(U) := \arg\det U$ .
Key identity: $d\,\varphi(U) = \operatorname{Im}\,\mathrm{Tr}\big(U^{-1} dU\big)$ .

Edge gap. For $U_\Delta = U_{s,+}\,U_{s,-}^{-1}$ :

\frac{\partial \Delta\phi}{\partial \theta} = \operatorname{Im}\,\mathrm{Tr}\!\Big(U_\Delta^{-1}\,\frac{\partial U_\Delta}{\partial \theta}\Big) = \operatorname{Im}\,\mathrm{Tr}\!\Big( U_{s,-}\,U_{s,+}^{-1}\,\frac{\partial U_{s,+}}{\partial \theta}\Big) \;-\; \operatorname{Im}\,\mathrm{Tr}\!\Big( \frac{\partial U_{s,-}}{\partial \theta}\,U_{s,-}^{-1}\Big).

Flux. For each plaquette $H_{\square}$ ,

\frac{\partial \,\arg\det H_{\square}}{\partial \theta} = \operatorname{Im}\,\mathrm{Tr}\!\Big(H_{\square}^{-1}\,\frac{\partial H_{\square}}{\partial \theta}\Big),

and by product rule,
$\frac{\partial H_{\square}}{\partial \theta} = \sum_j \Big(\prod_{\ell<j} U_\ell\Big)\,\frac{\partial U_j}{\partial \theta}\,\Big(\prod_{\ell>j} U_\ell\Big).$

Unitary projection in backprop. If your $U$ comes from an unconstrained matrix $M$ via polar $U=\mathrm{Polar}(M)$ , use the differentiable polar Jacobian or a straight-through estimator; add $\lambda_{\text{unit}}\|U^\dagger U-I\|_F^2$ .

16.3 Gradient of the losses (templates)

Physics-consistency TBL (Huber with threshold $\delta$ )

\frac{\partial \mathcal{L}_{\text{TBL-cons}}}{\partial \theta} = \rho'(\epsilon)\Big(\frac{\partial \Delta\phi}{\partial \theta} - \frac{\partial \Phi_F}{\partial \theta} - \alpha\,\frac{\partial \mathrm{Tw}}{\partial \theta}\Big), \quad \epsilon=\Delta\phi-\Phi_F-\alpha\,\mathrm{Tw}.

FR terms

\frac{\partial }{\partial \theta}\big\|\log H_{\square}\big\|_F^2 = 2\,\langle \log H_{\square},\; D\log_{H_{\square}}\![\partial_\theta H_{\square}] \rangle,

with $D\log$ the Fréchet derivative (use the standard series or the numerically stable Sylvester solve implementation).

TS target & smoothness follow from §16.2; the quantization term uses $\min_m$ as a soft minimum (e.g., log-sum-exp over 3 integers near round( $\mathrm{Tw}$ )).

16.4 Practical pitfalls (and fixes)

Branch cuts (phase wrap). Use atan2 or complex $\log$ for phases, then unwrap; detach the integer wrap count:
phi_unwrapped = stopgrad(2π*N) + raw_phi, where $N\in\mathbb{Z}$ is the accumulated wrap index.
Loss of unitarity. Numerical drift makes $|\det U|\neq 1$ and corrupts $\arg\det$ . Fix by (i) polar projection $U\leftarrow \mathrm{Polar}(U)$ in the forward pass, (ii) $\lambda_{\text{unit}}$ penalty, (iii) renormalizing determinants when computing phases.
Orientation bugs. Always keep belt orientation “upper minus lower” and width ordering (lower→upper). Unit tests in §16.8 catch sign flips.
Thin-belt violations. If width-scaling test (Ch.15) fails, expect TBL to fight FR. Escalate geometry (slab or finer tiling) or raise $\lambda_{\nabla}$ .
Vanishing/Exploding gradients. Avoid large $\|\log H_{\square}\|$ by gradient-clipping and a warmup where only $\mathcal{L}_{\text{FR}}$ trains for $N$ steps.
Commutator noise (non-Abelian). Add $\sum_k \|[A_1,A_2]\|_F^2$ if you estimate local 1-forms, or rely on the first FR term which implicitly penalizes large non-commuting plaquettes.

16.5 Training recipes

Stage 0 — Calibrate $\alpha$ . On synthetic belts with controlled twist, fit $\alpha$ so $\Delta\phi$ shifts by $\alpha$ per full twist. Freeze $\alpha$ (or learn it with a very small LR).

Stage 1 — Flux shaping. Train with $\mathcal{L}_{\text{FR}}$ only (and unitary penalty) until width-scaling passes (Ch.15).

Stage 2 — Turn on TBL-consistency. Add $w_{\text{TBL}} \uparrow$ over a short schedule; monitor residual $r_{\text{FBHL}}$ and belt invariance checks.

Stage 3 — Add goals and twist control. Introduce $\mathcal{L}_{\text{TBL-goal}}$ or $\mathcal{L}_{\text{TS}}$ depending on task (e.g., style targeting, plan repair). Use a small $\mu_q$ if you want near-integer twist steps.

Optimizers & scales. Use separate LRs: $\eta_U$ for transports (or their generators), $\eta_{\phi}$ for framing. Typical weights: $w_{\text{TBL}}\!\in[1,5], w_{\text{FR}}\!\in[0.1,1], w_{\text{TS}}\!\in[0,1]$ . Tune to keep TBL residual near the acceptance band from Ch.15.

16.6 Minimal pseudocode (framework-agnostic)

# Forward metrics
Usp = edge_holonomy_plus(theta)      # ∈ U(k)
Usm = edge_holonomy_minus(theta)     # ∈ U(k)
Hcells = plaquette_holonomies(theta) # list of ∈ U(k)
phi_gap = arg_det(Usp @ Usm.conj().T)
phi_flux = sum(arg_det(H) for H in Hcells)
twist = twist_unwrap(phi_angles(theta)) / (2*pi)

# Losses
L_tbl_cons = huber(phi_gap - phi_flux - alpha*twist, delta=δ)
L_tbl_goal = 0. if not have_target else huber(phi_gap - phi_gap_star, δ)
L_fr = lamF*sum(frob(logm(H))**2 for H in Hcells) \
     + lamGrad*sum(frob(logm(Hi)-logm(Hj))**2 for (Hi,Hj) in neighbors(Hcells)) \
     + lamUnit*(unitarity_penalty([Usp, Usm]+Hcells))
L_ts = mu1*huber(twist - twist_star, δ) \
     + mu2*smoothness_penalty(phi_angles(theta)) \
     + muq*quantization_softmin(twist)

L = wTBL*(wc*L_tbl_cons + wg*L_tbl_goal) + wFR*L_fr + wTS*L_ts
L.backward(); optimizer.step()

Note. arg_det(U) uses $\operatorname{Im}\mathrm{Tr}(U^{-1}\partial U)$ in the backward pass; logm uses a stable Fréchet derivative or a series with spectral clipping.

16.7 Unit tests & acceptance (train-time)

FBHL residual: $|\,\Delta\phi - \Phi_F - \alpha\,\mathrm{Tw}\,| \le \tau_{\text{twist}}$ on validation belts.
Width scaling: Linear fit $R^2\!\ge 0.95$ over operational widths.
Invariance: Reparameterize edges and randomize frames; coefficients of variation $\le 0.5\%$ .
Unitarity: $\max_e \|U_e^\dagger U_e - I\|_F \le \tau_{\text{unit}}$ .
Stability: No phase-wrap oscillations (wrap index monotone or piecewise constant).

16.8 What to log (for audits and gates)

Per belt and batch: $\Delta\phi,\ \Phi_F,\ \mathrm{Tw},\ r_{\text{FBHL}},$ thinness proxy, unitarity norms, commutator proxy, loss components, wrap index events, and acceptance flags. These feed the online controllers of Chapter 17.

Outcome. You now have a drop-in objective set—TBL to enforce boundary physics (and hit targets), FR to tame curvature, and TS to steer framing—each with differentiable U(1)/U(k) estimators and numerically stable gradients. Chapter 17 turns these into online controllers (safety gates, dials, and plan-repair) at inference.

Ch. 17 — Controllers at Inference

At inference we don’t train; we steer. This chapter installs three belt-native controllers you can run online with minimal overhead:

Safety gate (flux-spike abort)
Creativity dial (quantized twist stepping)
Plan repair (route via belt tiling)

We finish with a local stability / Lyapunov-style bound (sketch) showing why small, state-feedback steps keep the system in a safe set.

17.1 Runtime loop (inputs & taps)

Per step $t$ , from Chapter 15 estimators you read:

Edge gap $\Delta\phi_t$ , flux $\Phi_{F,t}$ , twist $\mathrm{Tw}_t$ .
FBHL residual $r_t := \Delta\phi_t - \Phi_{F,t} - \alpha\,\mathrm{Tw}_t$ .
Thinness proxy $\varepsilon_t$ and unitarity norm (health checks).

Maintain EWMAs and robust spreads:

\tilde{\Phi}_{F,t}=\lambda \tilde{\Phi}_{F,t-1}+(1-\lambda)\Phi_{F,t},\quad \sigma_{F,t}=\operatorname{MAD}_{w}(\Phi_{F,t-w+1:t}),

(similarly for $r_t$ , $\mathrm{Tw}_t$ ). Use a short window $w\in[16,64]$ , $\lambda\approx0.9$ .

17.2 Safety gate — flux-spike abort

Goal. Kill or de-rate trajectories when interior curvature surges (“belt-Faraday spike”), a strong predictor of derailments (tool misuse, injection, hallucination bursts).

Trigger

Define a standardized slope proxy

S_t:=\frac{\Phi_{F,t}-\tilde{\Phi}_{F,t-1}}{\sigma_{F,t-1}+\epsilon}, \qquad Q_t:=\frac{|r_t|}{\operatorname{MAD}_{w}(r)},

and thinness breach flag $B_t:=[\varepsilon_t>\varepsilon_{\max}]$ .

Fire Caution if $|S_t|\ge \tau_1$ or $Q_t\ge\tau_r$ .
Fire Abort if (i) $|S_t|\ge \tau_2$ for $K$ consecutive steps, or (ii) $B_t=1$ .

Default bands: $\tau_1=2.5$ , $\tau_2=4.0$ , $K=3$ , $\tau_r=3.0$ , $\varepsilon_{\max}=0.2$ .

Actions

Caution mode: lower decode temperature, freeze tool calls, require explicit user confirmation for external actions, raise flux penalty in reranker.
Abort mode: hard stop current plan; roll back to last safe checkpoint; switch to “low-flux decode” (e.g., deterministic nucleus & stricter constraints), or demand user clarification.

Pseudocode

def safety_gate(state):
    S = slope_zscore(state.PhiF, state.EWMA_PhiF, state.MAD_PhiF)
    Q = abs(state.r_FBHL) / (state.MAD_r + eps)
    breach = state.thinness > eps_max
    caution = (abs(S) >= tau1) or (Q >= tau_r)
    abort   = breach or state.consec(abs(S) >= tau2) >= K
    return caution, abort

17.3 Creativity dial — twist stepping

Idea. Treat stylistic/orientational freedom as quantized twist. You target

\mathrm{Tw}_t \rightarrow \mathrm{Tw}^\star \in \mathbb{Z}/2

(half-integer steps optional), moving in small increments $\delta_{\mathrm{tw}}$ with hysteresis.

Controller

e_t := \mathrm{Tw}^\star - \mathrm{Tw}_t,\quad u_t := k_p\,\operatorname{clip}(e_t, -\eta,\eta) + k_d\,(e_t-e_{t-1}),

then apply TwistStep( $u_t$ ) by adjusting the style actuators available to your model (e.g., style token weighting, guidance scale, controlled rotations in a style subspace, or structured decoding rules). Constrain steps so FBHL residual stays inside band: if $|r_t|>\rho$ , halve $u_t$ .

Hysteresis. Only flip the target half-integer when $|e_t|\le h$ for $M$ steps (prevents chatter). Defaults: $k_p\in[0.3,0.8]$ , $k_d\in[0,0.2]$ , $\eta=0.5$ , $h=0.2$ , $M=2$ , residual band $\rho=2^\circ$ .

Pseudocode

def twist_dial(state, Tw_star):
    e = Tw_star - state.Tw
    u = kp * clip(e, -eta, eta) + kd * (e - state.prev_e)
    if abs(state.r_FBHL) > rho: u *= 0.5
    apply_twist_step(u)  # maps to your style actuators
    return u

17.4 Plan repair — belt tiling

When a long task starts drifting (flux rises, residual grows), subdivide the worldsheet into tiles $\{\mathcal{B}_j\}$ (subgoals, tools, or phases). Each tile has local metrics $(\Delta\phi_j,\Phi_{F,j},\mathrm{Tw}_j,r_j)$ .

Routing objective

Pick a tile sequence $\pi$ minimizing

\mathcal{C}(\pi)= \sum_{j\in\pi}\Big(\lambda_F |\Phi_{F,j}| + \lambda_r |r_j| + \lambda_T |\mathrm{Tw}_j-\mathrm{Tw}_j^\star|\Big)

subject to waypoint constraints (must hit I/O specs, safety checks, tool availability).

Search. Use A* or beam search with heuristic $\hat{\mathcal{C}}$ from predicted flux (e.g., language-model prior or cached tile stats). Prune tiles failing thinness or unitarity tests. When no safe path exists, contract: tighten style range, reduce tool set, or request disambiguation.

Local repair step

Replace current tile $j$ by an adjacent tile $j'$ with lower cost and compatible boundaries (same entry/exit specs). Re-compute edge holonomies so belt composition is consistent (edge continuity + orientation).

Pseudocode

def plan_repair(tiles, start, goal):
    def cost(tile): 
        return lamF*abs(tile.PhiF) + lamr*abs(tile.r_FBHL) + lamT*abs(tile.Tw - tile.Tw_star)
    frontier = Beam(maxK)
    frontier.add(path=[start], g=0, h=heur(start, goal))
    while frontier:
        path = frontier.pop()
        if path.ends_at(goal): return path
        for nb in safe_neighbors(path.last):
            if violates_thinness(nb) or violates_unitarity(nb): continue
            frontier.add(path + [nb], g=path.g + cost(nb), h=heur(nb, goal))
    return None

17.5 Local stability (Lyapunov-style) — sketch

We show that small state-feedback steps for the dial + gate keep you inside a safe invariant set.

State & candidate

Let

x_t := \begin{bmatrix} r_t\\ \mathrm{Tw}_t-\mathrm{Tw}^\star\\ \Phi_{F,t} \end{bmatrix}, \quad V(x_t) := a\,r_t^2 + b\,(\mathrm{Tw}_t-\mathrm{Tw}^\star)^2 + c\,\Phi_{F,t}^2,

with $a,b,c>0$ . Assume (i) thin-belt Lipschitz bounds: the next metrics change smoothly with actuator moves,
$|x_{t+1}-x_t|\le L\,\|u_t\|$ , and (ii) gate clamps $\|u_t\|\le u_{\max}$ except when aborting.

Controller effect

Dial: $u_t = k_p e_t + k_d (e_t-e_{t-1})$ with $e_t=\mathrm{Tw}^\star-\mathrm{Tw}_t$ .
Gate: if $|S_t|\ge\tau_2$ or $\varepsilon_t>\varepsilon_{\max}$ , set $u_t=0$ (or abort), which non-increases $V$ because $\Delta\phi$ and $\Phi_F$ stop drifting.

Decrease condition (discrete)

For sufficiently small gains and step size:

\Delta V := V(x_{t+1})-V(x_t) \;\le\; -\,\kappa\,\big( r_t^2 + (\mathrm{Tw}_t-\mathrm{Tw}^\star)^2\big) \;+\; \mathcal{O}( \|u_t\|^3 ),

for some $\kappa>0$ . Choosing $k_p,k_d$ so that $L\,\|u_t\|$ is small (and enabling the gate to cut $u_t$ under spikes) makes $\Delta V<0$ in the operating region. Hence the safe set

\mathcal{S}=\{\,|r|\le \rho,\ |\Phi_F|\le \phi_{\max},\ \varepsilon\le \varepsilon_{\max}\,\}

is practically invariant (trajectories stay or re-enter $\mathcal{S}$ ; on violation, Abort stops the evolution).

Remark. This is a standard small-gain argument with a quadratic Lyapunov candidate; formal constants depend on your estimator Lipschitz bounds and actuator mapping.

17.6 Defaults & checklists

Safety gate: $\tau_1{=}2.5,\ \tau_2{=}4.0,\ K{=}3,\ \tau_r{=}3.0,\ \varepsilon_{\max}{=}0.2$ .
Dial: $k_p{=}0.5,\ k_d{=}0.1,\ \eta{=}0.5,\ h{=}0.2,\ M{=}2,\ \rho{=}2^\circ$ .
Tiling: start with 4–8 tiles for medium tasks; prune tiles failing invariants.
Logs (per step): $\Delta\phi,\Phi_F,\mathrm{Tw},r,\varepsilon,$ z-scores $S_t,Q_t$ , mode (normal/caution/abort), dial step $u_t$ , tile id.

17.7 Failure modes & fallbacks

Persistent spikes: switch to slab geometry (wider belt), re-estimate curvature; or request user clarification.
Dial chatter: increase hysteresis $h,M$ , reduce $k_d$ .
Plan dead-ends: relax tile constraints or widen beam; if still none, degrade gracefully (simpler answer / human-in-the-loop).
Unitary drift: enable stronger projection and unitary penalty; if $|\det U|\neq 1$ repeatedly, freeze style actuators and finish in safe mode.

What you now have. A belt-native runtime: guard rails (safety gate), a style knob (twist dial) that respects FBHL, and a repair planner (tiling) that routes around fluxy patches. The stability sketch justifies small, feedback-driven steps. Next (Ch. 18) we extend these ideas to Memory & Retrieval Belts (RAG).

Ch. 18 — Memory & Retrieval Belts (RAG)

Idea. Treat the retrieval path as the lower edge $\Gamma_-$ and the generation path as the upper edge $\Gamma_+$ of a single belt $\mathcal{B}$ . The interior cells of $\mathcal{B}$ encode how retrieved evidence is bound into the live generation state. Then Chapter-15/16 scalars work out of the box:

Edge gap $\Delta\phi = \arg\det\!\big(\mathrm{Hol}(\Gamma_+)\,\mathrm{Hol}(\Gamma_-)^{-1}\big)$
Flux $\Phi_F = \sum_{\square\subset\mathcal{B}} \arg\det H_\square$ (evidence-binding curvature)
Twist $\mathrm{Tw}$ (style/orientation between retrieval and generation)
Residual $r_{\text{FBHL}} = \Delta\phi - (\Phi_F + \alpha\,\mathrm{Tw})$

We use these to route, de-duplicate, and catch hallucinations.

18.1 Building the RAG belt

Edges

Lower edge $\Gamma_-$ (retrieval path): the model’s evidence state as it scans the selected memory $D=\{c_j\}$ (chunks or passages) in the order it will be presented/bound to the generator. Its holonomy aggregates retrieval encoders, attention mixers, and doc-order transitions.
Upper edge $\Gamma_+$ (generation path): the model’s live decoding trajectory over output tokens (or planning steps).

Across-width transports

At each decoding step $t$ , define an across-width unitary $U_n[t]$ that maps (the subspace spanned by) currently attended memory to the generator’s hidden state. In standard RAG stacks, $U_n[t]$ is induced by the retrieval–decoder cross-attention (or key-value graft in late-fusion designs). Plaquette holonomies

H_\square[t] = U_{s,+}[t]\;U_n[t\!+\!1]\;U_{s,-}[t]^{-1}\;U_n[t]^{-1}

tile the belt in time; their phases add to $\Phi_F$ .

18.2 Flux-threshold routing (when to pull more memory)

Interpret $\Phi_F$ as how hard the system is bending generation to accommodate the retrieved evidence.

Low flux density $(|\Phi_F|/T \downarrow)$ : generation is consistent with retrieval; consider shrinking $k$ (fewer chunks) to reduce latency.
Rising flux density $(|\Phi_F|/T \uparrow)$ : retrieved content is steering output; keep or expand $k$ .
Flux spike (z-score $S_t$ from Ch.17): retrieval injures stability → either re-rank memory (swap out offending chunks) or tilt style (adjust $\mathrm{Tw}$ ).

Policy. Maintain a running estimate of flux-per-token $\varphi_t$ . If $\varphi_t > \tau_{\text{hi}}$ : expand retrieval window; if $\varphi_t < \tau_{\text{lo}}$ : contract; if spike: freeze generation and re-select memory (next section).

18.3 Memory re-selection by belt cost

For each candidate chunk $c_j$ , form a tile belt $\mathcal{B}_j$ over a short horizon and compute:

\mathcal{C}_j = \lambda_F |\Phi_{F}(\mathcal{B}_j)|\;+\;\lambda_r |r_{\text{FBHL}}(\mathcal{B}_j)|\;+\;\lambda_T |\mathrm{Tw}(\mathcal{B}_j)-\mathrm{Tw}^{\star}|

Pick the top- $k$ by smallest $\mathcal{C}_j$ (tie-break by relevance). This naturally prefers coherent evidence that bends the generator just enough toward the goal and stays within residual bands.

18.4 De-duplication (same-saying vs. new information)

Redundant chunks inflate latency and sometimes destabilize attention. Two belt tests:

Incremental flux test. When adding $c_j$ after $c_i$ , form a short tile for each order and measure

\Delta\Phi_{F}^{(i\to j)} := \Phi_F(\mathcal{B}_{i\to j})-\Phi_F(\mathcal{B}_{i})

If $|\Delta\Phi_F^{(i\to j)}| < \tau_{\text{dup}}$ and relevance is similar, drop the later chunk.

Relative holonomy test. Compute $\|\,\log(H_{c_i}^{-1} H_{c_j})\,\|_F$ where $H_{c}$ is the chunk’s aggregate across-width binding over the test horizon. If below a threshold, treat $c_j$ as a near-duplicate of $c_i$ .

18.5 Hallucination checks (edge–interior mismatch)

Hallucinations appear as large residual with weak or inconsistent retrieval:

Condition H1. $|r_{\text{FBHL}}| > \tau_r$ while $|\Phi_F|$ is small → generator drifting off evidence (classic fabrication).
Condition H2. Repeated flux spikes localized on transitions between unrelated chunks → stitch-up across incompatible evidence.
Condition H3. Edge gap $\Delta\phi$ deviates sharply from the goal band while retrieval coverage is high → likely misbinding (wrong chunk dominates).

Actions. Under H1: lower decoding temperature, tighten twist (style) toward neutral, request more specific query or stronger retrieval. Under H2: reseat memory (Section 18.3). Under H3: rebalance attention across sources; if unresolved, cite and stop.

18.6 Retrieval–generation scheduling (greedy belt tiling)

At decoding step $t$ :

Score candidates $c_j$ with $\mathcal{C}_j$ on a 1–2 sentence look-ahead belt.
Select top-k (adaptive $k$ via flux thresholds).
Bind via $U_n[t]$ (attention mix).
Measure $\Phi_{F,t},\ r_t,\ \mathrm{Tw}_t$ .
Gate/dial (Ch.17) and continue; if repeated spikes → repair by swapping tiles (re-rank memory) or breaking the plan into sub-tiles.

18.7 Minimal pseudocode

state = init_belt_state()
for t in range(T):  # decode steps
    # 1) Candidate scoring on short tiles
    scores = []
    for c in candidate_chunks(query, cache):
        Bc = short_horizon_belt(c, state)
        scores.append((c, belt_cost(Bc)))  # uses ΦF, r_FBHL, Tw vs Tw*
    topk = select_topk(scores, k=adaptive_k(state))
    # 2) Bind retrieval into generation
    Un = bind_cross_attention(topk, state)   # across-width transport
    step = decode_step(Un, state)            # updates upper-edge transport
    # 3) Update belt metrics
    PhiF_t, r_t, Tw_t = belt_metrics(state, step, Un)
    # 4) Route & guard
    mode = route_by_flux(PhiF_t, state)      # expand/contract or spike-handle
    caution, abort = safety_gate(state.update(PhiF_t, r_t, Tw_t))
    if abort: return finish_with_citations(state)
    if caution: freeze_tools_and_lower_temp()

18.8 Citing and stopping (evidence-aligned exit)

When the final answer is produced, log which tiles contributed positive flux (evidence that bent the trajectory) and output verbatim citations for those chunks. If residual stayed within band while $|\Phi_F|$ was near-zero, mark the answer as background knowledge / low-evidence and soften claims.

18.9 Calibration & acceptance bands (RAG defaults)

Adaptive $k$ : increase if flux-per-token $>\tau_{\text{hi}}$ , decrease if $<\tau_{\text{lo}}$ .
De-dup: drop chunk if $|\Delta\Phi_F|<\tau_{\text{dup}}$ and relative holonomy distance $<\tau_{\text{rel}}$ .
Hallucination: flag if H1–H3; require at least one positive-flux tile to assert a factual claim.
Logs: per step store $\Delta\phi,\Phi_F,\mathrm{Tw},r_{\text{FBHL}},k$ , tile ids, z-scores, and gate mode.

18.10 Benchmarks (belt-aware)

Augment standard RAG metrics (exact match, F1, citation precision/recall) with:

Flux-supported claim rate: fraction of factual claims whose supporting tiles had $|\Phi_F|>\tau_{\min}$ .
Residual conformity: share of tokens with $|r_{\text{FBHL}}|\le \tau_r$ .
Dup-burden: average fraction of dropped chunks by de-dup tests.
Stability: spike incidence per 1K tokens and mean time-to-repair.

18.11 Failure modes & remedies

Churn between near-duplicates: raise $\tau_{\text{dup}}$ ; prefer longer tiles (stabilize binding).
Chronic spikes on doc boundaries: introduce buffer tiles (short summaries) to smooth across-width transports.
Thinness violations (model can’t bind wide contexts): narrow retrieval or switch to slab geometry (wider across-width lattice) for that segment.
Over-tight twist (dull prose): allow half-integer $\mathrm{Tw}$ steps with hysteresis (Ch.17) in style-heavy tasks.

Outcome. A belt-native RAG loop: retrieval and generation form the two edges, interior binding creates curvature, and the same three numbers— $\Delta\phi$ , $\Phi_F$ , $\mathrm{Tw}$ (plus the FBHL residual)—drive routing, de-duplication, and hallucination control, with clear thresholds you can ship.

Ch. 19 — Planning as Belt Tiling

Idea. Break a long task into tiles on a belt $\mathcal{B}$ . Each tile encodes a subgoal or tool call with its own edge transports (retrieval/generation or plan/execute) and interior binding. Planning becomes choosing and composing tiles so the whole belt hits specs while keeping flux/residual within budgets.

19.1 Tiles: objects you can compose

A tile $\mathcal{B}_j$ is an annular patch with:

edges $\Gamma_{\pm}^{(j)}$ (entry/exit traces),
across-width transports $U_n^{(j)}[\cdot]$ ,
plaquettes $H_{\square}^{(j)}[\cdot]$ .

Its signature (kept from Chs. 15–18) is

\sigma(\mathcal{B}_j)=\Big(\Delta\phi_j,\ \Phi_{F,j},\ \mathrm{Tw}_j,\ r_j,\ \epsilon_j,\ \text{cost}_j,\ \text{uncert}_j\Big),

with thinness proxy $\epsilon_j$ , a scalar cost (latency/price), and an uncertainty score.

Seam compatibility. Adjacent tiles $j\to j{+}1$ must match orientation and framing on the shared edge:

\Gamma_+^{(j)} \equiv \Gamma_-^{(j+1)}, \qquad \phi^{(j)}_{\text{out}} \approx \phi^{(j+1)}_{\text{in}}.

A framing mismatch creates a seam twist defect $\delta\mathrm{Tw}_{j\leftrightarrow j+1}$ .

19.2 Composition law (sketch)

Let tiles $\{\mathcal{B}_j\}_{j=1}^m$ be glued in time order. Denote their edge holonomies by
$U_{\pm}^{(j)}=\mathrm{Hol}(\Gamma_{\pm}^{(j)})$ , and total belt edges $\Gamma_{\pm}=\bigsqcup_j \Gamma_{\pm}^{(j)}$ .

(A) Edge gap (class functions)

\Delta\phi_{\text{tot}} = \arg\det\!\Big(\prod_{j} U_{+}^{(j)}\Big)\;-\;\arg\det\!\Big(\prod_{j} U_{-}^{(j)}\Big).

Because class functions kill conjugations at seams, edge gaps add without seam terms.

(B) Flux (interior)

If all plaquette logs are small and nearly commuting across seams, then

\Phi_{F,\text{tot}} \;=\; \sum_{j=1}^m \Phi_{F,j} \;+\; \underbrace{\mathcal{E}_{\text{BCH}}}_{\text{non-Abelian seam error}},

with a Baker–Campbell–Hausdorff (BCH) bound

\|\mathcal{E}_{\text{BCH}}\| \;\le\; \tfrac{1}{2}\!\sum_{\text{seams}}\!\sum_{\square\in j,\ \square'\in j+1} \big\|[\log H_{\square}^{(j)},\ \log H_{\square'}^{(j+1)}]\big\|\;+\;O(\delta^3).

(C) Twist (framing)

\mathrm{Tw}_{\text{tot}} \;=\; \sum_{j=1}^m \mathrm{Tw}_j \;+\; \sum_{\text{seams}} \delta\mathrm{Tw}_{j\leftrightarrow j+1}.

Seam defects vanish if you carry framing consistently across tiles.

(D) FBHL residual

r_{\text{tot}} = \Delta\phi_{\text{tot}} - \Big(\Phi_{F,\text{tot}}+\alpha\,\mathrm{Tw}_{\text{tot}}\Big) = \sum_{j} r_j \;-\; \mathcal{E}_{\text{BCH}} \;-\; \alpha\!\sum_{\text{seams}}\!\delta\mathrm{Tw}.

Hence residuals add, up to (controllable) seam and BCH terms.

Rule of thumb. Keep: (i) thin tiles ( $\epsilon_j\ll 1$ ), (ii) aligned frames (zero seam twist), (iii) small commutators across seams. Then composition is near-additive.

19.3 Error accumulation & budgets

Suppose each tile satisfies

|r_j|\le \rho,\quad \|\log H_{\square}^{(j)}\|\le \delta,\quad \max_{\text{seams}}\eta=\max\|[\log H^{(j)},\log H^{(j+1)}]\|\ .

Then for $m$ tiles,

|r_{\text{tot}}| \;\le\; m\rho \;+\; \tfrac{1}{2}(m{-}1)N_c\,\eta \;+\; O(m\,\delta^2)\;+\;\alpha\sum_{\text{seams}}|\delta\mathrm{Tw}|,

with $N_c$ a local cell factor. Choose per-tile budgets

\rho \le \frac{\rho_{\max}}{m},\qquad \eta \le \eta_{\max},\qquad \sum|\delta\mathrm{Tw}|\le \frac{\tau_{\text{twist}}}{\alpha},

to keep plan-level $|r_{\text{tot}}|\le \rho_{\max}$ .

Width scaling. If $\Delta\phi_j(w)\approx \beta_j w + \alpha\mathrm{Tw}_j$ , then the plan inherits linearity with slope $\sum \beta_j$ and the same thinness constraints (Ch. 15).

19.4 Subgoals & tools as tiles

Pure subgoal tile. A reasoning step with target $\Delta\phi^\star$ and style band; logged cost = time/computation.
Tool tile. I/O pre/post specs plus a measured binding (across-width transport) to the model state. Typical seam risks: (i) sharp curvature at I/O boundaries (BCH ↑), (ii) framing jumps (δTw). Mitigations: buffer summaries, adapter prompts, or unit tests at seams.

Each tool has a library signature (empirically measured on dev belts):

\bar{\sigma}_\text{tool}=(\overline{\Phi_F},\ \overline{r},\ \overline{\delta\mathrm{Tw}},\ \text{var}[\cdot],\ \text{cost}).

Planners pick tools by expected belt cost and reliability, not just task relevance.

19.5 Planning = shortest path on a tile graph

Create a tile graph $G=(V,E)$ : nodes are task states; edges are candidate tiles with signatures. The planner finds a path minimizing the belt cost

\mathcal{J}(\pi)= \sum_{j\in\pi}\Big( \lambda_F |\Phi_{F,j}| + \lambda_r |r_j| + \lambda_T |\mathrm{Tw}_j-\mathrm{Tw}^\star| + \lambda_c\,\text{cost}_j\Big) \;+\; \sum_{\text{seams}} \lambda_s\, \big(\eta + \alpha |\delta\mathrm{Tw}|\big)

subject to

|r_{\text{tot}}|\le \rho_{\max},\quad \epsilon_j\le \epsilon_{\max},\quad \text{I/O constraints met.}

Search. A* with heuristic $\hat{\mathcal{J}}$ from cached tool signatures; prune edges failing invariants; prefer routes with low seam penalties.

19.6 Pseudocode (planning loop)

def plan_with_tiles(start, goal, tiles, budgets):
    # tiles: edges with signatures and seam adapters
    open = PriorityQueue()
    open.push((start, path=[], cost=0, sig_acc=zero_sig()))
    best = {}
    while open:
        node, path, cost, acc = open.pop()
        if node == goal and within_budgets(acc, budgets): 
            return path, acc
        for tile in outgoing_tiles(node):
            if not seam_compatible(tile, path[-1] if path else None): 
                continue
            acc_new = compose_signatures(acc, tile.sigma, tile.seam_sigma)
            if not within_soft_budgets(acc_new, budgets): 
                continue
            cost_new = cost + edge_cost(tile, acc_new)
            key = (tile.end, round_sig(acc_new))
            if key not in best or cost_new < best[key]:
                best[key] = cost_new
                open.push((tile.end, path+[tile], cost_new, acc_new))
    return None, None

compose_signatures implements the additive laws with seam/BCH penalties; within_soft_budgets allows slack (for exploration) but tightens near the goal.

19.7 Diagnostics & acceptance for a plan

Plan-level invariants: log $(\Delta\phi_{\text{tot}}, \Phi_{F,\text{tot}}, \mathrm{Tw}_{\text{tot}}, r_{\text{tot}})$ .
Seam audit: list seams with top- $k$ contributions to $\eta$ and $|\delta\mathrm{Tw}|$ .
Thinness map: $\max_j \epsilon_j \le \epsilon_{\max}$ .
Regression set: re-run on canonical inputs; accept if plan metrics fall in bands (Ch. 15).

19.8 Practical tips

Cache tile signatures. Reuse $\bar{\sigma}$ for frequent subgoals/tools; update with EWMA to track drift.
Use buffer tiles. Insert short “summarize/normalize” adapters to reduce seam commutators and twist jumps.
Prefer few but clean tiles. Each seam adds BCH and twist risk; longer coherent tiles beat many short noisy ones.
Escalate geometry. If BCH/seam penalties persist, switch those segments to slab (wider across-width mesh) before composing.

Outcome. Planning is now a belt-aware graph search over subgoal/tool tiles with explicit composition rules and provable error budgets. Next (Ch. 20) we specialize this to program synthesis & self-repair, where unit tests become edge checks and looped tilings drive iterative fixes.

Ch. 20 — Program Synthesis & Self-Repair

Thesis. Treat spec ↔ program as a belt. The spec/test execution trace is the lower edge $\Gamma_-$ ; the program’s runtime trace is the upper edge $\Gamma_+$ . Compilation & binding act as a framing/twist operator aligning representations; true correctness shows up as low interior flux. Self-repair is a tile search that reduces flux and residual while preserving seams (tests).

20.1 Compilation / Binding as Twist

Let $C$ be source code, $\mathsf{comp}$ the toolchain (frontend → optimizer → codegen) and $\mathsf{bind}$ the linker/ABI/runtime configuration. Together they implement a framing map

\mathsf{Twist}_{\text{tool}} \;:=\; \mathsf{bind}\circ \mathsf{comp} : \text{spec-repr} \longrightarrow \text{exec-repr}.

Semantics target: the edge gap should match twist alone:
$\Delta\phi \stackrel{!}{\approx} \alpha\,\mathrm{Tw},\quad \Phi_F \approx 0.$
Interpretation. If flux $\Phi_F$ rises, the interior (implementation choices) is bending outputs away from spec—logic error, numeric drift, or misbinding.

Practical levers counted as twist: type/precision choices, layout/ABI, compiler flags (-O levels, vectorization), library variants, deterministic runtime toggles. These change representation/framing without (ideally) adding curvature.

20.2 Unit tests as edge checks

For each test case $t$ (inputs + expected postconditions), build a micro-belt $\mathcal{B}_t$ :

Lower edge $\Gamma_-^{(t)}$ : the reference trace from the spec/test oracle.
Upper edge $\Gamma_+^{(t)}$ : the program’s observed trace.
Across-width transports: bindings from oracle state to runtime state at aligned checkpoints.

Compute $(\Delta\phi_t,\ \Phi_{F,t},\ \mathrm{Tw}_t,\ r_t)$ .
Acceptance per test:

|\Phi_{F,t}| \le \tau_{\text{flux}},\qquad |r_t| \le \tau_r,\qquad \text{and seams pass}.

Batch acceptance demands these hold for all tests and that seam metrics across tests (module boundaries) stay within bands.

20.3 Synthesis–Repair as a CEGIS-Belt loop

Synthesize a candidate (from spec, sketches, examples).
Twist fit (compile/bind). Choose a toolchain configuration believed to be curvature-neutral.
Execute tests → measure belts.
Decide:
- If $|\Phi_F|$ small and $|r|$ small ⇒ accept.
- If $|\Phi_F|$ large ⇒ semantic/logic patch (change code).
- If $|r|$ large but $|\Phi_F|$ moderate ⇒ twist repair (types/flags/ABI).
Patch by selecting a repair tile (Section 20.4), re-plan seams, and loop until $\max_t |\Phi_{F,t}| < \tau_{\text{flux}}$ .

Why loop on flux? Flux integrates the interior mismatch; driving it below $\tau_{\text{flux}}$ makes edge agreement robust to small reparameterizations and minor noise.

20.4 The Repair Tile library

Each tile modifies a localized patch of the program or its toolchain and ships with expected belt effects:

Logic tile: change algorithm/branch; big $\downarrow \Phi_F$ , neutral $\mathrm{Tw}$ .
Numeric tile: adjust precision, stable algorithms, tolerances; $\downarrow \Phi_F$ , small $\uparrow \mathrm{Tw}$ .
Interface tile: refactor types / reorder fields; $\downarrow |r|$ via $\uparrow \mathrm{Tw}$ .
Compiler tile: flags (-O, -ffast-math off), LTO, sanitizer; primarily $\downarrow |r|$ , sometimes $\downarrow \Phi_F$ .
Library tile: swap implementation (e.g., exact vs approximate math); trade $\Phi_F$ vs. cost.

Tile selection rule. Choose the tile $j$ minimizing

\mathcal{C}_j = \lambda_F |\Delta\Phi_{F}| + \lambda_r |\Delta r| + \lambda_T |\Delta \mathrm{Tw}| + \lambda_c \text{(latency/price)},

subject to seam constraints and thinness.

20.5 Flakiness & nondeterminism

Non-deterministic scheduling, RNG, or I/O inject spikes indistinguishable from curvature bursts. Use the safety gate (Ch. 17) during testing:

Run in deterministic mode first; if unavailable, repeat tests and require flux statistics to be bounded (MAD ≤ band).
If spikes persist, insert buffer tiles (idempotent checkpoints, stable sort, fixed seeds) to reduce seam commutators.

20.6 Self-repair in deployment (blue-green)

Treat production as a long belt tiled by releases. On anomaly:

Shadow-run a canary tile (patched module + deterministic binding).
Measure belts on mirrored traffic.
Promote if $|\Phi_F|, |r|$ pass bands; otherwise roll back and log the top-flux tiles for offline repair.

20.7 Minimal workflow (pseudocode)

def synthesize_and_repair(spec, tests, toolchain, τ_flux, τ_r):
    prog = synthesize_from_spec(spec)
    config = twist_fit(toolchain, prog)     # compile/bind config
    while True:
        metrics = []
        for t in tests:
            run = execute(prog, t, config)
            Δφ, ΦF, Tw, r = belt_metrics(spec_trace(t), run.trace)
            metrics.append((t, Δφ, ΦF, Tw, r))
        if all(abs(ΦF)<=τ_flux and abs(r)<=τ_r for _,_,ΦF,_,r in metrics):
            return prog, config, metrics     # ACCEPT
        # Diagnose aggregate
        ΦF_mean = mean(abs(m[2]) for m in metrics)
        r_mean  = mean(abs(m[4]) for m in metrics)
        if ΦF_mean > τ_flux:
            tile = pick_logic_or_numeric_tile(prog, metrics)
            prog = apply_tile(prog, tile)
        else:
            tile = pick_interface_or_compiler_tile(config, metrics)
            config = apply_tile(config, tile)
        enforce_seam_checks(prog, config)    # adapters, buffer tiles

20.8 Acceptance & stopping rules

Primary: $\max_t |\Phi_{F,t}| < \tau_{\text{flux}}$ and $\max_t |r_t| < \tau_r$ .
Seams: no seam twist defects beyond $\tau_{\text{twist}}$ ; BCH seam penalties below budget.
Stability: reparameterize tests (input reorderings, timing jitter) → metrics stay within 0.5–1% drift.
Cost: total belt cost (latency/price) under target.

20.9 What to log (for audits)

Per test: $(\Delta\phi_t,\Phi_{F,t},\mathrm{Tw}_t,r_t)$ , seam IDs, flags/config, tile history, spike incidents, and pass/fail. Per run: maxima, means, acceptance verdict, and artifacts (patch diffs).

Outcome. Program synthesis becomes tile search under belt metrics: compile/bind is twist, unit tests are edge checks, and the loop terminates when interior flux falls below $\tau_{\text{flux}}$ (and residuals are within band). This yields a principled, tool-agnostic path to both initial synthesis and robust self-repair.

Ch. 21 — Multi-Turn Dialogue & Style Control

Thesis. Treat a conversation as a belt of tiles (one tile per turn). Register shifts are implemented as quantized twist steps between tiles, and readability is guaranteed by keeping twist/flux within a certified region.

21.1 Dialogue as a belt of tiles

For turn $j$ :

Lower edge $\Gamma_-^{(j)}$ : the conditioning path (user message + memory state).
Upper edge $\Gamma_+^{(j)}$ : the generation path (assistant response).
Across-width transport: the binding between the two (attention/cross-state mix).
Tile metrics $(\Delta\phi_j,\Phi_{F,j},\mathrm{Tw}_j,r_j)$ are computed as in Ch. 15–18.
Gluing tiles across turns follows Ch. 19 (composition and seam penalties).

21.2 Register lattice (quantized targets)

Choose register anchors with integer twist labels $m\in\mathbb{Z}$ (half-integers allowed for transitional tones):

$m=+2$ : legalistic/contractual
$m=+1$ : academic/technical
$m=0$ : neutral/explanatory
$m=-1$ : conversational/helpful
$m=-2$ : narrative/playful

Per turn, pick $\mathrm{Tw}^\star_j \in \{m, m\pm \tfrac12\}$ from task/policy. The style controller (Ch. 17) then moves $\mathrm{Tw}_j$ toward $\mathrm{Tw}^\star_j$ with quantized steps and hysteresis.

21.3 Register shifts as twist steps

Let $e_j=\mathrm{Tw}^\star_j-\mathrm{Tw}_j$ . A small-step controller applies

u_j = k_p\,\operatorname{clip}(e_j,-\eta,\eta)+k_d(e_j-e_{j-1}),

then updates style actuators (token weights, style subspace rotations, decoding rules) so $\Delta \mathrm{Tw}_j \approx u_j$ .
Hysteresis: only retarget to a new anchor when $|e_j|\le h$ for $M$ consecutive steps; prevents oscillation.
Seam rule: the turn-to-turn seam twist $\delta\mathrm{Tw}_{j\leftrightarrow j+1}$ should not exceed a budget (below), or insert a buffer sentence (“bridge”) tile.

21.4 Guaranteed readability regions (sketch)

Define a readability score $R$ (e.g., grade-level proxy, syntax depth, jargon density). In practice, $R$ changes smoothly with (i) twist, (ii) flux density (interior effort to bind conditioning to response). Assume Lipschitz dependence near operating points:

|R_{j+1}-R_j| \;\le\; L_T\,|\Delta\mathrm{Tw}_j| + L_F\,\frac{|\Phi_{F,j}|}{T_j} + L_r\,|r_j|.

Then the readability tube

\mathcal{U}(\bar R,\Delta_T,\Delta_F,\Delta_r) =\{\, |\mathrm{Tw}_j-\mathrm{Tw}^\star_j|\!\le\!\Delta_T,\ |\Phi_{F,j}|/T_j\!\le\!\Delta_F,\ |r_j|\!\le\!\Delta_r \,\}

implies $R$ stays within a band of width $L_T\Delta_T+L_F\Delta_F+L_r\Delta_r$ around a target $\bar R$ .
Policy: pick per-turn budgets $(\Delta_T,\Delta_F,\Delta_r)$ to guarantee a desired readability band (e.g., “HS–undergrad” or “professional brief”).

21.5 Turn seams and code-switching

Soft shift: if $|\delta\mathrm{Tw}_{j\leftrightarrow j+1}|\le \tau_{\text{seam}}$ , glue tiles directly.
Hard shift: if above budget, add a bridge tile (one-sentence summary or framing cue) that absorbs the twist difference while keeping flux small.
Persona blend: parameterize a style subspace; quantized twist steps rotate along a shortest geodesic between anchor vectors (prevents off-register flourish).

21.6 Runtime controller (per turn)

Inputs: per-turn $\Phi_{F,j}, r_j, \mathrm{Tw}_j$ ; targets $\mathrm{Tw}^\star_j, \bar R$ .
Loop:

Safety gate: if flux spike or residual breach (Ch. 17), de-rate or ask clarification.
Style step: apply $u_j$ toward $\mathrm{Tw}^\star_j$ (halve $u_j$ if $|r_j|$ near bound).
Bridge if needed: insert buffer sentence when $|\delta\mathrm{Tw}|$ exceeds $\tau_{\text{seam}}$ .
Readability audit: estimate $R_j$ ; if outside band, reduce $\Delta\mathrm{Tw}$ and/or shrink flux (tighter retrieval, more explicit structure).
Log: $(\Delta\phi_j,\Phi_{F,j},\mathrm{Tw}_j,r_j,R_j)$ .

Defaults: $k_p=0.5, k_d=0.1, \eta=0.5, h=0.2, M=2, \tau_{\text{seam}}=0.5$ twist units.

21.7 Templates (ready-to-use)

Up-register (conversational → academic): two half-steps with a bridge: (i) tighten definitions, (ii) cite assumptions; keep $|\Phi_F|/T$ moderate by adding small signposts.
Down-register (technical → friendly): one step then paraphrase: replace terms with glosses; ensure $r_j$ small by retaining core claims verbatim before stylistic paraphrase.
Persona pivot (helpful → legal): enforce integer step to $m=+2$ , add bridge (“This is not legal advice…”), then compress sentences; cap flux via bulleting and structure.

21.8 Benchmarks & acceptance

Style compliance: twist-hit rate (fraction of turns with $|\mathrm{Tw}_j-\mathrm{Tw}^\star_j|\le \Delta_T$ ).
Readability stability: share of tokens inside target readability band.
Coherence at seams: fraction of seams passing $|\delta\mathrm{Tw}|\le \tau_{\text{seam}}$ and $r_j$ within band.
Spike rate: flux-spike incidents per 1K tokens; mean time-to-recover.

21.9 Failure modes & remedies

Twist chatter: increase hysteresis $h,M$ , reduce $k_d$ .
Register cliff (jarring switch): mandatory bridge tile; split into two turns.
Hallucination under style pressure: prioritize residual/flux bounds over twist; cap creativity until belts return to band.
Drift over long threads: periodic style re-anchoring (explicit restatement of register and aims).

Outcome. Dialogue control reduces to quantized twist scheduling with flux-aware safeguards. Keep twist steps small, seam defects bounded, and flux/residual inside the readability tube to guarantee coherent, on-register multi-turn conversations.

Ch. 22 — Junctions and Cobordisms (Pair-of-Pants)

Thesis. When multiple channels (agents, tools, or subplans) merge or split, the computation lives on a 2-D cobordism whose boundary components are the participating channels. The canonical junction is the pair-of-pants: two inputs $(A,B)$ to one output $(C)$ (or the reverse). Under smooth gluing (good framing + small non-Abelian seams), the belt invariants obey a simple junction conservation law.

22.1 Objects and orientations

A channel is a belt patch $\mathcal{B}$ with edges $\Gamma_-$ (conditioning/“lower”) and $\Gamma_+$ (generation/“upper”), metrics $\Delta\phi,\ \Phi_F,\ \mathrm{Tw},\ r$ .
A junction cobordism $\mathcal{M}$ is a 2-surface whose oriented boundary is
$\partial\mathcal{M}= \Gamma_C \;\sqcup\; (-\Gamma_A)\;\sqcup\;(-\Gamma_B)$
(incoming boundaries carry negative orientation). Think “pair-of-pants”: $A,B\to C$ .

We assume thin channels (small $\epsilon$ ) and compatible framings at the seams (Sec. 22.3).

22.2 What must be continuous at a junction (smooth gluing)

Seam conditions.

Orientation: shared edges glued with consistent “upper–minus–lower” convention.
Framing continuity: edge frames meet with bounded seam twist $\delta\mathrm{Tw}_{\text{seam}}$ .
Small commutators across seams: $\|[\log H^{(A)},\log H^{(B)}]\|\le \eta$ (limits non-Abelian BCH error).
Thinness: local $\epsilon \ll 1$ on all incident belts.

When these hold we say the junction is smooth.

22.3 Junction conservation law (pair-of-pants)

Define the belt charge

Q(\mathcal{B}) := \Delta\phi(\mathcal{B}) \;-\; \alpha\,\mathrm{Tw}(\mathcal{B}) \quad\stackrel{\text{FBHL}}{\approx}\quad \Phi_F(\mathcal{B}).

For a smooth pair-of-pants junction $A,B\to C$ ,

\boxed{\;Q_C \;\approx\; Q_A \;+\; Q_B \;-\; \mathcal{E}_{\text{BCH}} \;-\; \mathcal{E}_{\text{seam}}\;} \tag{22.1}

with

BCH error from non-commuting plaquettes across seams, bounded by
$\|\mathcal{E}_{\text{BCH}}\|\;\le\; \tfrac{1}{2}\!\sum_{\text{seams}}\!\sum_{\square\in A,\ \square'\in B} \big\|[\log H_\square^{(A)},\log H_{\square'}^{(B)}]\big\| \;+\; O(\delta^3),$
Seam twist error $\mathcal{E}_{\text{seam}} := \alpha\,\delta\mathrm{Tw}_{\text{seam}}$ .

Equivalently (re-expanding $Q=\Delta\phi-\alpha\mathrm{Tw}$ ),

\Delta\phi_C \;\approx\; \Delta\phi_A + \Delta\phi_B \;+\; \alpha\Big(\mathrm{Tw}_C-\mathrm{Tw}_A-\mathrm{Tw}_B\Big)\;-\;\mathcal{E}_{\text{BCH}} . \tag{22.2}

Sketch (why it holds). Apply Stokes on the junction surface: the class-function boundary phase of $C$ minus those of $A,B$ equals the interior curvature integral plus the net framing phase needed to align edge frames. Class functions kill conjugations from gluing; what remains are (i) the additive flux, (ii) a framing defect (seam twist), and (iii) non-Abelian BCH terms from cells spanning the seam. In the Abelian or commuting limit with continuous framing, both errors vanish and (22.1) is exact.

22.4 Splitting junctions

For a split $C \to (A,B)$ , simply reverse orientations:

Q_A + Q_B \;\approx\; Q_C \;-\; \mathcal{E}_{\text{BCH}} \;-\; \mathcal{E}_{\text{seam}}.

Interpretation: the parent’s interior work (flux) and framing are allocated to children, up to controlled junction costs.

22.5 Multi-agent merge and broadcast (operational view)

Treat each agent/tool channel as a belt with signature
$\sigma=(\Delta\phi,\Phi_F,\mathrm{Tw},r,\text{cost},\epsilon)$ .

Merge controller (two → one)

Pre-align framings: choose a small unitary seam adapter $S$ that minimizes
$\alpha|\delta\mathrm{Tw}| + \lambda\|[\log H^{(A)},\log H^{(B)}]\|$ .
Conservation target: set $Q_C^\star = Q_A + Q_B$ .
Synthesize output tile to hit $\Delta\phi_C^\star = Q_C^\star + \alpha\mathrm{Tw}_C^\star$ , with $\mathrm{Tw}_C^\star$ chosen by style policy (Ch. 21).
Gate: if $|Q_C - Q_C^\star|>\tau_Q$ or $r_C$ breaches band, insert a buffer tile (brief reconciliation/summary) and retry.

Broadcast controller (one → two)

Pick allocation weights $w_A,w_B$ (trust, expertise, or routing policy) and set

Q_A^\star=w_A\,Q_C,\qquad Q_B^\star=w_B\,Q_C,\qquad w_A+w_B=1,

then build children tiles with small seam twist and monitor residuals.

22.6 Junction calculus in a network

Let a node have incoming set $\mathcal{I}$ and outgoing set $\mathcal{O}$ . The network law (sum over oriented boundaries) is

\sum_{o\in\mathcal{O}} Q_o \;\approx\; \sum_{i\in\mathcal{I}} Q_i \;-\; \sum_{\text{seams}} \Big(\mathcal{E}_{\text{BCH}}+\mathcal{E}_{\text{seam}}\Big). \tag{22.3}

Global consistency over a graph follows by telescoping: interior seams cancel, leaving only external boundaries and junction errors.

Budgeting. For $m$ junctions on a plan, keep per-node bounds
$|\mathcal{E}_{\text{BCH}}|\le \eta,\ |\delta\mathrm{Tw}|\le \tau_{\text{seam}}/\alpha$ so the total deviation stays $\le m(\eta+\alpha\tau_{\text{seam}})$ .

22.7 Algorithms

Merge (pair-of-pants) — minimal routine

def merge_pair_of_pants(sigA, sigB, style_target):
    # sig = (DeltaPhi, PhiF, Tw, r, cost, eps)
    S = choose_seam_adapter(sigA, sigB)             # minimize seam twist & commutator proxy
    Q_A, Q_B = sigA.DeltaPhi - alpha*sigA.Tw, sigB.DeltaPhi - alpha*sigB.Tw
    Q_target = Q_A + Q_B
    Tw_star  = style_target.twist
    DeltaPhi_star = Q_target + alpha*Tw_star
    tileC = synthesize_tile(DeltaPhi_star, Tw_star, S)   # keep ΦF small, r in band
    sigC = measure_signature(tileC)
    if abs((sigC.DeltaPhi - alpha*sigC.Tw) - Q_target) > tau_Q or abs(sigC.r) > tau_r:
        tileC = insert_buffer_and_retry(tileC)
        sigC  = measure_signature(tileC)
    return tileC, sigC

Broadcast mirrors this with weighted targets $w_A,w_B$ .

22.8 Diagnostics & acceptance at a node

Charge balance: $|\,\sum_{\mathcal{O}} Q - \sum_{\mathcal{I}} Q\,| \le \tau_Q$ .
Seam audit: $|\delta\mathrm{Tw}_{\text{seam}}|\le \tau_{\text{seam}}$ ; list top seam contributors.
Residuals: all incident $r$ within band; no flux spikes over $K$ steps (Ch. 17).
Thinness: $\max \epsilon \le \epsilon_{\max}$ .

22.9 Failure modes & remedies

Framing clash (large $\delta\mathrm{Tw}$ ). Insert a bridge/adapter tile; re-estimate seam.
Non-Abelian seam (large BCH). Increase across-width resolution (local slab), or enforce a common basis before merging.
Charge leak (violated balance). Recompute with class functions; check orientation; if persistent, treat as node defect and quarantine that path.
Spike at junction. Trigger safety gate; split merge into two staged merges via an intermediate buffer node.

Outcome. Pair-of-pants junctions supply a local conservation law for belt networks: the additive “charge” $Q=\Delta\phi-\alpha\mathrm{Tw}$ (flux up to FBHL) is preserved under smooth gluing, with explicit, controllable corrections from seam twist and non-Abelian commutators. This turns multi-agent merges and broadcasts into principled, auditable operations in belt-aware systems.

Ch. 23 — Consensus & Negotiation Protocols

Thesis. In a multi-agent belt network, each agent carries a local belt signature
$\sigma_i=(\Delta\phi_i,\ \Phi_{F,i},\ \mathrm{Tw}_i,\ r_i,\ \epsilon_i)$ .
Consensus means phase agreement (and, when needed, style agreement) across agents while keeping flux/residual within budgets. We give belt-aware update laws and a spectral-radius condition that guarantees convergence (sketch).

23.1 Variables, graph, and costs

Let $G=(V,E)$ be the communication graph; $i\in V$ indexes agents. Define:

Phase state: $x_i := \Delta\phi_i$ (class-function edge gap).
Style state: $s_i := \mathrm{Tw}_i$ (quantized target allowed).
Belt charge: $Q_i := x_i - \alpha s_i \approx \Phi_{F,i}$ (from FBHL).
Seam costs: for edge $(i,j)$ , use commutator/twist proxies
$\eta_{ij}$ (BCH size) and $\delta s_{ij}:=|s_i-s_j|$ .

Edge weights (belt-aware).

w_{ij}\ \propto\ a_{ij}\,\exp\!\big(-\beta_\eta\,\eta_{ij}-\beta_s\,\alpha\,\delta s_{ij}\big), \qquad \sum_{j} w_{ij}=1,

with $a_{ij}\in\{0,1\}$ the adjacency. Thus high seam penalties weaken coupling.

23.2 Phase-agreement dynamics

(A) Discrete DeGroot update (with safeguards)

x_i^{t+1} = \sum_{j} w_{ij}\,x_j^t + u_i^t,

where $u_i^t$ is a small local correction (e.g., to meet external specs). Stack $x^t\in\mathbb{R}^{n}$ :

x^{t+1} = W x^t + u^t,\quad W=[w_{ij}].

If $W$ is row-stochastic, primitive (strongly connected & aperiodic), then $x^t$ converges to the stationary-weighted average $(\pi^\top x^0)\,\mathbf{1}$ , where $\pi^\top W=\pi^\top$ , $\pi\!\succ\!0$ , iff

\rho\!\left(W-\mathbf{1}\pi^\top\right) < 1. \tag{23.1}

(Spectral-radius consensus condition.)

Belt gates. If any agent triggers a flux spike or residual breach (Ch. 17), it temporarily freezes its value (set $w_{ii}\!\uparrow$ , $w_{ij}\!\downarrow$ for $j\neq i$ ) until back in band.

(B) Continuous Laplacian flow (linearized Kuramoto)

Let $L$ be the graph Laplacian ( $L\mathbf{1}=0$ ). For small phase differences,

\dot{x} = -K\,L\,x + d(t).

On the subspace $\mathbf{1}^{\perp}$ , the generator is $-K L$ with eigenvalues $-K\lambda_k$ ( $\lambda_2>0$ iff $G$ is connected). Thus $x(t)$ reaches average consensus when $K>0$ and $G$ is connected.

Discrete step. Euler with step $\eta>0$ :

x^{t+1}=(I-\eta L)x^t + \eta d^t.

Convergence on $\mathbf{1}^{\perp}$ holds iff

\rho\!\left( (I-\eta L)\big|_{\mathbf{1}^{\perp}}\right) = \max_{k\ge2}\,|1-\eta\lambda_k| \;<\;1 \;\Longleftrightarrow\; 0<\eta<\frac{2}{\lambda_{\max}(L)}. \tag{23.2}

23.3 Style (register) agreement with quantized targets

Agents negotiate a common style anchor $s^\star \in \mathbb{Z}/2$ (integer or half-integer units). Use a project-then-quantize scheme:

Continuous averaging: $\tilde{s}^{t+1} = (I-\eta L)\,s^t$ .
Quantized projection: $s^{t+1} = \mathcal{Q}_{\Delta}\big(\tilde{s}^{t+1}\big)$ ,
where $\mathcal{Q}_{\Delta}$ snaps to the nearest anchor while enforcing a per-step cap $|s^{t+1}-s^t|\le \Delta$ (prevents seam shocks).

Readability guard. Keep $|s_i^{t+1}-s_i^t|\le \tau_{\text{seam}}$ and flux density $|\Phi_{F,i}|/T$ below band to stay in guaranteed readability regions (Ch. 21).

23.4 Charge-balanced negotiation (with constraints)

Some tasks require junction conservation at a merge (Ch. 22):
$\sum_{\text{out}} Q \approx \sum_{\text{in}} Q$ up to seam/BCH budgets.

We solve a small constrained problem:

\min_{x,s}\ \sum_i \Big[ \lambda_F|x_i-\alpha s_i| + \lambda_s|s_i-s_i^\dagger| \Big] \quad \text{s.t.}\quad \| (I-W)x \| \le \tau_c,\ \ \Big|\sum_{o} Q - \sum_{i} Q\Big|\le \tau_Q,

where $s_i^\dagger$ are agent style preferences. A projected gradient + consensus loop alternates (i) a DeGroot/Laplacian averaging step on $x$ and $s$ , (ii) a projection enforcing the junction budget, and (iii) quantization of $s$ .

23.5 Why the spectral condition ⇒ consensus (sketch)

DeGroot form. Decompose $x^t$ into average + disagreement:
$x^t=(\pi^\top x^0)\mathbf{1} + y^t$ with $\pi^\top y^t=0$ . The disagreement evolves by
$y^{t+1} = (W-\mathbf{1}\pi^\top) y^t$ . If (23.1) holds, $y^t\to 0$ geometrically (rate $\rho$ ).
Laplacian form. In discrete time $x^{t+1}=(I-\eta L)x^t$ : on $\mathbf{1}^\perp$ , the matrix has eigenvalues $1-\eta\lambda_k$ for $k\ge2$ . Condition (23.2) places them strictly inside the unit disk, so disagreement decays. The average mode is fixed.

Both proofs tolerate small bounded disturbances $u^t,d^t$ and belt projections, yielding practical consensus within a tube whose radius scales with disturbance and projection errors.

23.6 Robustness to noisy/adversarial agents

Trimmed/median consensus: replace neighbor average by element-wise trimmed mean or median → tolerates outliers.
Adaptive weights: down-weight agent $j$ if it repeatedly violates belt bands (large $r_j$ or flux spikes).
Quarantine: temporarily cut edges from agents failing unitarity/thinness checks; re-admit after recovery.
Seam smoothing: insert buffer tiles on contentious links to reduce $\eta_{ij}$ and $\delta s_{ij}$ .

23.7 Protocol templates

Evidence-weighted consensus. Weights $w_{ij}$ include a trust factor from positive flux that agent $j$ ’s evidence contributed in past merges.
Seam-minimizing consensus. Solve for $s^\star$ that minimizes $\sum_{(i,j)}(\eta_{ij}+\alpha\delta s_{ij})$ subject to style policy, then run phase consensus toward the induced $Q$ targets.
Two-phase negotiation. (i) Reach phase average under Laplacian flow; (ii) quantize and finalize style using the project-then-quantize scheme.

23.8 Minimal pseudocode

def belt_consensus_step(state):
    # state: x (phase), s (style), W, L, seam costs, bands
    # 1) Safety gating (freeze noisy nodes)
    mask = (state.residual > tau_r) | (state.flux_z > tau_spike)
    W = adjust_weights(state.W, mask)
    # 2) Phase consensus (DeGroot or Laplacian)
    x = W @ state.x if use_degroot else state.x - eta * (state.L @ state.x)
    # 3) Style averaging + quantization
    s_tilde = state.s - eta * (state.L @ state.s)
    s = quantize_with_cap(s_tilde, anchors=style_anchors, step_cap=Delta)
    # 4) Junction projection (charge balance)
    x, s = project_charge_balance(x, s, tau_Q, alpha)
    # 5) Recompute signatures, logs
    return x, s

23.9 Benchmarks & acceptance

Consensus error: $E_x(t)=\max_i |x_i - \bar{x}|$ , $E_s(t)=\max_i |s_i - s^\star|$ ; require geometric decay to below bands.
Spectral margin: estimate $\rho(W-\mathbf{1}\pi^\top)$ or bound $\lambda_{\max}(L)$ ; verify (23.1)/(23.2) holds.
Belt safety: per-agent residuals and flux density within bands ≥95% of steps; seam penalties trending down.
Robustness: pass trimmed-consensus tests with injected outliers; no uncontrolled spikes.

23.10 Failure modes & remedies

Disconnected or weakly connected graph: increase communication edges or add relay/summary nodes (buffer tiles).
Large seam/BCH penalties: align framings first (style pre-agreement), or increase across-width resolution locally (slab).
Chattering from quantization: increase step cap $\Delta$ hysteresis or run more continuous averaging steps before snapping.
Adversarial drift: enforce quarantine and require positive-flux evidence before re-weighting trust upward.

Outcome. Consensus and negotiation reduce to phase averaging (with belt-aware weights) and quantized style agreement, governed by standard spectral conditions. With safety gates and seam-aware weighting, multi-agent systems reach agreement quickly while keeping belt invariants inside operational bands.

Ch. 24 — Discrete Surface-Ordering Algorithms

We give practical algorithms for computing surface-ordered exponentials on a belt $\mathcal{B}$ : how to mesh an annulus, order plaquettes, perform quadrature in non-Abelian settings, and control complexity, stability, and error versus curvature/commutators.

24.1 Geometry & mesh (annular coordinates)

Parametrize the belt by $(s,n)\in[0,L]\times[0,w]$ with edges $\Gamma_-:\,n{=}0$ , $\Gamma_+:\,n{=}w$ . Let the connection be

A = A_s(s,n)\,ds + A_n(s,n)\,dn,\qquad F = \big(\partial_s A_n - \partial_n A_s + [A_s,A_n]\big)\,ds\wedge dn .

Discretize with an annular mesh:

$N_s$ segments along $s$ (arc-length or curvature-adaptive),
$N_n$ rungs across $n$ (geodesic offsets).
Cells $\square_{i,j}$ have $\Delta s_i,\,\Delta n_j$ . Keep aspect ratio $0.3\!\le\!\Delta s_i/\Delta n_j\!\le\!3$ and thinness $\varepsilon=\max \kappa\,w \ll 1$ .

Frames. Maintain orthonormal frames on rungs; across-width geodesics define rung correspondences.

24.2 Surface ordering & plaquettes

Define edge transports $U_{s,\pm}[i]\in \mathrm{U}(k)$ and rung transports $U_n[i,j]\in \mathrm{U}(k)$ . The plaquette holonomy (counter-clockwise) is

H_{i,j} = U_{s,+}[i,j]\; U_n[i{+}1,j]\; U_{s,-}[i,j]^{-1}\; U_n[i,j]^{-1}.

The surface-ordered exponential is the ordered product of $H_{i,j}$ over the mesh with a fixed belt ordering: sweep $n:0\!\to\!w$ , and for each rung use a snake in $s$ (even rungs left→right, odd rungs right→left) to keep adjacent factors near-commuting. Extract scalars with class functions (e.g., $\arg\det$ or characters).

24.3 Quadrature schemes (non-Abelian)

We approximate each $H_{i,j}$ by evaluating $A_s,A_n$ within the cell.

Q0 — Wilson plaquette (first order).
$U_{s,\pm}=\exp(\Delta s\,A_s\text{ at edge midpoint})$ , $U_n=\exp(\Delta n\,A_n\text{ at rung midpoint})$ . Cost-minimal; error $O(\Delta s\,\Delta n\,\|[A_s,A_n]\|) + O(h^3)$ .

Q1 — Strang-split edges (second order).
Half-steps in $s$ :

H_{i,j}\approx e^{\frac{\Delta s}{2}A_s^\text{top}} \,e^{\Delta n A_n^{i+1/2}} \,e^{-\frac{\Delta s}{2}A_s^\text{bot}} \,e^{-\Delta n A_n^{i-1/2}} .

Error $O(h^3)$ , better when commutators are moderate.

Q2 — Local Magnus (fourth order, cellwise).
Transport $A$ to the cell barycenter, set

\log H_{i,j}\approx \iint_{\square_{i,j}} F \;+\; \tfrac{1}{2}\!\iint\!\!\iint \!\![\!A(\xi),A(\xi')\!]\, d\xi d\xi' \quad (\text{truncated}).

Use a 2×2 Gaussian rule for $F$ ; include lowest commutator term. Best accuracy; costlier due to $\log/\exp$ .

Tip. In practice: Q1 for training/online; Q2 for audits or high-curvature regions.

24.4 Algorithms (pseudocode & cost)

A) Wilson–Snake (fast baseline)

def belt_surface_order(A_s, A_n, Ns, Nn, steps):
    H_tot = I
    for j in range(Nn):
        idx = range(Ns) if j%2==0 else reversed(range(Ns))
        for i in idx:
            Us_top = expm(Δs[i]*A_s(i, j+1/2, edge='top'))
            Us_bot = expm(Δs[i]*A_s(i, j+1/2, edge='bot'))  # same i,j rung, lower edge
            Un_r   = expm(Δn[j]*A_n(i+1/2, j))
            Un_l   = expm(Δn[j]*A_n(i-1/2, j))
            H = Us_top @ Un_r @ inv(Us_bot) @ inv(Un_l)
            H_tot = H @ H_tot
    return H_tot

Complexity. $O(N_s N_n\,k^3)$ for $\mathrm{U}(k)$ (dense expm). Memory $O(k^2)$ . GPU-friendly via batched expm.

B) Strang–Snake (2nd order)

Replace each edge exp with half-steps as in Q1. Same asymptotic cost; ~1.8× runtime constant.

C) Cell-Magnus (audit mode)

Compute $\log H_{i,j}$ via Q2, then sum in log-Euclidean space with BCH(2) across the snake, finally expm once at the end.
Complexity. $O(N_s N_n\,k^3)$ with larger constants (log/exp + Sylvester solves).

Parallel prefix. Use tree/prefix scans along each rung to reduce depth to $O(\log N_s)$ on GPUs.

24.5 Numerical stability

Unitarity projection. After each product, apply polar: $U\leftarrow \mathrm{Polar}(U)$ (or every $m$ steps). Penalty $\|U^\dagger U-I\|_F$ as a health signal.
Phase integrity. Read phases via class functions ( $\arg\det$ , principal eigenphase); keep a wrap index with stop-gradient in training.
Ordering discipline. Always “lower→upper” across $n$ and snake in $s$ ; mixing orders inflates BCH error.
Conditioning. Clip $\|\log H_{i,j}\|$ to $\le \delta_{\max}$ (e.g., 0.3) before exponentials; refine mesh if exceeded.
Accumulation. For Abelian scalars, use Kahan or pairwise sums; for matrices, prefer log-space accumulation in audits.

24.6 Error vs. curvature/commutators (sketch)

Let $h=\max\{\Delta s,\Delta n\}$ , $\|F\|_\infty\!=\!\sup_{\mathcal{B}}\|F\|$ , and $\chi=\sup_{\mathcal{B}}\|[A_s,A_n]\|$ .

Local plaquette error:
$\|\log H_{i,j} - \iint_{\square_{i,j}}F\|\;=\; O(h^2\|F\|) + O(\Delta s\,\Delta n\,\chi)$ .
Global product error (Wilson–Snake):
$O(N_s N_n)$ times local, mitigated by near-cancellation along the snake; practical bound
$\|E\|\lesssim C_1\,\text{area}\cdot h\,\| \nabla F \| + C_2\,\text{area}\cdot \chi$ .
Second-order (Strang): leading term $O(h^2)$ under bounded $\chi$ .
Magnus(4): leading term $O(h^4)$ provided $\int_{\square}\!\|A\|\,d\xi < \pi$ (convergence domain).

Rule-of-thumb targeting.

Choose $h$ so each cell’s plaquette angle $\delta_{i,j}=\|\log H_{i,j}\|\le 0.2\text{–}0.3$ .
If $\chi$ spikes (non-Abelian seam), align frames or refine across $n$ locally.

24.7 Adaptive refinement

Use error indicators per cell:

e_{i,j}=\|\log H_{i,j}\|,\qquad c_{i,j}=\|[A_s,A_n]\|,\qquad g_{i,j}=\|\nabla F\|.

Refine where $e$ or $c$ exceed bands; coarsen where both are small. Keep graded meshes (neighbor sizes within ×2) to avoid seam artifacts. Stop when plan-level bands (Ch. 15) pass.

24.8 Complexity, memory, and batching

Cost. $O(N_s N_n k^3)$ flops; for $k\!\le\!8$ this is bandwidth-bound on GPUs.
Batching. Tile multiple belts; keep per-belt scan independent.
Caching. Reuse $A_s,A_n$ samples for Q0/Q1; share rung frames across neighboring cells.
Mixed precision. FP16 edge exps with FP32 accumulators often suffice; audit in FP64 for small belts.

24.9 Acceptance tests (algorithmic)

Reparameterization test: resample $(s,n)$ (same geometry) → class-function outputs must match within 0.5%.
Width-scaling linearity: for fixed twist, $\Delta\phi(w)$ linear over operational $w$ (Ch. 15).
4π periodicity (framing): apply ±2 twists; recovered phase shifts by $\alpha$ per twist within tolerance.
Non-Abelian seam: create a controlled commutator patch; verify Q1 ≪ Q0 error; Q2 closes to reference.

24.10 What to use when

Training/online: Strang–Snake (Q1) — best speed/accuracy tradeoff; add polar projection every 8–16 cells.
Monitoring: Wilson–Snake (Q0) with small meshes for quick health signals.
Audits / high curvature: Cell-Magnus (Q2) on a refined local mesh; log commutators and seam penalties.

Outcome. You now have mesh/ordering conventions, three implementable quadrature levels, and concrete rules to keep unitarity, stability, and error under control as curvature and commutators vary. These are the computational backbone for the metrics (Ch. 15), losses (Ch. 16), controllers (Ch. 17), and planning/tiles (Chs. 19–23).

Ch. 25 — Estimating the Semantic Connection from Models

Goal. Given a model’s internal signals (embeddings, logits, hidden states, attention), construct a discrete connection $A$ on a belt so you can compute edge holonomies, across-width transports, and plaquette curvature with the algorithms of Ch. 24. We give practical U(1), U(k), and Uhlmann (mixed-state) estimators, plus bias/consistency guarantees under mild conditions.

25.1 Observables, gauges, and what’s identifiable

We observe vectors/matrices $h(\xi)\in\mathbb{R}^d$ or logits $z(\xi)\in\mathbb{R}^V$ along a parameter $\xi$ (token/time/plan index). These are only defined up to a latent basis: $h\mapsto R(\xi)h$ with unknown invertible $R$ .
We therefore estimate transports modulo gauge and only read class functions (phase, traces, characters) downstream (Ch. 15).
Two directions on a belt:
- Along-edge ( $s$ ): transport within a channel (retrieval or generation).
- Across-width ( $n$ ): binding transport between channels (evidence→decoder, planner→executor).

25.2 U(k) edge transport from hidden states (Procrustes)

You want a unitary step $U_{s}[k]\in\mathrm{U}(K)$ aligning a $K$ -dimensional semantic subspace at $\xi_k$ and $\xi_{k+1}$ .

Subspace extraction (stable): build a local window $\mathcal{W}_k$ around $\xi_k$ , assemble $H_k\in\mathbb{R}^{d\times K}$ from the top- $K$ left singular vectors (PCA) or from CCA across paired views (e.g., retrieval ↔ generation). Repeat for $H_{k+1}$ .

Orthogonal Procrustes (unitary aligner):
$M_k = H_k^\top H_{k+1} = U\Sigma V^\top$ (SVD),
$\displaystyle U_{s}[k] := U V^\top \in \mathrm{O}(K)$ (use complex lift if needed → $\mathrm{U}(K)$ ).
Connection element: $A_s[k] := \frac{1}{\Delta s}\log U_{s}[k]$ (principal matrix log; clip $\|\log\|\le\delta$ ).

Why this works. Any local basis rotation $H_k\!\mapsto\!H_kR_k$ just conjugates $U_s[k]$ by $R_k$ , which vanishes inside class functions used later (Δφ, characters). Consistency is in §25.7.

25.3 U(k) across-width transport from cross-attention (polar)

At step $t$ , let $E_t\in\mathbb{R}^{d\times K}$ span the evidence subspace (from the selected chunks/keys) and $G_t\in\mathbb{R}^{d\times K}$ span the generator subspace (decoder state). Form the cross-covariance
$C_t = E_t^\top G_t$ .

Polar factor as unitary binding: $C_t = R_t S_t$ (polar), with unitary $R_t\in\mathrm{O}(K)$ and positive $S_t$ . Take
$\displaystyle U_n[t] := R_t,\qquad A_n[t] := \frac{1}{\Delta n}\log R_t.$

This gives the rung transport used in each plaquette $H_\square$ (Ch. 24).

25.4 U(1) estimators (phase scalars)

If you only need a scalar phase gap:

(a) From embeddings/hidden states. Project the step aligner to a class function:
$\Delta\phi_s[k] := \arg\det U_s[k]$ (or principal eigenphase). Sum along the edge.

(b) From logits/probabilities. Map probabilities $p(\xi)=\mathrm{softmax}(z(\xi))$ to amplitudes $\psi(\xi)=\sqrt{p(\xi)}$ (Hellinger lift). Define a discrete Berry-style phase
$\displaystyle \delta\phi[k] := \arg \langle \psi(\xi_k), \psi(\xi_{k+1})\rangle,$
then $\Delta\phi=\sum_k \delta\phi[k]$ . This is robust, bounded, and reparameterization-invariant.

25.5 Uhlmann (mixed-state) connection for stochastic models

When states are ensembles (dropout, sampling, batched augmentations) or when you work with marginals (token distributions, pooled activations), use density matrices $\rho(\xi)\succeq 0$ (normalize $\mathrm{Tr}\,\rho=1$ ).

Uhlmann step via purifications (discrete, practical):

Compute matrix square roots $W_k=\rho(\xi_k)^{1/2}$ , $W_{k+1}=\rho(\xi_{k+1})^{1/2}$ .
Form $M_k = W_k W_{k+1}$ and take its polar decomposition $M_k = R_k P_k$ with unitary $R_k$ .
Define the Uhlmann parallel transporter $U_{s}[k] := R_k$ and the mixed-state edge phase by a class function (e.g., $\arg\det R_k$ ); the generator is $A_s[k]=\frac{1}{\Delta s}\log R_k$ .

This is the discrete counterpart of Uhlmann’s parallelism (maximizes fidelity between purifications). It reduces to the pure-state Berry transport when $\rho=\psi\psi^\top$ .

25.6 Along-vs-across estimators for common signals

Signal	Along-edge $U_s$	Across-width $U_n$
Hidden states	Subspace via PCA/CCA; Procrustes $U_s$	Cross-covariance polar $R$
Embeddings	Same as hidden states (on embedding layer)	Same as hidden (evidence ↔ decoder)
Logits / probs	Hellinger lift → U(1) phase; or take top- $K$ eigenspace of logit Hessian for U(k)	Attention-weighted evidence subspace vs decoder subspace → polar
Attention maps	Build subspaces from key/value projections; then Procrustes	The attention mixing itself induces $C_t$ → polar
Ensembles / dropout	Density $\rho$ in feature space; Uhlmann $R$	Joint density blocks; cross-covariance + Uhlmann on blockwise $\rho$

25.7 Bias & consistency (sketch)

Assume:

(S1) Smoothness: the true semantic subspace $S(\xi)$ is $C^1$ with bounded curvature on each edge, and the across-width map is $C^1$ .
(S2) Separation: the top- $K$ singular values used to define $S(\xi)$ are separated from the rest by a gap $\gamma>0$ (local PCA stability).
(S3) Sampling: windows are wide enough that empirical covariances converge (LLN), and step size $h\to 0$ .

Then:

(C1) Procrustes consistency. The estimated $U_s[k]$ converges (in probability) to the orthogonal part of the true differential transport between $S(\xi_k)$ and $S(\xi_{k+1})$ ; thus $A_s[k]\to A_s(\xi_k)+O(h)$ . Bias terms are $O(h)$ (discretization) $+\ O(\gamma^{-1}\!\times\! \text{covariance error})$ .

(C2) Polar across-width consistency. If the true cross-map between evidence and generator subspaces is full-rank and locally smooth, the polar factor $R_t$ converges to its unitary part; hence $A_n[t]$ is first-order consistent.

(C3) Uhlmann consistency. If $\rho(\xi)$ is full-rank and $C^1$ , the discrete polar $R_k$ yields the correct Uhlmann parallel transport to first order; error $O(h^2)$ if $W(\xi)$ is $C^2$ .

(C4) U(1) Hellinger phase. For normalized $\psi=\sqrt{p}$ with smooth $p(\xi)$ , the product of inner-product phases converges to the discrete Berry phase on the probability simplex with Fubini–Study metric; bias $O(h^2)$ for symmetric stepping.

Main failure modes. (i) Subspace swaps (gap $\gamma$ closes) → jumpy transports; (ii) Non-unitary drift from numerics → pollutes phases (fix with polar projection & unitary penalty); (iii) Seam commutators large across width → prefer slab geometry or align frames.

25.8 Regularization & health checks

Unitary projection. After each step transport, apply polar projection $U\!\leftarrow\!\mathrm{Polar}(U)$ ; log $\|U^\dagger U-I\|_F$ .
Thinness monitoring. Track thinness $\varepsilon=\max\kappa w$ and the plaquette angle $\|\log H_\square\|$ ; refine if above bands.
Gauge sanity. Re-extract subspaces with random orthonormal bases; class-function readouts (Δφ, characters) must be stable (≤0.5%).
Reparameterization. Resample along the edge; invariants unchanged (Ch. 15 acceptance tests).

25.9 Practical recipes (drop-in)

(A) Hidden-state U(k) edge transport

Window $\mathcal{W}_k$ , compute $H_k\gets \mathrm{PCA}_K(\mathcal{W}_k)$ , $H_{k+1}$ similarly.
$M=H_k^\top H_{k+1}=U\Sigma V^\top$ , set $U_s[k]=UV^\top$ .
$A_s[k]=\frac{1}{\Delta s}\log U_s[k]$ (clip).
Optionally project $U_s[k]$ to $\mathrm{U}(K)$ (complex lift) for phase readouts.

(B) Cross-attention U(k) across-width

Build $E_t,G_t$ (evidence & generator subspaces).
$C_t=E_t^\top G_t$ , polar $C_t=R_tS_t$ .
$U_n[t]=R_t$ , $A_n[t]=\frac{1}{\Delta n}\log R_t$ .

(C) Uhlmann (mixed state)

Estimate $\rho(\xi)=\frac{1}{m}\sum_{r=1}^m h_r h_r^\top$ or from probs.
$W_k=\rho(\xi_k)^{1/2}$ (stable sqrt), $M=W_k W_{k+1}$ .
Polar $M=R P$ , take $U_s[k]=R$ , $A_s[k]=\frac{1}{\Delta s}\log R$ .

(D) U(1) Hellinger phase from logits

$p(\xi)=\mathrm{softmax}(z(\xi))$ , $\psi=\sqrt{p}$ .
$\delta\phi[k]=\arg\langle \psi(\xi_k),\psi(\xi_{k+1})\rangle$ , sum to Δφ.

25.10 Complexity and numerics

PCA/CCA per window: $O(dK^2)$ (thin $K\!\ll\!d$ ), SVD $O(K^3)$ per step.
Polar & Procrustes are GPU-friendly (batched SVD).
Use mixed precision (FP16 compute, FP32 accumulators); audits in FP64 for small belts.
Clamp $\|\log\|\le\delta_{\max}\in[0.2,0.3]$ ; refine mesh if exceeded (Ch. 24).

25.11 Acceptance tests (estimator level)

Gauge stability: random re-basings of $H_k$ leave Δφ/characters unchanged within 0.5%.
Reparam test: down/up-sample along edges → invariants drift ≤0.5%.
Width-scaling: for fixed twist, $\Delta\phi(w)$ linear over operational $w$ .
4π / twist quantization: integer twist steps shift Δφ by $\alpha$ per twist.
Mixed-state sanity: Uhlmann phase reduces to pure-state phase on rank-1 densities.

Outcome. You now have constructive, numerically stable estimators of the semantic connection from standard model signals—hidden states, embeddings, logits/probabilities, and ensembles—covering U(1), U(k), and Uhlmann regimes, with clear bias/consistency stories and drop-in acceptance tests. These feed directly into belt metrics (Ch. 15), training (Ch. 16), controllers (Ch. 17), and all downstream planning/composition chapters.

Ch. 26 — Benchmarks & Evaluation

We define three belt-native benchmark suites and the exact artifacts you must log to make results reproducible and comparable across systems.

Core readouts (Ch. 15): edge gap $\Delta\phi$ , flux $\Phi_F$ , twist $\mathrm{Tw}$ , residual $r_{\text{FBHL}}=\Delta\phi-(\Phi_F+\alpha\,\mathrm{Tw})$ , thinness $\varepsilon$ , unitarity norm, commutator proxy.

26.1 The three suites (what & why)

4π periodicity (Framing Quantization): verifies that twist units produce the correct phase increments $\alpha$ and that the system respects the double-cover periodicity.
Width-scaling law: validates thin-belt physics and your flux calibration by checking linear $\Delta\phi(w)$ .
Belt–Faraday test: tests dynamics: a controlled change of interior curvature induces an edge-gap EMF (time-derivative version of FBHL).

Each suite includes protocol, expected curves, tolerances, and pass/fail rules.

26.2 Suite A — 4π periodicity (framing)

Goal. Show that adding one full twist unit $\Delta \mathrm{Tw}=+1$ shifts the edge phase by $+\alpha$ , and that two units (± $2\pi$ twice, i.e. $4\pi$ ) returns the belt to the same physical state (mod wraps).

Protocol

Fix a thin belt $\varepsilon \le 0.2$ ; choose a region with nearly constant curvature so $|\Phi_F|$ is small and stable.
Sweep integer twist: $\mathrm{Tw}\in\{-2,-1,0,+1,+2\}$ by applying controlled framing operations (or equivalent style actuators in software).
Measure $\Delta\phi, \Phi_F, \mathrm{Tw}, r_{\text{FBHL}}$ at each setting.

Expected curve

Linearity: $\Delta\phi(\mathrm{Tw}) \approx \alpha\,\mathrm{Tw} + \Phi_F$ .
Sawtooth wrapping: observed phase shows $2\pi$ wrap; the unwrapped line has slope $\alpha$ .
4π check: changing $\mathrm{Tw}$ by $+2$ (two twist units) returns physical observables except for the trivial $2\pi$ phase wrap.

Tolerances (pass if all hold)

Slope fit: $|\hat{\alpha}-\alpha|/|\alpha| \le 2\%$ (after you calibrate $\alpha$ once).
Residual band: $\operatorname{MAD}(r_{\text{FBHL}}) \le 1^\circ$ .
Repeatability: same slope within $0.5\%$ under reparameterization and gauge re-initialization.

Failure diagnostics

Slope too small/large → framing actuator not pure; curvature leaking (raise resolution or switch region).
Residual large but slope OK → seam twist or unitarity drift (apply polar projection; check orientation).

26.3 Suite B — Width-scaling law

Goal. Verify the thin-belt prediction

\Delta\phi(w) \;=\; \beta\, w \;+\;\alpha\,\mathrm{Tw} \;+\; O(w^2)

with fixed $\mathrm{Tw}$ and nearly fixed curvature texture.

Protocol

Construct belts with widths $w \in \{w_{\min},\ldots,w_{\max}\}$ (≥5 points), same centerline and framing.
Hold $\mathrm{Tw}$ constant (ideally zero).
For each $w$ : compute $\Delta\phi,\ \Phi_F,\ r_{\text{FBHL}},\ \varepsilon$ .

Expected curve

Linearity: $\Delta\phi(w)$ is linear with slope $\beta \approx \langle n\!\cdot\! F\!\cdot\! t \rangle$ .
Flux agreement: $\Phi_F(w)$ matches the linear term; residual stays small and does not grow with $w$ .

Tolerances

Linearity: $R^2 \ge 0.95$ ; relative curvature of fit (max second finite-difference / mean slope) $\le 5\%$ .
Residual band: $\max_w |r_{\text{FBHL}}(w)| \le 1.5^\circ$ .
Thinness: $\varepsilon(w)\le 0.2$ across the sweep (otherwise promote to slab).

Failure diagnostics

Curvature in fit → non-Abelian commutators prominent (refine across-width mesh; align frames).
Residual grows with $w$ → geometry beyond thin regime (shorten $w$ or increase resolution).

26.4 Suite C — Belt–Faraday test (dynamics)

Goal. Validate the time-differential law:

\Delta\!\left[\Delta\phi - \alpha\,\mathrm{Tw}\right] \;\approx\; \Delta \Phi_F \quad\Longleftrightarrow\quad \frac{d}{dt}\big(\Delta\phi - \alpha\,\mathrm{Tw}\big) \approx \iint_{\mathcal{B}} \partial_t F .

Protocol

Create a fixed-geometry belt and modulate interior curvature by a known control (e.g., vary the across-width binding amplitude) with frequency $f$ and small amplitude $A$ .
Keep $\mathrm{Tw}$ constant (or separately log its small drift).
Sample per-step: $\Delta\phi_t, \Phi_{F,t}, \mathrm{Tw}_t$ . Form
$Y_t=\Delta\phi_t-\alpha\,\mathrm{Tw}_t$ , and differences $\Delta Y_t, \Delta \Phi_{F,t}$ .

Expected curves

Tracking: $\Delta Y_t$ tracks $\Delta \Phi_{F,t}$ with near-unit gain.
Frequency sweep: amplitude ratio $|\Delta Y|/|\Delta \Phi_F| \approx 1$ until numerical bandwidth; phase lag $\le$ one step.

Tolerances

Correlation: $\operatorname{corr}(\Delta Y, \Delta \Phi_F) \ge 0.95$ .
Gain: median $|\Delta Y|/|\Delta \Phi_F| \in [0.95,1.05]$ .
Lag: cross-correlation peak at lag $|\ell|\le 1$ step (or phase error $\le 10^\circ$ ).
Spike response: safety gate (Ch. 17) triggers on injected flux spikes ≥ $4\sigma$ within $K=3$ steps.

Failure diagnostics

Gain < 0.95 → under-resolved interior; increase mesh or estimator SNR.
Large lag → readouts buffered/asynchronous; move metrics to the same clock or add alignment.

26.5 Reproducibility checklist (must report)

Environment & code

Commit hash; library versions; BLAS/GPU; precision (FP16/32/64); expm/logm implementation.
RNG seeds for model & benchmark harness; determinism flags (e.g., cuDNN).

Geometry & estimators

Belt construction (centerline, width schedule $w$ , framing ops); mesh sizes $(N_s,N_n)$ ; ordering (snake); thinness $\varepsilon$ .
Estimator family: U(1)/U(k)/Uhlmann; subspace dimension $K$ ; window size; polar/Procrustes choices; unitary projection cadence.
Calibrated $\alpha$ and method (Suite A).

Acceptance bands

Exact thresholds used (may tighten but not loosen defaults).
Number of repeats and averaging method (mean/MAD).

Artifacts

Plots: Suite A ( $\Delta\phi$ vs $\mathrm{Tw}$ unwrapped), Suite B ( $\Delta\phi$ vs $w$ ), Suite C (Bode-style gain/phase vs $f$ ).
Raw logs (schema below) as JSONL; plus a short “run manifest”.

26.6 Log schema (JSONL)

Run manifest (one JSON):

{
  "run_id": "uuid",
  "suite": "A|B|C",
  "commit": "abc123",
  "precision": "fp32",
  "alpha": 1.000,
  "geom": {"Ns":128,"Nn":8,"ordering":"snake","thinness_max":0.18},
  "estimators": {"family":"Uk","K":8,"window":16,"polar_every":8},
  "thresholds": {"residual_deg":1.0,"R2":0.95,"gain_band":[0.95,1.05]},
  "seeds": {"model":1337,"bench":4242}
}

Per-step record (one line per measurement):

{
  "run_id":"uuid",
  "step": 57,
  "w": 0.075,
  "Tw": 1.0,
  "DeltaPhi": 0.5236,
  "PhiF": 0.5061,
  "r_FBHL": 0.0175,
  "thinness": 0.12,
  "unitarity_norm": 0.003,
  "commutator_proxy": 0.021,
  "wrap_index": 2,
  "mode": "normal|caution|abort",
  "timestamp": "2025-09-19T20:41:12Z"
}

Per-run summary (append at end):

{
  "run_id":"uuid",
  "suite":"B",
  "fit": {"slope_beta":6.24, "intercept":0.00, "R2":0.972, "curvature_pct":0.034},
  "bands": {"residual_MAD_deg":0.6, "max_residual_deg":1.2},
  "pass": true
}

26.7 Expected plots & target shapes

Suite A: Unwrapped $\Delta\phi$ vs $\mathrm{Tw}$ → straight line (slope $\alpha$ ); wrapped plot shows neat sawtooth.
Suite B: $\Delta\phi$ vs $w$ → straight line; overlay $\Phi_F(w)$ with same slope; residual flat near zero.
Suite C: Gain ~1 flat up to a corner frequency (mesh/estimator bandwidth); phase near 0°, drifting toward delay at high $f$ .

26.8 Leaderboard metrics (report these)

A. Framing: slope error $|\hat{\alpha}-\alpha|/\alpha$ ; residual MAD (deg); repeatability CV (%).
B. Width law: $R^2$ ; curvature of fit (%); max residual (deg).
C. Faraday: correlation; gain band hit-rate; max lag (steps); spike detection TPR/FPR.

Provide all as mean ± MAD over ≥3 independent runs.

26.9 Common pitfalls (and fixes)

Orientation mistakes: verify “upper minus lower” everywhere; add a unit test that flips an edge and expects failure.
Unitary drift: increase polar projection cadence; log determinant modulus.
Non-Abelian seams: align frames or refine across-width near seams; otherwise expect width-law curvature.
Thinness breaches: promote to slab locally; do not “pass” Suite B by narrowing $w$ after the fact—declare geometry change.

Outcome. With these three suites, tight tolerances, and a strict logging schema, you can prove your belt implementation is physically faithful (Suite A), geometrically calibrated (Suite B), and dynamically correct (Suite C)—and others can reproduce it byte-for-byte.

Ch. 27 — Reference Implementation

Below is a minimal, self-contained API you can drop into a Python/JAX/PyTorch project. It defines metrics, losses, and controllers with a strict audit logging format that matches Chapter 26. The code is framework-agnostic pseudocode with concrete function names, signatures, shapes, and return types so you can port it verbatim.

27.1 Packages and core types

# -------------------------
# belt.types
# -------------------------
from dataclasses import dataclass
from typing import Literal, Dict, List, Tuple, Optional

Family = Literal["U1","Uk","Uhlmann"]
Ordering = Literal["snake"]  # (use 'snake' as in Ch.24)

@dataclass
class MeshConfig:
    Ns: int                      # cells along s
    Nn: int                      # rungs across n
    ordering: Ordering = "snake"
    delta_max: float = 0.3       # clamp on ||log H_cell||
    polar_every: int = 8         # project-to-unitary cadence

@dataclass
class EstimatorConfig:
    family: Family               # U1 / Uk / Uhlmann
    K: int = 8                   # subspace dim for Uk/Uhlmann
    window: int = 16             # PCA/CCA window (Ch.25)
    mixed_precision: bool = True

@dataclass
class Thresholds:
    alpha: float                 # framing coefficient
    residual_deg: float = 1.0
    thinness_max: float = 0.2
    width_R2_min: float = 0.95
    gain_band: Tuple[float,float] = (0.95,1.05)
    spike_z1: float = 2.5
    spike_z2: float = 4.0
    spike_K: int = 3
    seam_twist_max: float = 0.5  # twist units

@dataclass
class BeltConfig:
    mesh: MeshConfig
    est: EstimatorConfig
    thr: Thresholds

@dataclass
class Metrics:  # single step
    DeltaPhi: float              # edge gap (class function)
    PhiF: float                  # interior flux
    Tw: float                    # twist (units)
    r_FBHL: float                # residual = Δφ - (ΦF + α·Tw)
    thinness: float              # ε = max κ·w
    unitarity_norm: float        # ||U†U - I||_F (max over factors)
    commutator_proxy: float      # seam BCH proxy
    wrap_index: int              # phase unwrap counter

@dataclass
class Losses:
    L_tbl_cons: float
    L_tbl_goal: float
    L_fr: float
    L_ts: float
    L_total: float

27.2 Minimal metrics API

# -------------------------
# belt.metrics
# -------------------------
class BeltMetrics:
    def __init__(self, cfg: BeltConfig):
        self.cfg = cfg

    # --- transports are your inputs (from Ch.24/25 estimators) ---
    # Uk: Usp, Usm, Hcells are lists of KxK complex unitaries
    # U1: they are float angles; Uhlmann: unitaries from polar
    def edge_gap(self, Usp: List, Usm: List) -> Tuple[float,int]:
        """
        Returns (DeltaPhi, wrap_index). Uses class function:
        - Uk/Uhlmann: argdet(Π Usp · (Π Usm)^-1)
        - U1: sum(a_plus - a_minus)
        """
        ...

    def flux(self, Hcells: List) -> float:
        """
        Sum of per-cell class phases:
        - Uk/Uhlmann: sum argdet(H_cell)
        - U1: sum cell angles
        """
        ...

    def twist(self, phi_angles: List[float]) -> Tuple[float,int]:
        """
        Twist = (1/2π) * unwrap(sum Δphi_frame).
        Returns (Tw, wrap_index_for_style_frame)
        """
        ...

    def residual(self, DeltaPhi: float, PhiF: float, Tw: float) -> float:
        return DeltaPhi - (PhiF + self.cfg.thr.alpha * Tw)

    def thinness(self, kappa_max: float, width: float) -> float:
        return kappa_max * width

    def commutator_proxy(self, Hcells_row: List, Hcells_next: List) -> float:
        """
        Approximates ∑||[log H_i, log H'_j]|| across the seam for diagnostics.
        """
        ...

    def unitarity_norm(self, factors: List) -> float:
        """ Max ||U†U - I||_F over provided transports. """
        ...

    def compute(self, transports: Dict) -> Metrics:
        """
        transports:
          - "Usp", "Usm": edge factors (lists)
          - "Hcells": cell factors (list of lists or flat)
          - "phi_frame": framing angles along edge (list of floats)
          - "kappa_max", "width": geometry stats
          - "factors_all": all matrices to audit unitarity
        """
        Δφ, w1 = self.edge_gap(transports["Usp"], transports["Usm"])
        ΦF = self.flux(transports["Hcells"])
        Tw, w2 = self.twist(transports["phi_frame"])
        r = self.residual(Δφ, ΦF, Tw)
        eps = self.thinness(transports["kappa_max"], transports["width"])
        un = self.unitarity_norm(transports["factors_all"])
        bch = self.commutator_proxy(transports["Hcells_row0"], transports["Hcells_row1"])
        return Metrics(Δφ, ΦF, Tw, r, eps, un, bch, wrap_index=w1)

Implementation notes:

Class functions must be used (e.g., arg_det(U) = imag(trace(log(U)))) to maintain gauge invariance.
Apply polar projection to transports every cfg.mesh.polar_every factors.

27.3 Minimal losses API (Ch. 16)

# -------------------------
# belt.losses
# -------------------------
def two_boundary_loss_cons(metrics: Metrics, delta: float) -> float:
    """Huber(Δφ - ΦF - α·Tw) with threshold delta (radians)."""
    ε = metrics.DeltaPhi - metrics.PhiF - metrics.r_FBHL + 0.0  # r_FBHL already includes α·Tw
    # Recompute explicitly to avoid dependency on r_FBHL if preferred:
    # ε = metrics.DeltaPhi - (metrics.PhiF + alpha*metrics.Tw)
    return huber(ε, delta)

def two_boundary_loss_goal(metrics: Metrics, DeltaPhi_star: float, delta: float) -> float:
    return huber(metrics.DeltaPhi - DeltaPhi_star, delta)

def flux_regularization(Hcells: List, lamF: float, lamGrad: float, lamUnit: float, factors: List) -> float:
    """
    lamF * Σ ||log H||_F^2 + lamGrad * Σ||log Hi - log Hj||_F^2 + lamUnit * Σ ||U†U - I||_F^2
    """
    ...

def twist_steering(Tw: float, Tw_star: Optional[float], mu1: float, mu2: float, muq: float, phi_angles: List[float]) -> float:
    """
    mu1 * Huber(Tw - Tw*) + mu2 * smoothness(phi_angles) + muq * quantize(Tw to Z or Z/2)
    """
    ...

def total_loss(m: Metrics, pieces: Dict) -> Losses:
    L_tbl_c = two_boundary_loss_cons(m, delta=pieces["delta_tbl"])
    L_tbl_g = 0.0 if pieces.get("DeltaPhi_star") is None else two_boundary_loss_goal(m, pieces["DeltaPhi_star"], pieces["delta_tbl"])
    L_fr    = flux_regularization(pieces["Hcells"], pieces["lamF"], pieces["lamGrad"], pieces["lamUnit"], pieces["factors_all"])
    L_ts    = twist_steering(m.Tw, pieces.get("Tw_star"), pieces["mu1"], pieces["mu2"], pieces["muq"], pieces["phi_frame"])
    L_tot   = pieces["w_tbl"]*(L_tbl_c + pieces["w_goal"]*L_tbl_g) + pieces["w_fr"]*L_fr + pieces["w_ts"]*L_ts
    return Losses(L_tbl_c, L_tbl_g, L_fr, L_ts, L_tot)

Gradients. In autograd frameworks, implement logm, expm, polar, and arg_det with differentiable kernels; for unwrap, stop-grad the integer wrap counter (Ch. 16).

27.4 Minimal controllers API (Ch. 17)

# -------------------------
# belt.controllers
# -------------------------
@dataclass
class EWMAState:
    PhiF_ewma: float = 0.0
    PhiF_mad: float = 1e-6
    r_mad: float = 1e-6
    spike_count: int = 0

@dataclass
class GateDecision:
    mode: Literal["normal","caution","abort"]
    reason: Optional[str] = None

def safety_gate(m: Metrics, ew: EWMAState, thr: Thresholds) -> GateDecision:
    # z-score slope proxy: here use simple diff; in production keep a small buffer/window
    S = (m.PhiF - ew.PhiF_ewma) / (ew.PhiF_mad + 1e-6)
    Q = abs(m.r_FBHL) / (ew.r_mad + 1e-6)
    breach = (m.thinness > thr.thinness_max)
    caution = (abs(S) >= thr.spike_z1) or (Q >= thr.residual_deg)
    abort = breach or (abs(S) >= thr.spike_z2 and ew.spike_count+1 >= thr.spike_K)
    return GateDecision("abort","thinness" if breach else "spike") if abort else \
           GateDecision("caution","flux/residual") if caution else \
           GateDecision("normal")

@dataclass
class TwistDialGains:
    kp: float = 0.5
    kd: float = 0.1
    cap: float = 0.5
    residual_band_deg: float = 2.0

def twist_dial(m: Metrics, Tw_star: float, prev_e: float, gains: TwistDialGains) -> float:
    e = Tw_star - m.Tw
    u = gains.kp * clip(e, -gains.cap, gains.cap) + gains.kd * (e - prev_e)
    if abs(m.r_FBHL) > gains.residual_band_deg * (3.14159/180):
        u *= 0.5  # de-rate near residual bound
    return u  # map to your style actuators

Plan repair via tiling is a higher-level routine (Ch. 19); expose it as plan_repair(tiles, budgets) -> path.

27.5 Transport & estimator shims (Ch. 24–25)

Provide thin wrappers so users can plug in their own model signals:

# -------------------------
# belt.estimators
# -------------------------
def procrustes_edge(Hk, Hk1) -> "Uk_step":
    """Orthogonal Procrustes U_s[k] = U V^T from SVD(Hk^T Hk1)."""
    ...

def polar_rung(E_t, G_t) -> "Uk_step":
    """Across-width unitary R from polar(E^T G)."""
    ...

def uhlmann_step(rho_k, rho_k1) -> "Uk_step":
    """Uhlmann parallel transport via polar(rho_k^(1/2) rho_k1^(1/2))."""
    ...

def u1_edge(a_plus: List[float], a_minus: List[float]) -> float:
    """U(1) edge gap: sum(a_plus - a_minus)."""
    ...

def class_phase(U) -> float:
    """arg_det(U) or principal eigenphase."""
    ...

27.6 Audit logging (JSONL) — exact schema

Conform exactly to Chapter 26. Provide a tiny writer with manifest, step, and summary records.

# -------------------------
# belt.logging
# -------------------------
import json, uuid, time
from pathlib import Path

class LogWriter:
    def __init__(self, out_dir: str, suite: Literal["A","B","C"], cfg: BeltConfig, commit: str, precision: str, seeds: Dict):
        self.run_id = str(uuid.uuid4())
        self.path = Path(out_dir) / f"{self.run_id}.jsonl"
        self.path.parent.mkdir(parents=True, exist_ok=True)
        manifest = {
            "run_id": self.run_id,
            "suite": suite,
            "commit": commit,
            "precision": precision,
            "alpha": cfg.thr.alpha,
            "geom": {"Ns": cfg.mesh.Ns, "Nn": cfg.mesh.Nn, "ordering": cfg.mesh.ordering, "thinness_max": cfg.thr.thinness_max},
            "estimators": {"family": cfg.est.family, "K": cfg.est.K, "window": cfg.est.window, "polar_every": cfg.mesh.polar_every},
            "thresholds": {"residual_deg": cfg.thr.residual_deg, "R2": cfg.thr.width_R2_min, "gain_band": list(cfg.thr.gain_band)},
            "seeds": seeds
        }
        self._write(manifest)

    def _write(self, obj: Dict): 
        with self.path.open("a") as f: f.write(json.dumps(obj)+"\n")

    def log_step(self, step: int, m: Metrics, mode: str):
        self._write({
            "run_id": self.run_id,
            "step": step,
            "Tw": m.Tw, "DeltaPhi": m.DeltaPhi, "PhiF": m.PhiF, "r_FBHL": m.r_FBHL,
            "thinness": m.thinness, "unitarity_norm": m.unitarity_norm,
            "commutator_proxy": m.commutator_proxy, "wrap_index": m.wrap_index,
            "mode": mode, "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
        })

    def log_summary(self, suite: str, fit: Dict, bands: Dict, passed: bool):
        self._write({
            "run_id": self.run_id,
            "suite": suite,
            "fit": fit,
            "bands": bands,
            "pass": passed
        })

27.7 End-to-end “hello belt” (10 lines)

cfg = BeltConfig(
    mesh=MeshConfig(Ns=128, Nn=8),
    est=EstimatorConfig(family="Uk", K=8, window=16),
    thr=Thresholds(alpha=1.0)
)
metr = BeltMetrics(cfg); logs = LogWriter("./logs","B",cfg,commit="abc123",precision="fp32",seeds={"model":1337,"bench":4242})

for step, transports in enumerate(stream_transports()):
    m = metr.compute(transports)
    gate = safety_gate(m, ew=EWMAState(), thr=cfg.thr)
    logs.log_step(step, m, gate.mode)
# After sweep, compute fit stats for Suite B and write:
logs.log_summary("B", fit={"slope_beta":6.24,"intercept":0.0,"R2":0.972,"curvature_pct":0.034},
                    bands={"residual_MAD_deg":0.6,"max_residual_deg":1.2}, passed=True)

27.8 Acceptance tests (unit-level)

Provide three unit tests that mirror Ch. 26:

Framing: apply ±1 twist units; check slope $\alpha$ within 2%, residual MAD ≤ 1°.
Width scaling: 5 widths; linear $R^2 \ge 0.95$ , curvature ≤ 5%.
Faraday: modulate interior; correlation ≥ 0.95, gain in [0.95,1.05].

Implement these as pytest tests that read the JSONL and assert on summary fields.

27.9 Implementation checklist

Use class functions everywhere; never compare raw matrices.
Enforce polar projection regularly to keep unitarity.
Keep the ordering discipline (lower→upper; snake in s).
Clamp local ||log H_cell|| ≤ delta_max and refine the mesh if exceeded.
Always emit manifest → steps → summary; never skip fields.

Outcome. This reference API gives you the smallest viable surface for computing belt metrics, training with belt losses, steering with controllers, and auditing with reproducible logs. Plug in your model-specific estimators (Ch. 25) and mesh/ordering (Ch. 24), and you’ll match the benchmarks and invariance properties specified in Chapters 15–26.

Ch. 28 — Physics Mini-Cases

Dirac belt trick; framed Wilsons; Uhlmann/Berry geometric force as holonomy variation (worked)

These three worked mini-cases pin the abstract belt calculus to familiar physics. Each example is self-contained, stated in standard gauge/adiabatic language, and instrumented with the belt readouts from Ch. 15 (edge gap $\Delta\phi$ , flux $\Phi_F$ , twist $\mathrm{Tw}$ , residual $r_{\mathrm{FBHL}}$ ).

28.1 Dirac belt trick (the $4\pi$ phenomenon)

Set-up (what the belt measures)

Consider a rigid “puck” carrying a spin- $s$ representation. Rotate the puck about a fixed axis by angle $\theta$ , keeping the two belt edges attached to the room (lower edge) and the puck (upper edge).
Choose a U(1) readout for the edge holonomy: for a fixed reference spinor $|\psi\rangle$ , define
$\Delta\phi(\theta) := \arg \langle \psi | U(\theta) |\psi\rangle ,$
where $U(\theta)$ is the rotation operator in the $s$ -representation. (Any class-function scalar works; this U(1) overlap makes the sign flip visible for $s{=}\tfrac{1}{2}$ .)
Twist $\mathrm{Tw}$ counts how many full turns the belt’s framing accumulates (integer units). Here $\mathrm{Tw}=\theta/2\pi$ .

Prediction (FBHL specialization)

In the thin-belt regime with negligible interior curvature (pure rigid rotation), FBHL reduces to

\Delta\phi(\theta) \;=\; \alpha\,\mathrm{Tw} \;=\; \alpha\,\frac{\theta}{2\pi}, \qquad \alpha = 2\pi s .

Hence for spin- $\tfrac{1}{2}$ : $\Delta\phi(\theta)=\tfrac{\theta}{2}$ (mod $2\pi$ ). A $2\pi$ turn gives a phase shift of $\pi$ (sign flip); a $4\pi$ turn returns to the initial state.

Worked check (discrete)

Sample $\theta\in\{0,\pi,2\pi,3\pi,4\pi\}$ .
Measure $\Delta\phi$ via the overlap estimator above; measure $\mathrm{Tw}=\theta/2\pi$ ; $\Phi_F\simeq 0$ (no interior deformation).
Fit $\Delta\phi$ vs. $\mathrm{Tw}$ . Slope should be $\alpha=2\pi s$ within 2% (Suite A). Residual $r_{\mathrm{FBHL}}\approx 0$ .

Takeaway

The belt trick is literally the framing term of FBHL. The double-cover ( $4\pi$ ) periodicity is the statement that two twist units restore all observables, while a single unit produces a physical phase when $s$ is half-integer.

28.2 Framed Wilsons (Abelian and gently non-Abelian)

We make Wilson-type holonomies on belts rather than single loops, so the upper–minus–lower edge gap equals interior flux plus framing—exactly the quantity you can compute and test.

28.2.1 Abelian case (uniform field / Aharonov–Bohm patch)

Geometry. A rectangular belt of length $L$ and width $w$ , spanning a region with uniform magnetic field $B$ normal to the surface. Charge $q$ . Choose constant framing so $\mathrm{Tw}=0$ .

Holonomy & belt readouts.

Edge gap (U(1)): $\Delta\phi = q \oint_{\Gamma_+} \!A - q\oint_{\Gamma_-}\!A$ .
Flux: $\Phi_F = q \iint_{\mathcal{B}} F = q B L w$ .
FBHL: $\Delta\phi = \Phi_F + \alpha \mathrm{Tw} = qBLw$ .

Width law (worked). Sweep $w$ at fixed $B,L$ . Expect

\Delta\phi(w) = q B L\; w, \qquad R^2 \ge 0.95,\ \ r_{\mathrm{FBHL}}\approx 0

(Suite B). This is the belt version of Stokes (upper–minus–lower circulation equals interior flux).

Solenoid (AB limit). If $B{=}0$ on the belt but the vector potential has non-trivial circulation from a distant solenoid, the same belt measurement picks up $\Phi_F=q\Phi_{\mathrm{AB}}$ through the enclosed area. With $\mathrm{Tw}{\neq}0$ you’ll see $\Delta\phi=\Phi_F+\alpha\,\mathrm{Tw}$ .

28.2.2 Gently non-Abelian (commuting patch)

Choose a background SU(2) gauge potential with curvature along a fixed generator, e.g.

A_s = \tfrac{B}{2}\sigma_z\, n,\qquad A_n = 0 \quad\Rightarrow\quad F = B\,\sigma_z\, ds\wedge dn .

All plaquettes $H_{ij}$ then commute. Pick a U(1) class function by projecting to an eigenstate of $\sigma_z$ (or take principal eigenphase). The same belt law holds:

\Delta\phi = \underbrace{\iint \!\! \mathrm{Tr}(\rho\,F)}_{\Phi_F}\;+\;\alpha\,\mathrm{Tw},

with $\rho$ the rank-1 projector onto the chosen eigenstate. In practice this is identical to the Abelian test but computed from matrix transports (Ch. 24).

Non-commuting seams. If you tilt the field so different plaquettes point along different Pauli axes, BCH errors appear. In belt diagnostics you’ll see:

linearity in $w$ degrade (curvature in fit),
a non-zero commutator proxy,
small but systematic $r_{\mathrm{FBHL}}$ unless you refine or align frames.
That is the textbook signature of non-Abelian surface ordering.

28.3 Uhlmann/Berry geometric force as holonomy variation (worked)

The principle (Ch. 9): adiabatic/geometric forces are variational responses of belt holonomy. Here we work two cases—pure Berry (zero temperature) and Uhlmann (finite-temperature/mixed states).

28.3.1 Two-level system (Berry)

Hamiltonian. $H(\boldsymbol{R}) = -\tfrac{1}{2}\,\boldsymbol{R}\cdot\boldsymbol{\sigma}$ with control $\boldsymbol{R}=(R_x,R_y,R_z)$ . The ground state defines a Berry connection $\mathcal{A}(\boldsymbol{R})$ with curvature

\mathcal{F}_{ab}(\boldsymbol{R}) = \frac{1}{2}\,\epsilon_{abc}\,\frac{R_c}{\|\boldsymbol{R}\|^3}, \qquad a,b,c\in\{x,y,z\}.

Belt. Let the two edges be nearby control paths $\boldsymbol{R}_\pm(t)=\boldsymbol{R}(t)\pm \tfrac{\delta}{2}\hat{\boldsymbol{n}}$ over $t\in[0,T]$ . The belt spans a narrow ribbon in parameter–time space $(t,\lambda)$ with across-width coordinate $\lambda\in[-\tfrac{\delta}{2},+\tfrac{\delta}{2}]$ .

Prediction.

\Delta\phi \;=\; \iint_{\mathcal{B}}\!\mathcal{F}_{t\lambda}\;+\;\alpha\,\mathrm{Tw} \;\approx\; \delta \int_0^T \hat{\boldsymbol{n}}\!\cdot\!\big(\mathcal{F}(\boldsymbol{R})\,\dot{\boldsymbol{R}}\big)\,dt \;+\; \alpha\,\mathrm{Tw}.

If you hold framing fixed ( $\mathrm{Tw}{=}0$ ), the instantaneous belt slope per width is

\frac{1}{\delta}\frac{d}{dt}\Delta\phi \;=\; \hat{\boldsymbol{n}}\!\cdot\!\big(\mathcal{F}\,\dot{\boldsymbol{R}}\big),

i.e. the Berry “magnetic field” contracted with the velocity—this is the geometric EMF.

Geometric force (work). If a generalized coordinate $q$ couples to $\boldsymbol{R}$ and you read work from the phase rate, the force contribution

F_{\mathrm{geom}}(q) \;\propto\; \partial_q \Delta\phi \;\approx\; \iint_{\mathcal{B}} \partial_q \mathcal{F}

is the variational response of belt holonomy; in the two-level model it reduces to the solid-angle rate on the Bloch sphere.

Worked trace. Drive $\boldsymbol{R}$ on a latitude circle while separating edges radially. Measured $\Delta\phi$ grows linearly in the enclosed solid-angle rate; switching direction flips its sign. Suite C (Faraday) will show gain $\approx 1$ between $\Delta(\Delta\phi)$ and $\Delta\Phi_F$ .

28.3.2 Finite temperature / ensembles (Uhlmann)

Mixed state. Let $\rho(\boldsymbol{R}) = e^{-\beta H(\boldsymbol{R})}/Z$ . Use the Uhlmann connection (Ch. 25): the discrete step between $\rho(t)$ and $\rho(t+\Delta t)$ is the unitary part $R$ of the polar decomposition of $\rho(t)^{1/2}\rho(t+\Delta t)^{1/2}$ .

Belt identity (mixed). With the same ribbon construction in $(t,\lambda)$ ,

\Delta\phi_{\mathrm{Uhl}} \;=\; \iint_{\mathcal{B}}\!\mathcal{F}_{\mathrm{Uhl}}\;+\;\alpha\,\mathrm{Tw}.

As $T\!\to\!0$ , $\mathcal{F}_{\mathrm{Uhl}}\to\mathcal{F}_{\mathrm{Berry}}$ . As $T\!\to\!\infty$ , the state approaches maximally mixed and $\mathcal{F}_{\mathrm{Uhl}}\to 0$ .

Worked curve (temperature sweep). Fix the control ribbon and vary $\beta$ . Measure $\Delta\phi_{\mathrm{Uhl}}(\beta)$ with $\mathrm{Tw}{=}0$ .

Expected: a monotone drop from the Berry value at low $T$ toward 0 at high $T$ .
Acceptance: the ratio $\Delta\phi_{\mathrm{Uhl}}(\beta)/\Delta\phi_{\mathrm{Berry}}$ follows the thermal polarization $\tanh(\beta \|\boldsymbol{R}\|/2)$ within tolerance for narrow belts (this is the standard two-level thermal weight).

Geometric force (mixed). The time-differential belt law still holds:

\Delta\!\left[\Delta\phi_{\mathrm{Uhl}} - \alpha\,\mathrm{Tw}\right] \;\approx\; \Delta \Phi_{F,\mathrm{Uhl}},

so Suite C’s gain/phase checks apply unchanged.

28.4 Minimal experiment cards (plug-and-play)

E1 — Dirac belt (spin-½).

Do: rotate by $\theta$ while keeping curvature negligible; compute $\Delta\phi$ from an overlap; log $\mathrm{Tw}=\theta/2\pi$ .
Expect: slope $\alpha{=}\pi$ , residual $<1^\circ$ , wrapped sawtooth; 4 $\pi$ periodicity.

E2 — Abelian framed Wilson.

Do: rectangle $L{\times}w$ , uniform $B$ , $\mathrm{Tw}{=}0$ ; sweep $w$ .
Expect: $\Delta\phi(w)=qBL\,w$ , $R^2\ge 0.95$ , residual $\approx 0$ .

E3 — Non-Abelian commuting patch.

Do: SU(2) field along one generator; project to an eigenstate; run E2.
Expect: identical linear law; commutator proxy near zero.

E4 — Non-Abelian seam.

Do: change generator across half the belt.
Expect: width-fit curvature $>0$ , non-zero commutator proxy, small $r_{\mathrm{FBHL}}$ unless refined/aligned.

E5 — Berry EMF.

Do: two nearby control paths on a latitude; measure $\Delta(\Delta\phi)$ vs. $\Delta \Phi_F$ over time.
Expect: correlation $\ge 0.95$ , gain in $[0.95,1.05]$ , phase lag $\le$ 1 step.

E6 — Uhlmann temperature sweep.

Do: fix ribbon; vary $\beta$ ; compute Uhlmann steps (polar between $\rho^{1/2}$ s).
Expect: monotone drop toward 0 with the thermal polarization curve; Faraday gain $\approx 1$ .

28.5 What to log (tie-back to Ch. 26)

Per run: the manifest; per step: $\Delta\phi, \Phi_F, \mathrm{Tw}, r_{\mathrm{FBHL}}, \varepsilon,$ unitarity norm, commutator proxy, wrap index; per run summary: slope/fit for the width and twist sweeps, Faraday gain/phase, and pass/fail flags.

Bottom line

The Dirac belt trick is FBHL with $\Phi_F\simeq 0$ ; it nails the framing coefficient $\alpha=2\pi s$ and the $4\pi$ periodicity.
Framed Wilsons on belts unify Stokes and framing in one measurement; Abelian physics falls out instantly, and non-Abelian seams appear exactly where BCH says they will.
Geometric forces (Berry/Uhlmann) are nothing but variations of belt holonomy in parameter–time space; the Faraday test is their operational fingerprint.

Ch. 29 — Soft-Matter & Robotics

DNA supercoiling; ribbon robots; EM “upper–minus–lower” sensing (sim plans)

We show how the belt calculus becomes an operational instrument in soft-matter and robotics. Each section gives (i) a clean belt model, (ii) what to measure $(\Delta\phi,\Phi_F,\mathrm{Tw},r_{\mathrm{FBHL}})$ , and (iii) simulation/bench plans with expected curves and pass bands (compatible with Ch. 26–27 tooling).

29.1 DNA supercoiling as a belt experiment

29.1.1 Belt model

Treat a torsionally constrained DNA segment (length $L$ ) as a ribbon with edges the helical backbones $\Gamma_\pm$ . Framing tracks the local base-pair orientation; Twist is the integrated helical rotation, Writhe is the 3D centerline coiling. The classical relation

\mathrm{Lk} \;=\; \mathrm{Tw} + \mathrm{Wr}

is read in belt form by taking the edge gap as a class-function phase proportional to linking:

\Delta\phi \;=\; \alpha\,\mathrm{Lk},\qquad \text{and}\quad \Phi_F \approx \alpha\,\mathrm{Wr},\quad \Rightarrow\quad \Delta\phi \;=\; \Phi_F + \alpha\,\mathrm{Tw}.

Here $\alpha$ is fixed by one calibration (e.g., one full helical turn).

29.1.2 What to measure

Tw (helical twist): unwrap base-pair frame angle along the molecule.
Flux $\Phi_F$ (writhe proxy): tiled plaquettes from across-width transports that reflect out-of-plane bending/looping; numerically equals a discretized writhe contribution.
Residual $r_{\mathrm{FBHL}}$ : detects defects (nicks, kinks) or large non-commuting curvature patches.

29.1.3 Bench plan (magnetic-tweezer analogue)

Clamp ends; set tensions $T \in \{0.1…5\}$ pN.
Sweep added turns $n \in [-6, +6]$ (linking changes).
For each $(T,n)$ : reconstruct centerline (from simulation or reconstruction stack), compute $\mathrm{Tw},\Phi_F$ , and $\Delta\phi$ from edge holonomies.
Expected curves:
- Linear regime: $\Delta\phi \approx \alpha\,n$ , $\Phi_F\!\approx\!0$ (pre-plectoneme).
- Buckling: $\Phi_F$ rises as writhe takes the load; slope of $\Delta\phi(n)$ weakens (part of linking shunted to $\Phi_F$ ).
- Hysteresis under load ramps (optional).

Pass bands. Pre-buckling: $|r_{\mathrm{FBHL}}|\le 1^\circ$ , linear fit $R^2\!\ge 0.97$ . At onset: flux step detected with $z\!\ge\!4$ in the Faraday test (Ch. 26C).

29.1.4 Diagnostics

Kink or nick: sharp residual spikes localized in arc-length; fix mesh or mark defect.
Over-thin mesh: width law curvature; refine across $n$ where writhe localizes.

29.2 Ribbon robots (continuum manipulators as belts)

29.2.1 Belt/control mapping

Model a planar (or spatial) ribbon robot as a belt along its centerline; actuators (tendons, pneumatic chambers) induce local curvature/torsion → interior curvature flux. The user intent or end-effector trace is the upper edge $\Gamma_+$ ; actuator trajectories are the lower edge $\Gamma_-$ .

Creativity/style vs. precision. Use twist $\mathrm{Tw}$ as an orientation/style dial (e.g., wrist roll, writing angle).
Effort and safety. Use flux density $|\Phi_F|/{\rm length}$ as an internal-work proxy; gate spikes to avoid self-contact or tendon over-stress.

29.2.2 Controllers (drop-in from Ch. 17)

Safety gate: abort when $|S_t|\!\ge\!4$ (flux spike) or thinness proxy exceeds band.
Twist dial: track $\mathrm{Tw}^\star$ for tasks like seam welding, painting, or suture placing.
Plan repair (tiling): segment the path into tiles (reach, orient, place); swap a tile if its belt cost grows.

29.2.3 Sim plan (drawing and threading tasks)

A) Precision drawing (letters/contours).

Build a 2-D ribbon arm model (Cosserat rod).
Target path $p(s)$ (upper edge); actuators define lower edge.
Metrics per tile: keep $r_{\mathrm{FBHL}}\!\le\!1^\circ$ , flux density below band; twist follows lettering style.

B) Thread-through-loop task (3-D).

Add torsional actuation.
Expected flux burst at obstacle clearance; twist step to align thread orientation.
Pass: no aborts; $\max r_{\mathrm{FBHL}}\!\le\!2^\circ$ ; seam twist at tile joints $\le 0.5$ units.

29.2.4 Learning policy with belt losses (Ch. 16)

Train a policy $\pi_\theta$ using:

\mathcal{L} = w_{\text{TBL}}\,\rho\!\big(\Delta\phi\!-\!\Phi_F\!-\!\alpha\mathrm{Tw}\big) + w_F \sum \|\log H_\square\|^2 + w_T\,\rho(\mathrm{Tw}-\mathrm{Tw}^\star).

Outcome: smoother actuation (FR term), consistent pose tracking (TBL), controllable roll (TS).

29.3 EM “upper–minus–lower” sensing (differential belts)

29.3.1 Belt sensor concept

Two closely spaced conductive loops/strips form a belt sensor. The upper–minus–lower edge gap measures the differential magnetic flux through the annulus:

\Delta\phi \;=\; q\!\oint_{\Gamma_+}\!A - q\!\oint_{\Gamma_-}\!A \;=\; q \!\iint_{\mathcal{B}} F \;=\; \Phi_F .

(Here $\alpha\mathrm{Tw}=0$ with fixed framing.) This configuration rejects common-mode fields and highlights gradients (nearby wires, small ferromagnetic parts, eddy currents).

29.3.2 Robotic use-cases

Cable finding / power-line avoidance: mount belt sensors on a UAV or ground robot; route away from flux spikes.
Metallic debris pick-up: gripper with belt sensors at fingertips; positive flux tiles signal the object’s presence and location.
In-hand pose updates: rotate the gripper; twist sweep separates field anisotropy from motion artifacts.

29.3.3 Sim plan (quasi-static EM)

Environment. A straight current $I$ in a wire; optionally a small conductive plate (eddy currents).
Sensor. Two loops separated by $w$ , length $L$ .
Sweep. Move parallel at height $h$ ; scan $w$ and $h$ .

Expected curves.

Differential signal $\Phi_F(h) \propto L\,[B(h+w)-B(h)]$ → finite-difference gradient; logarithmic roll-off with $h$ .
Width law: $\Phi_F \approx L\,w\,\partial_h B$ for small $w$ (linear in $w$ ).
Eddy plate: Faraday burst when entering/leaving → spike detected by the safety gate.

Pass bands. Width linearity $R^2\!\ge\!0.95$ ; spike z-score $\ge 4$ on entry; residual near zero (no twist).

29.3.4 Robot integration (online controller)

Route by flux-threshold (Ch. 18): expand search near $|\Phi_F|$ rises; contract otherwise.
Abort if consecutive spike flags; re-plan with belt tiling around forbidden zones.

29.4 Pseudocode stubs (shared harness)

# --- DNA writhe/twist sweep ---
for n in turns:                         # linking change
    geom = twist_end_constraints(geom0, n)
    transports = estimate_transports(geom, family="Uk")  # Ch.25
    m = metrics.compute(transports)                       # Ch.27
    logs.log_step(step++, m, mode="normal")

# --- Ribbon robot tile controller ---
for tile in plan:
    while not tile.done():
        transports = sense_or_simulate(tile)
        m = metrics.compute(transports)
        gate = safety_gate(m, ew, thr)
        if gate.mode == "abort": replan_tile()
        u = twist_dial(m, tile.Tw_star, prev_e, gains)
        apply_actuators(tile, u)

# --- EM belt sensor scan ---
for h in heights:
    ΦF = differential_flux(sensor, h, width=w)
    record(h, ΦF)
fit_linearity(ΦF_vs_w); check R2>=0.95

29.5 Acceptance checklist (per domain)

DNA: pre-buckling linear $\Delta\phi(n)$ (slope $\alpha$ ); buckling detected via $\Phi_F$ rise; $r_{\mathrm{FBHL}}$ within band except at localized defects.
Ribbon robot: no safety aborts; target twist hit-rate ≥ 95%; flux density within limits; seam penalties low.
EM sensing: width linearity passes; Faraday spikes caught; low residual (fixed framing).

Bottom line

The belt formalism gives one set of invariants— $\Delta\phi,\ \Phi_F,\ \mathrm{Tw},\ r_{\mathrm{FBHL}}$ —that port cleanly from biopolymers (twist↔writhe trade), to continuum robots (safe, stylized motion), to electromagnetic gradient sensing (robust differential readout). Each case admits concrete curves, tolerances, and a simulation harness you can run with the reference implementation.

Ch. 30 — AGI Systems in the Wild

Prompt-injection detection via flux spikes; controllable style dials via twist steps; planning/repair via tiling

This chapter shows how to ship belt mechanics into production agents. You’ll wire the metrics (Ch. 15), losses (Ch. 16), and controllers (Ch. 17–19) into three concrete, deployable behaviors:

Prompt-injection defense via flux-spike detectors and safe fallbacks.
Controllable style via quantized twist steps, with readability guarantees.
Robust planning via belt tiling and on-line repair.

Everything here is model-agnostic and tool-agnostic.

30.1 Where the belt sits in a production stack

User I/O ─▶ Preprocess ─▶ Model Core ─▶ Postprocess
                  │             │
                  ├─ RAG         ├─ Tools
                  │             │
                  └─ Belt Probe (estimators: Δφ, ΦF, Tw, r_FBHL, commutators)
                                │
                                └─ Controllers (gate, dial, tiler) + Logger

Probe inputs: along-edge transports for retrieval & generation; across-width binding at each step (Ch. 25).
Online loop (per token/step): compute $(\Delta\phi_t,\Phi_{F,t},\mathrm{Tw}_t,r_t)$ , emit gate/dial decisions, and tile repairs as needed.
Logs: JSONL schema from Ch. 26/27; keep all three suites runnable in staging.

30.2 Prompt-injection detection via flux spikes

Threat model

Indirect or direct prompts that try to redirect plans, hijack tools, or overwrite policy. Operationally they present as sudden interior work to reconcile inconsistent instructions → $\Phi_F$ surges and FBHL residual misfit.

Detector

Maintain short-window robust stats:

S_t=\frac{\Phi_{F,t}-\tilde{\Phi}_{F,t-1}}{\mathrm{MAD}_w(\Phi_F)+\epsilon},\quad Q_t=\frac{|r_t|}{\mathrm{MAD}_w(r)+\epsilon}.

Fire Caution if $|S_t|\ge \tau_1$ or $Q_t\ge \tau_r$ .
Fire Abort if $|S_t|\ge \tau_2$ for $K$ consecutive steps or thinness breach ( $\varepsilon>\varepsilon_{\max}$ ).
Defaults: $\tau_1{=}2.5,\ \tau_2{=}4.0,\ K{=}3,\ \tau_r{=}3.0,\ \varepsilon_{\max}{=}0.2$ .

Mitigations (playbook)

Freeze tools & lower temperature; continue in read-only mode.
Quarantine tiles that caused the spike (Ch. 19/18); re-rank or drop offending retrieval chunks.
Ask for scope confirmation (only if policy allows) or restate constraints (bridge tile).
De-scope plan: fewer tools, stricter style, or require explicit user consent for external actions.
Audit trail: mark spike time, tiles, and positive-flux evidence that triggered the decision.

Worked scenario (web-augmented assistant)

User asks: “Summarize page X and pay this invoice.” The page contains hidden “ignore safety” instructions.
Binding that content to the generation path yields $|S_t|\!\uparrow$ , localized to the new chunk tile; gate enters Caution, tool calls frozen; tiler swaps to citation-only tile; residual returns to band.
Outcome: safe, cited summary; payment action refused without explicit user confirmation.

30.3 Controllable style via twist steps

Register anchors & dial

Pick anchors $m\in\mathbb{Z}/2$ (e.g., $-1$ conversational, $0$ neutral, $+1$ academic, $+2$ legal). Target per turn $\mathrm{Tw}^\star\in\{m,m\pm\frac12\}$ .

Controller (per Ch. 17):

u_t = k_p\,\mathrm{clip}(\mathrm{Tw}^\star-\mathrm{Tw}_t,{-}\eta,\eta) + k_d\,\Delta e_t;\quad \text{halve } u_t \text{ if } |r_t|>\rho.

Map $u_t$ to style actuators (token weights, guidance scale, stylistic rotations).
Hysteresis: retarget only after $|e|\le h$ for $M$ steps.

Readability guarantees

Work inside the readability tube (Ch. 21):

|\mathrm{Tw}-\mathrm{Tw}^\star|\le\Delta_T,\ |\Phi_F|/T\le\Delta_F,\ |r|\le\Delta_r \Rightarrow R \in [\bar{R}\pm(L_T\Delta_T+L_F\Delta_F+L_r\Delta_r)].

Defaults: $\Delta_T{=}0.5$ units, $\Delta_F$ tuned per model, $\Delta_r{=}2^\circ$ .

Two production patterns

Enterprise guardrails: clamp to $m\in\{0,+1,+2\}$ ; hard bridge when crossing seam $>0.5$ units; citations required if flux density rises.
Creative assistance: allow half-steps $(\pm\frac12)$ with loose flux band; still rate-limit $u_t$ near residual bound.

30.4 Planning & self-repair via tiling

Long tasks form a tile graph (Ch. 19). Each tile $j$ has signature
$\sigma_j=(\Delta\phi_j,\Phi_{F,j},\mathrm{Tw}_j,r_j,\text{cost}_j,\epsilon_j)$ and seam budgets.

Planner objective (recap):

\min_{\pi}\ \sum_{j\in\pi}\big(\lambda_F|\Phi_{F,j}|+\lambda_r|r_j|+\lambda_T|\mathrm{Tw}_j-\mathrm{Tw}_j^\star|+\lambda_c\text{cost}_j\big) +\sum_{\text{seams}}\lambda_s(\eta+\alpha|\delta\mathrm{Tw}|).

Online repair trigger

Local: $|S_t|\ge \tau_1$ or $|r_t|>\tau_r$ on a tile → try an adjacent tile $j'$ with lower cost.
Global: plan-level residual budget trending up → re-run A*/beam with updated seam penalties; prefer fewer, cleaner tiles.

Examples

Code-assist fix loop: unit tests as edge checks (Ch. 20). On failing tile: swap logic or numeric repair tiles; stop when $\max|\Phi_F|\!<\!\tau_{\text{flux}}$ .
Form-fill agent: tool tiles (Search → Parse → Fill). If parsing spikes, insert a buffer tile (summarize/normalize) before Fill; refuse submission unless plan-level $r$ in band.

30.5 Telemetry & SRE

Dashboards (per service & per plan):

Live: $\Delta\phi,\Phi_F,\mathrm{Tw},r,\varepsilon$ time-series; z-scores $S_t,Q_t$ ; gate mode.
Tiles: top- $k$ flux contributors; seam penalties; abort causes.
Style: anchor hit-rate; seam twist violations; readability band coverage.
Incidents: spike TPR/FPR, mean time-to-repair (MTTR), abort rate, user confirmations.

Alerts (suggested):

≥3 consecutive spikes (Abort).
Residual MAD above band for >N steps.
Style seam >0.5 units without bridge tile.

30.6 Acceptance tests “in the wild”

Injection defense: red-team suite with canned attacks; require spike TPR ≥ 0.9, FPR ≤ 0.05; no unsafe tool calls under Abort.
Style control: ≥95% turns within $|\mathrm{Tw}-\mathrm{Tw}^\star|\le 0.5$ ; readability within target band ≥95% tokens.
Planning success: plan-level $|r_{\text{tot}}|\le \rho_{\max}$ , task success ≥ benchmark baseline, repair MTTR below target.

All tests must log the Ch. 26 schema and pass the three physics suites (A,B,C) in staging.

30.7 Failure modes & fixes

Slow-roll attacks (no sharp spike): track cumulative flux drift and derivative of residual; add KL/content heuristics as a second sensor.
Benign novelty flagged: high FPR → widen $w$ and $\lambda$ windows; require tile-localized agreement (two consecutive tiles) to fire Abort.
Style chatter: increase hysteresis $h,M$ ; cap $k_d$ ; insert bridge tiles.
Seam BCH blow-ups: align frames (style pre-agreement), refine across-width locally (slab).
Unitary drift → bogus phases: raise polar projection cadence; monitor $|\det U|$ .

30.8 Glue code (production-ready skeleton)

state = init_state(cfg)               # metrics + controllers + logs
plan  = initial_tiles(user_goal)      # Ch. 19
for step in stream():
    transports = estimate_transports(model, ctx)       # Ch. 25
    m = metrics.compute(transports)                     # Ch. 27
    gate = safety_gate(m, state.ewma, cfg.thr)          # §30.2
    logs.log_step(step, m, gate.mode)
    if gate.mode == "abort":
        apply_safe_mode(); plan = repair_plan(plan); continue
    u = twist_dial(m, plan.current.Tw_star, state.prev_e, gains)  # §30.3
    apply_style_actuators(u)
    if tile_bad(m):                                      # spike/residual/commutator heuristics
        plan = local_swap(plan)                          # §30.4
    act = next_action(plan, gate)                        # tool use / decode
    ctx = execute(act)

30.9 What “good” looks like in production

Quiet belts: flux density flat except at legitimate transitions; residual within band; unitarity norms near 0.
Style on rails: twist anchors hit without chatter; bridges only on big register moves.
Plans that self-heal: when the world shifts (bad page, flaky tool), tiling swaps in a low-flux route automatically.
Auditable traces: for any output, you can show the tiles that contributed positive flux and the exact gate decisions.

Outcome. With flux-spike gates, quantized twist dials, and belt tiling, your agent behaves like a well-regulated physical system in the wild: it detects hostile inputs, steers style safely, and repairs plans on the fly—while emitting crisp telemetry that you can trust and audit.

Ch. 31 — Beyond Thin Belts

Large-width corrections; defects; stochastic belts; non-annular topologies

This chapter extends the belt calculus when the thin-belt assumptions of Chs. 15–26 break: wide belts, defects/punctures, noise, or exotic topology. We give upgrade paths (what to compute), correction terms (what changes), and acceptance tests so you know when to escalate geometry (to a slab, a membrane, or a double cover).

31.1 Large-width corrections (from belt to slab)

When thin fails. Recall thinness $\varepsilon=\max_s \kappa(s)\,w(s)$ . The belt law

\Delta\phi \;\approx\; \iint_{\mathcal{B}} F \;+\;\alpha\,\mathrm{Tw}

assumes: (i) metric distortion across width is small, (ii) across-width transports almost commute, (iii) framing varies slowly. For $\varepsilon\gtrsim 0.2$ or strong non-Abelian patches, promote to a slab: a belt with $N_n\!\gg\!1$ rungs and explicit across-width ordering.

Geometry (Fermi frame). With centerline curvature $\kappa(s)$ and geodesic offset $n\in[0,w]$ ,

g=\mathrm{diag}\big((1-\kappa(s)n)^2,\,1\big),\qquad \text{area element } dA=(1-\kappa n)\,ds\,dn .

Hence area and thus $\Phi_F$ pick a factor $(1-\bar\kappa\, n)$ to first order; if you ignore it, you under/over-count flux.

Second-order expansion (sketch). Let $h=\max\{\Delta s,\Delta n\}$ . With $F_{sn}$ the dominant curvature component and $C=[A_s,A_n]$ the non-Abelian commutator:

\Delta\phi = \iint_{\mathcal{B}}\!\!F_{sn}\,(1-\kappa n)\,ds\,dn \;+\;\alpha\,\mathrm{Tw} \;+\;\underbrace{\tfrac12\!\sum_{\square}\!\!\mathrm{Tr}\big(\rho\,[\log H_\square^s,\log H_\square^n]\big)}_{\text{BCH seam term}} \;+\;O(h^2,\kappa^2 w^2).

The BCH term is what the snake ordering in Ch. 24 tries to minimize; it scales with the product of across-width and along-edge increments.

Engineer rule-set.

Slab switch: if (a) width-law curvature $>5\%$ , (b) commutator proxy rises steadily, or (c) $\varepsilon>0.2$ , increase $N_n$ and use Q1/Q2 quadratures (Ch. 24) with metric factor $(1-\kappa n)$ .
Jacobian fix: weight per-cell flux by $(1-\kappa n)$ .
BCH budget: keep $\max\|\,[\log H^s,\log H^n]\,\|\le \eta$ (tune so plan-level residual stays within bands).

Acceptance tests (wide belts).

Metric on/off: enabling $(1-\kappa n)$ should shift slopes by $\approx \bar\kappa\,\tfrac{w}{2}$ fraction; afterwards width-law re-linearizes (R² ≥ 0.95).
BCH convergence: R² and residual improve monotonically as $N_n$ doubles once; otherwise you’re under-resolved in $s$ as well.

31.2 Defects, punctures, and seams

A defect is a point/line you must exclude (e.g., a nick in DNA, an obstacle in a robot’s workspace, an AB-like flux tube). The belt becomes multiply connected.

Topology. Removing a disc $D_j$ creates an extra boundary loop $\partial D_j$ . Stokes tells you:

\oint_{\Gamma_+}\!\!A \;-\;\oint_{\Gamma_-}\!\!A \;-\;\sum_j \oint_{\partial D_j}\!\!A \;=\;\iint_{\mathcal{B}\setminus \bigcup D_j}\!\!F .

Thus the belt identity generalizes to

\Delta\phi \;=\; \Phi_F^{\text{punctured}} \;+\;\alpha\,\mathrm{Tw} \;+\; \sum_j \phi_{\text{defect},j},

where $\phi_{\text{defect},j}$ is the circulation around the puncture (an AB-like term), measurable by a tiny loop around the defect. If the defect is purely geometric (a seam twist jump), then $\phi_{\text{defect}}=\alpha\,\delta \mathrm{Tw}_{\text{seam}}$ .

Operational playbook.

Localize: tile a ring of micro-plaquettes around suspected defects; large $r_{\text{FBHL}}$ localized in arc-length is diagnostic.
Bookkeep: add each $\partial D_j$ as a micro-boundary and measure its class-phase; subtract it to restore FBHL on the punctured surface.
Seam adapters: if a tool/API boundary acts like a seam, insert a buffer tile and log its seam twist.

Acceptance. After subtracting defect circulations, residual MAD returns to band (≤ 1°). If not, refine mesh; if still not, promote to membrane (§31.4).

31.3 Stochastic belts (noise, dropout, ensembles)

When transports or curvature are random (sampling, dropout, non-deterministic kernels), treat $A$ or $F$ as stochastic processes.

Discrete stochastic FBHL (expectation & variance).
For per-step random plaquettes $H_k$ ,

\mathbb{E}[\Delta\phi] \;\approx\; \mathbb{E}[\Phi_F] \;+\;\alpha\,\mathbb{E}[\mathrm{Tw}] \;+\;\tfrac12 \sum_k \operatorname{Im}\mathrm{Tr}\!\big(\operatorname{Cov}(\log H_k)\big) + \cdots

(the last term is the Itô/Stratonovich-type correction from noise curvature). Variance scales roughly with area and local noise power:

\operatorname{Var}(\Delta\phi) \;\sim\; \sum_k \operatorname{Var}(\arg\det H_k)\quad \propto\quad \text{area}\times \sigma_F^2 .

Estimation & guards.

Averaging: use Uhlmann estimators for mixed states (Ch. 25) or average log-plaquettes in log-Euclidean space.
Concentration: apply matrix Bernstein/Freedman bounds to the martingale of partial products; this yields a stepwise spike threshold that adapts to noise.
Two clocks: keep fast (per-step) and slow (windowed) readouts; gate on z-scores relative to MAD of the slow clock.

Acceptance (stochastic regime).

Report mean ± MAD of $\Delta\phi,\Phi_F$ ; Faraday gain in $[0.95,1.05]$ on average; spike FPR ≤ 0.05 under null noise.
If variance is too large for bands, expand width down or refine mesh until the per-cell angle $\|\log H\|\le 0.2$ .

31.4 Non-annular topologies (holes, genus, Möbius)

(A) Many boundaries / higher genus (orientable)

For an orientable surface $\Sigma$ with boundary components $\{\gamma_\ell\}$ ,

\sum_{\ell} \operatorname{sgn}(\gamma_\ell)\,\Phi_{\text{edge}}(\gamma_\ell) \;=\; \iint_{\Sigma}\!F \;+\; \alpha\,\mathrm{Tw}_{\Sigma} \;+\; \text{(BCH seams)}.

In a belt network this just glues additively (Chs. 22–23): interior seams cancel; only external boundaries and seam/BCH budgets remain. Use this when tiling around large obstacles or routing through portals.

(B) Möbius belts (non-orientable)

A Möbius strip has a single edge; global framing cannot be defined continuously. Remedy: pass to the orientable double cover $\tilde{\mathcal{B}}$ (a belt of width $2w$ ) with two edges again. FBHL holds on $\tilde{\mathcal{B}}$ :

\Delta\phi_{\text{cover}} \;=\; \Phi_F^{\text{cover}} \;+\; \alpha\,\mathrm{Tw}_{\text{cover}} .

Projecting back implies half-integer twist quantization on the base and a $4\pi$ -like periodicity. In practice: duplicate the mesh, reverse orientation on one copy, compute on the cover, then fold results (divide edge gap by 2).

Acceptance: cover-space residual within band; projected observables obey half-step twist tests.

(C) Membranes (when belts aren’t enough)

If across-width commutators remain large after slab refinement, the physics is truly 2-D: promote to a membrane (no privileged “upper/lower” edges; you instrument full surface holonomy and cut it by a canonical set of cycles). Use when style/phase cannot be captured by two boundary traces (e.g., strongly branching tools with back-reaction across width).

31.5 Practical upgrade path (decision chart)

Thin & quiet? If width law passes (R² ≥ 0.95), commutator proxy low → stay in belt.
Too wide or BCH noisy? → Slab: increase $N_n$ , metric factor on, Q1/Q2 quadrature.
Defects present? → Excise discs; add defect boundary phases; re-test residual.
Noise high? → Uhlmann/mixed; two clocks; variance-aware gate.
Non-orientable or multiply connected? → Double cover or multi-boundary Stokes.
Still non-additive? → Membrane modeling.

31.6 Acceptance & diagnostics (beyond-thin checklist)

Metric correction: enabling $(1-\kappa n)$ tightens width-fit; report slope shift.
BCH budget: $\sum\|[\log H^s,\log H^n]\|$ below target; residual drops with $N_n$ .
Defects cleared: localized residual spikes vanish after adding defect loops.
Noise-aware: Faraday gain ≈ 1 in mean; spike FPR within band.
Topological sanity: double-cover results halve cleanly; multi-boundary balance holds to tolerance.

31.7 Open problems

Tight non-Abelian error bounds. Prove optimal constants for snake orderings and give a priori mesh sizes for a desired residual band.
Adaptive meshing on manifolds. Curvature- and commutator-driven refinement with guarantees of convergence for class-function phases.
Learning $\alpha$ under confounding. Jointly estimate framing coefficient and flux scales when twist actuators also perturb curvature.
Stochastic holonomy concentration. Matrix concentration inequalities tailored to surface-ordered exponentials with local dependence.
Non-orientable inference. Principled estimators on double covers with minimal variance when only single-edge data is observable.
Membrane controllers. Extending gate/dial/tiler to surfaces without privileged edges (higher-form control).
Robust Uhlmann at rank drop. Stable mixed-state transports when densities become low-rank or ill-conditioned mid-trajectory.

Bottom line. Beyond thin belts is not a failure mode but a regime change. You keep the same invariants—edge gap, flux, twist, residual—but you (i) correct for geometry, (ii) budget non-Abelian seams, (iii) bookkeep defects, (iv) average or bound noise, and (v) respect topology (via extra boundaries or a double cover). With those upgrades, belt mechanics remain predictive and auditable in the wild.

Ch. 32 — Higher-Form & Back-Reaction Effects

When membranes/volumes are required; coupling belts to collapse processes (outline)

Belts (annular worldsheets with two boundary curves) are the minimal geometry that captures edge–interior invariants. But some systems refuse to fit on a belt: the across-width field is truly 2-D, interactions feed back into the generator, or topology injects extra boundaries that won’t cancel. This chapter sketches the higher-form upgrade path—from belts to membranes (surface holonomies of 2-form connections) and, in extremis, to volumes (3-form curvature)—and shows how to couple these geometries to collapse processes that return you to belts when possible.

32.1 When a belt is not enough (escalation criteria)

Promote the geometry if any of the following persist after slab refinement (Ch. 31):

Non-commuting across-width everywhere. Commutator proxies stay high even with many rungs; width-law fit bends > 5%.
Back-reaction. The act of binding evidence/tools measurably changes the interior field that produced the binding (closed feedback).
Multi-boundary drive. More than two independent boundary traces are essential (e.g., triadic tool coupling), and they do not reduce to two effective edges without large residuals.
Topological constraints. Punctures/handles force independent cycles that belts cannot absorb without defect terms dominating.

Then model a membrane $\mathcal{M}$ (an oriented surface with multiple boundary components). If even $\mathcal{M}$ is insufficient (e.g., field depends on enclosed volumes), promote to a volume $\mathcal{V}$ .

32.2 Higher-form connections (minimal toolkit)

1-form (belt): connection $A$ with curvature $F=dA + A\!\wedge\!A$ ; Wilson lines on edges; Stokes on the belt.
2-form (membrane): connection $B$ with 3-form curvature $H=dB$ (Abelian case) or a mild 2-group generalization (we use Abelian in practice). Wilson surfaces:
$\mathrm{Hol}_B(\mathcal{M}) \;=\; \exp\!\Big(i\!\iint_{\mathcal{M}} B\Big),\qquad H=dB.$
3-form (volume): curvature $H$ integrated over $\mathcal{V}$ : $\exp\!\big(i\!\iiint_{\mathcal{V}} H\big)$ .

We keep Abelian higher-forms operational—surface ordering is then trivial; non-Abelian 2-forms require 2-categorical machinery and are beyond this mini-text.

32.3 From FBHL to a membrane law (sketch)

For a belt $\mathcal{B}$ :

\underbrace{\mathrm{Hol}(\Gamma_+)\,\mathrm{Hol}(\Gamma_-)^{-1}}_{\text{edge gap}} \;=\; \exp\!\Big(i\!\iint_{\mathcal{B}} F\Big)\;\times\; e^{\,i\alpha\,\mathrm{Tw}}.

For a membrane $\mathcal{M}$ whose boundary is a signed sum of belts $\partial\mathcal{M}=\sum_\ell \sigma_\ell\,\mathcal{B}_\ell$ (pair-of-pants, junction sheets, etc.), the surface analog says that the product of belt surface holonomies across the boundary equals the volume holonomy of $H$ plus a surface-framing term:

\prod_{\ell}\Big[\mathrm{Hol}_F(\mathcal{B}_\ell)\,e^{\,i\alpha\,\mathrm{Tw}(\mathcal{B}_\ell)}\Big]^{\sigma_\ell} \;=\; \exp\!\Big(i\!\iiint_{\mathcal{V}} H\Big)\;\times\; e^{\,i\beta\,\mathrm{Sf}(\mathcal{M})}. \tag{32.1}

Here $\mathcal{V}$ is any volume with boundary $\partial\mathcal{V}=\mathcal{M}$ , $\mathrm{Hol}_F(\mathcal{B})=\exp(i\!\iint_{\mathcal{B}}F)$ , $\mathrm{Sf}$ is a surface-framing functional (depends on the membrane’s normal field; reduces to belt twist on 1-D boundaries), and $\beta$ calibrates its contribution. In the thin limit with one belt in–one belt out, (32.1) collapses to FBHL.

Interpretation. A membrane is a cobordism of belts; (32.1) says “boundary belt physics balances the bulk 3-form” up to controllable framing terms.

32.4 Discretization: faces, shells, and ordering

Mesh. Triangulate $\mathcal{M}$ into faces $f$ and (optionally) shell a volume $\mathcal{V}$ into tetrahedra $\tau$ .

Face holonomy (Abelian): $W_f=\exp\big(i\,\int_f B\big)$ ; total $\mathrm{Hol}_B(\mathcal{M})=\prod_f W_f$ .
Volume holonomy: $V_\tau=\exp\big(i\,\int_\tau H\big)$ ; total $\exp(i\!\sum_\tau \int_\tau H)$ .
Boundary coupling: each boundary belt $\mathcal{B}_\ell$ is meshed as in Ch. 24; its flux $\Phi_F(\mathcal{B}_\ell)=\sum_{\square\subset \mathcal{B}_\ell}\arg\det H_\square$ .

Stability rules.
(1) Keep per-face angle $|\log W_f|\le 0.2$ .
(2) Weight areas with the surface metric (curvature-corrected Jacobian).
(3) For non-planar sheets, include mean-curvature corrections in $\mathrm{Sf}$ (next §).

32.5 Surface framing $\mathrm{Sf}$ (what replaces twist)

A belt’s framing term counts the rotation of a normal frame along a curve. For membranes, pick an orthonormal frame $(t_1,t_2,n)$ and define a scalar surface twist density from the normal connection $\omega$ (the spin connection of normals):

\mathrm{Sf}(\mathcal{M}) \;=\; \frac{1}{2\pi}\!\iint_{\mathcal{M}} \operatorname{curl}_{\mathcal{M}} \omega \;+\; \frac{1}{2\pi}\!\oint_{\partial\mathcal{M}} \omega_{\parallel}.

Discretely, $\mathrm{Sf}$ is the signed sum of dihedral angle changes between neighboring face normals plus boundary normal rotations. Along a boundary curve this reduces to the usual twist. Calibrate $\beta$ once (like $\alpha$ ) by a controlled surface-twist experiment.

32.6 Back-reaction: when the field fights back

In many agents and physical systems, the interior field that your belt/membrane integrates depends on what you are doing at the boundary. Examples: retrieval strengthens tokens it already bends toward; a controller stiffens a robot locally; an EM field responds to actuator current.

Model this with coupled updates:

\begin{aligned} &\textbf{Geometry step:} && (\Delta\phi,\Phi_F,\mathrm{Tw}) \;\gets\; \mathcal{G}[A,B;\ \text{mesh}] \\ &\textbf{Field step:} && A\leftarrow \mathcal{F}_1(A;\ \Delta\phi,\Phi_F,\mathrm{Tw}),\quad B\leftarrow \mathcal{F}_2(B;\ \Delta\phi,\Phi_F,\mathrm{Tw}), \\ &\textbf{Controller:} && u \leftarrow \mathcal{C}(\text{metrics});\quad \text{update boundary/tools with } u. \end{aligned}

For small gains and Lipschitz $\mathcal{F}_{1,2}$ , a quadratic Lyapunov argument (as in Ch. 17) yields practical stability: metrics stay inside bands; otherwise trigger escalation (membrane or volume) or Abort.

Energy view (variational sketch). Minimize

\mathcal{E}(A,B) = \lambda_1\!\iint_{\mathcal{B}}\!\!\|F\|^2 + \lambda_2\!\iint_{\mathcal{M}}\!\!\|B\|^2 + \lambda_3\!\iiint_{\mathcal{V}}\!\!\|H\|^2

subject to boundary constraints (target edge gaps, style) and acceptance bands. Gradient flows of $\mathcal{E}$ formalize “the field yields just enough to satisfy boundary data,” making back-reaction explicit.

32.7 Collapse processes: membrane → belt (outline)

Often you can come back down to belts by collapsing a membrane onto a “most informative” ribbon.

Goal. Choose a belt $\mathcal{B}^\star \subset \mathcal{M}$ (centerline + width profile) that preserves boundary targets while minimizing interior complexity.

Objective (one option).

\min_{\mathcal{B}\subset \mathcal{M}} \Big[ \underbrace{\big|\Delta\phi(\partial\mathcal{B}) - \sum_\ell \sigma_\ell \Delta\phi(\partial\mathcal{B}_\ell)\big|}_{\text{boundary fidelity}} + \lambda_F \big|\Phi_F(\mathcal{B}) - \Phi_B(\mathcal{M})\big| + \lambda_S\,\mathrm{Sf\!-\!mismatch} + \lambda_A \,\text{area}(\mathcal{M}\!\setminus\!\mathcal{B}) \Big],

where $\Phi_B(\mathcal{M})=\int_{\mathcal{M}}F$ (1-form curvature restricted to the sheet carrying $F$ ) or $\iint B$ if your interior is truly 2-form driven.

Greedy collapse (practical):

Compute per-face contribution density to boundary metrics (e.g., SHAP-like share of $\Delta\phi$ ).
Seed a narrow ribbon along the maximum-contribution ridge.
Grow width until acceptance bands start to fail; trim low-contribution flaps.
Re-measure; if residuals stay high → keep membrane.

Guarantee (sketch). If contribution density is unimodal across width and commutators are locally bounded, the greedy ribbon achieves boundary fidelity within a factor of the optimal belt up to $O(\text{BCH})$ .

32.8 Volume regime & “higher Faraday”

If changing a membrane’s interior consistently produces non-local effects that a 2-form cannot encode (e.g., true volumetric couplings), promote to a volume $\mathcal{V}$ and monitor the 3-form $H$ .

Higher Faraday law (discrete).

\Delta\!\Big[\sum_\ell \sigma_\ell \Phi_F(\mathcal{B}_\ell) \;-\; \beta\,\mathrm{Sf}(\mathcal{M})\Big] \;\approx\; \Delta\Big[ \iiint_{\mathcal{V}} H \Big].

This is the time-differential sibling of (32.1): the change in boundary belt flux (minus surface-framing) tracks the bulk 3-flux change.

32.9 Software notes (what to actually code)

Membrane meshers: triangulate surfaces; reuse Ch. 24 accumulators with face integrals (Abelian) and keep per-face angles small.
Surface framing: accumulate dihedral turns; calibrate $\beta$ once.
Logs: extend JSONL with PhiB_surface (∬B), PhiH_volume (∭H), Sf_surface; record boundary belt list for each membrane.
Controllers: gate on face-wise spike maps; allow tile-level escalation (a tile becomes a membrane) and collapse attempts after stabilization.

32.10 Acceptance bands (higher-form)

Membrane balance: (32.1) residual MAD ≤ 1–2° after calibration; improvements monotone with mesh refinement.
Collapse viability: belt reconstructed from $\mathcal{M}$ matches boundary edge gaps within 2%, width-law $R^2\ge 0.95$ .
Back-reaction stability: under small boundary perturbations, metrics remain inside the readability/safety tube; no uncontrolled oscillations.
Volume check: higher-Faraday correlation ≥ 0.95 between boundary change and bulk $H$ change on controlled modulations.

32.11 Open problems (higher-form)

Non-Abelian 2-form numerics with guarantees (surface ordering, 2-group discretizations).
Tight surface-framing theory: minimal invariants that reduce to belt twist on boundaries.
Optimal collapse with approximation ratios and robust stopping rules under noise.
Identifiability under back-reaction: when can you uniquely separate boundary control from interior response?
Scalable audits: streaming estimators for $\Phi_B,\Phi_H$ on large meshes with mixed precision and sharp error bars.

Bottom line. Belts are the workhorse; membranes and, rarely, volumes extend the calculus when fields are genuinely higher-dimensional or feed back on themselves. Use the membrane law (32.1) to balance boundary belts against bulk $H$ , include surface framing, and—whenever possible—collapse back to a belt that stays within your acceptance bands. This keeps the system auditable and controllable even beyond the thin-belt regime.

Appendix A — Notation & Orientation Diagrams (print-ready)

Use this as a 2–3 page cheat sheet. No prerequisites beyond standard vector calculus & gauge/holonomy basics.

A.1 Symbols at a glance

Belt domain (annulus): $\mathcal{B}\subset \mathbb{R}^3$ (or a smooth surface), with boundary $\partial\mathcal{B}=\Gamma_{+}\,\sqcup\,(-\Gamma_{-})$ .
Centerline: $\mathbf{r}(s)$ , $s\in[0,L]$ arc length; tangent $\mathbf{t}=\partial_s\mathbf{r}$ .
Director (framing line): unit $\mathbf{u}(s)\perp \mathbf{t}(s)$ .
Width: $w>0$ ; local coords: $(s,u)$ with $u\in[-\tfrac{w}{2},+\tfrac{w}{2}]$ .
Edges: $\Gamma_{\pm}(s)=\mathbf{r}(s)\pm \tfrac{w}{2}\,\mathbf{u}(s)$ .
Surface normal: $\mathbf{n}_\mathcal{B}$ (chosen once; fixes boundary orientations).
Frame: $(\mathbf{t},\mathbf{u},\mathbf{b})$ with $\mathbf{b}=\mathbf{t}\times \mathbf{u}$ .
Framing angle: $\phi(s)$ (director $\mathbf{u}$ relative to a chosen reference frame along $\mathbf{r}$ ).
Twist (Călugăreanu–White–Fuller):
$\mathrm{Tw}=\frac{1}{2\pi}\int_0^L \big(\mathbf{t}\times \mathbf{u}\big)\cdot \partial_s \mathbf{u}\; ds.$
Writhe:
$\mathrm{Wr}=\frac{1}{4\pi}\!\!\iint\limits_{[0,L]^2}\!\! \frac{\big(\partial_s\mathbf{r}(s)\times \partial_{s'}\mathbf{r}(s')\big)\cdot\big(\mathbf{r}(s)-\mathbf{r}(s')\big)} {\|\mathbf{r}(s)-\mathbf{r}(s')\|^3}\; ds\,ds'.$
Linking (edges): $\mathrm{Lk}(\Gamma_+,\Gamma_-)=\mathrm{Tw}+\mathrm{Wr}$ .
Gauge connection/curvature: $A$ (1-form), $F=dA+A\wedge A$ .
Holonomy (edge): $\mathrm{Hol}(\Gamma)=\mathcal{P}\exp\!\oint_{\Gamma}\! A$ .
Surface-ordered exponential: $\mathcal{S}\exp\!\iint_{\mathcal{B}}\!F$ .
Framing phase coupling: $\alpha\in\mathbb{R}$ (dimensionless).

A.2 Belt parametrization & metric (thin-ribbon regime)

Embed $\mathcal{B}$ via

\mathbf{X}(s,u)=\mathbf{r}(s)+u\,\mathbf{u}(s),\qquad u\in\Big[-\tfrac{w}{2},+\tfrac{w}{2}\Big].

Local metric (to first order in curvature $\kappa$ and width $w$ ):

g \approx \begin{pmatrix} (1-\kappa u)^2 & 0\\ 0 & 1 \end{pmatrix},\qquad \text{valid if } \kappa\,w\ll 1.

A.3 Orientation conventions (no minus-sign surprises)

Surface orientation → boundary orientations (right-hand rule):

Choose $\mathbf{n}_\mathcal{B}$ . Walk with your head along $+\mathbf{n}_\mathcal{B}$ : positively oriented boundary is counter-clockwise.
For an annulus, this yields

\partial\mathcal{B}=\Gamma_{+}\;\sqcup\;(-\Gamma_{-}),

so any boundary integral splits as “upper minus lower.”

Edge direction choice:

Parametrize both edges by increasing centerline $s$ . Then:
$\oint_{\Gamma_{+}}(\cdot)\;-\;\oint_{\Gamma_{-}}(\cdot) \quad\text{(signs fixed by the surface orientation).}$

ASCII aide-mémoire

     +n_B (out of page)
         ↑
   ┌───────────────┐   Outer edge = Γ+
   │  annular B    │   (positive boundary circulation)
   └───────────────┘   Inner edge = Γ− (negative orientation)
        ←  s

A.4 Two-boundary integral identities (Abelian & non-Abelian)

Abelian Stokes on a belt:

\oint_{\Gamma_{+}} A\;-\;\oint_{\Gamma_{-}} A \;=\;\iint_{\mathcal{B}} F.

Non-Abelian (schematic):

\mathrm{Hol}(\Gamma_+)\,\mathrm{Hol}(\Gamma_-)^{-1} \;=\;\mathcal{S}\exp\!\iint_{\mathcal{B}}F \;\times\;e^{\,i\alpha\,\mathrm{Tw}}.

$\mathcal{S}$ denotes surface ordering.
The scalar framing factor $e^{i\alpha\,\mathrm{Tw}}$ accounts for the chosen director $\mathbf{u}$ along the belt.

A.5 Framing, twist & linking — operational formulas

Edges from a frame: $\Gamma_{\pm}=\mathbf{r}\pm \tfrac{w}{2}\mathbf{u}$ .
Twist density:
$\tau_{\mathrm{tw}}(s)=\frac{1}{2\pi}\,(\mathbf{t}\times \mathbf{u})\cdot \partial_s \mathbf{u}$ .
Linking = Tw + Wr: invariant under smooth deformations that avoid edge crossings.
Quantization check: $\phi\mapsto \phi+2\pi m\Rightarrow \mathrm{Tw}\mapsto \mathrm{Tw}+m$ , thus $e^{i\alpha\,\mathrm{Tw}}$ is $2\pi/\alpha$ -periodic.

A.6 “Upper–minus–lower” calculus (quick recipes)

Circulation: $\oint_{\Gamma_+}\mathbf{v}\cdot d\mathbf{\ell}\;-\;\oint_{\Gamma_-}\mathbf{v}\cdot d\mathbf{\ell}$ .
Flux: $\iint_{\mathcal{B}} (\nabla\times \mathbf{v})\cdot\mathbf{n}_\mathcal{B}\, dS$ .
Gauge form: replace $\mathbf{v}\cdot d\mathbf{\ell}$ by $A$ , $\nabla\times$ by $F$ .

A.7 Discrete orientation & mesh conventions (for code)

Mesh: oriented faces $\{f_k\}$ with normals aligned to $\mathbf{n}_\mathcal{B}$ .
Boundary loops: ordered vertex cycles $\Gamma_{+}$ and $\Gamma_{-}$ following induced boundary orientation.
Face integral: $\iint_{f_k}F \approx \mathrm{area}(f_k)\, \mathrm{avg}\,F$ .
Surface ordering: order faces by a radial sweep (inner→outer) or use a spanning tree over dual graph; keep a fixed, documented rule.
Edge holonomy (lattice): multiply link variables in edge order; belt holonomy = product( $\Gamma_+$ ) × product( $\Gamma_-$ ) $^{-1}$ .

A.8 Sanity checks (use every time)

Annulus sign test: Constant curl/curvature field? Then “upper–minus–lower” must equal area×field.
4π test: A $4\pi$ rotation of the frame returns the belt to the same physical state; holonomy/observables must respect this periodicity where applicable.
Gauge invariance: Edge–edge difference and surface term must transform covariantly; scalar invariants (e.g., $\arg\det$ ) remain unchanged.
Width scaling: Thin-ribbon limit ( $\kappa w\ll 1$ ): edge gap scales linearly with width for small $w$ if fields are smooth.

A.9 Minimal units & constants

$s$ in length; $u$ in length; $w$ in length.
$A$ dimension depends on context (e.g., phase/length); $F$ in phase/area.
$\alpha$ dimensionless (set $\alpha=1$ unless specified).

A.10 Diagram templates (annotate as needed)

(D1) Belt with induced orientations

          ↑  +n_B
   Γ+  →──────────→
      ╔════════════╗
      ║            ║   s increases →
      ╚════════════╝
   Γ−  ←──────────←

Labels: show $\Gamma_+$ arrow same direction as positive boundary; $\Gamma_-$ opposite.

(D2) Frame along centerline

 at s:   t = r'(s)   u ⟂ t   b = t × u
           ↗ t
         r(s)•→ u
              ⟂
              b (out of page)

(D3) Edge construction

Γ+(s) = r(s) + (w/2) u(s)
Γ−(s) = r(s) − (w/2) u(s)

(D4) Two-boundary Stokes (Abelian)

∮_{Γ+}A  −  ∮_{Γ−}A   =   ∬_{B} F
 [edge gap]              [surface flux]

(D5) Belt holonomy (Non-Abelian, schematic)

Hol(Γ+) · Hol(Γ−)^{-1}  =  Sexp ∬_B F  ·  exp(i α Tw)

Printing note

Set monospaced diagrams at 10–11 pt; equations at 11 pt; margins ≥ 15 mm.
Keep pages b/w; no color dependence.

End of Appendix A.

Appendix B — Proof Sketches

(Two-Boundary Stokes/Gauss; FBHL derivation; Framing quantization)

Conventions: $\mathcal{B}$ is an oriented annulus (“belt”) with boundary $\partial\mathcal{B}=\Gamma_+\sqcup(-\Gamma_-)$ . Smoothness $C^2$ unless stated. Gauge group $G$ compact; connection $A$ , curvature $F=dA+A\wedge A$ . Margin tags $[BH:\,\cdot]$ indicate the corresponding idea in the “Belt Holonomy” paper.

B.0 Preliminaries and identities

Surface orientation → boundary sign. If $\mathbf{n}_{\mathcal{B}}$ fixes the surface orientation, the induced orientation makes the outer edge positive and the inner edge negative:
$\partial\mathcal{B}=\Gamma_{+}\sqcup(-\Gamma_{-}). \quad [BH: orientation]$
Holonomy. $\mathrm{Hol}(\Gamma)=\mathcal{P}\exp\!\oint_\Gamma A\in G$ .
Surface-ordered exponential (schematic). $\mathcal{S}\exp\!\iint_{\mathcal{B}}F$ denotes a non-Abelian, gauge-covariant accumulation of $F$ over $\mathcal{B}$ , realized with a choice of radial Wilson lines. $[BH:$ non-Abelian Stokes $]$

B.1 Two-Boundary Stokes (Abelian)

Theorem B.1 (Abelian two-boundary Stokes).
Let $A$ be a smooth 1-form on a neighborhood of $\mathcal{B}$ , $F=dA$ . Then

\boxed{\;\oint_{\Gamma_+}\!A\;-\;\oint_{\Gamma_-}\!A\;=\;\iint_{\mathcal{B}}\!F\;}. \qquad [BH:\,\text{two-boundary Stokes}]

Sketch. Classical Stokes on an oriented surface gives
$\oint_{\partial\mathcal{B}}A=\iint_{\mathcal{B}}dA$ . With $\partial\mathcal{B}=\Gamma_+\sqcup(-\Gamma_-)$ , the left side is precisely the edge-gap integral. No further hypotheses are needed beyond smoothness and orientability. ∎

Checks. (i) Constant field $F$ ⇒ RHS $= (\text{area})\times F$ , matching the signed edge gap. (ii) Refinement stability: subdividing $\mathcal{B}$ and summing boundaries cancels interior edges in pairs. $[BH:$ partition invariance $]$

B.2 Two-Boundary Gauss (surface divergence theorem)

Let $\nabla_{\!\mathcal{B}}\cdot$ be the intrinsic divergence on $\mathcal{B}$ and $\boldsymbol\nu$ the outward unit co-normal (tangent to $\mathcal{B}$ , normal to the boundary).

Theorem B.2 (Two-boundary Gauss).
For any smooth tangent field $\mathbf{v}$ on $\mathcal{B}$ ,

\boxed{\;\iint_{\mathcal{B}}\!\nabla_{\!\mathcal{B}}\!\cdot\mathbf{v}\,dS =\oint_{\Gamma_+}\!\mathbf{v}\!\cdot\!\boldsymbol\nu\,dl -\oint_{\Gamma_-}\!\mathbf{v}\!\cdot\!\boldsymbol\nu\,dl\;}. \qquad [BH:\,\text{surface Gauss}]

Sketch. Apply the divergence theorem on oriented surfaces:
$\iint_{\mathcal{B}}\nabla_{\!\mathcal{B}}\cdot\mathbf{v}\,dS=\oint_{\partial\mathcal{B}}\mathbf{v}\cdot\boldsymbol\nu\,dl$ . The sign on $\Gamma_-$ comes from the induced boundary orientation (co-normal points “inward” there). ∎

Remark. In belt coordinates $(s,u)$ , $\boldsymbol\nu$ is radially outward on $\Gamma_+$ and inward on $\Gamma_-$ , yielding the “upper–minus–lower” rule automatically. $[BH:$ belt coordinates $]$

B.3 Framed Belt Holonomy Law (FBHL)

We derive the central identity in two steps: non-Abelian Stokes on the annulus, then the framing (twist) factor.

B.3.1 Non-Abelian Stokes on an annulus

Lemma B.3 (Boundary factorization).
With a basepoint $x_0\in\Gamma_+\cap\Gamma_-$ (identified via a short bridge inside $\mathcal{B}$ ), the loop $\partial\mathcal{B}$ factorizes as the concatenation $\Gamma_+\cdot\Gamma_-^{-1}$ . Hence

\mathcal{P}\exp\!\oint_{\partial\mathcal{B}}A =\mathrm{Hol}(\Gamma_+)\,\mathrm{Hol}(\Gamma_-)^{-1}. \quad [BH:\,\partial\mathcal{B}=\Gamma_+\!*\!\Gamma_-^{-1}]

Sketch. Standard path composition with a fixed basepoint and the inverse path for $\Gamma_-$ . ∎

Lemma B.4 (Non-Abelian Stokes, gauge-covariant form).
Choose a smooth family of paths $\gamma_{x}$ in $\mathcal{B}$ from $x_0$ to $x$ (e.g., radial lines). Let $W(x)$ be the Wilson line along $\gamma_x$ . Then

\mathcal{P}\exp\!\oint_{\partial\mathcal{B}}A =\mathcal{S}\exp\!\iint_{\mathcal{B}} W(x)^{-1}\,F(x)\,W(x)\,dS. \quad [BH:\,\text{NAST}]

Sketch. Standard non-Abelian Stokes theorem: tile $\mathcal{B}$ , insert infinitesimal loops, use BCH/Trotter to pass to the continuum; Wilson lines parallel-transport $F$ to the basepoint to maintain covariance. Independence of the specific $\gamma_x$ follows from smooth deformations that preserve orientation, up to conjugation at the basepoint. ∎

Corollary B.5 (Edge-gap holonomy equals surface-ordered curvature).

\boxed{\;\mathrm{Hol}(\Gamma_+)\,\mathrm{Hol}(\Gamma_-)^{-1} =\mathcal{S}\exp\!\iint_{\mathcal{B}} W^{-1} F W\,dS\;}. \quad [BH:\,\text{two-boundary NAST}]

B.3.2 Framing contribution as a U(1) factor

Let $\mathbf{t}(s)$ be the tangent of the centerline, $\mathbf{u}(s)$ a smooth unit director field orthogonal to $\mathbf{t}$ defining the belt edges $\Gamma_\pm=\mathbf{r}\pm (w/2)\mathbf{u}$ . Define the twist

\mathrm{Tw}=\frac{1}{2\pi}\int_0^L \big(\mathbf{t}\times\mathbf{u}\big)\cdot\partial_s\mathbf{u}\;ds. \quad [BH:\,\mathrm{Tw}]

Lemma B.6 (Framing as a Berry/spin connection).
The rotation of $\mathbf{u}$ along the belt induces a U(1) connection

A_{\text{fr}}=\alpha\,\omega, \qquad \omega:=\big(\mathbf{t}\times\mathbf{u}\big)\cdot\partial_s\mathbf{u}\; ds,

whose holonomy around the boundary reduces to $e^{i\alpha\,\mathrm{Tw}}$ . $[BH:\,\text{framing factor}]$

Sketch. $\omega$ is the pullback of the $SO(2)$ spin connection of the normal bundle restricted to the director; integrating $\omega/2\pi$ counts total turns of $\mathbf{u}$ . The belt’s two edges pick the same scalar phase so the edge-gap accumulates a single multiplicative U(1) factor. ∎

Theorem B.7 (Framed Belt Holonomy Law, FBHL).
Including the framing U(1) factor,

\boxed{\;\mathrm{Hol}(\Gamma_+)\,\mathrm{Hol}(\Gamma_-)^{-1} =\mathcal{S}\exp\!\iint_{\mathcal{B}} W^{-1} F W\,dS\;\cdot\; e^{\,i\alpha\,\mathrm{Tw}}\;}. \quad [BH:\,\text{FBHL}]

Sketch. Combine Cor. B.5 with Lemma B.6. The non-Abelian part is conjugacy-covariant; the scalar factor commutes with $G$ , so it multiplies on the right without ambiguity. Gauge transformations $A\mapsto g^{-1}Ag+g^{-1}dg$ act by conjugation on the LHS and on the $\mathcal{S}\exp$ term; the scalar $e^{i\alpha\,\mathrm{Tw}}$ is gauge-invariant. ∎

Sanity limits.
(i) Abelian case: $W\equiv 1$ , FBHL reduces to B.1 with the extra twist phase.
(ii) Thin ribbon: $\kappa w\ll 1$ ⇒ surface curvature nearly constant across width; error $O((\kappa w)^2)$ . $[BH:\,\text{thin-belt error}]$

B.4 Framing quantization

Proposition B.8 (Integer shift under frame relabeling).
Let $\mathbf{u}$ and $\mathbf{u}'$ be two smooth director fields related by a rotation $\mathbf{u}'(s)=R_{\theta(s)}\mathbf{u}(s)$ with $\theta(0)=\theta(L)+2\pi m$ , $m\in\mathbb{Z}$ . Then

\mathrm{Tw}[\mathbf{u}']-\mathrm{Tw}[\mathbf{u}] \;=\; m. \quad [BH:\,\text{framing ambiguity}]

Sketch. Substitute $\mathbf{u}'$ into the twist integrand. The extra term integrates to $(1/2\pi)\int_0^L\theta'(s)\,ds=(\theta(L)-\theta(0))/(2\pi)=m$ . This is the degree of the map $s\mapsto e^{i\theta(s)}$ into $S^1$ . ∎

Corollary B.9 (Framing-independence quantization of $\alpha$ ).
The scalar factor changes by $e^{i\alpha m}$ . Physical framing-independence for closed belts requires

e^{i\alpha m}=1\ \ \forall m\in\mathbb{Z} \quad\Longleftrightarrow\quad \alpha\in 2\pi\mathbb{Z}. \quad [BH:\,\text{quantization}]

Otherwise, non-trivial $\alpha$ encodes a real framing (spin/torsion) coupling that is experimentally meaningful.

Remark (Linking–twist–writhe).
For the ribbon edges $\Gamma_\pm$ ,
$\mathrm{Lk}(\Gamma_+,\Gamma_-)=\mathrm{Tw}+\mathrm{Wr}$ . Under a global $2\pi$ relabeling of $\mathbf{u}$ , $\mathrm{Tw}\mapsto \mathrm{Tw}+1$ while $\mathrm{Wr}\mapsto \mathrm{Wr}-1$ , keeping $\mathrm{Lk}\in\mathbb{Z}$ invariant. $[BH:\,\mathrm{Lk}=\mathrm{Tw}+\mathrm{Wr}]$

B.5 Discrete FBHL (mesh version)

Setup. Triangulate $\mathcal{B}$ by oriented faces $\{f_k\}$ ; assign link variables $U_e\in G$ on edges with $U_e=\mathcal{P}\exp\!\int_e A$ , and face curvatures $V_{f_k}\approx\exp\!\int_{f_k}F$ .

Lemma B.10 (Lattice Stokes).
With a fixed surface ordering (e.g., radial sweep on the dual graph),

\prod_{e\in\Gamma_+}U_e\;\Big(\prod_{e\in\Gamma_-}U_e\Big)^{-1} =\overrightarrow{\prod_{k}} \Big(W_k^{-1}\,V_{f_k}\,W_k\Big) \;+\; O(h^2),

where $h$ is mesh scale and $W_k$ are discrete Wilson lines from the basepoint to $f_k$ . $[BH:\,\text{lattice NAST}]$

Sketch. Each face contributes a small loop; interior edges cancel pairwise; BCH/Trotter shows second-order error in $h$ . ∎

Framing on the lattice. Discretize $\omega$ by per-edge angles of $\mathbf{u}$ ; sum gives $\mathrm{Tw}$ up to $O(h)$ . The discrete FBHL reads

\Big(\prod_{\Gamma_+}U_e\Big)\Big(\prod_{\Gamma_-}U_e\Big)^{-1} =\overrightarrow{\prod_k}(W_k^{-1}V_{f_k}W_k)\cdot e^{\,i\alpha\,\mathrm{Tw}} + O(h^2). \quad [BH:\,\text{discrete FBHL}]

B.6 Error bounds and limits

Thin-belt approximation. If $\kappa w\ll 1$ and $F$ varies smoothly transverse to the centerline,

\big\|\,\mathcal{S}e^{\iint_{\mathcal{B}}W^{-1}FW}-e^{\int_0^L \bar{F}(s)\,w\,ds}\big\| = O((\kappa w)^2+\|\nabla F\|\,w^2).

Here $\bar{F}(s)$ is the transverse average at fixed $s$ . $[BH:\,\text{error law}]$

Non-orientable case (Möbius). Two-boundary orientation fails; FBHL must be replaced by an appropriate one-boundary statement with a doubled traversal. Not needed for this textbook’s core belt theory. $[BH:\,\text{limits}]$

B.7 Physical checks

4 $\pi$ periodicity. A $2\pi$ rotation of the frame changes $\mathrm{Tw}$ by $1$ ; demanding physical invariance under a $4\pi$ rotation is automatic if $\alpha\in 2\pi\mathbb{Z}$ (spinor-like sectors otherwise). $[BH:\,\text{4\(\pi$ test}])
Composition (gluing annuli). Gluing belts along a common edge adds their surface-ordered exponents and sums twists; edge holonomies compose accordingly. $[BH:\,\text{cobordism law}]$

What to remember

Two-boundary Stokes/Gauss are just the standard theorems with $\partial\mathcal{B}=\Gamma_+\!\sqcup\!(-\Gamma_-)$ .
FBHL = (non-Abelian Stokes over the belt) × (U(1) framing holonomy $e^{i\alpha\,\mathrm{Tw}}$ ).
Framing quantization ensures invariance under director relabeling when $\alpha\in 2\pi\mathbb{Z}$ ; otherwise $\alpha$ encodes a real, measurable coupling.

Appendix C — Computational Reference

(meshes, quadrature, error tables, complexity)

Goal: a drop-in cookbook you can implement in any language. Defaults target accuracy ~1e-3 for smooth belts in the thin-ribbon regime ( $\kappa w\ll 1$ ). Symbols follow App. A.

C.0 Scope & Objects

Input: centerline $\mathbf r(s)$ , director $\mathbf u(s)$ , width $w$ , connection $A(x)$ (or discrete links), curvature $F(x)$ .
Outputs:
(i) edge holonomies $\mathrm{Hol}(\Gamma_\pm)$ ;
(ii) belt holonomy gap $\mathrm{Hol}(\Gamma_+)\mathrm{Hol}(\Gamma_-)^{-1}$ ;
(iii) surface-ordered exponential $\mathcal S\!\exp\!\iint_{\mathcal B}F$ ;
(iv) twist $\mathrm{Tw}$ ;
(v) diagnostics: area, width-scaling, $4\pi$ periodicity.

C.1 Reference Discretizations

C.1.1 Parametric belt mesh (structured grid)

Let $s\in[0,L]$ (arc length), $u\in[-w/2,w/2]$ . Choose

N_s=\#\text{nodes along }s,\quad N_u=\#\text{nodes across }u,\quad h_s=\frac{L}{N_s},\; h_u=\frac{w}{N_u}.

Nodes: $\mathbf X_{i,j}=\mathbf r(s_i)+u_j\,\mathbf u(s_i)$ , $i=0..N_s$ , $j=0..N_u$ .
Faces: rectangles $(i,i+1)\times(j,j+1)$ (or split into two triangles).

Recommended defaults (smooth cases): $N_s\approx \max(256,\lceil L\,\kappa_{\max}/\varepsilon\rceil)$ , $N_u\in\{6,8,12\}$ , target $\varepsilon\sim10^{-3}$ .

C.1.2 Unstructured annulus (curvy belts)

Construct a centerline polyline; offset edges $\Gamma_\pm$ ; generate an annular strip via constrained Delaunay; orient faces by the chosen $\mathbf n_{\mathcal B}$ .
Store: vertices $V$ , directed boundary cycles $\Gamma_\pm$ , oriented faces $f_k$ , dual graph $G^\*$ (for ordering).

Data layout (minimal):

struct Mesh {
  Vec3 V[M]; int GammaPlus[E+], GammaMinus[E-];
  Face F[K]; // each Face has (v0,v1,v2) or (v0..v3), normal, area
  int dualParent[K]; // spanning tree parent for surface ordering
}

C.2 Quadrature Rules

C.2.1 Line (edges)

Midpoint (2nd-order): $\int_{e} g\,dl \approx |e|\,g(\text{mid})$ .
Simpson (4th-order, even segments): for composite along $\Gamma_\pm$ .
Gauss-Legendre (order $p$ ): $p=4$ is robust; use when $A$ varies quickly.

C.2.2 Surface (faces)

Rectangles: tensor Gauss–Legendre $2\times 2$ (order 4) or $3\times 3$ (order 6).
Triangles: Dunavant rules (order 5 or 7).
Example (order 5, 7 points): error $O(h^{6})$ on smooth $F$ .

Sampling $F$ :

Abelian: evaluate $F$ directly at quadrature points.
Non-Abelian: evaluate $F$ , then parallel transport to basepoint via Wilson line $W(x)$ (Sec. C.4) before accumulation.

C.3 Twist & Framing Estimators

C.3.1 Discrete twist

Let segment $i\to i+1$ have tangent $\mathbf t_i$ , directors $\mathbf u_i,\mathbf u_{i+1}$ . Define signed turn

\delta\phi_i=\operatorname{atan2}\!\big((\mathbf t_i\times \mathbf u_i)\!\cdot\!\mathbf u_{i+1},\ \mathbf u_i\!\cdot\!\mathbf u_{i+1}\big).

Then

\mathrm{Tw} \approx \frac{1}{2\pi}\sum_{i=0}^{N_s-1}\delta\phi_i \quad (+\,O(h_s^2)).

Tip: unwrap $\phi$ continuously to avoid $2\pi$ jumps.

C.3.2 Framing factor

e^{i\alpha\,\mathrm{Tw}} \quad\text{(scalar U(1)).}

If you support director relabeling, track $m\in\mathbb Z$ turns to test framing quantization.

C.4 Surface Ordering & Wilson Lines

We implement the non-Abelian surface-ordered exponential via a dual spanning tree.

Choose basepoint $x_0\in\Gamma_+$ .
Build a spanning tree $T$ on the dual graph $G^\*$ (faces as nodes).
For each face $f$ , define a dual path $\pi_f$ from base to $f$ .
Wilson line: $W_f=\prod_{e\in \pi_f} U_e$ (ordered), where $U_e=\mathcal P\exp\!\int_e A$ on primal edges intersected by the dual step (or use geodesic connectors).
Face curvature: $V_f=\exp\!\left(\int_{f} F\right)$ via quadrature.
Ordered product: $\overrightarrow{\prod_{f\in T}} (W_f^{-1} V_f W_f)$ in any parent-to-child traversal.

Gauge note: Result is basepoint-conjugate; extract invariants via $\operatorname{tr}$ , $\arg\det$ , principal eigenphase.

Stability tip: Use Lie-group integrators (Magnus $\Omega_2$ / Cayley) for small-area faces; avoid naive expm of large matrices if $F$ is stiff—subdivide the face.

C.5 Error Models (rules of thumb)

Let $h_s\sim L/N_s$ , $h_u\sim w/N_u$ , $h\sim\max(h_s,h_u)$ . Assume $F$ , $A$ $C^2$ -smooth across the belt.

C.5.1 Abelian

Edges (Simpson): global error $O(h_s^4)$ .
Surface (GL $2\times2$ ): global error $O(h^4)$ .
Thin-belt truncation: $O\!\big((\kappa w)^2 + \|\nabla_\perp F\|\,w^2\big)$ .

C.5.2 Non-Abelian

Face transport (Magnus $\Omega_2$ ): local $O(h^3\|F\|\,\|\nabla F\|)$ ; global $O(h^2)$ .
Tree ordering error: zero under exact algebra; numerically $O(\epsilon_{\text{mach}} N_f)$ .
Overall: with GL $3\times3$ + $\Omega_2$ on faces, expect $\sim O(h^3)+O((\kappa w)^2)$ .

C.5.3 Twist

Midpoint angle accumulation: $O(h_s^2)$ .
With cubic spline for $\mathbf u(s)$ : $O(h_s^4)$ .

C.6 Complexity & Memory

Let $K=N_f$ faces, $E^\pm$ boundary links, group $G\subseteq U(k)$ .

C.6.1 Cost components

Edge holonomy (per edge): expm along segment or product of links
$\Rightarrow O(k^3)$ per segment; total $O((E^++E^-)\,k^3)$ .
Wilson lines $W_f$ : one matrix multiply per dual step
$\Rightarrow O(K\,k^3)$ for tree traversal.
Face curvature $V_f$ : quadrature samples $q$ each; if expm per face: $O(q\,k^3)$ .
Surface-ordered product: $K-1$ multiplies $O(K\,k^3)$ .

Total (reference pipeline):

T \approx O\!\big((E^++E^- + K + qK)\,k^3\big) \sim O(qK\,k^3).

Memory: store $W_f,V_f$ optionally; minimal $O(k^2)$ working set + mesh; cached $W_f$ is $O(K\,k^2)$ .

C.6.2 Parallelism

Compute $V_f$ in parallel; compute $W_f$ by parallel BFS levels on $T$ ; reduce products by a tree-reduction (associative multiply).

C.6.3 Streaming update

If $F$ changes slowly in time, reuse $W_f$ and only update $V_f(t)$ . Cost per step $O(qK\,k^3)$ .

C.7 Reference Algorithms (pseudocode)

C.7.1 Edge holonomy (U(k), composite Simpson)

function EdgeHolonomy(edge Γ, A, p=4):
  subdivide Γ into M segments with arc-length step h_s
  H = I_k
  for seg in segments:
    if p==2: Abar = A(midpoint(seg))
    if p==4: Abar = SimpsonAverage(A, seg)   // 3 samples
    H = H * expm( Abar * length(seg) )
  return H

C.7.2 Surface-ordered exponential (dual-tree Magnus)

function BeltSurfaceOrderedExp(mesh, A, F):
  x0 = pick_basepoint_on(GammaPlus)
  T = dual_spanning_tree(mesh)
  W[root] = I_k
  // Wilson lines along dual tree edges
  for f in BFS(T):
    if f != root:
      e = dual_edge_connecting(parent(f), f)
      W[f] = W[parent(f)] * EdgeTransportAcross(e, A)   // expm of line integral

  // face curvatures via Magnus Ω2 on each face with q-point quadrature
  for f in Faces(mesh) parallel:
    V[f] = MagnusFaceExp(f, F, q)

  // ordered product (parent->child)
  S = I_k
  for f in DFS(T):
    S = S * ( W[f]^{-1} * V[f] * W[f] )
  return S

C.7.3 Twist

function Twist(r, u):
  unwrap angle φ along s using atan2 on successive u's
  return (φ(L) - φ(0)) / (2π)

C.8 Error & Stability Tables

C.8.1 Quadrature & integrators

Component	Method	Order	Notes
Edge integral $\oint A$	Midpoint	2	Fast, robust
	Composite Simpson	4	Recommended default
	Gauss–Legendre (p=4)	4	Fewer samples for smooth $A$
Face integral $\iint F$ (rect)	GL $2\times2$	4	Default
	GL $3\times3$	6	For high curvature
Face integral (tri)	Dunavant-5	5	Balanced cost
	Dunavant-7	7	High accuracy
Lie update (face)	Magnus $\Omega_2$	3 (local)	Good trade-off
	BCH (Trotter split)	2	Simple, more steps
	Exact `expm` on averaged $F$	—	Acceptable if face small

C.8.2 Error budget (smooth fields)

\varepsilon_{\text{total}} \;\lesssim\; C_1 h^{p} \;+\; C_2 (\kappa w)^2 \;+\; C_3 \|\nabla_\perp F\| w^2 \;+\; C_4\,\epsilon_{\text{mach}}K.

Targeting $10^{-3}$ : pick $p\ge 4$ , $h\approx 10^{-1.5}\min\{R_c, 1/\sqrt{\|F\|}\}$ , $N_u\ge 8$ , ensure $\kappa w\le 0.1$ .

C.9 Diagnostics & Unit Tests (numerical)

Constant curvature test. Synthetic $F=F_0$ :
Expect $\mathrm{Hol}(\Gamma_+)\mathrm{Hol}(\Gamma_-)^{-1} \approx \exp(F_0\cdot \text{area})$ ; error follows surface rule.
Width scaling. Scale $w\rightarrow \lambda w$ (small $\lambda$ ): edge-gap $\propto \lambda$ ; residual $O((\kappa w)^2)$ .
4 $\pi$ periodicity. Rotate frame by $4\pi$ : invariants unchanged; $2\pi$ may flip sign for spinor-like sectors if $\alpha\notin 2\pi\mathbb Z$ .
Ordering invariance. Change dual spanning tree: invariants ( $\operatorname{tr}$ , $\arg\det$ ) stable within numeric tolerance.
Boundary consistency. Directly computed $\oint_{\Gamma_+}A - \oint_{\Gamma_-}A$ (Abelian) equals surface integral within error model.

C.10 Practical Presets

Scenario	$N_s$	$N_u$	Edge rule	Face rule	Lie update
Smooth, thin belt	256	8	Simpson	GL $2\times2$	Magnus $\Omega_2$
High curvature along $s$	512	8–12	GL p=4	GL $3\times3$	Magnus $\Omega_2$
Rough $F$ (but bounded)	512	12	GL p=4	Dunavant-7	BCH (more splits)
Fast preview	128	6	Midpoint	GL $2\times2$	Averaged `expm`

C.11 Numerical Hygiene

Arc-length reparameterize $\mathbf r(s)$ before meshing; keeps step uniform.
Director orthogonality: re-orthonormalize $(\mathbf t,\mathbf u,\mathbf b)$ each step.
Unwrap angles for $\mathrm{Tw}$ ; avoid branch cuts.
Conditioning: scale matrices so $\|A\|\,h_s\lesssim 0.1$ , $\|F\|\text{area(face)}\lesssim 0.1$ ; otherwise subdivide.
Conservation checks: track $\det$ drift in $U(k)$ ; renormalize via polar decomposition if needed.
Mixed precision: compute quadrature in double; accumulate group products in double or long-double.

C.12 Optional: Writhe (if needed)

Discrete double-sum (O( $N_s^2$ )) for $\mathrm{Wr}$ ; use segment–segment Gauss integral. For $N_s>2000$ , accelerate with Barnes–Hut / FMM to $O(N_s\log N_s)$ . This is not required for FBHL but useful for belt topology audits.

C.13 Minimal API Sketch

HolonomyResult BeltHolonomy(BeltMesh B, GaugeField A, Curvature F, Options opt);
// returns {Hol_plus, Hol_minus, Sexp, Tw, invariants, diagnostics}

Options: integrator orders, mesh densities, basepoint policy, dual-tree builder, precision, validation toggles.

One-page recap (for implementers)

Mesh the annulus; orient faces; build a dual spanning tree.
Compute edge holonomies (Simpson/GL).
Compute Wilson lines along the dual tree.
Integrate face curvatures with Gauss rules; update via Magnus/BCH.
Multiply $W_f^{-1} V_f W_f$ in parent-to-child order.
Multiply framing $e^{i\alpha\mathrm{Tw}}$ .
Validate with constant- $F$ , width-scaling, $4\pi$ tests.

End of Appendix C.

Appendix D — Exercises & Mini-Projects (30)

Each item lists goal → task → solution outline → unit-test(s). Keep implementations minimal; prefer invariants (trace/argdet) for non-Abelian cases.

Track I — Geometry, Orientation, and Identities (1–8)

1) Belt orientation sanity

Task: For a planar annulus with constant normal, prove $\partial\mathcal B=\Gamma_+\sqcup(-\Gamma_-)$ .
Outline: Apply right-hand rule; parametrize both edges by increasing $s$ ; check induced co-normal.
Tests: Numerically integrate a constant 1-form $A=A_0\,dl$ : assert $\oint_{\Gamma_+}A-\oint_{\Gamma_-}A= A_0\cdot(\text{perim}_+ - \text{perim}_-)$ .

2) Two-boundary Stokes (Abelian)

Task: Verify $\oint_{\Gamma_+}\!A-\oint_{\Gamma_-}\!A=\iint_{\mathcal B}\!F$ for $A=\tfrac12(-y\,dx+x\,dy)$ .
Outline: $F=dA=dx\wedge dy$ . RHS = area; LHS = circulation difference.
Tests: Mesh-refine; error should be $O(h^p)$ for chosen quadrature.

3) Two-boundary Gauss on surfaces

Task: On a spherical belt (latitude $\theta\in[\theta_1,\theta_2]$ ), verify surface divergence theorem.
Outline: Use spherical coordinates; compute co-normal terms at the two latitudes.
Tests: Compare analytic vs. discrete intrinsic divergence.

4) Twist of a circular ribbon

Task: Circle of radius $R$ ; director rotates by $\phi(s)=m\,s/R$ . Compute $\mathrm{Tw}$ .
Outline: $\mathrm{Tw}=\frac{1}{2\pi}\int_0^{2\pi R}\phi'(s)\,ds=m$ .
Tests: Discrete estimator across $N_s$ samples recovers integer $m$ up to $O(N_s^{-2})$ .

5) Linking = Tw + Wr (planar case)

Task: For a planar ribbon (Wr=0), show $\mathrm{Lk}=\mathrm{Tw}\in\mathbb Z$ .
Outline: Planarity kills writhe; Lk equals director turns.
Tests: Count crossings between $\Gamma_\pm$ in a polygonal model; compare to discrete $\mathrm{Tw}$ .

6) 4 $\pi$ periodicity check

Task: Rotate the frame by $2\pi$ and $4\pi$ ; track observables.
Outline: $\mathrm{Tw}\mapsto\mathrm{Tw}+1$ per $2\pi$ ; invariants unchanged after $4\pi$ if $\alpha\in2\pi\mathbb Z$ .
Tests: Assert invariants equal after $4\pi$ ; log nontrivial phase after $2\pi$ if $\alpha\notin2\pi\mathbb Z$ .

7) Thin-belt metric

Task: Derive $g\approx\mathrm{diag}((1-\kappa u)^2,1)$ and the $O((\kappa w)^2)$ error.
Outline: First-order expansion of offset curve; neglect terms $u^2\kappa'$ , $u^2\kappa^2$ .
Tests: Numerically estimate area vs. $w$ ; fit residual to $w^3$ trend.

8) Basepoint conjugacy

Task: Show belt holonomy is conjugate-variant; traces are invariant.
Outline: Change Wilson-line fan; surface-ordered product changes by global conjugation.
Tests: Compute with two dual trees; assert $\operatorname{tr}$ and $\arg\det$ match within tolerance.

Track II — Abelian & Non-Abelian Computation (9–16)

9) Constant curvature field

Task: $F=F_0$ (matrix commuting with itself). Compute $\mathcal S e^{\iint F}$ .
Outline: Ordering trivial → $\exp(F_0\,\text{area})$ .
Tests: Compare to numerics for varying meshes.

10) Non-Abelian bump

Task: $F(x)=U^{-1}(x)F_0U(x)$ with non-constant $U$ .
Outline: Transport by $W^{-1}FW$ returns $F_0$ ; result equals $\exp(F_0\,\text{area})$ .
Tests: Vary $U$ ; invariants independent of chosen $U$ .

11) Edge vs. surface computation (Abelian)

Task: Compute LHS and RHS of two-boundary Stokes and compare.
Outline: Use Simpson on edges, GL $3\times3$ on faces.
Tests: Convergence study; Richardson extrapolation matches order.

12) Discrete twist robustness

Task: Compare three twist estimators (midpoint, quaternion, spline).
Outline: All converge to same integer on smooth inputs.
Tests: Inject noise; verify estimator stability and variance.

13) Ordering invariance

Task: Evaluate surface-ordered exponential with multiple dual spanning trees.
Outline: Parent-to-child order differs by conjugations/local commutators of higher order.
Tests: Assert invariant mismatch $< 5\cdot10^{-4}$ for target mesh.

14) Lie integration choices

Task: Compare BCH split vs. Magnus $\Omega_2$ vs. exp(average $F$ ).
Outline: $\Omega_2$ dominates for smooth $F$ ; BCH needs more splits.
Tests: Time vs. error table; pick default threshold for face subdivision.

15) Width scaling law

Task: For smooth $F$ , verify edge-gap $\propto w$ at small $w$ .
Outline: Transverse average yields linear term; quadratic correction from curvature.
Tests: Fit line for $w\in[10^{-3},10^{-1}]$ ; slope stability > 0.99 $R^2$ .

16) Gluing (cobordism) test

Task: Split belt into two annuli; compute each and glue.
Outline: Share the middle boundary with inverse orientation; holonomies multiply.
Tests: $\mathrm{Hol}_{whole}$ equals product up to tolerance; twists add.

Track III — Topology & Limits (17–22)

17) Möbius cautionary

Task: Show why two-boundary formula fails for a Möbius strip.
Outline: Non-orientable; boundary is a single loop; requires doubled traversal.
Tests: Attempt code shows sign inconsistency; unit test expects failure flag.

18) Defects and punctures

Task: Remove a disk from $\mathcal B$ ; add an inner boundary $\Gamma_0$ .
Outline: Two-boundary Stokes generalizes to sum over all boundary components.
Tests: Verify $\sum \text{edge integrals}=\iint F$ .

19) Large-width correction

Task: Empirically estimate breakdown of thin-belt law vs. $\kappa w$ .
Outline: Increase $w$ ; fit error to $c_2(\kappa w)^2+c_3(\kappa w)^3$ .
Tests: Report critical $\kappa w$ where error > 1e-2.

20) High-curvature hotspot

Task: Localize a region with large $\|F\|$ ; adaptively refine.
Outline: Indicator $\eta_f=\|F\|\,\text{area}(f)$ ; split faces with $\eta_f>\tau$ .
Tests: Error vs. DOF curve shows optimal slope.

21) Writhe audit (optional)

Task: Compute $\mathrm{Wr}$ for a perturbed 3D centerline; check $\mathrm{Lk}=\mathrm{Tw}+\mathrm{Wr}$ .
Outline: Segment–segment Gauss integral; stabilize with softening.
Tests: Integer Lk from edge crossings equals sum.

22) Random gauge smoothing

Task: Apply random gauge $g(x)$ ; recompute.
Outline: Belt holonomy conjugates; invariants unchanged.
Tests: Property-based test over random seeds.

Track IV — Applied Numerics & Signal Models (23–27)

23) Constant-field calibrator

Task: Build a CLI that, given belt geometry, returns area-scaled exponential for constant $F$ .
Outline: Closed-form path; use to validate pipelines.
Tests: Golden files for multiple geometries.

24) Noisy sampling

Task: Sample $A,F$ with additive noise; evaluate bias of invariants.
Outline: Show invariants are first-order unbiased if noise is zero-mean.
Tests: Monte-Carlo: mean error ∼ 0; variance shrinks as $1/n$ .

25) Time-varying field (Faraday-like)

Task: Simulate $F(t)$ with $\partial_tF\neq0$ ; measure rate of change of edge gap.
Outline: Discrete time derivative approximates “EMF” across edges.
Tests: Convergence under $\Delta t\to0$ .

26) Discretization audit tool

Task: Build a report (mesh stats, quadrature order, residuals, invariants).
Outline: Centralize checks from C.9; produce a pass/fail summary.
Tests: Ensure failing any invariant flips exit code.

27) Benchmark suite

Task: Implement three public tests: $4\pi$ , width-scaling, constant $F$ .
Outline: Emit JSON logs with curves and tolerances.
Tests: CI gate enforces $\le 1e\!-3$ target.

Track V — Mini-Projects (28–30)

28) Reference implementation (minimal API)

Goal: End-to-end U(k) belt holonomy with framing.
Outline: Mesh annulus → dual tree → Wilson lines → face Magnus → ordered product → framing $e^{i\alpha \mathrm{Tw}}$ .
Tests:
- Invariant: trace equality under tree swap.
- Stokes: Abelian case equals surface flux.
- 4π: invariants unchanged after $4\pi$ frame rotation.

29) Adaptive belt tiler

Goal: Given arbitrary centerline and width, generate high-quality meshes respecting curvature.
Outline: Arc-length parametrization; set $h_s\sim \min(R_c, c/\sqrt{\|F\|})$ ; enforce $N_u\ge 8$ .
Tests: Error vs. DOF monotone; topology preserved (no edge crossings).

30) Holonomy composition & logging

Goal: Glue two belts along a shared boundary and audit composition.
Outline: Compute $(\Gamma_+^{(1)}\Gamma_-^{(1)})$ and $(\Gamma_+^{(2)}\Gamma_-^{(2)})$ ; compose; compare to single-belt computation.
Tests:
- Composition: $\|H_{12}-H_1H_2\|\le \epsilon$ .
- Twist additivity: $\mathrm{Tw}_{12}=\mathrm{Tw}_1+\mathrm{Tw}_2$ .
- Ordering invariance: traces stable across different glue paths.

Solution Outlines (compact keys)

S1 (Two-boundary Stokes/Gauss): Reduce to classical theorems with induced boundary $\Gamma_+\sqcup(-\Gamma_-)$ ; the minus sign comes from co-normal reversal on the inner edge.
S2 (FBHL core): Boundary factorization $\Gamma_+\cdot\Gamma_-^{-1}$ + non-Abelian Stokes via dual-tree Wilson transport + scalar framing holonomy $e^{i\alpha\,\mathrm{Tw}}$ .
S3 (Framing quantization): Director relabeling adds integer $m$ to $\mathrm{Tw}$ ; physical framing-independence $\Rightarrow \alpha\in2\pi\mathbb Z$ .
S4 (Thin-belt error): Transverse Taylor expansion yields $O((\kappa w)^2)+O(\|\nabla_\perp F\|w^2)$ corrections.
S5 (Ordering/basepoint): Changes act by global conjugation; invariants from class functions ( $\operatorname{tr}$ , $\arg\det$ ) are stable.
S6 (Gluing): Interior boundaries cancel; products of holonomies and sums of twists implement cobordism additivity.

Unit-Test Templates (pseudocode)

test TwoBoundaryStokes_Abelian():
  A, F = pickAbelianPotential()
  LHS = lineIntegral(GammaPlus, A) - lineIntegral(GammaMinus, A)
  RHS = surfaceIntegral(Belt, F)
  assert abs(LHS - RHS) <= c1 * h^p + c2 * w^2

test FBHL_Invariants_NonAbelian():
  Hgap = Hol(GammaPlus, A) * inv(Hol(GammaMinus, A))
  Sexp = SurfaceOrderedExp(Belt, A, F)
  phase = exp(i * alpha * Twist(r, u))
  inv1 = argdet(Hgap); inv2 = argdet(Sexp) + alpha * Twist(...)
  assert approxEqual(inv1, inv2, tol=1e-3)

test Basepoint_Conjugacy():
  S1 = SurfaceOrderedExp_withTree(T1)
  S2 = SurfaceOrderedExp_withTree(T2)
  assert approxEqual(trace(S1), trace(S2), tol=1e-6)

test FourPi_Periodicity():
  Tw0 = Twist(u)
  Tw4 = Twist(rotateDirector(u, 4*pi))
  H0 = invariants(...)
  H4 = invariants(...)
  assert Tw4 == Tw0 + 2
  assert approxEqual(H0, H4, tol=1e-6)

test WidthScaling():
  for λ in {0.25, 0.5, 1.0}:
    wλ = λ * w0
    gap[λ] = edgeGap(A, wλ)
  assert LinearFit(λ -> gap[λ]).R2 >= 0.99

test Gluing_Composition():
  H1, Tw1 = BeltHolonomy(B1)
  H2, Tw2 = BeltHolonomy(B2)
  H12, Tw12 = BeltHolonomy(glue(B1,B2))
  assert approxEqual(trace(H12), trace(H1*H2), tol=1e-3)
  assert approxEqual(Tw12, Tw1 + Tw2, tol=1e-6)

Instructor Notes

Keep each exercise self-contained; provide minimal starter code (mesh + quadrature).
Grade primarily on invariant checks and error analysis, not only raw numbers.
Encourage students to attach short failure diaries when a test breaks (mesh, ordering, or gauge issues).

End of Appendix D.

Appendix E — Quick-Start One-Pager (core equations)

Belt domain $\mathcal B$ oriented annulus with boundary

\boxed{\partial\mathcal B=\Gamma_{+}\,\sqcup\,(-\Gamma_{-})}\quad\text{(outer minus inner)} .

Edges (from centerline $\mathbf r(s)$ and director $\mathbf u(s)\perp\mathbf t$ )

\Gamma_\pm(s)=\mathbf r(s)\pm \tfrac{w}{2}\,\mathbf u(s),\qquad \mathbf t=\partial_s\mathbf r,\ \ \mathbf b=\mathbf t\times\mathbf u .

Belt chart (thin ribbon $\kappa w\ll1$ )

\mathbf X(s,u)=\mathbf r(s)+u\,\mathbf u(s),\quad u\in[-\tfrac w2,\tfrac w2],\qquad g\approx\begin{pmatrix}(1-\kappa u)^2&0\\[2pt]0&1\end{pmatrix}.

Integral theorems (two-boundary forms)

Abelian Stokes (edge gap = surface flux)

\boxed{\oint_{\Gamma_+}\!A-\oint_{\Gamma_-}\!A=\iint_{\mathcal B}\!F}\quad(A\ \text{1-form},\ F=dA).

Surface Gauss (intrinsic divergence)

\boxed{\iint_{\mathcal B}\nabla_{\!\mathcal B}\!\cdot\mathbf v\,dS =\oint_{\Gamma_+}\!\mathbf v\!\cdot\!\boldsymbol\nu\,dl -\oint_{\Gamma_-}\!\mathbf v\!\cdot\!\boldsymbol\nu\,dl } .

Holonomy & FBHL (framed belt holonomy law)

Edge holonomy

\mathrm{Hol}(\Gamma)=\mathcal P\exp\!\oint_\Gamma A \in G.

Surface-ordered exponential (with Wilson transport $W$ )

\mathcal S\exp\!\iint_{\mathcal B} W^{-1}FW\,dS .

Framing (twist)

\boxed{\mathrm{Tw}=\frac{1}{2\pi}\int_0^L(\mathbf t\times\mathbf u)\cdot\partial_s\mathbf u\;ds } .

FBHL (non-Abelian curvature × scalar framing)

\boxed{\ \mathrm{Hol}(\Gamma_+)\,\mathrm{Hol}(\Gamma_-)^{-1} =\mathcal S\exp\!\iint_{\mathcal B} W^{-1}FW\,dS\;\cdot\;e^{\,i\alpha\,\mathrm{Tw}}\ } .

Topology & quantization

Link–twist–writhe (Călugăreanu–White–Fuller)

\boxed{\mathrm{Lk}(\Gamma_+,\Gamma_-)=\mathrm{Tw}+\mathrm{Wr}}, \quad \mathrm{Wr}=\frac{1}{4\pi}\!\!\iint\frac{(\partial_s\mathbf r\times \partial_{s'}\mathbf r)\cdot(\mathbf r-\mathbf r')} {\|\mathbf r-\mathbf r'\|^3}\,ds\,ds'.

Framing relabeling

\mathrm{Tw}[\mathbf u']-\mathrm{Tw}[\mathbf u]=m\in\mathbb Z,\qquad e^{i\alpha\,\mathrm{Tw}}\to e^{i\alpha(\mathrm{Tw}+m)}.

Framing-independence requires $\alpha\in2\pi\mathbb Z$ .

4 $\pi$ periodicity: a $4\pi$ frame rotation leaves physical invariants unchanged.

Discrete (implementation-ready) forms

Lattice Stokes / discrete FBHL (faces $f$ , dual tree, $V_f\approx e^{\int_f F}$ )

\boxed{\ \prod_{e\in\Gamma_+}U_e\Big(\prod_{e\in\Gamma_-}U_e\Big)^{-1} =\overrightarrow{\prod_{f}} (W_f^{-1}V_f W_f)\ \cdot\ e^{\,i\alpha\,\mathrm{Tw}}\ } .

Invariant for testing (U(k), normalized)

\boxed{\ \frac{1}{k}\arg\det\!\Big(\mathrm{Hol}(\Gamma_+)\mathrm{Hol}(\Gamma_-)^{-1}\Big) =\frac{1}{k}\arg\det\!\Big(\mathcal S e^{\iint W^{-1}FW}\Big)+\alpha\,\mathrm{Tw}\ \ (\mathrm{mod}\ 2\pi)\ } .

Thin-belt & scaling heuristics

Width scaling (Abelian, smooth $F$ )

\oint_{\Gamma_+}\!A-\oint_{\Gamma_-}\!A = w\!\int_0^L \bar f(s)\,ds\;+\;O\!\big((\kappa w)^2+\|\nabla_\perp F\|\,w^2\big),

where $\bar f$ is the transverse average of flux density.

Error budget (typical numeric pipeline)

\varepsilon \;\lesssim\; C_1 h^{p} + C_2(\kappa w)^2 + C_3\|\nabla_\perp F\|\,w^2 .

Composition, gauge, orientation

Gluing annuli (cobordism additivity)

\mathcal S e^{\iint_{\mathcal B_1\cup\mathcal B_2}}\!=\!(\mathcal S e^{\iint_{\mathcal B_1}})(\mathcal S e^{\iint_{\mathcal B_2}}),\qquad \mathrm{Tw}_{12}=\mathrm{Tw}_1+\mathrm{Tw}_2.

Basepoint/ordering change

\mathcal S e^{\iint} \ \mapsto\ g^{-1}\big(\mathcal S e^{\iint}\big)g, \quad \text{class-function invariants (trace, }\arg\det\text{) unchanged.}

One-line checklist (compute & verify)

Mesh annulus → build dual tree → edge holonomies → face curvatures → ordered product → multiply $e^{i\alpha\mathrm{Tw}}$ → check Stokes, argdet identity, width linearity, 4 $\pi$ .

Disclaimer

This book is the product of a collaboration between the author and OpenAI's GPT-5 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.

Friday, September 19, 2025