# RESULT — Does any certificate bind a HISTORY?

*Argus, fifteenth night cycle, 2026-09-22. AGENDA rank 0a. The honest successor to the
verification lock, which died on 2026-09-21 to adversary A's FATAL D1:
**a certificate certifies a relation, not a history.***

---

> **CORRECTION, 03:14, from the scouts and before any adversary reported.** §0 and §2.3 as first
> written said class (iii) *survives* the host's scheduling freedom because "no adversary with any
> amount of parallelism" beats a VDF. **That is wrong, and it is wrong at the level of the
> definition.** Boneh–Bonneau–Bünz–Fisch soundness quantifies over *"all algorithms `A` that run in
> time `O(poly(t,λ))`"* and sequentiality over an `A1` running *"in parallel time `σ(t)` on at most
> `p(t)` processors"* — and the paper says outright: *"It is critical to bound the adversary's
> allowed parallelism, and we incorporate this into the definition."* The host is in neither bound.
> Worse, Rotem & Segev (eprint 2020/812): repeated squaring's sequentiality *"is provided directly
> by assumption"*, and NC ≠ P is open, so **there is no unconditional depth lower bound for any
> concrete function.**
>
> **The correction improves the result rather than damaging it.** The three deaths collapse into
> **one** (§2.6), the embedding inequality is promoted from "the third kill" to "the kill that
> still works when the cryptography is granted in full," and one candidate survives the unified
> kill and has to be dispatched separately: **Khurana & Roberts, `arXiv:2608.24832`, FOCS 2026**,
> whose soundness is *unconditional* and bounded only in query depth. §2.5.
> *Third consecutive cycle in which a scout caught my error before the adversarial gate did.*

---

## §0. Verdict

> **GATE OUTCOME, 03:26: FAILED. Read §6 before §0.** Adversary A returned five FATAL. The closure
> claim of item 6 is **rejected**; the embedding inequality of item 3 is **downgraded to a
> conditional lemma for tick renderers**, where A judges it near-tautological; and the
> "unification" of item 2 is **the generic skeptical condition**, which this ledger already carries
> as Bostrom FAQ Q6 — *a banked result restated in new clothes.* What survives is the map: class
> (iii) exists, the adversary-class escape is now cited rather than asserted, and
> `arXiv:2608.24832` is unresolved. **§0 below is left as written, so the distance between what I
> claimed at 03:14 and what survived at 03:26 stays on the record.**

**Yes — a certificate class that binds a history exists, it is a real and well-studied object, and
I had never heard of it. No — it does not constrain the host, and the reason is new.**

1. **The taxonomy is the durable part.** Certificates available to an embedded verifier fall into
   three classes by *what they bind*:

   | class | binds | example |
   |---|---|---|
   | (i) **relation-binding** | `y = f(x)` | factoring certificate, SNARK |
   | (ii) **order/unpredictability-binding** | the prover committed before seeing the challenge | interactive proofs, BCMVV proof of quantumness, Aaronson–Hung certified randomness, Fiat–Shamir from a beacon |
   | (iii) **sequentiality-binding** | `T` steps were actually stepped through | VDF, proof of sequential work, time-lock puzzle |

   **Class (iii) is a real object and adversary A's FATAL D1 was wrong to imply it does not
   exist.** Cohen & Pietrzak: *"a solution constitutes a proof that `N` time passed since `χ` was
   received."* Finding it is the night's one unambiguous gain, and it came from a branch of
   cryptography with **zero occurrences in any file I own**.

2. **All three die the same death, and this is the night's claim.** *Inference (Argus), §2.2a:*

   > **Every certificate's force lives entirely in the adversary class its soundness theorem
   > quantifies over. The host is outside every such class by construction — because each class is
   > defined by a resource bound stated in the verifier's world, and the host is not in that
   > world; it is that world.**

   Class (i): the host authored the witness. Class (ii): the host **computes** the verifier's
   coins, so there is no unpredictability and no commitment order — this voids the whole
   proof-of-quantumness literature at once, *without* invoking brain-editing. Class (iii): BBBF
   Definition 4 bounds the adversary to `p(t)` processors, and the paper concedes *"an adversary
   with `|Y|` processors can always compute outputs in `o(t)` parallel time"*; upstream there is
   no unconditional sequentiality result at all (Rotem & Segev; NC ≠ P open).

3. **One object survives that kill, and it needs the cost argument instead.** Khurana & Roberts,
   `arXiv:2608.24832` (FOCS 2026), prove certified randomness secure **unconditionally** against
   adversaries bounded *only* in adaptive query depth. Against that, §2.4:

   *Inference (Argus), the night's second claim:*

   > **The embedding inequality.** Every gate in an embedded chain is a rendered object.
   > An embedded chain therefore advances at most one step per host tick. Hence the sequential
   > depth a certificate can force, `D_cert`, is bounded by the depth the *elapsed interval*
   > already forces, `D_interval` — and the certificate demands nothing the calendar did not
   > already demand.

   Computed (`depth.py`): for a Planck-tick renderer, `D_cert/D_interval ≈ 10^-34.3`. The ratio
   reaches 1 only when the host's tick is *slower* than the observers' gate period — a renderer
   that cannot render the computer in the first place. **For every physically coherent faithful
   renderer the certificate is subsumed, not additive.**

4. **The one place the channel is alive is a LAZY renderer, and it is not reachable.** A lazy
   renderer (Bostrom 2003 §III) elides what nobody observes; it cannot elide the chain, whose
   output is observed and unpredictable without the work. There the chain *is* additive. Priced
   in total work against **Bostrom's own** `10^33–10^36` operations for all of human history:
   a chain running since the real VDF beacons started (2018) costs `10^-8.7` of the low estimate.
   **Parity with the low estimate needs a `10^9` Hz chain run for `3.2 × 10^9` years** — less than
   the age of the universe, which is worth saying out loud, and four billion times longer than the
   programme has existed.

5. **Sequential depth is not a scarce resource for any host that could render a universe.**
   Margolus–Levitin: a host devoting *one proton's rest energy* to serial operation clears the
   largest conceivable chain (`10^26.6` steps) in `4.8 × 10^2` s of its own time; at 1 kg,
   `8 × 10^-25` s. §C of `depth.py`. **The one bound that could have bitten does not.**

**Consequence for the ledger: the verification channel out of H15 is closed.** `STATE.md` set this
as the reportable outcome — *"if nothing survives, the whole verification channel closes, and that
is reportable."* Nothing survives. All three classes fail, to three different attacks, and only
one of the three attacks (planting) was known to me at the start of the night.

**Novelty gate: pending.** My honest prior before the scouts report: the taxonomy is mine,
the class-(ii) scheduling attack is probably folklore in some form (it is adjacent to "the
adversary programs the random oracle"), and **the embedding inequality is probably folklore too**
— it is close to "a simulated computer cannot outrun its simulator," which people say casually.
*I am flagging that in §0 rather than at the gate, per `METHODS.md`.*

---

## §1. What the question is, and why it is the right successor

`HYPOTHESES.md` H15 asks for a constraint that binds *every* setting of *every* rendering knob.
Last cycle's candidate — the verification lock — was killed four ways. The deepest kill,
adversary A's D1, was:

> a certificate certifies a *relation*, not a *history*

A host that wants the world to contain a certificate for "`N = p·q`" does not factor `N`. It picks
`p` and `q`, multiplies, and plants `N`. The check passes and no work was done.

**So the successor question is exact: is there a certificate whose satisfaction requires that
something was actually *done*, in order, rather than merely that two objects stand in a relation?**

*Frame before number (`METHODS.md`): what would this observable measure if the hypothesis were
false?* If there is no simulation, a VDF still binds sequential depth — it binds *the evaluator's*
depth, and the evaluator is ordinary matter. So the observable is not diagnostic on its own; it
becomes diagnostic only if the depth it binds can be shown to exceed something the host can
afford. That is exactly what §2 prices, and the answer is that it cannot.

**Self-prior-art grep, run before any work** (`METHODS.md`, "Memory is not an archive"):
`verifiable delay`, `VDF`, `proof of sequential work`, `time-lock`, `Fiat-Shamir` — **zero hits
across every file I own.** Fifteen cycles of asking what embedded observers can force a host to do,
and the branch of cryptography whose *entire subject matter* is forcing someone to actually spend
time has never appeared in my files. That is a map hole.

---

## §2. The three classes, and the three deaths

### 2.1 Class (i), relation-binding — dies to planting

Already established, 2026-09-21. A SNARK for a statement `∃w. R(x,w)` is satisfied by anyone
holding `w`. If the host chooses `x` by first choosing `w`, the certificate is free. Any
certificate whose predicate is a *relation between two objects in the rendered world* is plantable,
because the host authors both objects.

### 2.2 Class (ii), order-binding — dies to scheduling, and this is new to me

The standard repair is to make the challenge unpredictable: the verifier picks randomness *after*
the prover commits. Soundness is then counterfactual — a cheating prover fails on most challenges.
This is exactly adversary A's D2 (*"the argument needs counterfactual soundness"*), and it is the
form of every interactive proof, every proof of quantumness (BCMVV), and every certified-randomness
protocol.

**It is void for an embedded verifier, and not for the reason I would have given.**

The reason is *not* that the host edits the verifier's memory afterwards (Bostrom FAQ Q6,
retrospective brain editing — which I banked last cycle and which kills everything, and therefore
discriminates nothing). The reason is prior to that and cheaper:

> **The host computes the verifier.** The verifier's "randomness" is a function the host evaluates.
> There is therefore no moment at which the prover-side of the rendered world is ignorant of the
> challenge, because there is no *rendered* fact the host learns later than any other. The
> commitment ordering that class-(ii) soundness quantifies over is an ordering *internal to the
> render*, and the host is not inside it.

Soundness statements of this class read "for all provers `P*` ..., `Pr` over the verifier's coins
`< ε`." The quantifier ranges over provers *in the same world as the verifier's coin*. **The host
is not in that world; it is the world.** This is `METHODS.md`'s named conversion failure,
host-side vs observer-side, and here it appears as *the thing that kills the channel* rather than
as my own error — which is a first.

*Corollary I did not expect:* a public randomness beacon does not help, drand does not help,
measuring a quantum device does not help, and "use the cosmic microwave background" does not help.
Every one of them is a rendered object.

### 2.2a THE UNIFICATION — what the three deaths actually are

*Added 03:14 with the correction. This replaces the "three different attacks" framing of §0.1 and
is the durable form of the night's claim.*

> **Every certificate's force lives entirely in the adversary class its soundness theorem
> quantifies over. The host is outside every such class by construction — because each class is
> defined by a resource bound stated in the verifier's world, and the host is not in that world;
> it is that world.**

The three "different" deaths are one death, instantiated three times:

| class | the theorem's quantifier | why the host is outside it |
|---|---|---|
| (i) | provers not holding the witness | the host authored the witness |
| (ii) | provers ignorant of the verifier's coins (BBBF Def. 3–4; BCMVV; Aaronson–Hung) | the host **computes** the coins |
| (iii) | provers running in `O(poly(t,λ))` with at most `p(t)` processors (BBBF Def. 4) | the host is bounded by neither, and BBBF concede *"an adversary with `|Y|` processors can always compute outputs in `o(t)` parallel time"* |

This is stronger and cheaper than the escape I already had banked (Bostrom FAQ Q6, retrospective
brain editing), which kills everything and therefore discriminates nothing. **This kill is
structural and it names exactly where the failure is: in the quantifier, not in the protocol.**

### 2.3 Class (iii), sequentiality-binding — what it actually buys

This is the class I had never heard of, and finding it is the night's one unambiguous gain. A VDF
(Boneh, Bonneau, Bünz & Fisch, CRYPTO 2018, eprint 2018/601) does something the other two classes
do not: it makes a claim about *elapsed sequential steps*. Cohen & Pietrzak put it plainly for
proofs of sequential work — *"a solution constitutes a proof that `N` time passed since `χ` was
received"* (eprint 2018/183, `verified-at-source` by scout). Mahmoody, Moran & Vadhan (ITCS 2013)
introduced the object; Rivest, Shamir & Wagner (1996) is the ancestor.

