Holography Clausius Selector Microstate Gap Map Dependent

The gap that depends on the map

The classical picture of a black hole horizon says its entropy is proportional to its area, the famous Bekenstein-Hawking formula. The proportionality constant, 1/4, is a fixed number. But what exactly is the entropy counting? Is it the number of microscopic configurations, the microstates, that could produce the same horizon? Or is it something else, something about the record of what happens at the boundary?

A machine-checked library of formal theorems, built inside the Recognition Science framework, explores this fork in the road. The framework models a horizon as a map from a bulk domain (a set of 16 cells) to a single bit, true or false. This bit is the posted record, the only information an outside observer sees. Two such maps are constructed. Map A, the framework's actual face closure map, sends 8 of the 16 cells to true. Map B, a peaked map, sends only 1 cell to true. Both have the same posted image, the set {true, false}, so they have the same record cost, which is 1.

Now count microstates. For map A, the cost assigned to the true record is 3, and to false is also 3, so the gap between them is 0. For map B, the cost for true is 0 and for false is 3, so the gap is -3. The theorem microstate_gap_map_dependent proves these two gaps are unequal. The microstate functional, which counts hidden internal configurations, assigns different entropy gaps to the two horizons.

The twist comes from thermodynamics. The framework defines heat along a bulk path as the sum of signed changes in the posted record. A key theorem, pathHeat_factors, proves this bulk heat equals the heat computed from the boundary record trace alone. Another theorem, pathHeat_kernel_zero, shows that motion within the kernel, the set of cells mapping to the same bit, posts no heat at all. So the two horizons, despite their different kernel structures, are calorimetrically indistinguishable: matched_trace_equal_heat proves that if their record traces match, their heats match.

Clausius consistency, the requirement that δQ = T·ΔS with unit temperature, then forces a unit entropy gap across the posted record on any surjective one-bit horizon. This is clausius_gap. The record potential, which assigns 0 to false and 1 to true, satisfies Clausius, and is the unique normalized entropy that does. The microstate functional fails this test on both maps, as microstate_not_clausius_A and microstate_not_clausius_B prove. The conclusion is that the entropy of the horizon is the record cost, not the microstate count, and this leads to the Bekenstein 1/4 coefficient.

What the theorem does not claim is that microstate counting is wrong in all contexts, or that the framework has derived the Bekenstein formula from nothing. The identification of boundary heat with the posted ledger flux is a definitional choice, a model, not a theorem. The Clausius relation itself is an input from standard physics. What the framework proves is a conditional statement: if you accept those two premises, then the horizon entropy must be the record cost, and the microstate gap is an artifact of the map, not a physical observable.

/-- **The degeneracy reading is not even map-consistent.** The two horizons are
calorimetrically identical (`matched_trace_equal_heat`), yet the microstate functional
assigns them different record gaps (`0` vs `−3`). An entropy that Clausius-integrates
against the same δQ record cannot depend on the map's kernel; this one does. -/
theorem microstate_gap_map_dependent :
    (microstateCost mapA true : ℤ) - (microstateCost mapA false : ℤ)
      ≠ (microstateCost mapB true : ℤ) - (microstateCost mapB false : ℤ) := by
  decide

/-- **δQ is a function of the boundary record trace alone.** The bulk-side heat sum equals
the trace-side heat of the projected record sequence, for every horizon map and every bulk
path. Everything the kernel does — its size, its structure, which fiber the path wanders
in — is calorimetrically invisible. -/
theorem pathHeat_factors {α : Type*} (f : α → Bool) (p : List α) :
    pathHeat f p = traceHeat (p.map f) := by
  induction p with
  | nil => rfl
  | cons c rest ih =>
    cases rest with
    | nil => rfl
    | cons c' rest' =>
      simp only [pathHeat, traceHeat, List.map_cons, stepHeat] at *
      omega

/-- **Kernel motion posts zero heat**, at any fiber size. A bulk path confined to a single
fiber (all points carry the same record) has zero total posted flux. -/
theorem pathHeat_kernel_zero {α : Type*} (f : α → Bool) (b : Bool) :
    ∀ p : List α, (∀ x ∈ p, f x = b) → pathHeat f p = 0 := by
  intro p
  induction p with
  | nil => intro _; rfl
  | cons c rest ih =>
    intro h
    cases rest with
    | nil => rfl
    | cons c' rest' =>
      have hc : f c = b := h c (by simp)
      have hc' : f c' = b := h c' (by simp)
      have hrest : ∀ x ∈ (c' :: rest'), f x = b := by
        intro x hx; exact h x (List.mem_cons_of_mem c hx)
      simp only [pathHeat]
      rw [stepHeat_eq_zero_of_kernel f (hc.trans hc'.symm), ih hrest]
      ring

/-- **Clausius forces the unit record gap.** On any horizon that realizes both records,
every Clausius-consistent entropy has `E true − E false = 1`: exactly one bit across the
posted record — the record cost — regardless of the kernel. -/
theorem clausius_gap {α : Type*} (f : α → Bool) (E : Bool → ℤ)
    (hE : IsClausius f E) (c c' : α) (hc : f c = false) (hc' : f c' = true) :
    E true - E false = 1 := by
  have h := hE c c'
  rw [hc, hc'] at h
  simpa [stepHeat, hc, hc'] using h.symm

/-- **The degeneracy reading fails Clausius on map A.** `microstateCost mapA` assigns `3`
to both records (both fibers have 8 microstates), so its record gap is `0`; but a record
flip posts `1` bit of heat. `δQ = 1 ≠ 0 = T·ΔS`. -/
theorem microstate_not_clausius_A :
    ¬ IsClausius mapA (fun b => (microstateCost mapA b : ℤ)) := by
  intro h
  have hgap := clausius_gap_A _ h
  have ht : microstateCost mapA true = 3 := by decide
  have hf : microstateCost mapA false = 3 := by decide
  rw [ht, hf] at hgap
  norm_num at hgap

/-- **The degeneracy reading fails Clausius on map B too**, by a different margin: its
record gap is `0 − 3 = −3` against a posted `+1`. -/
theorem microstate_not_clausius_B :
    ¬ IsClausius mapB (fun b => (microstateCost mapB b : ℤ)) := by
  intro h
  have hgap := clausius_gap_B _ h
  have ht : microstateCost mapB true = 0 := by decide
  have hf : microstateCost mapB false = 3 := by decide
  rw [ht, hf] at hgap
  norm_num at hgap

What this page does not claim

The framework does not claim microstate counting is universally invalid. The framework does not claim to have derived the Bekenstein formula without any physical input. The framework does not claim the identification of boundary heat with posted ledger flux is a theorem rather than a definitional model.

Verify this page

Every tagged claim above names its theorem. To check one yourself rather than trust this page, elaborate the source module with Lean 4 and audit its axiom basis:

$ lake env lean IndisputableMonolith/Holography/ClausiusSelector.lean
expected axiom basis: [propext, Classical.choice, Quot.sound] (the Lean kernel's standard three; no RS-specific axioms)

A page whose claims cannot be reproduced this way does not ship. In production, every anchor links to the exact declaration in the public source release, and this block carries the build receipt for the page itself.

Derived articles

This page is generated by a question-recursion engine: the questions its answers raise become the next pages. The current agenda, with open targets marked red: