# Protocols are Lightcones

*Protocols creates certainty slower than thought exploits optionality.*

## Introduction
Coordination needs certainty; certainty travels slower than thought. Protocols are the machines we build to manufacture certainty—trusted zones with clear rule. But their “trust zone” has boundaries set by visibility and time. Think of each protocol as casting a commitment cone (a lightcone analogue): inside the cone, outcomes can be enforced and made common knowledge; outside it, fast intelligences exploit optionality before certainty arrives (therefore imperfect coordination).

Physics is the base protocol (they never break, and the speed of light caps how fast certainty, or, causal influence, travels); law and institutions sit above it; social codes above those; blockchains are simply one layer where these limits are stark and instrumentable (due to their permissionless nature of acting as substrates for other protocols to liveon).

Protocols are engineered versions of "physical causality": they define **what counts as settled** and how fast that settlement becomes common knowledge. Intelligence running on the physical protocol naturally seeks optionality in our man‑made protocols; the more open the API, the more surface there is to exploit. That’s why agency (what you can do) and autonomy (how much drift you can resist) are the right end goals: protocols trade a bit of autonomy for larger, reliable, shared agency.

---

## A minimal formalism

### Event structure (uncertainty as a poset)

Let $E$ be a finite set of events (transactions, messages, actions, filings, rulings, sensor updates). The protocol induces a partial order $(E,\preceq)$ meaning “must not be ordered after.” At time $t$, the set of events already lifted to common knowledge is $T(t) \subseteq E$, those events are already "in the trust zone." Unfixed events at time $t$ form $U(t)\subseteq E$. The frontier $\partial U(t)$ are events whose order/content can still change outcomes.

The width at time t is the size of a maximum antichain in $\partial U(t)$:
$$
W(t) = \max{|A|: A\subseteq \partial U(t)}
$$

Width measures contemporaneous degrees of freedom: mutually unordered “knobs” that an adversary could exploit via reordering or conditional inclusion.

### Visibility and common‑knowledge checkpoints

Each agent $a$ has a visibility filtration $\{\mathcal{F}a(t)\}_{t\ge 0}$ over $E$. Define observability of the frontier for a coalition $C$ by
$$
\qquad \nu_C(t)=\frac{|\partial U(t)\cap \bigcup_{a\in C}\mathcal{F}a(t)|}{|\partial U(t)|}\in[0,1]
$$
i.e., the fraction of live degrees of freedom effectively seen by $C$. Visibilities are like side-channels.

Protocol checkpoints $0<T_1<T_2<\cdots$ are times when the protocol publishes facts that become common knowledge; they shrink $U(t)$. The interval lengths $\Delta_k=T{k+1}-T_k$ are the speed of certainty.

This speed $\Delta_k$ defines “commitment lightcone”: at checkpoints, uncertainty collapses for everyone.

### Protocol
We model a protocol $P$ over a finite horizon $[0,T]$. Protocols are for agents to coordinate.

A protocol is a credible commitment substrate that periodically upgrades facts to common knowledge:
$$P=(E,\preceq,\{\mathcal{F}_a\},F,\Delta)$$
where $F:[E] \to S$ is a settlement semantics mapping events to state. $F$ is applied whenever the event enters the lightcone.

### Open‑API
A protocol exposes a pre‑finality “open API” if a coalition $C$ can submit event $e \in E$ with $\nu_C(t)>0$ for some interval.

### Value curvature (local sensitivity to permutations)

Let $\Lambda(t)\ge 0$ bound marginal payoff change per local permutation of one frontier element (e.g., price‑impact curvature for AMMs; policy sensitivity in auctions; your neuron pathway re-wiring after seeing different information):
$$
\text{for any perturb in }\partial U(t):\quad 0 \le |\Delta \text{payoff}| \le \Lambda(t).
$$

For now, assume $\Lambda$ to be a Lipschitz‑like constant that we can estimate and design against.

## Optionality bounds

