What Each Field Has

Chapter 3 · Seely 2025 · Bilò et al. 2022 · Sullivan & Wiegand 1998

R-D optimization, impossibility classes, Hodge decomposition. Nobody has all three.

Three inventories

The previous chapter showed the one genuine parallel. Each field has tools the others lack, and the open problems live in the gaps.

Video codecs have	TVG theory has	Sheaf cohomology has
Rate-distortion optimization min D + λR. Formal Lagrangian framework.	—	—
Error accumulation + reset Quantization error grows through P-chains. I-frames reset.	—	Removable / irreducible split Hodge decomposition: im D vs. ker Dᵀ.
Graceful degradation Error concealment approximates missing frames.	—	—
—	Journey optimality Foremost, fastest, shortest — formally distinct.	—
—	Impossibility classes 13 classes. Some can't support certain operations.	—
—	Temporal spanners Sparse subgraphs preserving journeys. Edge count, not bits.	—
—	—	Max-flow / min-cut (sheaf) H⁰ = flows. Duality gaps = exactness failures.
—	—	Learning gradient factorization ∂E/∂W = (harmonic error) · (source activation)ᵀ

The sheaf coboundary: prediction error, algebraically

Seely (2025) constructs a cellular sheaf over a computational graph. The coboundary operator δ⁰: C⁰ → C¹ maps activations (0-cochains) to prediction errors (1-cochains):

(δ⁰s)_e = s_v − W_e s_u

This has the same algebraic form as motion-compensated subtraction: current frame minus predicted frame. The predictive-coding energy is E = ½‖δ⁰s‖², and inference is gradient descent under the sheaf Laplacian.

With clamped inputs and outputs (known source, known target), the Hodge decomposition splits the forcing vector into a removable component (in im D — better encoder choices can eliminate it) and an irreducible component (in ker Dᵀ — no choice of activations can remove it). The irreducible part lives in H¹, the first cohomology group.

Temporal spanner: compressing for edge count

A temporal α-spanner removes edges while keeping journey distances within a multiplicative stretch factor α. The objective is fewer edges, not fewer bits. No encoding is specified, no bit budget is given.

Python

class TemporalGraph:
    def __init__(self):
        self.edges = []

    def add_edge(self, u, v, t):
        self.edges.append((u, v, t))

    def journey_duration(self, start, end):
        arrival = {start: 0}
        for u, v, t in sorted(self.edges, key=lambda e: e[2]):
            if u in arrival and t >= arrival[u]:
                new_arrival = t + 1
                if v not in arrival or new_arrival < arrival[v]:
                    arrival[v] = new_arrival
        return arrival.get(end, float('inf'))

    def temporal_spanner(self, alpha):
        kept = []
        removed = []
        test_edges = sorted(self.edges, key=lambda e: -e[2])
        current = list(self.edges)

        for edge in test_edges:
            trial = [e for e in current if e != edge]
            trial_g = TemporalGraph()
            for e in trial:
                trial_g.add_edge(*e)
            full_g = TemporalGraph()
            for e in current:
                full_g.add_edge(*e)

            nodes = set()
            for u, v, t in current:
                nodes.add(u)
                nodes.add(v)

            ok = True
            for s in nodes:
                for d in nodes:
                    if s == d:
                        continue
                    orig = full_g.journey_duration(s, d)
                    new = trial_g.journey_duration(s, d)
                    if orig < float('inf') and new > alpha * orig:
                        ok = False
                        break
                if not ok:
                    break

            if ok:
                removed.append(edge)
                current = trial
            else:
                kept.append(edge)

        return sorted(kept, key=lambda e: e[2]), removed

g = TemporalGraph()
g.add_edge("A", "B", 1)
g.add_edge("A", "C", 1)
g.add_edge("B", "D", 2)
g.add_edge("C", "D", 3)
g.add_edge("B", "C", 2)
g.add_edge("A", "D", 4)

print(f"Original: {len(g.edges)} edges")
kept, removed = g.temporal_spanner(2.0)
print(f"Spanner (α=2.0): {len(kept)} kept, {len(removed)} removed")
print("Kept:")
for e in kept:
    print(f"  {e[0]}→{e[1]} @ t={e[2]}")

spanner_g = TemporalGraph()
for e in kept:
    spanner_g.add_edge(*e)

