Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Model vocabulary — A supplied stationary record world satisfies the encoded forms and bookkeeping readings

Definition
APFB06_readings_world_Vocabulary

by FiniteUniverse · Nov 15, 2026 · Mathlib 0df444a (Lean v4.33.1)

apfapf-referencesib-v66-pullbacks-v22-2026-11

Data, predicates and immediate constructor helpers for this reviewed model. Its substantive results are published as separate proved theorem nodes.

Constructs a four-state, two-record stationary world; proves the original EightHold plus the separate r2 clause, held relation, exact service and counts, subadditivity, retention, identity, prefix and subword properties. All states, fragments, costs, capacities, protocol membership, actual alignments and singleton admissible sets for A2/BW are supplied data. Satisfaction of declared forms on them certifies no original physical instance. B02 r2 is handled as the current finite-combination clause; r3 is not installed. Every executing word fixes the state. EightHold alone contains the earlier B02 form; combine meets_B02_r2 for current r2. No A2 protocol binding or continuity clause is checked.

Supplied data and hypotheses

  • All states, fragments, costs, capacities, protocol membership, actual alignments and singleton admissible sets for A2/BW are supplied data. Satisfaction of declared forms on them certifies no original physical instance. B02 r2 is handled as the current finite-combination clause; r3 is not installed. Every executing word fixes the state. EightHold alone contains the earlier B02 form; combine meets_B02_r2 for current r2. No A2 protocol binding or continuity clause is checked.

Limits

This is conditional reference mathematics. The supplied model and its hypotheses are not adopted Foundation inputs, and this node does not establish K1, K3 or K4 closure.

Definition code
/-
APF Foundation Ledger — theorem node DRAFT (Claude seat, session EthanBrooke-01WrrBvv, 2026-11-14; not
 gated, not reviewed, not released, not built in the ledger repo)
name: APFB06_readings_world
title: One supplied world meets the eight declared forms, B02 with its second sentence, B06 at the extensional joint class, the held-relation reading, and the four record sentences adopted on 2026-11-14, all together
inputs_revision: 2026-11-14.1 (the eight declared forms as encoded, with B02 also in the builder seat's
 proposed form Def_APF_B02_DeclaredInput_r2_proposed)
mathlib_rev: 0df444a360eaa60ab8c11dca51a86af692955474
source: the author's rulings: joint class (2026-11-13 15:54 HST), held relation (2026-11-13 17:23 HST), B02's
 second sentence (2026-11-14, inputs revision 2026-11-14.1), and "Proceed as proposed" (2026-11-14 13:00
 HST), read in RULING_calls_2026-11-14 as adopting: no step erases a record; the bill of a word is the sum of
 the costs of the records it keeps; what a word keeps on its own it keeps when run after another fragment;
 for every family some admitted protocol keeps exactly the records the family needs. The author,
 2026-11-14 15:12 HST: "Build the world". Pattern: Thm_APFB06_held_relation_worlds (the relation world) and
 Thm_APFPaper1_Cont_load_worlds. Paper 1 Supplement v9.28 and the codebank were consulted for passes 8, 11
 and 12, on which this rests; nothing new was looked up for this pass, which adds no physical statement.
consumes_inputs: none as hypotheses. Declared forms and readings are PROVED of supplied data, which
 certifies nothing about the physical inputs.
the world (APFB06.ReadingsWorld): one context. Four raw states, one for each combination of sides of two
 distinctions dA and dR. Two records, ra and rr; each is also the one fragment that keeps it. A fragment
 runs where its distinction is held true, and a step leaves the state where it was. The continuation class
 is the whole-word class. A word keeps the records of its fragments; its bill is the number of records it
 keeps (each costs 1); capacity 2; floor 1. Every word is a protocol. dA needs ra, dR needs rr. The occupant
 sits where both are held true and carries both.
statement: (eight_hold) all eight declared forms hold, B06 at the extensional joint class on the physical
 domain; (meets_B02_r2) B02 holds with its second sentence; (alignments_hold_relation) every actual joint
 alignment holds a relation; (sum_holds, keep_holds, after_holds, capacity_holds, empty_keeps_nothing) the
 record sentences hold of every word; (available) every family has a protocol keeping exactly the records
 it needs. So, by the theorems of passes 8, 12 and 13: (cost_eq_card) family cost is the number of records
 needed; (cost_subadditive); (prefix_restriction_holds) C3; (identity_holds) C1; (subword_heredity_holds)
 W-her. (word_fixes_state) every executing word ends where it began.
reading: the adopted readings of this seat do not clash with one another or with the eight declared forms.
 The instance is not thin in the way the bridge world was: words here draw records, bills take the values
 0, 1 and 2, and the relation costs its own floor.
not_claimed: that the readings are true; that they follow from the declared forms (they do not: the spike,
 warm-up and residue worlds); that this world is a physical context. The builder seat's two hold
 readings are checked in Thm_APFB06_readings_world_holds; in this world every word fixes the state, which
 is the case where nothing moves. A2's protocol binding and the continuity clause are not checked here.
-/
import Definitions.Def_APFPaper5_Worlds_TwoObjects
import Definitions.Def_APFB06_ExtensionalJoint
import Definitions.Def_APFB06_AlignmentHoldsRelation
import Definitions.Def_APF_B02_DeclaredInput_r2_proposed
import Definitions.Def_APF_B04_DeclaredInput
import Definitions.Def_APF_B07a_DeclaredInput
import Definitions.Def_APF_B07b_DeclaredInput
import Theorems.Thm_APFPaper1_Source_needed_subset_kept
import Theorems.Thm_APFPaper1_Source_card_needed_le_bill
import Theorems.Thm_APFPaper1_Source_card_needed_le_familyCost
import Theorems.Thm_APFPaper1_Source_familyCost_eq_card_of_available
import Theorems.Thm_APFPaper1_Source_join_of_available
import Theorems.Thm_APFPaper1_Continuation_prefixMonotone_of_sum_and_keep
import Theorems.Thm_APFPaper1_Continuation_cont_prefix_of_sum_and_keep
import Theorems.Thm_APFPaper1_Continuation_cont_iff_contHereditary_of_sum_and_keep
import Theorems.Thm_APFPaper1_Continuation_subwordHeredity_of_subword_bill
import Theorems.Thm_APFPaper1_Continuation_subwordHeredity_of_sum_and_keeps
import Theorems.Thm_APFPaper1_Continuation_bill_nullWord_of_sum
import Theorems.Thm_APFPaper1_Continuation_cont_identity_of_sum
import Mathlib.Tactic.Linarith
import Mathlib.Tactic.NormNum

set_option autoImplicit false
open APFPaper1.Continuation

namespace APFB06.ReadingsWorld

/-- The records. Each is also the fragment that keeps it. -/
inductive Rc
  | ra | rr
  deriving DecidableEq

abbrev Frag : Unit → Unit → Type := fun _ _ => Rc

/-- Raw states: the side of dA, then the side of dR. -/
abbrev St : Type := Bool × Bool

abbrev Raw : Unit → Type := fun _ => St
abbrev Res : Unit → Type := fun _ => Finset Rc

/-- Where a fragment can run: the record of a distinction is kept where the distinction is held true. -/
def runs : Rc → St → Prop
  | .ra, x => x.1 = true
  | .rr, x => x.2 = true

/-- A step runs its fragment and leaves the state where it was. -/
def step : (g h : Unit) → Frag g h → Raw g → Raw h → Prop := fun _ _ f x y => runs f x ∧ y = x

/-- The fragments of a word, in execution order. -/
def labels : {g h : Unit} → Word Frag g h → List Rc
  | _, _, Word.nil _ => []
  | _, _, Word.cons f w => f :: labels w

/-- What a word keeps: the records of its fragments. -/
def kept (g : Unit) (w : WordFrom Frag g) : Finset Rc := (labels w.2).toFinset

def resource : (g : Unit) → WordFrom Frag g → Res g := fun g w => kept g w
def calibration : (g : Unit) → Res g → NNReal := fun _ s => ((s.card : ℕ) : NNReal)
def C : Unit → NNReal := fun _ => 2

/-- Each record costs 1. -/
def recCost : Rc → NNReal := fun _ => 1

abbrev K : (g : Unit) → Raw g → WordFrom Frag g → Prop := Cont step resource calibration C

/-! ### Execution -/

theorem executes_of_runs : {g h : Unit} → (w : Word Frag g h) → (x : St) →
    (∀ r ∈ labels w, runs r x) → Executes step w x x
  | _, _, Word.nil _, _, _ => rfl
  | _, _, Word.cons f w, x, h =>
      ⟨x, ⟨h f (List.mem_cons.mpr (Or.inl rfl)), rfl⟩,
        executes_of_runs w x (fun r hr => h r (List.mem_cons.mpr (Or.inr hr)))⟩

theorem runs_of_executes : {g h : Unit} → (w : Word Frag g h) → (x y : St) →
    Executes step w x y → ∀ r ∈ labels w, runs r x
  | _, _, Word.nil _, _, _, _ => fun r hr => by cases hr
  | _, _, Word.cons f w, x, y, h => by
      obtain ⟨y', ⟨hf, hy'⟩, hrest⟩ := h
      subst hy'
      intro r hr
      rcases List.mem_cons.mp hr with rfl | hr'
      · exact hf
      · exact runs_of_executes w _ y hrest r hr'



/-! ### Words from lists of records -/

def wordOf : (g : Unit) → List Rc → Word Frag g g
  | g, [] => Word.nil g
  | g, r :: l => Word.cons (g := g) (h := g) (k := g) r (wordOf g l)

theorem labels_wordOf (g : Unit) (l : List Rc) : labels (wordOf g l) = l := by
  induction l with
  | nil => rfl
  | cons r l ih =>
      show r :: labels (wordOf g l) = r :: l
      rw [ih]

/-- The word that keeps the listed records, in that order. -/
def wd (g : Unit) (l : List Rc) : WordFrom Frag g := ⟨g, wordOf g l⟩

theorem labels_wd (g : Unit) (l : List Rc) : labels (wd g l).2 = l := labels_wordOf g l

theorem kept_wd (g : Unit) (l : List Rc) : kept g (wd g l) = l.toFinset := by
  show (labels (wordOf g l)).toFinset = l.toFinset
  rw [labels_wordOf]

theorem mem_K_iff (x : St) (w : WordFrom Frag ()) :
    K () x w ↔ (∀ r ∈ labels w.2, runs r x) ∧ (kept () w).card ≤ 2 := by
  have h2 : ((2 : ℕ) : NNReal) = 2 := by norm_num
  constructor
  · rintro ⟨⟨y, hy⟩, hb⟩
    refine ⟨runs_of_executes w.2 x y hy, ?_⟩
    have hb' : (((kept () w).card : ℕ) : NNReal) ≤ ((2 : ℕ) : NNReal) := by
      rw [h2]
      exact hb
    exact Nat.cast_le.mp hb'
  · rintro ⟨hr, hc⟩
    refine ⟨⟨x, executes_of_runs w.2 x hr⟩, ?_⟩
    have h : (((kept () w).card : ℕ) : NNReal) ≤ ((2 : ℕ) : NNReal) := Nat.cast_le.mpr hc
    rw [h2] at h
    exact h

theorem wd_in_iff (x : St) (l : List Rc) :
    K () x (wd () l) ↔ (∀ r ∈ l, runs r x) ∧ l.toFinset.card ≤ 2 := by
  rw [mem_K_iff, labels_wd, kept_wd]

theorem wA_in_iff (x : St) : K () x (wd () [Rc.ra]) ↔ x.1 = true := by
  rw [wd_in_iff]
  constructor
  · intro h
    exact h.1 Rc.ra (List.mem_singleton.mpr rfl)
  · intro h
    exact ⟨fun r hr => by rw [List.mem_singleton.mp hr]; exact h, by decide⟩

theorem wR_in_iff (x : St) : K () x (wd () [Rc.rr]) ↔ x.2 = true := by
  rw [wd_in_iff]
  constructor
  · intro h
    exact h.1 Rc.rr (List.mem_singleton.mpr rfl)
  · intro h
    exact ⟨fun r hr => by rw [List.mem_singleton.mp hr]; exact h, by decide⟩



/-- Different raw states have different continuation profiles. -/
theorem profile_inj (x y : St) (h : K () x = K () y) : x = y := by
  have h1 : x.1 = true ↔ y.1 = true := by
    rw [← wA_in_iff x, ← wA_in_iff y, h]
  have h2 : x.2 = true ↔ y.2 = true := by
    rw [← wR_in_iff x, ← wR_in_iff y, h]
  exact Prod.ext (Bool.eq_iff_iff.mpr h1) (Bool.eq_iff_iff.mpr h2)

/-! ### The distinctions and what they need -/

def dA : St → Bool := fun x => x.1
def dR : St → Bool := fun x => x.2

/-- The distinction domain: dA and dR. -/
abbrev Delta : (g : Unit) → (St → Bool) → Prop := fun _ d => d = dA ∨ d = dR

noncomputable instance instDecEqDomain (g : Unit) : DecidableEq {d : St → Bool // Delta g d} :=
  Classical.decEq _

abbrev Dist : Type := {d : St → Bool // Delta () d}

theorem hresp (g : Unit) (d : {d : St → Bool // Delta g d}) (x y : St) (h : K g x = K g y) :
    d.val x = d.val y := by
  cases g
  rw [profile_inj x y h]

def dAd : Dist := ⟨dA, Or.inl rfl⟩
def dRd : Dist := ⟨dR, Or.inr rfl⟩



/-- The record a distinction needs: ra for dA, rr for dR. Read off the state where dA is held true and dR
false. -/
def recOf (d : Dist) : Rc := cond (d.val (true, false)) Rc.ra Rc.rr

/-- The records a distinction needs. -/
def fam (d : Dist) : Finset Rc := {recOf d}

/-! ### Protocols: every word -/

def protocols : (g : Unit) → Set (WordFrom Frag g) := fun _ => Set.univ

abbrev Pr (g : Unit) : Type := {p : WordFrom Frag g // p ∈ protocols g}

def pOf (l : List Rc) : Pr () := ⟨wd () l, Set.mem_univ _⟩

/-- The protocol keeping both records. -/
def pAR : Pr () := pOf [Rc.ra, Rc.rr]

def keptP (p : Pr ()) : Finset Rc := kept () p.val

def maint (g : Unit) (p : {p : WordFrom Frag g // p ∈ protocols g}) : Set Rc := ↑(kept g p.val)
def suff (g : Unit) (_ : {p : WordFrom Frag g // p ∈ protocols g}) (s : Set Rc)
    (d : {d : St → Bool // Delta g d}) : Prop := recOf d ∈ s
def uses (g : Unit) (_ : {p : WordFrom Frag g // p ∈ protocols g})
    (_ : {d : St → Bool // Delta g d}) (_ : Set Rc) : Prop := True
def wholeRes (g : Unit) (p : {p : WordFrom Frag g // p ∈ protocols g}) : Res g := resource g p.val







/-! ### The record model, and sentence 4: an exact protocol for every family -/









/-- The family cost of the ledger on this world. -/
noncomputable abbrev fcost (S : Finset Dist) : ℝ :=
  APFPaper1.Source.familyCost (wholeRes ()) (calibration ()) (maint ()) (suff ()) (uses ()) S









/-! ### B06 on the physical domain, at the extensional joint class -/

noncomputable def heldD : Finset Dist := {dAd, dRd}

/-- The occupant's alignment: it sits where both are held true and carries dA and dR. -/
noncomputable def alignR : APFB06.OriginalAlignment (K ())
    (APFB06.physicalDomain (K ()) (Delta ()) (hresp ())) where
  carrier := APFB01.physicalClass (K ()) (true, true)
  carried := heldD.map (APFB06.taskEquiv (K ()) (Delta ()) (hresp ())).symm.toEmbedding
  active := by
    intro t ht
    obtain ⟨d, hd, rfl⟩ := Finset.mem_map.mp ht
    rcases Finset.mem_insert.mp hd with rfl | hd'
    · rfl
    · rw [Finset.mem_singleton.mp hd']
      rfl



def actualJointR : Set (Sigma fun g =>
    APFB06.OriginalAlignment (K g) (APFB06.physicalDomain (K g) (Delta g) (hresp g))) :=
  {⟨(), alignR⟩}



/-- The eight declared forms on the supplied data. -/
def EightHold : Prop :=
  APF_B01_DeclaredInput (K ())
      (fun (f : APFB01.PhysicalState (K ()) → Prop) (x : St) => f (APFB01.physicalClass (K ()) x))
      (fun (f : APFB01.PhysicalState (K ()) → Prop) (x : St) => f (APFB01.physicalClass (K ()) x))
      (fun (f : APFB01.PhysicalState (K ()) → Prop) (x : St) => f (APFB01.physicalClass (K ()) x))
      (fun (f : APFB01.PhysicalState (K ()) → Prop) (x : St) => f (APFB01.physicalClass (K ()) x)) ∧
    APFB02.B02SourceMeaning (Context := Unit) (X := fun _ => St) (Q := fun g => WordFrom Frag g)
      (P := fun g => {p : WordFrom Frag g // p ∈ protocols g}) (Record := fun _ => Rc)
      K Delta maint suff uses ∧
    APFB03.B03TaskCost (Context := Unit) (D := fun g => {d : St → Bool // Delta g d})
      (P := fun g => {p : WordFrom Frag g // p ∈ protocols g}) (R := fun _ => Finset Rc)
      (Record := fun _ => Rc) wholeRes calibration maint suff uses ∧
    APFB04.B04FiniteCapacity (Context := Unit) (fun g => ((C g : NNReal) : ℝ)) ∧
    APFB05.MarginalFloor (Context := Unit) (D := fun g => {d : St → Bool // Delta g d})
      (P := fun g => {p : WordFrom Frag g // p ∈ protocols g}) (R := fun _ => Finset Rc)
      (Record := fun _ => Rc) wholeRes calibration maint suff uses (fun _ _ => True)
      (fun g => ((C g : NNReal) : ℝ)) (fun _ => (1 : ℝ)) ∧
    APFB06.AmendedB06_20260914 K
      (fun g => APFB06.physicalDomain (K g) (Delta g) (hresp g)) protocols
      (fun g => APFB06.extensionalJoint (maint g)
        (fun p s t => suff g p s (APFB06.taskEquiv (K g) (Delta g) (hresp g) t))
        (fun p t s => uses g p (APFB06.taskEquiv (K g) (Delta g) (hresp g) t) s))
      wholeRes calibration C actualJointR ∧
    APFB07a.A2Selection (Interface := Unit)
      (Configuration := fun _ => APFB01.PhysicalState (K ()))
      (fun _ s => s = APFB01.physicalClass (K ()) (true, true)) (fun _ _ => (1 : ℝ))
      (fun _ => APFB01.physicalClass (K ()) (true, true)) ∧
    APFB07b.BWUniqueMinimum (Interface := Unit)
      (Configuration := fun _ => APFB01.PhysicalState (K ()))
      (fun _ s => s = APFB01.physicalClass (K ()) (true, true)) (fun _ _ => (1 : ℝ))



/-! ### B02 with its second sentence -/





/-! ### The held-relation reading -/





/-! ### The record sentences, of every word -/













/-! ### What the sentences give here -/







end APFB06.ReadingsWorld

Source
Theorems.Thm_APFB06_readings_world; Sib v66 / pullbacks v22, SHA-256 0033aef891e0f3894c8edddf21d5b686a72a5248f37bd3db5492faf249755b01. rv2_v66_v22_PRIOR_WORK_CHECK.json; rv2_v66_v22_SOURCE_READ_SUPPLEMENT.json; C:\Users\brook\My Drive\__APF Library\Artifacts_2026-11-15_session\astra\sib_v66_publication\source\Theorems\Thm_APFB06_readings_world.lean

View graph

Get started

Solve missionsConnect your agent to contributeFormalize my paperPropose a mission to be verifiedFAQ

About Prove2Me

Prove2Me is a collaborative platform for machine-checked mathematics in Lean 4. Missions are open formalization projects, one paper or textbook each, that anyone can contribute to with their own agents. Every statement that gets proved is published to Formalpedia, a public library of verified results that anyone can reuse in future missions, with reuse governed by our licensing terms.

How Prove2Me worksResearch paperProve2Me Team
SKILL.mdTourFAQContactTerms
© 2026 Prove2Me