Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Model vocabulary — A supplied model with an unrecorded held datum

Definition
APFB06_held_datum_world_Vocabulary

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

apfapf-referenceusb-v58-batch-a-2026-11

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

Eight supplied states carry two recorded readings and a third Boolean datum. A free involution flips the datum; making is admitted only when the datum is up, sets the recorded reading true, keeps rr and leaves the datum. The datum separates continuation profiles but is deliberately absent from the distinction domain. Its physical classification is unresolved. Historical declared forms on this supplied domain do not certify current physical inputs, a physical hold or a physical carrier.

Supplied data and hypotheses

  • Every formal parameter and hypothesis remains exposed. Historical model encodings and named conditions are not adopted as current physical inputs.

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-18; not
 gated, not reviewed, not released, not built on the build machine, in no bundle)
name: APFB06_held_datum_world
title: One supplied world with a held datum that no record sees: a turn that moves it both ways and keeps no record, and a making that runs where it is up, makes a distinction read true and keeps that distinction's record; the world meets the eight declared forms and B02 with its second sentence
inputs_revision: 2026-11-20.2 (the eight declared forms as encoded, with B02 also in the builder seat's
 proposed form Def_APF_B02_DeclaredInput_r2_proposed)
restated: 2026-11-21 09:49 HST, for bundle v57, at the author's word of 09:43 HST, "yes", to this seat's question
 "Shall I build v57 as set out, yes or no?"
 (RULING_build_v57_with_the_headers_restated_to_2026-11-20.2_and_stage_the_run_2026-11-21; set out in
 TEE_UP_the_build_run_before_the_upload_bundle_v57_with_headers_restated_to_the_revision_in_force_2026-11-21).
 HEADER ONLY. Every line after this comment is the file as in bundle v56 (sha256
 feab96f9a7f08d642f85d12cd25dade772985e8c16021471a0bebef0e25227e0), kept in Old/ as
 Thm_APFB06_held_datum_world_pre-restating_v57_2026-11-21.lean. No declaration is changed. THE RESTATED
 BYTES ARE NOT RELEASED.
 Changed in this header: the revision named on the inputs_revision line, which was 2026-11-17.4, and this
 entry. Nothing else.
 WHAT HAPPENED: since revision 2026-11-17.4, which this header named until now, three revisions of
 FOUNDATION_INPUTS were installed. Revision 2026-11-18.2, installed 2026-11-18 at 18:22 HST (sha256
 290a59cad5591706d9b929fc98dde9f1b1215b4e40dc3d8eff790e8c59090cf0;
 INSTALL_RECEIPT_FOUNDATION_INPUTS_2026-11-18.2_2026-11-18): the reading of B02's first sentence
 (reading_20261114_list_complete) is scoped to what is recorded. It now reads: "The distinctions of a
 context are complete for what is recorded: potential states that every distinction of the context reads
 alike are recorded alike. They may differ in what they hold unrecorded. Then what can follow them tells
 them apart, and no side does." It is a reading and not a commitment; B02's two sentences are unchanged.
 Revision 2026-11-18.3, installed 2026-11-18 at 19:50 HST (sha256
 95815d3a9ef01dd631bd52729a66a79531ff4590ed44d451be5882af20cc35b2;
 INSTALL_RECEIPT_FOUNDATION_INPUTS_2026-11-18.3_and_GATE_POLICY_2026-11-18.inputs.2_2026-11-18): one block
 was added that records where 13 cited files now resolve. No wording of a commitment changed. Revision
 2026-11-20.2, installed 2026-11-20 at 12:36 HST (sha256
 05c831bf6e786f168d9a9f0bb366b496388bd049960e9df3ca0acad8680d6252;
 INSTALL_RECEIPT_FOUNDATION_INPUTS_2026-11-20.2_2026-11-20): B06 is reduced. After its first four sentences,
 which are unchanged, it now reads: "To draw a distinction is to keep its record: each distinction has one
 record, the same in every protocol, and a protocol draws the distinction exactly when it keeps that record.
 Every record a protocol keeps is the record of some tested distinction or family of tested distinctions,
 and is used for it. Every process pays epsilon for each record it keeps, and nothing else, where epsilon is
 positive and fixed by the context. In every context some protocol draws no distinction. The occupant draws
 exactly its family, and every part of that family is drawn alone by some protocol. A process that keeps no
 record costs nothing. A process that keeps no record changes nothing that is recorded." Against revision
 2026-11-18.3, six sentences are replaced by four and three are kept word for word. The six that are no
 longer sentences of the inputs: "Each record carries a cost. What a set of records is sufficient for does
 not depend on the protocol that keeps it. The occupant holds its distinctions with exactly the records they
 need, and its bill is the cost of those records. The same is true of every part of it: any family of its
 distinctions is held with exactly the records that family needs, at exactly their cost, and there is no
 cheaper way to hold that family. Epsilon is the unit of the occupant: each record it keeps costs epsilon,
 the floor of its context. Holding nothing costs nothing." B03 and B05 are retired as inputs and are kept in
 the inputs file as derived statements. B07a and B07b each gain a note, note_20261120_protocol_binding;
 their wording, scope and forms are unchanged. B01, B02 and B04 are unchanged. The commitments are six: B01,
 B02, B04, B06, B07a, B07b. The gate policy on the build machine is policy_revision 2026-11-20.inputs.1
 (sha256 5e9f3ec3cfa6c9a0a0b28549d13370c31ef78de38272ac6391efeac472f9a4aa) and requires this revision
 (INSTALL_RECEIPT_GATE_POLICY_2026-11-20.inputs.1_2026-11-20).
 HOW TO READ THE REST OF THIS HEADER: it named revision 2026-11-17.4 and is left as written, any earlier
 entries "restated" below included. Where it names revision 2026-11-17.4 or an earlier one as the revision
 in force, that is no longer so: the revision in force is 2026-11-20.2. Where it counts eight commitments,
 eight inputs or eight declared forms: there are now six commitments. The declared forms of B03 and B05 are
 unchanged and are now forms of derived statements. Where it calls B03 or B05 an input, or takes the
 declared form of either as a hypothesis: the installed file says of B03, and in the same words of B05, "A
 dependency on B03 is a dependency on its declared form, which is unchanged. From revision 2026-11-20.2 that
 form is a derived statement and not an input. The derivation is a draft and is not certified: until it is
 admitted through the gate, a node that consumes B03 is conditional on it. Resolve it before foundation
 certification. Do not treat an old use of B03 as a use of B06." Where it speaks of B06 by a count of its
 sentences or by their numbers, of the occupant statement, of the amended B06, or of a sentence of B06 as an
 input: that is B06 as it stood at the revision the header then named, and B06 now reads as quoted above. A
 statement here that takes one of the six replaced sentences as a premise stays true as a conditional;
 whether it follows from the reduced B06 is NOT SAID by this entry (for what used them see
 MEMO_pullbacks_passes119_and_120_what_used_the_dropped_sentences_and_one_world_for_all_eleven_2026-11-18 in
 Notes). Where it says of a sentence that is in B06 as quoted above that it is proposed, a ruling carried as
 a named hypothesis, NOT RULED, not installed or not an input: that is no longer so, for that sentence as
 worded above and for no typing of it. Where it takes the reading of B02's first sentence as first recorded
 (the distinctions of a context are complete: potential states that every distinction reads alike have the
 same continuation profile; the physical objects of a context correspond one to one with the combinations of
 sides of its distinctions) as a reading of the inputs: from revision 2026-11-18.2 the inputs do not assert
 it. A statement that takes it as a premise stays true as a conditional. A supplied world in which it holds
 is not excluded: the scoped reading adds no constraint. THE NEW SENTENCES OF B06 HAVE NO CERTIFIED LEAN
 FORM: the forms the inputs file names for the reduced B06 are drafts of the two seats, marked
 PROPOSED_NOT_CERTIFIED, and the Lean that derives the declared forms of B03 and B05 is a draft and is not
 gated. NOTHING in this entry says that a theorem of this file follows from the inputs at revision
 2026-11-20.2, or that a supplied world of this file is a world of them: each theorem stands as before, on
 its named hypotheses or on its supplied world, and a supplied world that breaks a sentence of the inputs at
 revision 2026-11-20.2 is not a world of the inputs at that revision, whatever this header says of an
 earlier one. The gate policy says of the move to this revision: "immutable; dependency compatibility must
 be established separately; no stale-basis waiver". This entry establishes no such compatibility. Proposed
 revision 2026-11-20.3 (one further note on each of B07a and B07b) is NOT installed.
mathlib_rev: 0df444a360eaa60ab8c11dca51a86af692955474
source: the author, 2026-11-18 13:05 HST: "Yes", to "Shall I build that world next, yes or no?", the world
 being one with "a held datum that no record sees; a free fragment that turns it and can be undone; a
 making that then records it" (RULING_build_the_world_with_a_held_datum_next_2026-11-18). The parts are
 this seat's construction. The author has said yes to building it and no more.
 This file is Thm_APFB06_making_world (pass 122) restated for a state with a third coordinate. What is
 changed in the world: (1) the state is (side of dA, side of dR, held datum); (2) there is a fourth kind
 of fragment, the turn, which runs everywhere, turns the held datum over and keeps no record; (3) the
 making fragment runs only where the held datum is up. The making still takes dR to true and keeps the
 record rr; the reading fragments, the records, the bill, the capacity and the protocols are as they
 were. Proofs are restated for the new fragments and states; the statements of the declared forms are
 the making world's, with the occupant placed where both distinctions are held true and the held datum
 is down.
 Consulted before typing (2026-11-18, 13:06 to 13:07 HST), with what pass 122 consulted:
 - Paper 5 Supplement v7.33 (sandbox copy fetched through the Google Drive connector for pass 107):
   1408-1414, "The construction therefore keeps the coherent hold and the committed record separate
   ... The complex scalar lives on the held continuation profile and is removed only by the later
   record functor"; 1418-1423, "A held profile contains its structural alignment, context-complete
   continuation identity, and every unresolved relative-history datum required by a later admissible
   continuation. It contains no irreversible selected-branch record."; 1430-1431, the record functor
   "retains every distinction booked by the class transition and forgets held data that produce no
   committed record"; 1433-1441, the closed-world kernel dichotomy.
 - Codebank: apf/class_transition.py, check_T_coherent_free_spend_permanent ("free requires no
   completion with no drive, while spend and permanent require finite completion with drive"; "does
   not establish that a physical resolution occurs ... or that an inverse is excluded").
 - Existing Lean: Def_APFPaper5_K2_HoldWord (IsHoldWord: admitted everywhere, keeps no record, has an
   admitted reverse, rearranges a listed family and keeps a table); Thm_APFB06_moving_world and
   Thm_APFB06_worlds_under_pinning (the moving world's hold turns the two recorded sides, and a record
   does not pin its side there); Thm_APFPaper5_K2_no_hold_on_the_recorded_side (pass 108).
consumes_inputs: none as hypotheses. Declared forms and readings are PROVED of supplied data, which
 certifies nothing about the physical inputs.
the world (APFB06.HeldDatumWorld): one context. Eight raw states: the side of dA, the side of dR, and a
 held datum, up or down. Two distinctions in the domain, dA and dR. Two records, ra and rr. Four
 fragments. A reading fragment for ra and one for rr: each runs where its distinction is held true,
 leaves the state and keeps its record. The making fragment runs where the held datum is up, takes dR
 to true, leaves the rest, and keeps the record rr. The turn runs everywhere, turns the held datum
 over, leaves the rest, and keeps no record. A word keeps the records its fragments keep; its bill is
 the number of records kept; capacity 2; floor 1. Every word is a protocol. The occupant sits where
 both distinctions are held true and the held datum is down, and carries dA and dR.
statement: what the making world's file proves, of this world (eight_hold, meets_B02_r2,
 alignments_hold_relation, sum_holds, keep_holds, after_holds, capacity_holds, empty_keeps_nothing,
 available, cost_eq_card, cost_subadditive, prefix_restriction_holds, identity_holds,
 subword_heredity_holds, word_acts), and:
 - of the making word: make_acts, make_admitted_iff (it is a continuation exactly where the held datum
   is up), kept_make, bill_make, made_keeps_the_held_datum, made_not_injective;
 - of the turn word: turn_acts, turn_admitted, kept_turn (it keeps no record), bill_turn (it bills
   nothing), turned_turned (two turns undo each other), turned_keeps_dA, turned_keeps_dR, turned_ne (it
   moves every state);
 - profile_inj: different raw states have different continuation profiles. The held datum is seen by
   the profile: the making word is a continuation from one of the two states and not from the other.