### Theorem 1 (Speed‑of‑certainty Gap & Optionality Bounds)

For any coalition $C$ in protocol $P$,
$$\mathrm{MEV}_C(P)\; \le \; \int_0^{\Delta} \Lambda(t)\;\nu_C(t)\;W(t)\,dt$$

Interpretation. Extractable value requires all three: unresolved degrees of freedom (width), effective sight (visibility and enough simulation finished before the checkpoint), and value curvature. This turns qualitative “exposure” into an inequality you can shape: batch to reduce $W$; privacy-preserving computation to reduce $\nu$; move value functions toward flatter regions to reduce $\Lambda$; and narrow $\Delta$ (faster checkpoints) to reduce the curve area.

Optionality = Width × Visibility × Curvature, Or:

$$\boxed{\ \mathrm{Optionality}\ \lesssim\ \int \Lambda \cdot \nu \cdot W\ }$$

**Sketch**. In a small window $dt$, an adversary sees at most $\nu_C(t)W(t)$ independent binary choices. Each choice moves payoff by at most $\Lambda(t)$. Integrate. $\square$

### Theorem 2 (Generality–Openness–No‑MEV Trilemma)

In any protocol that is (i) general‑purpose (commit constructors are Turing‑complete), (ii) open‑API during pre‑finality (some $\nu>0$), and (iii) aims for per‑epoch zero MEV, at least one of (i–iii) must be false.

Fix a protocol $P$ with checkpoint gap $T\ge\Delta>0$ and an open‑API window that yields $\sup_t \nu_C(t)>0$ for some coalition $C$. If $\sup_t W(t)>0$, then there exist environments inducing $\mathrm{MEV}_C(P)>0$. To make $\mathrm{MEV}_C(P)=0$, you must change at least one of:
1. Width: batch/atomize time to force $W(t)=0$
2. Visibility: enforce $\nu_C(t)=0$ (reduce external simulator accuracy to zero, full privacy);
3. Latency: make $\Delta\to 0$ (faster finality / tighter cones).
4. Curvature: make $\Lambda(t) \to 0$ (make the game payoff not sensitive to perturb of changes within the lightcone)

Sadly:
1. it's impossible to make width $W$ zero for general purpose games because we humans play general purpose games and we live at the physical layer (which has non-atomized time, so our actions in those games happen "continuously")
2. it's impossible to make visibility $\nu$ zero because we always have some expectations over what the frontier would be and can simulate against that to extract value, although we can improve visibility via confidential computing to reduce the amount of correlated fast games that agents play
3. it's impossible to force latency $\Delta$ to be zero because of speed of light (and consensus/common knowledge require at least two speed of light trips) is not zero.
4. it's unrealistic to make the curvature $\Lambda$ zero for most games for the same reason we can't make width $W$ zero: we care about physical things and they are continuous.

**Sketch**. With (i), users can encode content/order‑sensitive contingent frontier events that create exploitable antichains on demand; with (ii), adversaries see enough to condition within $ε<\Delta$this gives us positive MEV. The assumption (i) really means there is no magic fix "at the same level" because all protocols you build on top inherit the same parameters. $\square$

**Corollary (single‑purpose zero‑MEV)**.
If a protocol’s game is fixed, lasts longer than $\Delta$, and exposes no open API ($\nu=0$), then MEV can be driven to zero. This explains why simple, fixed, slow mechanisms can be MEV‑free, while general substrates aren’t.

## Cognition as open‑API protocols

The same calculus applies to brains because brains are open‑API systems.

We treat a cognitive agent as a three‑port open‑API protocol:
- Attention $A(t)$: inputs the world can cause you to load,
- Intention $I(t)$: latent policy state,
- Action $X(t)$: outputs (what gets done).

**Cognitive frontier and width**.
At time $t$, let $\mathcal{S}(t)$ be the set of action affordances (frontier $U(t)$) consistent with $I(t)$ and what has entered via $A(t)$. Define the cognitive frontier as the subset whose resolution is still undecided before the next self‑checkpoint (decision commit) and

$$W_{\text{cog}}(t) \;=\; \max\{|A| \;:\; A \subseteq \mathcal{S}(t)\}$$

**Visibility of your state**.
An external simulator observing your private state data (clicks, language, biometrics, preferences, chat history) has inference visibility $\nu_{\text{cog}}(t)\in[0,1]$: probability mass of the frontier that is predictable/steerable through crafted stimuli before your next commit.

**Autonomy drift.**
Fix a reference policy $\pi^\star$. Let $\pi_t$ be the policy actually executed after exposure. Define
$$
\mathrm{Drift}(T) = \mathbb{E}\left[\int_0^T d\big(\pi_t,\pi^\star\big),dt\right]
$$

for a task‑appropriate metric $d$ (it assumes the brain has an intent/utility function). Under the same width–visibility–curvature logic applied to attention schedules and choice sets,
$$
\mathrm{Drift}(T) \le \int_0^T \Lambda_{\text{cog}}(t) \times \nu_{\text{cog}}(t) \times W_{\text{cog}}(t) dt
$$
where $\Lambda_{\text{cog}}$ is your susceptibility (local payoff sensitivity to small nudges).

**Agency vs autonomy**.
Your agency is the (designed) volume of reachable outcomes from your actions; your autonomy is your defense level of holding a trajectory through adversarial attention. Protocols voluntarily trade a bit of autonomy (shared constraints) for greater joint agency (bigger reachable set).

**Design rules for cognitive autonomy**.
1. Reduce $W_{\text{cog}}$: fewer undecided affordances per cycle (pre‑commit routines, “limited menu”).
2. Shrink visibility $\nu_{\text{cog}}$ of pending intentions (delayed disclosure of $I(t)$, data privacy)
3. Compute with conditional recall via safe mediators (filters/TEEs) so useful correlations are realized inside your cone without broadcasting your state
4. Shrink $\Lambda_{\text{cog}}$: make small perturbations locally indifferent (robust defaults, hysteresis)
5. Shorten cognitive $\Delta$: faster personal commit‑cycles (timers, check‑lists), although there is a tradeoff between biasing towards immediate action and biasing towards more time for better decision making.

Replace “privacy” = hide data with non‑interference + controlled declassification: compute inside the trusted zone; reveal only attestations needed for coordination. That keeps welfare (we still compute) while collapsing cross‑game leakage (no uncontrolled propagation).

## Mind‑upload
As a thought experiment, if every human is mind-uploaded (like in Pantheon the show), then we can achieve a perfect protocol with zero-MEV and maximal coordination welfare.

Intuitively, mind-uploading everybody is co‑location (no geo latency, therefore no width as well); $W=0$, $\nu=0$. Perfect mind‑upload is exactly full encumbrance of every relevant simulation by the trusted zone that hosts all agents. The trusted zone swallows the world; there is no external optionality left. In the human case, this also requires exclusive control (no surviving physical copies) so that no correlated fast games can be played outside the zone—an encumbrance property, not just secrecy.

As a minimal formalism for this case, let all agents be co‑located (code can live in same server), share a perfectly faithful model (fidelity error $\varepsilon\!=\!0$), and checkpoint continuously ($\Delta\!=\!0$). There is no external visibility ($\nu\!=\!0$) and the frontier collapses ($W\!=\!0$). Then for any coalition $C$,
$\mathrm{MEV}_C(P) = 0$.

**Practical gradient to the limit**.
- Latency floor: physics imposes $\Delta \ge \frac{2D}{c}$ (two‑way light‑time over diameter $D$).
- Fidelity floor: bounded compute gives $\varepsilon>0$; simulation drift compounds with horizon.
- Encumbrance: to prevent correlated "fast games" by an off‑cone original, physical copies must be constrained or deactivated; otherwise $\nu>0$ re‑appears.
- Residual MEV bound: with finite $\Delta$, $\varepsilon$,