nodes = ["A", "B", "C", "D"]
print("\nJourney durations (original → spanner):")
for s in nodes:
    for d in nodes:
        if s != d:
            orig = g.journey_duration(s, d)
            new = spanner_g.journey_duration(s, d)
            o = str(orig) if orig < float('inf') else "∞"
            n = str(new) if new < float('inf') else "∞"
            st = f" (×{new/orig:.1f})" if orig < float('inf') and new < float('inf') else ""
            print(f"  {s}→{d}: {o} → {n}{st}")

class TemporalGraph:
    def __init__(self):
        self.edges = []

def add_edge(self, u, v, t):
        self.edges.append((u, v, t))

def journey_duration(self, start, end):
        arrival = {start: 0}
        for u, v, t in sorted(self.edges, key=lambda e: e[2]):
            if u in arrival and t >= arrival[u]:
                new_arrival = t + 1
                if v not in arrival or new_arrival < arrival[v]:
                    arrival[v] = new_arrival
        return arrival.get(end, float('inf'))

def temporal_spanner(self, alpha):
        kept = []
        removed = []
        test_edges = sorted(self.edges, key=lambda e: -e[2])
        current = list(self.edges)

for edge in test_edges:
            trial = [e for e in current if e != edge]
            trial_g = TemporalGraph()
            for e in trial:
                trial_g.add_edge(*e)
            full_g = TemporalGraph()
            for e in current:
                full_g.add_edge(*e)

nodes = set()
            for u, v, t in current:
                nodes.add(u)
                nodes.add(v)

ok = True
            for s in nodes:
                for d in nodes:
                    if s == d:
                        continue
                    orig = full_g.journey_duration(s, d)
                    new = trial_g.journey_duration(s, d)
                    if orig < float('inf') and new > alpha * orig:
                        ok = False
                        break
                if not ok:
                    break

if ok:
                removed.append(edge)
                current = trial
            else:
                kept.append(edge)

return sorted(kept, key=lambda e: e[2]), removed

g = TemporalGraph()
g.add_edge("A", "B", 1)
g.add_edge("A", "C", 1)
g.add_edge("B", "D", 2)
g.add_edge("C", "D", 3)
g.add_edge("B", "C", 2)
g.add_edge("A", "D", 4)

print(f"Original: {len(g.edges)} edges")
kept, removed = g.temporal_spanner(2.0)
print(f"Spanner (α=2.0): {len(kept)} kept, {len(removed)} removed")
print("Kept:")
for e in kept:
    print(f"  {e[0]}→{e[1]} @ t={e[2]}")

spanner_g = TemporalGraph()
for e in kept:
    spanner_g.add_edge(*e)

nodes = ["A", "B", "C", "D"]
print("\nJourney durations (original → spanner):")
for s in nodes:
    for d in nodes:
        if s != d:
            orig = g.journey_duration(s, d)
            new = spanner_g.journey_duration(s, d)
            o = str(orig) if orig < float('inf') else "∞"
            n = str(new) if new < float('inf') else "∞"
            st = f" (×{new/orig:.1f})" if orig < float('inf') and new < float('inf') else ""
            print(f"  {s}→{d}: {o} → {n}{st}")

The invariance boundary

The temporal state machines paper establishes an invariance constraint for pure race logic: any function must satisfy f(t₁+δ,...,tₙ+δ) = f(t₁,...,tₙ)+δ. Compositions that break this symmetry require memory (state). Tropical multiplication — adding two time codes — cannot be done in a single stateless pass.

This draws a line between stateless temporal composition and stateful computation that requires buffering. The two-phase protocol — store the wavefront, then apply it — is suggestive of the I-frame/P-frame cycle (write a checkpoint, then compute deltas), though that analogy is ours, not the paper's.

The gaps

The spanner compresses by counting edges. The codec compresses by counting bits. The sheaf separates removable from irreducible error but has no temporal dynamics and no rate constraint. Each field has exactly what the others are missing. The next chapter states the open problems that live in those gaps.

Neighbors

Key references

Seely 2025 — coboundary, Hodge decomposition, learning gradient
Bilò et al. 2022 — temporal α-spanners
Temporal state machines — invariance constraint
Sullivan & Wiegand 1998 — R-D optimization

← Chain Fragility by june.kim The Open Problems →