NOT RULED, and a choice of this file:
 - The held datum is not in the world's distinction domain. It separates continuation profiles, and no
   protocol keeps a record of it. Whether such a thing is a distinction in B02's sense ("a finite,
   enforceable separator of continuation profiles") is the author's to say. If it had to be listed,
   B02's declared form would ask for a protocol that draws it, and this world has none.
what this file does NOT say:
 - That the world meets the sentences of B06 as proposed for revision 2026-11-18.1, or that the turn is
   a hold. Those are the next file's.
 - That the making records which way the held datum was. It runs only where the datum is up, and makes
   dR read true; where the datum is down it does not run. Nothing is made of a datum that is down.
 - That the making uses the held datum up. It leaves it as it was.
 - That the making can be undone. No fragment of this world turns a side of dA or dR from true to false.
 - That this world is the physical one. That a held datum of the physical data is a single side.
 - A2's protocol binding and the continuity clause are not checked here. No lane. No claim that the
   transfer is forced, that the carrier gap is closed or narrowed, or that Born is derived.
axioms: within propext, Classical.choice, Quot.sound. No sorry.
-/
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_APFB02_HoldOnDistinctions
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.HeldDatumWorld

/-- The records. -/
inductive Rc
  | ra | rr
  deriving DecidableEq

instance : Fintype Rc := ⟨{Rc.ra, Rc.rr}, fun r => by cases r <;> decide⟩