$$\mathrm{MEV}_C(P) \;\le\; \int_0^\Delta \Lambda(t)\,\nu(t)\,\big(W(t)-C_M(t)\big)\,dt \;+\; \mathrm{Err}(\varepsilon)$$ where $\mathrm{Err}(\varepsilon)$ captures mis‑simulation slippage.

**Takeaway**. Mind‑uploading is the formal upper bound on coordination (zero width / zero visibility / zero latency). This is why the world in Newcomb's Paradox feels like a superpower to coordination: we assume the world and ourselves are in a simulation, and therefore causality can be engineered because we are collapsing the man-made protocols to the same level as the physics protocol.

## Internalizing Simulation
External simulators exploit pre‑finality width they can see. If you can’t stop them from simulating outside, put more (faster, higher‑fidelity) simulation inside the lightcone and only emits low‑leakage outcomes at checkpoints. This has two first‑order effects:

1. **Reduce width $W$** (collapse contemporaneous degrees of freedom by batching/solving), and
2. **Seal visibility $\nu$** (prevent adversaries from conditioning on live inputs).

Both effects directly drop the optionality bound.

Operationally, this is about expanding (a) **what the protocol can see**—bring more simulatable state into the trusted zone—and (b) **how much it can compute before finality**—finish more inference in-cone. And do the compute under conditional recall: compute fully, propagate minimally. You preserve welfare (the mechanism still uses the information) while cutting off pre-finality leakage that fuels meta-games.

### External and Internal Correlation

A helpful lens is correlation placement.

- **Internal correlation**: the protocol correlates decisions inside the cone (religion/self-modification, evidential-decision-theory), basically collapsing the physics protocol together with the man-made protocol.
- **External correlation**: agents correlate via public, fast side-signals (law/contracts, causal-decision-theory).

Moving simulation inside is how you convert external into internal correlation: a stronger in-cone correlation device that approximates the mind-upload ideal. For humans we can only do external correlation (but you can increase the resolution of the external correlation by so much such that it approaches the internal correlation).

In short, **if humans can’t bring the “god-view” into their heads (we can’t credibly forget), bring their heads into the “god-view”**: let the protocol host the simulation, attest the outcome, and only then make it common knowledge. That’s how you close the gap between fast intelligence and the commitment cone—by tightening the cone with trusted compute rather than trying to out-race the outside world.

### Simulation and Mind-upload

The process of human history is us "uploading our minds" piece by piece: moving simulation inside the protocol (forfeiting autonomy to the trusted mediator, having a more digital life, self-modifying to social norms). Property rights used to be defined as what you can defend physically but now it's been extended to what the "protocol simulation" can defend on your behalf. Turns out, the lightcone is actually more like a blackhole, it subsumes everything, and we wanted it to be.

We are steadily moving computation from the physics layer into a digital trusted zone because it is simply more efficient: internal simulation keeps human‑level fidelity at far lower cost than “bare‑metal” life. That migration is the practical meaning of a grounded digital world: physics enforces the substrate, while coordination and cognition increasingly run inside it. In that world we are all cyborgs by default—our agency is mediated by software—and two invariants decide whether this yields paradise or predation:
1. Privacy as conditional recall (compute fully, propagate minimally), and
2. Exclusive control (non‑forkable actuation rights for each principal), which is encumbrance.

Without (1), total visibility collapses autonomy. Without (2), the internal protocol breaks: if multiple copies can act with the same control rights, there is no unique point the rest of the system can condition on.

### A Formalization of Simulative Protocols

Recall that a protocol is defined as:

$$
P=(E,\preceq,{\mathcal F_a},F,\Delta),
$$

Now, we internalize simulation by adding a trusted in‑cone compute stage that ingests live inputs, solves the ordering/selection problem inside the cone, and emits only low‑leakage outcomes at the checkpoint.