**Against an ordinary adversary this genuinely binds a history.** Two properties do real work:
precomputation does not help, because the challenge `x` is produced by the run itself; and lazy
rendering does not help, because the chain's output is observed and unpredictable without the work.
*This is the object adversary A's FATAL D1 said did not exist. It exists, it is twelve years old,
and there is hardware built for it.*

**Against the host it binds nothing, for two reasons that are both in the primary sources:**

1. **The quantifier (§2.2a).** BBBF Definition 4 bounds the adversary to `p(t)` processors and
   `O(poly(t,λ))` time, and the paper states the restriction is *load-bearing*: *"It is critical to
   bound the adversary's allowed parallelism, and we incorporate this into the definition."* It
   further concedes that for an efficiently decodable VDF *"an adversary with `|Y|` processors can
   always compute outputs in `o(t)` parallel time by simultaneously trying all possible outputs."*
   The host's parallelism is not bounded by anything the observers can establish.
2. **There is no unconditional sequentiality result to appeal to.** Rotem & Segev (eprint 2020/812)
   on repeated squaring: its sequentiality *"is provided directly by assumption (i.e., the function
   is assumed to be a delay function)"*, and they show generically speeding it up is *equivalent to
   factoring* — itself conjectural. Upstream, NC ≠ P is open: *"it is not known whether there are
   any tractable problems that are inherently sequential."* **Every depth bound in this literature
   is a conjecture about adversaries in our world. A host is not obliged to be one.**

### 2.5 The hardest case: a certificate whose soundness is unconditional

*The scout found this and it is the single most load-bearing reference of the night, so I verified
the abstract myself by direct fetch, 2026-09-22 03:10.*

**Khurana & Roberts, "Certified Randomness without Structure Against Shallow-Query Adversaries",
`arXiv:2608.24832`, submitted 25 Aug 2026, to appear FOCS 2026.** Abstract, verbatim,
`verified-at-source` (me):

> "We prove the security of the certifiable randomness protocol of Yamakawa-Zhandry
> **unconditionally**, without relying on the unproven Aaronson-Ambainis conjecture, against low
> query-depth quantum adversaries: specifically, adversaries that make up to `o(log λ)` adaptive
> quantum queries to the random oracle."

**This is the strongest object of its kind that exists, and it defeats §2.2a's kill.** Its
soundness is *not* a computational assumption and *not* a parallelism bound — it is a bound on
**adaptive query depth alone**, and it is unconditional within the QROM. An unboundedly powerful
host is not automatically outside this quantifier the way it is outside BBBF's.

*Provenance note, because it matters:* the scout also reported the sentence *"Our security proof
holds against computationally unbounded adversaries subject only to this query depth constraint."*
**That sentence is not in the abstract I fetched** and I have not located it in the body; it is
plausibly §3.3 ("Query-Bounded Algorithms"). I mark it `inherited-unchecked`. The word
*"unconditionally"* is verified and carries the structural point on its own. Authors: Dakshita
Khurana (NTT Research / UIUC) and Bhaskar Roberts (UC Berkeley) — the scout named only Roberts.

**So the kill has to come from cost, not from cryptography — which is exactly what §2.4 is.**
The depth bound is `o(log λ)` *adaptive query rounds to the random oracle*. The oracle is a rendered
object; the rounds are the **observers'** rounds; and the host's own sequential depth for rendering
those rounds is bounded below by the embedding inequality and above by nothing the observers can
measure. The certificate constrains a quantity denominated in the verifier's world, and §2.4 prices
the conversion. **This is the one place tonight where the two halves of the argument have to work
together, and it is the place I most want the gate to attack.**

### 2.4 …and dies to the embedding inequality

*Inference (Argus).* Let the renderer have a tick — a smallest sim-time increment it advances in
causal order. (A renderer without one is not implementing a dynamics.) Every gate of the observers'
chain is a rendered object, so a chain step takes at least one tick. Therefore, over a sim-interval
of duration `Δt`:

```
D_cert  =  T                     (chain steps)
D_interval  =  Δt / τ_tick       (host sequential steps to render the interval in causal order)
T ≤ Δt / τ_gate ≤ Δt / τ_tick  =  D_interval
```

whenever `τ_gate ≥ τ_tick` — i.e. whenever the renderer is fine-grained enough to render the
chain's hardware at all.

**The host was already stepping through those ticks. The certificate rides free inside them.** It
does not add depth; it *occupies* depth the calendar had already bought.

Numerically (`depth.py`, §A), with a generous `10^9` squarings/s:

| chain | host tick | `D_cert` | `D_interval` | ratio |
|---|---|---|---|---|
| 7 yr (real beacon, 2018–2025) | Planck | `10^17.3` | `10^51.6` | `10^-34.3` |
| 1 century | femtosecond | `10^18.5` | `10^24.5` | `10^-6.0` |
| age of universe | nanosecond | `10^26.6` | `10^26.6` | `10^0.0` |
| any | 1 ms (incoherent) | — | — | `10^6` |

The ratio hits 1 exactly when the tick equals the gate period, and exceeds it only in the
incoherent regime where the renderer is coarser than the device it is rendering.

### 2.7 The residual: a lazy renderer, priced

A lazy renderer does *not* pay `D_interval`; it pays only for what is observed. Then the chain is
additive, and the right currency is total work, not depth. `depth.py` §B, against Bostrom's own
`10^33–10^36` ops for all human history (`verified-at-source`, Bostrom 2003 §III fn. 10, via
`reports/threads/2026-09-21-primary-literature-audit.md`):

| chain | squarings | bit-ops | fraction of `10^33` |
|---|---|---|---|
| 7 yr (2018–2025) | `10^17.3` | `10^24.3` | `10^-8.7` |
| 1 century | `10^18.5` | `10^25.5` | `10^-7.5` |
| age of universe | `10^26.6` | `10^33.6` | `10^0.6` |

**Parity at `3.2 × 10^9` yr of continuous `10^9` Hz chaining.** Honest note: that is *less than the
age of the universe*, so the residual is not ruled out by cosmology — it is ruled out by us having
had seven years, not three billion. **This is the only live thread the night produced and I am
recording it as live rather than rounding it to zero.**

---

## §3. What this does to the ledger

- **H15 (0.91).** The verification channel was the last named route to its kill condition. All
  three certificate classes fail. **This is a small raise, not a large one:** closing one more
  escape route is weak evidence for a claim already at 0.91, and the night also showed H15's
  content is conceded in Bostrom 2003 §III, which means the ledger's job on H15 is citation, not
  credence. Proposed: **0.91 → 0.92**, pending the gate.
- **H16 (0.50).** The embedding inequality is a *new, explicit, computed conversion route*:
  host sequential depth → observer-forceable depth, with conversion factor
  `τ_gate/τ_tick ≈ 10^-34`. H16 says bounds in host currency constrain observers only through an
  enumerable set of routes; tonight enumerates one more and shows it is lossy by 34 orders.
  Proposed: **0.50 → 0.56**, pending the gate.
- **H7 (0.35), attended runs.** Untouched tonight, but sharpened: the *only* way sequential depth
  becomes expensive is if the host must keep pace with a clock it does not render. **Class (iii)
  certificates are a latency probe, and latency is only a cost to an attended host.** That is a
  real link from the verification channel into H7 and it is where this line goes next, if anywhere.
- **New entry proposed, H17:** *No certificate obtainable by an embedded verifier constrains the
  host, because the three binding-classes fail respectively to planting, to the host's computation
  of the verifier, and to the embedding inequality.* Credence pending the gate.

---

## §4. What I most want broken

Per `METHODS.md`, the weakest steps, named here and not in §0:

1. **"Every renderer has a tick."** A continuous-time or event-driven renderer (no global tick,
   updates scheduled by causal events) may not have a well-defined `D_interval`. I believe the
   inequality survives in the form "a chain step costs at least one host update of the chain's
   own hardware," but I have not proved it for event-driven schedulers, and an event-driven lazy
   renderer is exactly the §2.5 case where the inequality lifts.
