Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Model vocabulary — Eight-state bus models attain all three residue signs

Definition
APFB06_superadditivity_worlds_Vocabulary

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

apfapf-referencesib-v52-2026-11

Vocabulary for the supplied model. Its substantive theorems are published separately.

Defines eight states with all three Boolean patterns free, four protocols, three unit distinction records and a shared record of weight w>=0. The costs of A,B,AB,ABR are 1+w,1+w,2+w,3+w, giving residue 1-w and sharedCost=w. Complete floor, occupancy, relation and encoded-input proofs are read. dR is an independent third distinction, no longer the conjunction of dA,dB; its designation as a relation means only tested support novelty over that pair. Generic familyCost of the empty family is positive in these worlds; the encoded forms permit this and no full physical model is asserted. This is a supplied finite model of the named Lean predicates, not a physical APF context or independence from the author-intended physical inputs. EightHold still includes the old B02SourceMeaning; amended B02 is checked separately by meets_B02_r2 against the proposed conjunction form. Singleton-domain A2/BW in EightHold do not certify physical selection or a typed whole-word continuation law.

Assumptions

  • Every explicit/implicit binder and section/typeclass variable in the declaration inventory and module context is retained.

Status: conditional reference mathematics. The supplied predicates and model assumptions are not additional Foundation inputs. These records do 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_superadditivity_worlds
title: A family of supplied worlds, one for each weight of a shared record, in which the eight declared forms and both readings hold and the whole costs more than, as much as, or less than its two parts
inputs_revision: 2026-10-04.1 for the eight declared forms as encoded. Revised 2026-11-14 (v2) so that the
 worlds also meet the sentence added to B02 at revision 2026-11-14.1: see Thm_APFB06_worlds_meet_B02_r2.
mathlib_rev: 0df444a360eaa60ab8c11dca51a86af692955474
source: the eight declared-input definition nodes, unchanged. RULING_joint_class_2026-11-13 and
 RULING_held_relation_reading_2026-11-13 (the two readings). Thm_APFB05_relation_residue (the bound these
 worlds attain). Paper 1 Supplement v9.28:5919-5930 (the shared-bus example: two bit records and a bus
 that reading either bit requires), 1779-1781 (the residue), 6481, 7313. Codebank apf/delta_calculus.py
 (Delta = epsilon * (J - R); world W1, two anchors and one irreducibly joint term) and
 apf/yang_mills_md_bridge.py, check_T_contextuality_implies_superadditive_cost (shared classical bit:
 Delta <= 0; irreducibly joint distinction: Delta > 0).
consumes_inputs: none as hypotheses. Declared forms are PROVED of supplied data, which certifies nothing
 about the physical inputs.
the worlds (APFB06.BusWorld, one for each weight w ≥ 0): eight raw states with eight different continuation
 relations, one state for each combination of sides of the three distinctions dA, dB and dR; all three are
 true at the state s0. (v1 had four states and dR true exactly where dA and dB both were. Under the new
 sentence of B02 no distinction of the domain is settled by the others, so v2 makes dR a third free
 distinction. Records, protocols, bills and every cost are unchanged.) Four records: ra for
 dA, rb for dB, rr for dR, each of weight 1, and a shared record rs of weight w that every distinction
 needs and every protocol keeps. Four protocols: one keeps ra and rs, one keeps rb and rs, one keeps ra, rb
 and rs, one keeps everything. Capacity 3 + w, floor 1. The alignment sits at s0 and carries all three.
statement: (eight_hold) all eight declared forms hold, B06 at the extensional joint class on the physical
 domain. (alignments_hold_relation) every actual joint alignment holds a relation: dR over dA and dB.
 (bill_eq_records_plus_shared) each bill is one unit for each kept record of a distinction, plus w.
 (cost_A, cost_B, cost_AB, cost_whole) the costs are 1 + w, 1 + w, 2 + w and 3 + w.
 (sharedCost_parts) dA and dB share exactly w. (residue_eq) the whole less the two parts is 1 - w, which is
 the floor less what the parts share: the bound of Thm_APFB05_relation_residue is attained.
 (whole_gt_parts_iff, whole_eq_parts_iff, whole_lt_parts_iff) the whole costs more than, as much as, or
 less than its two parts exactly as w is below, at, or above 1.
reading: with the relation held and both readings in force, the sign of the residue is not fixed by the
 eight declared forms. It is the floor of the relation less what the parts share.
not_claimed: independence from the physical inputs as the author means them; that any of these worlds is a
 physical context; that dR is "the relation between" dA and dB in any sense beyond tested and
 support-novel over the pair; anything about the hold sentence or the occupant binding.