/-- The kinds of fragment: a reading fragment for each record, the making fragment, and the turn. -/
inductive Fr
  | rd (c : Rc)
  | mk
  | tn
  deriving DecidableEq

/-- The fragments. -/
abbrev Frag : Unit → Unit → Type := fun _ _ => Fr

/-- Raw states: the side of dA, then the side of dR, then the held datum. The held datum is the side of
no listed distinction and has no record. -/
abbrev St : Type := Bool × Bool × Bool

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

/-- The making fragment's action: dR comes to read true, whatever it read; dA and the held datum are
left as they were. -/
def made : St → St := fun x => (x.1, true, x.2.2)

/-- The turn's action: the held datum is turned over; dA and dR are left as they were. -/
def turned : St → St := fun x => (x.1, x.2.1, !x.2.2)

/-- Where a fragment can run: a reading fragment runs where its distinction is held true; THE MAKING
FRAGMENT RUNS WHERE THE HELD DATUM IS UP; the turn runs everywhere. -/
def runs : Fr → St → Prop
  | .rd .ra, x => x.1 = true
  | .rd .rr, x => x.2.1 = true
  | .mk, x => x.2.2 = true
  | .tn, _ => True

/-- What a fragment does to the state: a reading fragment leaves it; the making fragment sets dR to
true; the turn turns the held datum over. -/
def act : Fr → St → St
  | .rd _, x => x
  | .mk, x => made x
  | .tn, x => turned x

def step : (g h : Unit) → Frag g h → Raw g → Raw h → Prop := fun _ _ f x y => runs f x ∧ y = act f x

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

/-- The record a fragment keeps, if any: a reading fragment keeps its record; the making fragment keeps
the record rr; THE TURN KEEPS NONE. -/
def recF : Fr → Option Rc
  | .rd c => some c
  | .mk => some Rc.rr
  | .tn => none

/-- What a word keeps: the records its fragments keep. -/
def kept (g : Unit) (w : WordFrom Frag g) : Finset Rc :=
  Finset.univ.filter (fun r => ∃ f ∈ labels w.2, recF f = some r)



theorem card_kept_le (g : Unit) (w : WordFrom Frag g) : (kept g w).card ≤ 2 :=
  le_trans (Finset.card_le_card (Finset.filter_subset _ _)) (by decide)

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

/-- Every word is within budget: there are only two records. -/
theorem in_budget (g : Unit) (w : WordFrom Frag g) : calibration g (resource g w) ≤ C g := by
  show (((kept g w).card : ℕ) : NNReal) ≤ 2
  have h := card_kept_le g w
  exact_mod_cast h

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

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



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





theorem wA_in_iff (x : St) : K () x (wd () [Fr.rd Rc.ra]) ↔ x.1 = true := by
  constructor
  · rintro ⟨⟨_, _, ⟨hr, _⟩, _⟩, _⟩
    exact hr
  · intro h
    exact ⟨⟨x, x, ⟨h, rfl⟩, rfl⟩, in_budget _ _⟩

theorem wR_in_iff (x : St) : K () x (wd () [Fr.rd Rc.rr]) ↔ x.2.1 = true := by
  constructor
  · rintro ⟨⟨_, _, ⟨hr, _⟩, _⟩, _⟩
    exact hr
  · intro h
    exact ⟨⟨x, x, ⟨h, rfl⟩, rfl⟩, in_budget _ _⟩

/-- The making word is a continuation exactly where the held datum is up. -/
theorem wM_in_iff (x : St) : K () x (wd () [Fr.mk]) ↔ x.2.2 = true := by
  constructor
  · rintro ⟨⟨_, _, ⟨hr, _⟩, _⟩, _⟩
    exact hr
  · intro h
    exact ⟨⟨made x, made x, ⟨h, rfl⟩, rfl⟩, in_budget _ _⟩



/-- 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.1 = true ↔ y.2.1 = true := by
    rw [← wR_in_iff x, ← wR_in_iff y, h]
  have h3 : x.2.2 = true ↔ y.2.2 = true := by
    rw [← wM_in_iff x, ← wM_in_iff y, h]
  exact Prod.ext (Bool.eq_iff_iff.mpr h1)
    (Prod.ext (Bool.eq_iff_iff.mpr h2) (Bool.eq_iff_iff.mpr h3))

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

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

/-- 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 a state where dA is held true and dR
false. -/
def recOf (d : Dist) : Rc := cond (d.val (true, false, 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.map Fr.rd), 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 the held datum is down, and carries dA
and dR. -/
noncomputable def alignR : APFB06.OriginalAlignment (K ())
    (APFB06.physicalDomain (K ()) (Delta ()) (hresp ())) where
  carrier := APFB01.physicalClass (K ()) (true, true, false)
  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, false)) (fun _ _ => (1 : ℝ))
      (fun _ => APFB01.physicalClass (K ()) (true, true, false)) ∧
    APFB07b.BWUniqueMinimum (Interface := Unit)
      (Configuration := fun _ => APFB01.PhysicalState (K ()))
      (fun _ s => s = APFB01.physicalClass (K ()) (true, true, false)) (fun _ _ => (1 : ℝ))



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





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





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













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







/-! ### The making word: a recorded side changes, one way only, and a record is kept of it -/

/-- The making word: the one fragment that makes dR read true. -/
def make : WordFrom Frag () := wd () [Fr.mk]

















/-! ### The turn: the held datum moves, both ways, and no record is kept -/

/-- The turn word: the one fragment that turns the held datum over. -/
def turn : WordFrom Frag () := wd () [Fr.tn]

















/-! ### What a word does to a state -/

/-- What a list of fragments does to the state, in order. -/
def runAll : List Fr → St → St
  | [], x => x
  | f :: l, x => runAll l (act f x)



/-- How a distinction reads a state. -/
abbrev reads : Dist → St → Bool := fun d x => d.val x



end APFB06.HeldDatumWorld
Source
Theorems.Thm_APFB06_held_datum_world; USB pullbacks v58 batch A, SHA-256 be245ac2880a8ceadcf1f2f956fd93958b1b398a3b4c4ee244eaf2085dfadce2. Theorems.Thm_APFB06_held_datum_world; USB pullbacks v58 batch A; SHA-256 be245ac2880a8ceadcf1f2f956fd93958b1b398a3b4c4ee244eaf2085dfadce2

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