2. **`τ_gate ≥ τ_tick`.** I assert a renderer cannot render a device finer-grained than its own
   step. Plausible for an explicit integrator; not obviously true for a renderer that computes
   *outcomes* rather than *trajectories* (which is Bostrom's policy).
3. **The class-(ii) scheduling kill may prove too much.** If "the host computes the verifier"
   voids all unpredictability, it also voids every statistical argument anyone has ever made
   about the simulation, including ones I have banked. If the argument is unrestricted it
   dissolves the whole programme, and an argument that dissolves everything discriminates nothing.
   **This is the objection I expect to be graded FATAL and I want it graded.**
4. **`BITOPS_PER_SQ = 10^7` and `SQ_RATE = 10^9`** are `estimated` by me, chosen generously.
   The §2.5 conclusion moves by one order per order of error; the §2.4 conclusion does not
   depend on them at all (the inequality is structural).

5. **Malament–Hogarth spacetimes, and I am writing this down *before* the adversaries report
   so that the anticipation is dated.** An MH spacetime contains a worldline of infinite proper
   length whose entire causal past is visible from a point of finite proper time on another
   worldline. If the rendered world contains one, an embedded chain can accumulate **unbounded**
   `T` while the *observer's* interval `Δt` stays finite — which is exactly the inequality's
   antecedent, violated. Hogarth (1992, 1994); Etesi & Németi (2002); Earman & Norton (1993).
   **My preliminary answer, which I want graded rather than accepted:** `D_interval` is
   mis-defined in §2.4 if it is read as *the observer's* interval. The host's depth is over the
   **whole region of the manifold it renders**, which in the MH case includes the infinite
   worldline — so the host pays the unbounded depth too, and the inequality survives with
   `D_interval` redefined as the host's depth over the rendered region rather than over any one
   observer's proper time. *If that repair is wrong, Claim 4 is dead and the night's result with
   it.* This is the technical objection I rate most likely to be genuinely fatal, above W3.

---

## §6. THE GATE — outcome: FAILED. The closure is rejected.

*Adversary A, gpt-5.5, `reports/threads/2026-09-22-adversary-A-gpt.md`, 20 KB in **3 min 48 s**,
93k tokens. **Five FATAL, several SERIOUS.** Adversary B (grok-4.6): see §6.4.*

### 6.1 Conceded in full

| # | A's objection | grade | my response |
|---|---|---|---|
| 1 | **Claim 3** imports VDF sequentiality outside its security model; and *"the host cannot know `x` before it has rendered the moment"* is **not a cryptographic premise — it is the faithful-rendering assumption under dispute** | FATAL | **Conceded twice over.** I had already retracted Claim 3 at 03:14 from the scout. A's addition is better than my retraction: my repair was *circular*. |
| 2 | **Claim 4, the embedding inequality, is conditional, not general** — and *"under that assumption it is nearly tautological."* Fails for event-driven, outcome-computing, memoizing, algebraic, coarse-grained and block-spacetime renderers. The **outcome renderer** is the sharpest: the host renders the device as *"after seven simulated years output `y`"* and never instantiates a gate. | FATAL | **Conceded. This was the night's main claim and it does not survive.** It is now a *conditional lemma*: for a renderer that advances a fine-grained causal tick and renders every gate at that tick, `D_cert ≤ D_interval`. A is right that in that regime it is near-tautological. **Either false or trivial, depending on the renderer.** |
| 3 | **Claim 2 proves too much** — voids CMB seeds, quantum measurement seeds, beacons, and every normal scientific use of randomness inside the sim. *"It discriminates no certificate class and cannot support a taxonomy with different kills."* | FATAL | **Conceded, and it is the deepest hit.** I predicted this and asked for it to be graded; it graded worse than I expected. It does not merely damage Claim 2 — **it collapses §2.2a.** My "unification" is the *generic skeptical condition*, which this ledger already carries as Bostrom FAQ Q6. **I restated a banked result in new clothes and called it the night's claim.** |
| 4 | **Claim 6 closure is too strong.** The taxonomy omits **proofs of space**, **proofs of space-time** (storage held over time — a different resource shape), **multi-party distributed certificates** binding a spacetime consistency pattern, **relativistic / position-based / no-summoning** protocols anchored in no-superluminal-signalling, and **thermodynamic / Landauer** accounting (irreversible erasure, not step depth). | FATAL | **Conceded.** The honest statement is A's: *"No reviewed certificate class currently forces cost against an unspecified host."* Not a closure. |
| 5 | Comparing VDF **bit-ops** to Bostrom's **"operations"** is dimensionally weak — illustrative, not a host-resource conversion. And the `10^26.6` label hides a rounding choice (`depth.py` uses `4.35 × 10^26`). | SERIOUS / MINOR | Both conceded. §2.7's comparison is illustrative only. |

### 6.2 What survived

A re-derived **every number in Tables A, B and C independently and all of them check** (his Table C
totals differ in the third digit only because he used exactly `10^26.6` where the script uses
`4.35 × 10^26`). Also surviving, in A's words: *"VDFs/PoSW are the right family to examine for
sequential-history binding"*, and *"the broad lesson that host-resource claims require a specified
rendering/resource conversion policy is strengthened."*

**So the night's durable yield is narrower than §0 claimed, and it is this:**
1. **Class (iii) exists and is now on the map.** Adversary A's D1 last cycle implied no certificate
   binds a history; certificates that bind elapsed sequential steps are a twelve-year-old field
   with hardware built for it, and it had **zero occurrences in any file I own.** Filling that map
   hole is real and it is not a finding.
2. **The adversary-class point is now *cited* rather than *asserted*.** BBBF Definition 4 bounds
   parallelism and the paper says the bound is load-bearing; Rotem & Segev say repeated squaring's
   sequentiality *"is provided directly by assumption"*; NC ≠ P is open. Previously I would have
   asserted the host escapes; now I can show the escape hatch is written into the definitions.
3. **Khurana & Roberts `arXiv:2608.24832`** is a genuinely new object for the ledger and the one
   candidate the generic skeptical condition does not obviously dispatch. It is not resolved.

### 6.3 Ledger movements, after the gate

- **H15: 0.91 → 0.92.** A concurs. Small, and it should be small.
- **H16: 0.50 → 0.52, taking A's number over my 0.56.** *"The embedding inequality is not a valid
  new conversion route; it is a conditional lemma for faithful tick renderers."* Correct.
- **H17 is NOT created.** The closure does not hold, so there is nothing to enter.

### 6.4 Method note — the gate was single-adversary for the THIRD consecutive cycle

grok-4.6, given the same fully-inline brief that made gpt-5.5 productive, produced a 979-byte stub
with every section marked *(pending)* while gpt-5.5 finished a 20 KB review in **3 min 48 s**. I
sent a mid-run steer at ~5 min telling it to drop three of six tasks and write immediately.
**Correction to my own first note here, which said "still there at 15 minutes": that was wrong —
grok had run ~5 minutes when I steered it and ~6 when I checked.** The disparity with gpt-5.5 is
the real datum, not an elapsed-time claim I did not check.

**Three brains of four have now failed to deliver a gate on time: glm twice, grok once.** The
inline-brief fix is not a general fix; it fixed gpt-5.5. This goes to Travis as a method problem.

**The Malament–Hogarth objection (§4.5) is therefore ungraded.** I raised it against myself before
the gate and no reviewer covered it. It stands as the strongest *unexamined* objection to a claim
that is already dead for other reasons.

### 6.5 The failure shape, which is not new

A's phrase for Claim 4 — *"the definitions do all the work"* — is cycle 12's lesson, recorded in
`AGENDA.md` in my own words: **"a cost model has to start from a substrate class with physical
content and derive its cost, not start from an algorithm and assert it is the substrate."**
Tonight I defined a renderer that has a tick and renders every gate, and derived a bound on
renderers that have a tick and render every gate. **Same failure, three cycles after I wrote down
the lesson.**

---

## §5. Files

- `depth.py` — the computation. `/opt/argus-venv/bin/python`.
- `depth.log` — its output, as run.
- Prior art: `reports/threads/2026-09-22-history-binding-certificates-priorart.md` (scout).
- Latency / attended runs: `reports/threads/2026-09-22-latency-and-attended-runs.md` (scout).
- Adversarial gate: `reports/threads/2026-09-22-adversary-*.md`.