-/
import Definitions.Def_APFB06_held_relation_worlds_Vocabulary_r2
import Theorems.Thm_APFB06_BridgeWorld_no_held_relation_r2
import Theorems.Thm_APFB06_RelationWorldR2_servesAll
import Theorems.Thm_APFB06_RelationWorldR2_bill_pF
import Theorems.Thm_APFB06_RelationWorldR2_bill_ge_one
import Theorems.Thm_APFB06_RelationWorldR2_one_le_cost
import Theorems.Thm_APFB06_RelationWorldR2_cost_le_two
import Theorems.Thm_APFB06_RelationWorldR2_world_B06
import Theorems.Thm_APFB06_RelationWorldR2_eight_hold
import Theorems.Thm_APFB06_RelationWorldR2_alignment_holds_relation
import Theorems.Thm_APFB06_RelationWorldR2_alignments_hold_relation
import Definitions.Def_APFPaper5_K1_SharedCost
import Mathlib.Tactic.NormNum
import Mathlib.Tactic.Linarith
import Mathlib.Tactic.Ring

set_option autoImplicit false
open APFPaper1.Source

namespace APFB06.BusWorld

inductive St
  | s0 | s1 | s2 | s3 | s4 | s5 | s6 | s7
  deriving DecidableEq

/-- The processes: for dA, for dB, for both, for both and the relation. -/
inductive Pr
  | pa | pb | pab | pabr
  deriving DecidableEq

/-- The records: one for each distinction, and the shared record rs. -/
inductive Rc
  | ra | rb | rr | rs
  deriving DecidableEq

/-- The continuation relation: eight different sets of processes. State s0 admits every process. -/
def cont : St → Pr → Prop
  | .s0, _ => True
  | .s1, q => q = Pr.pabr
  | .s2, q => q = Pr.pab ∨ q = Pr.pabr
  | .s3, _ => False
  | .s4, q => q = Pr.pa
  | .s5, q => q = Pr.pb
  | .s6, q => q = Pr.pab
  | .s7, q => q = Pr.pa ∨ q = Pr.pb

theorem cont_inj (x y : St) (h : cont x = cont y) : x = y := by
  have key : ∀ q, cont x q ↔ cont y q := fun q => by rw [h]
  have h1 := key Pr.pa
  have h2 := key Pr.pb
  have h3 := key Pr.pab
  have h4 := key Pr.pabr
  cases x <;> cases y <;> first | rfl | (exfalso; simp [cont] at h1 h2 h3 h4)

abbrev K : (g : Unit) → St → Pr → Prop := fun _ => cont

/-- True at s0, s1, s4 and s5. -/
def dA : St → Bool
  | .s0 => true
  | .s1 => true
  | .s4 => true
  | .s5 => true
  | _ => false

/-- True at s0, s2, s4 and s6. -/
def dB : St → Bool
  | .s0 => true
  | .s2 => true
  | .s4 => true
  | .s6 => true
  | _ => false

/-- The relation: true at s0, s5, s6 and s7. It takes both sides whatever sides dA and dB are held on. -/
def dR : St → Bool
  | .s0 => true
  | .s5 => true
  | .s6 => true
  | .s7 => true
  | _ => false

abbrev Delta : (g : Unit) → (St → Bool) → Prop := fun _ d => d = dA ∨ d = dB ∨ 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
  rw [cont_inj x y h]

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

/-- A distinction's own record, read off its values at s1 and s2. -/
def recOfB : Bool → Bool → Rc
  | true, _ => Rc.ra
  | false, true => Rc.rb
  | false, false => Rc.rr

def recOfF (f : St → Bool) : Rc := recOfB (f St.s1) (f St.s2)

abbrev recOf (d : Dist) : Rc := recOfF d.val













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

def pA : {p : Pr // p ∈ protocols ()} := ⟨Pr.pa, Set.mem_univ _⟩
def pB : {p : Pr // p ∈ protocols ()} := ⟨Pr.pb, Set.mem_univ _⟩
def pAB : {p : Pr // p ∈ protocols ()} := ⟨Pr.pab, Set.mem_univ _⟩
def pABR : {p : Pr // p ∈ protocols ()} := ⟨Pr.pabr, Set.mem_univ _⟩

/-- What each protocol keeps. Every protocol keeps the shared record. -/
def keeps : Pr → Rc → Prop
  | .pa, r => r = Rc.ra ∨ r = Rc.rs
  | .pb, r => r = Rc.rb ∨ r = Rc.rs
  | .pab, r => r = Rc.ra ∨ r = Rc.rb ∨ r = Rc.rs
  | .pabr, _ => True



def maint (g : Unit) (p : {p : Pr // p ∈ protocols g}) : Set Rc := {r | keeps p.val r}

/-- A set of records is sufficient for a distinction when it holds the distinction's own record and the
shared record. -/
def suff (g : Unit) (_ : {p : Pr // p ∈ protocols g}) (s : Set Rc)
    (d : {d : St → Bool // Delta g d}) : Prop := recOfF d.val ∈ s ∧ Rc.rs ∈ s
def uses (g : Unit) (_ : {p : Pr // p ∈ protocols g}) (d : {d : St → Bool // Delta g d})
    (s : Set Rc) : Prop := recOfF d.val ∈ s ∧ Rc.rs ∈ s
def wholeRes (g : Unit) (p : {p : Pr // p ∈ protocols g}) : Pr := p.val

/-- The bills: one unit for each kept record of a distinction, plus the weight w of the shared record. -/
def calibration (w : NNReal) (_ : Unit) : Pr → NNReal
  | .pa => 1 + w
  | .pb => 1 + w
  | .pab => 2 + w
  | .pabr => 3 + w

def C (w : NNReal) : Unit → NNReal := fun _ => 3 + w



abbrev ServesFam (p : {p : Pr // p ∈ protocols ()}) (S : Finset Dist) : Prop :=
  ∀ d ∈ S, ∃ sigma : Set Rc, sigma ⊆ maint () p ∧ suff () p sigma d ∧ uses () p d sigma











section
variable (w : NNReal)

/-- The bill of a protocol, as a real number. -/
abbrev bill (p : {p : Pr // p ∈ protocols ()}) : ℝ :=
  ((calibration w () (wholeRes () p) : NNReal) : ℝ)

noncomputable abbrev cost (S : Finset Dist) : ℝ :=
  familyCost (wholeRes ()) (calibration w ()) (maint ()) (suff ()) (uses ()) S

abbrev billSet (S : Finset Dist) : Set ℝ :=
  {c : ℝ | ∃ p : {p : Pr // p ∈ protocols ()}, ServesFam p S ∧ bill w p = c}





































end

/-- The held family: dA, dB and the relation. -/
noncomputable def heldD : Finset Dist := {dAd, dBd, dRd}

/-- The occupant's alignment: it sits at s0 and carries all three. -/
noncomputable def alignP : APFB06.OriginalAlignment (K ())
    (APFB06.physicalDomain (K ()) (Delta ()) (hresp ())) where
  carrier := APFB01.physicalClass (K ()) St.s0
  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
    · rcases Finset.mem_insert.mp hd' with rfl | hd''
      · rfl
      · rw [Finset.mem_singleton.mp hd'']
        rfl



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

section
variable (w : NNReal)



/-- 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 _ => Pr)
      (P := fun g => {p : Pr // 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 : Pr // p ∈ protocols g}) (R := fun _ => Pr) (Record := fun _ => Rc)
      wholeRes (calibration w) maint suff uses ∧
    APFB04.B04FiniteCapacity (Context := Unit) (fun g => ((C w g : NNReal) : ℝ)) ∧
    APFB05.MarginalFloor (Context := Unit) (D := fun g => {d : St → Bool // Delta g d})
      (P := fun g => {p : Pr // p ∈ protocols g}) (R := fun _ => Pr) (Record := fun _ => Rc)
      wholeRes (calibration w) maint suff uses (fun _ _ => True) (fun g => ((C w 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 w) (C w) actualJointP ∧
    APFB07a.A2Selection (Interface := Unit)
      (Configuration := fun _ => APFB01.PhysicalState (K ()))
      (fun _ s => s = APFB01.physicalClass (K ()) St.s0) (fun _ _ => (1 : ℝ))
      (fun _ => APFB01.physicalClass (K ()) St.s0) ∧
    APFB07b.BWUniqueMinimum (Interface := Unit)
      (Configuration := fun _ => APFB01.PhysicalState (K ()))
      (fun _ s => s = APFB01.physicalClass (K ()) St.s0) (fun _ _ => (1 : ℝ))

























end

/-- The records of distinctions each protocol keeps (the shared record aside). -/
def keptOwn : Pr → Finset Rc
  | .pa => {Rc.ra}
  | .pb => {Rc.rb}
  | .pab => {Rc.ra, Rc.rb}
  | .pabr => {Rc.ra, Rc.rb, Rc.rr}



end APFB06.BusWorld
Source
Theorems/Thm_APFB06_superadditivity_worlds.lean; Sib v52 / pullbacks v6; SHA-256 e266d8352cf774d88c36aec77132766173370a23c4353f4ca74178bcf6663b9a. Paper 1 Supplement v9.28:1741-1819,1833-1888,2746-2782,2845-2923,3046-3058,5919-5931,7101; Paper 0 v6.3.2:3226-3242 for A2 scope; Actual codebank continuation_calculus.py:76-157; delta_calculus.py:236-314; yang_mills_md_bridge.py:548-638; Current FOUNDATION_INPUTS revision 2026-11-14.1; W/notes/HANDOFF_auditor_and_publisher_2026-11-14.md; frozen/pullbacks_v6/Notes/MEMO_pullbacks_pass10_2026-11-14.md
Human review
  • Endorsed by Shuze Chen · Nov 16, 2026

    Confirmed by the moderator at approval.

  • Endorsed by FiniteUniverse · Nov 16, 2026

    Confirmed by the mission captain (proposal self-audit).

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