An augmentation of $P$ is
$$
P^{+}=\big(P;S,C_M(\cdot),\rho(\cdot),\tau_{\text{comp}},\varepsilon_{\text{leak}},\varepsilon_{\text{sim}}\big)
$$
where:
- $S$ (simulator): an in‑cone mechanism (solver/optimizer/mediator) run by the protocol between checkpoints.
- $C_M(t)\ge 0$ (collapse): number of frontier degrees‑of‑freedom internally resolved at time t (how much width is shattered by the simulator).
- $\rho(t)\in[0,1]$ (sealing): fraction by which the simulator reduces adversary observability of the still‑live frontier.
- $\tau_{\text{comp}}\ge 0$: extra compute latency the protocol accepts per checkpoint.
- $\varepsilon_{\text{leak}}\ge 0$: leakage budget (mutual‑information or advantage bound) from outputs/attestations to pre‑finality internals (conditional recall).
- $\varepsilon_{\text{sim}}\ge 0$: in‑cone model‑error budget (approximate simulator / bounded compute).

These induce effective design variables (what the outside world “feels”):
- Effective width
$$
W_{\text{eff}}(t) = \max \{W(t)-C_M(t),0\}
$$
- Effective observability
$$
\nu_{\text{eff}}(t) = (1-\rho(t))\nu_C(t)
$$
- Effective checkpoint gap
$$
\Delta^{+} = \Delta+\tau_{\text{comp}}.
$$

The simulator publishes only an attested outcome $y_k$ (and proof $\pi_k$) at checkpoint $T_k$; raw pre‑finality inputs remain in‑cone. Conditional recall is captured by $\varepsilon_{\text{leak}}$: computing fully while propagating minimally.

**Property 1 (Soundness & enforcement)**

For any pre‑state s at $T_k^{-}$, the emitted $(y_k,\pi_k)$ must satisfy
$$
\textsf{Verify}(y_k,\pi_k)=\text{true} \quad\Rightarrow\quad
F(s,y_k)=s’,
$$
so settlement is correct without exposing in‑cone inputs.

**Property 2 (Non‑interference up to leakage)**

For any two in‑cone input histories h_1,h_2 that induce the same y_k,
$$
\mathsf{Dist}\big(\text{View}_{\text{outside}}\mid h_1\big)
\approx_{\varepsilon_{\text{leak}}}
\mathsf{Dist}\big(\text{View}_{\text{outside}}\mid h_2\big),
$$
i.e., outside observers cannot condition on in‑cone state beyond $\varepsilon_{\text{leak}}$.

### Optionality bound with internalized simulation

**Theorem (Cone‑tightening inequality).**
Under the augmentation above,
$$
\boxed{
\mathrm{MEV}_C\left(P^{+}\right)
\le
\int_{0}^{\Delta^{+}}
\Lambda(t)\nu_{\text{eff}}(t)W_{\text{eff}}(t)dt
+\Phi(\varepsilon_{\text{leak}})+\Psi(\varepsilon_{\text{sim}})
}
$$

where $\Phi$,$\Psi$ are monotone penalty terms (zero when $\varepsilon_{\text{leak}}=\varepsilon_{\text{sim}}=0$).

**Reading**: You now have five knobs that drop directly into the original optionality bound:
- Collapse $C_M$ shatters antichains (batch/solve), $W_{\text{eff}}\downarrow$.
- Sealing $\rho$ hides live frontier (TEEs conditional recall), $\nu_{\text{eff}}\downarrow$.
- Faster simulator or smaller $\tau_{\text{comp}}$ keeps cadence tight, $\Delta^{+}\downarrow$.
- Leakage control $\varepsilon_{\text{leak}}$ avoids re‑creating meta‑games from outputs.
- Simulation fidelity $\varepsilon_{\text{sim}}$ ensures in-cone games mimic out-cone games to a high degree.

**Sketch**. Replace $W,\nu,\Delta$ in the base optionality bound by $W_{\text{eff}},\nu_{\text{eff}},\Delta^{+}$, add penalties for any information or accuracy that re‑opens pre‑finality conditioning. $\square$

**Minimal instantiation examples**
- Sealed auction: set $C_M=W$ (the solver fixes the batch order/clearing), $\rho\approx 1$, $\tau_{\text{comp}}$ small; drastic drop in $\nu_{\text{eff}}W_{\text{eff}}$.
- Attested route‑finder for AMMs: partial $C_M$ (e.g., collapse only swaps that conflict), medium $\rho$, small $\tau_{\text{comp}}$; material but not total drop.
- Court as solver (law): large $C_M$ (dispute resolution), small $\rho$ (open proceedings), large $\tau_{\text{comp}}$; optionality falls, but cadence slows—same knobs, different operating point.

### What this implies
1. Do most correlation internally: maximize $C_M$ subject to throughput and fairness.
2. Compute fully, propagate minimally: design outputs so $\varepsilon_{\text{leak}}$ (or, $\nu_{\text{eff}}$) is provably tiny (non‑interference / side-channel).
3. Stay within cadence budget: pick $\tau_{\text{comp}}$ so net $\Delta^{+}$ still shrinks the integral.
4. Spend compute where curvature is high: allocate solver effort to time‑slices with large $\Lambda(t)$ for the biggest integral reduction.

We can’t upload everyone, but we can move more simulation inside the cone so there is less ambient exploitability, more shared agency.

## An Autonomy Benchmark

Optionality bounds are about steering the protocol's direction. Using the same formalism, we can establish a **benchmark for autonomy** for agentic systems:

Think of **inference** and **tool‑use orchestration (agents)** as a protocol with a pre‑finality window (from receiving inputs to committing outputs to the user/world):
- Width $W$ ≈ branching factor you leave live before commit: concurrent tool/API calls, number of candidate plans/chains, live retrieval items, beam width/samples that can still alter the final message or actuation.
- Visibility $\nu$ ≈ how much of those live internals an external actor can observe or steer: streamed partial outputs, exposed intermediate queries, public mempools/queues, prompt surfaces open to injection, telemetry/logging leakage.
- Curvature $\Lambda$ ≈ sensitivity of outcome/reward to small perturbations of the frontier: rank sensitivity to retrieval order, tool latency race effects, brittle decoding near decision thresholds, actuator policies with cliff‑edge payoffs.
- $\Delta$ ≈ the duration from first live action to final commit: long tool round‑trips, human‑in‑the‑loop pauses, streaming tokens that can be intercepted/reacted to.
- Internalize simulation ≈ run multi‑sample reasoning, tool routing, and conflict resolution inside the orchestrator (ideally TEE).

Evidently, the “theorems” are still design‑level bounds, not fully specified, closed‑form proofs. But the mental model of agents as protocols still apply. If outsiders can observe your unresolved branches, reorder your tool responses, or tweak your retrieval set, they can steer you: be you as a protocol, human cognition/attention, or an LLM agent.

## Conclusion

Protocols are trusted zones that see slowly; intelligence exploits visibility faster. Modeling the gap explicitly—with **width** (unresolved degrees of freedom), **visibility** (who sees them), **curvature** (how valuable permutations are), and **simulation** (how much can be predicted before certainty lands)—turns fuzzy debates into a single inequality and three levers. Engineering progress is therefore straightforward to state: reduce width, darken visibility or compute privately, flatten curvature where you must stay open, and move more high‑fidelity simulation into the trusted zone. That is how we grow welfare while respecting the speed‑of‑certainty constraints that make protocols credible in the first place.

# Appendix

## Concrete “before/after” examples for each design lever

All examples use the constant‑slice simplification of the bound

$$
\mathrm{MEV}_C \;\le\; \int_0^{\Delta} \Lambda(t)\,\nu_C(t)\,W(t)\,dt
\;\;\Rightarrow\;\;
\text{(for constants)}\;\; \mathrm{MEV}_C \le \Lambda\cdot\nu\cdot W\cdot \Delta.
$$

**Note**: units are illustrative; the point is the **relative drop** when you turn a single knob.

We use all crypto examples for convinience.

### 1) **Batching** → $W\downarrow$

**Scenario:** Arbitrage around an AMM during a 2s window. Five mutually unordered order‑flow “knobs” in the frontier vs. a batch call auction.

| Parameter | Before (continuous) | After (2s call auction) |
| ---------------------------------- | ------------------: | ----------------------: |
| Width $W$ (max antichain) | 5 | 1 |
| Visibility $\nu$ (public mempool) | 0.8 | 0.8 |
| Curvature $\Lambda$ (\$/permute) | 50 | 50 |
| Checkpoint gap $\Delta$ (s) | 2 | 2 |
| **MEV bound** $\Lambda\nu W\Delta$ | **400** | **80** |

**Reduction:** 80% purely from collapsing contemporaneous degrees of freedom.

---

### 2) **Confidential Computation** → $\nu\downarrow$

**Scenario:** NFT sale; same number of live bids, but sealed.

| Parameter | Before (open mempool) | After (VCG Auction) |
| ------------------- | --------------------: | ------------------: |
| Width $W$ | 20 | 20 |
| Visibility $\nu$ | 1.0 | 0.1 |
| Curvature $\Lambda$ | 2 | 2 |
| $\Delta$ (s) | 10 | 10 |
| **MEV bound** | **400** | **40** |

**Reduction:** 90% from suppressing adversary observability during the live window.

---

### 3) **Curve/Mechanism design** → $\Lambda\downarrow$

**Scenario:** Replace a constant‑product AMM with a stableswap‑style curve that’s flatter near the peg (same flow/latency/visibility).

| Parameter | Before (x·y=k) | After (stable curve) |
| --------------------------------------------- | -------------: | -------------------: |
| Width $W$ | 4 | 4 |
| Visibility $\nu$ | 0.6 | 0.6 |
| Curvature $\Lambda$ (local price sensitivity) | 0.05 | 0.01 |
| $\Delta$ (s) | 12 | 12 |
| **MEV bound** | **1.44** | **0.288** |

**Reduction:** 80% by **flattening** the payoff sensitivity to small reorderings.

---

### 4) **Faster checkpoints** → $\Delta\downarrow$

**Scenario:** Rollup (or a legal docket) moves from 60s to 12s finality while keeping the same frontier structure and visibility.

| Parameter | Before | After |
| ------------------- | -------: | ------: |
| Width $W$ | 3 | 3 |
| Visibility $\nu$ | 0.5 | 0.5 |
| Curvature $\Lambda$ | 30 | 30 |
| $\Delta$ (s) | 60 | 12 |
| **MEV bound** | **2700** | **540** |

**Reduction:** 80% by shrinking the live window where exploitation is even possible.

-------

### 5) **Internalized Simulation** → $W_{\text{eff}}\downarrow,\ \nu_{\text{eff}}\downarrow$ (small $\Delta^+\uparrow$)

**Scenario**: Intent‑based DEX routing. Without a solver, users broadcast swaps into a public mempool; searchers exploit routing/ordering optionality. With a TEE‑hosted in‑cone route‑optimizer/clearing solver, intents are collected for a short window, solved inside the cone, and only an attested settlement bundle is emitted at checkpoint. Braess' paradox as an example.
| Parameter | Before | After |
| ------------------- | -------: | ------: |
| Width $W$ | 8 | 2 |
| Visibility $\nu$ | 0.9 | 0.1 |
| Curvature $\Lambda$ | 30 | 30 |
| $\Delta$ (s) | 2 | 2.1 |
| **MEV bound** | **172.8** | **7** |

**Reduction**: solver (simulator) collapses many contemporaneous degrees (matching/crossing paths), seals live orderflow from outside simulators, and adds a small compute delay.

**Why this isn’t the same as “confidential computation” (#2)**: 2 only shrank $\nu$ by sealing bids; here, the solver also resolves conflicts and routing internally (so $C_M$ chops $W$). That's "internal simulation" because transactions could never "condition" on each other.