Sync from openai/math@faee2cf485a8 (part 25)

lean/OAI/SetTheory/PartitionPrinciple/Definability/GroundTaggedComponentGraphs.lean

@@ -1,84 +1,84 @@
-import OAI.SetTheory.PartitionPrinciple.Geometry.GroundAttachmentEmbeddings
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing
-open SetFormula
-universe u
-
-noncomputable def taggedComponentGraph (P I B N : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => ∃ x ∈ ZFSet.prod {P} N, ∃ i ∈ I, ∃ n ∈ N, ∃ q ∈ B,
-    z = ZFSet.pair x i ∧ x = ZFSet.pair P n ∧ n = ZFSet.pair i q)
-    (ZFSet.prod (ZFSet.prod {P} N) I)
-
-theorem pair_mem_taggedComponentGraph (P I B N x i : ZFSet.{u}) :
-    ZFSet.pair x i ∈ taggedComponentGraph P I B N ↔
-      i ∈ I ∧ ∃ q ∈ B, ZFSet.pair i q ∈ N ∧ x = ZFSet.pair P (ZFSet.pair i q) := by
-  rw [taggedComponentGraph, ZFSet.mem_sep]
-  constructor
-  · rintro ⟨_, y, _, j, hj, n, hn, q, hq, equal, value, rfl⟩
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
-    exact ⟨hj, q, hq, hn, value⟩
-  · rintro ⟨hi, q, hq, hn, rfl⟩
-    have hx : ZFSet.pair P (ZFSet.pair i q) ∈ ZFSet.prod {P} N := ZFSet.pair_mem_prod.2 ⟨ZFSet.mem_singleton.2 rfl, hn⟩
-    exact ⟨ZFSet.pair_mem_prod.2 ⟨hx, hi⟩, _, hx, i, hi, _, hn, q, hq, rfl, rfl, rfl⟩
-
-theorem taggedComponentGraph_function {P I B N : ZFSet.{u}} (subset : N ⊆ ZFSet.prod I B) :
-    ZFSet.IsFunc (ZFSet.prod {P} N) I (taggedComponentGraph P I B N) := by
-  refine ⟨fun _ hz => (ZFSet.mem_sep.1 hz).1, ?_⟩
-  intro x hx
-  obtain ⟨p, hp, n, hn, rfl⟩ := ZFSet.mem_prod.1 hx
-  obtain rfl := ZFSet.mem_singleton.1 hp
-  obtain ⟨i, hi, q, hq, rfl⟩ := ZFSet.mem_prod.1 (subset hn)
-  refine ⟨i, (pair_mem_taggedComponentGraph _ _ _ _ _ _).2 ⟨hi, q, hq, hn, rfl⟩, ?_⟩
-  intro j hj
-  obtain ⟨_, r, _, _, equal⟩ := (pair_mem_taggedComponentGraph _ _ _ _ _ _).1 hj
-  exact ((ZFSet.pair_inj.1 ((ZFSet.pair_inj.1 equal).2)).1).symm
-
-namespace BoundedFormula
-
-def taggedComponentFormula : BoundedFormula 6 :=
-  exMem 1 (exMem 3 (exMem 5 (exMem 7
-    (.conj (orderedPairFormula 4 3 2)
-      (.conj (orderedPairFormula 3 9 1) (orderedPairFormula 1 2 0))))))
-
-theorem truth_taggedComponentFormula (env : Fin 6 → ZFSet.{u}) :
-    Truth taggedComponentFormula env ↔
-      ∃ x ∈ env 1, ∃ i ∈ env 2, ∃ n ∈ env 3, ∃ q ∈ env 4,
-        env 0 = ZFSet.pair x i ∧ x = ZFSet.pair (env 5) n ∧ n = ZFSet.pair i q := by
-  simp only [taggedComponentFormula, truth_exMem, Truth, truth_orderedPairFormula]
-  rfl
-end BoundedFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-
-theorem taggedComponentGraph_mem
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    {P I B N : ZFSet.{u}} (hP : P ∈ M.sets) (hI : I ∈ M.sets)
-    (hB : B ∈ M.sets) (hN : N ∈ M.sets) : taggedComponentGraph P I B N ∈ M.sets := by
-  have hSingle : ({P} : ZFSet.{u}) ∈ M.sets := by
-    simpa only [ZFSet.pair_eq_singleton] using M.unorderedPair_mem pairing hP hP
-  have hF := M.prod_mem pairing unions powers separation hSingle hN
-  let params := extend (ZFSet.prod {P} N) (extend I (extend N (extend B (extend P Fin.elim0))))
-  have selected := M.bounded_separation_mem separation BoundedFormula.taggedComponentFormula params
-    (Fin.cases hF (Fin.cases hI (Fin.cases hN (Fin.cases hB (Fin.cases hP (fun j => Fin.elim0 j))))))
-    (M.prod_mem pairing unions powers separation hF hI)
-  have equal : ZFSet.sep (fun z => BoundedFormula.Truth BoundedFormula.taggedComponentFormula
-      (extend z params)) (ZFSet.prod (ZFSet.prod {P} N) I) = taggedComponentGraph P I B N := by
-    apply ZFSet.ext
-    intro z
-    rw [ZFSet.mem_sep, taggedComponentGraph, ZFSet.mem_sep]
-    exact and_congr Iff.rfl (BoundedFormula.truth_taggedComponentFormula _)
-  exact equal ▸ selected
-end TransitiveGround
-
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Geometry.GroundAttachmentEmbeddings
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing
+open SetFormula
+universe u
+
+noncomputable def taggedComponentGraph (P I B N : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => ∃ x ∈ ZFSet.prod {P} N, ∃ i ∈ I, ∃ n ∈ N, ∃ q ∈ B,
+    z = ZFSet.pair x i ∧ x = ZFSet.pair P n ∧ n = ZFSet.pair i q)
+    (ZFSet.prod (ZFSet.prod {P} N) I)
+
+theorem pair_mem_taggedComponentGraph (P I B N x i : ZFSet.{u}) :
+    ZFSet.pair x i ∈ taggedComponentGraph P I B N ↔
+      i ∈ I ∧ ∃ q ∈ B, ZFSet.pair i q ∈ N ∧ x = ZFSet.pair P (ZFSet.pair i q) := by
+  rw [taggedComponentGraph, ZFSet.mem_sep]
+  constructor
+  · rintro ⟨_, y, _, j, hj, n, hn, q, hq, equal, value, rfl⟩
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
+    exact ⟨hj, q, hq, hn, value⟩
+  · rintro ⟨hi, q, hq, hn, rfl⟩
+    have hx : ZFSet.pair P (ZFSet.pair i q) ∈ ZFSet.prod {P} N := ZFSet.pair_mem_prod.2 ⟨ZFSet.mem_singleton.2 rfl, hn⟩
+    exact ⟨ZFSet.pair_mem_prod.2 ⟨hx, hi⟩, _, hx, i, hi, _, hn, q, hq, rfl, rfl, rfl⟩
+
+theorem taggedComponentGraph_function {P I B N : ZFSet.{u}} (subset : N ⊆ ZFSet.prod I B) :
+    ZFSet.IsFunc (ZFSet.prod {P} N) I (taggedComponentGraph P I B N) := by
+  refine ⟨fun _ hz => (ZFSet.mem_sep.1 hz).1, ?_⟩
+  intro x hx
+  obtain ⟨p, hp, n, hn, rfl⟩ := ZFSet.mem_prod.1 hx
+  obtain rfl := ZFSet.mem_singleton.1 hp
+  obtain ⟨i, hi, q, hq, rfl⟩ := ZFSet.mem_prod.1 (subset hn)
+  refine ⟨i, (pair_mem_taggedComponentGraph _ _ _ _ _ _).2 ⟨hi, q, hq, hn, rfl⟩, ?_⟩
+  intro j hj
+  obtain ⟨_, r, _, _, equal⟩ := (pair_mem_taggedComponentGraph _ _ _ _ _ _).1 hj
+  exact ((ZFSet.pair_inj.1 ((ZFSet.pair_inj.1 equal).2)).1).symm
+
+namespace BoundedFormula
+
+def taggedComponentFormula : BoundedFormula 6 :=
+  exMem 1 (exMem 3 (exMem 5 (exMem 7
+    (.conj (orderedPairFormula 4 3 2)
+      (.conj (orderedPairFormula 3 9 1) (orderedPairFormula 1 2 0))))))
+
+theorem truth_taggedComponentFormula (env : Fin 6 → ZFSet.{u}) :
+    Truth taggedComponentFormula env ↔
+      ∃ x ∈ env 1, ∃ i ∈ env 2, ∃ n ∈ env 3, ∃ q ∈ env 4,
+        env 0 = ZFSet.pair x i ∧ x = ZFSet.pair (env 5) n ∧ n = ZFSet.pair i q := by
+  simp only [taggedComponentFormula, truth_exMem, Truth, truth_orderedPairFormula]
+  rfl
+end BoundedFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+
+theorem taggedComponentGraph_mem
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    {P I B N : ZFSet.{u}} (hP : P ∈ M.sets) (hI : I ∈ M.sets)
+    (hB : B ∈ M.sets) (hN : N ∈ M.sets) : taggedComponentGraph P I B N ∈ M.sets := by
+  have hSingle : ({P} : ZFSet.{u}) ∈ M.sets := by
+    simpa only [ZFSet.pair_eq_singleton] using M.unorderedPair_mem pairing hP hP
+  have hF := M.prod_mem pairing unions powers separation hSingle hN
+  let params := extend (ZFSet.prod {P} N) (extend I (extend N (extend B (extend P Fin.elim0))))
+  have selected := M.bounded_separation_mem separation BoundedFormula.taggedComponentFormula params
+    (Fin.cases hF (Fin.cases hI (Fin.cases hN (Fin.cases hB (Fin.cases hP (fun j => Fin.elim0 j))))))
+    (M.prod_mem pairing unions powers separation hF hI)
+  have equal : ZFSet.sep (fun z => BoundedFormula.Truth BoundedFormula.taggedComponentFormula
+      (extend z params)) (ZFSet.prod (ZFSet.prod {P} N) I) = taggedComponentGraph P I B N := by
+    apply ZFSet.ext
+    intro z
+    rw [ZFSet.mem_sep, taggedComponentGraph, ZFSet.mem_sep]
+    exact and_congr Iff.rfl (BoundedFormula.truth_taggedComponentFormula _)
+  exact equal ▸ selected
+end TransitiveGround
+
+end PartitionPilot.Forcing
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/GroundVaryingPreparationRelations.lean

@@ -1,448 +1,448 @@
-import OAI.SetTheory.PartitionPrinciple.Forcing.GroundNicePreparationWitnessBounds
-import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundStructuralHistoryTestUnions
-
-namespace OAI
-
-
-
-namespace PartitionPilot.Forcing.TransitiveGround
-open SetFormula
-universe u
-variable (M : TransitiveGround.{u})
-
-def StoredPreparationCode (upperOrder cutGraph meet omega C E : ZFSet.{u})
-    (fields : Fin 15 → ZFSet.{u}) (p y : ZFSet.{u}) : Prop :=
-  ∃ row A r k enumerations q,
-    p = ZFSet.pair row A ∧ y = ZFSet.pair r (ZFSet.pair k enumerations) ∧
-    ZFSet.pair r p ∈ upperOrder ∧ ZFSet.pair r q ∈ cutGraph ∧
-    PreparedCertificateFamilyCode M (fields 7) (fields 8) q (fields 10) (fields 11)
-      meet (fields 14) (fields 13) (fields 9) omega (M.storedPreparationRequests A fields)
-      C E k enumerations
-
-private def transitionShape {n} (p y upperOrder cutGraph : Fin n) : BoundedFormula (n + 8) :=
-  let old := suffixIndex n 8
-  let v := prefixIndex n 8
-  .conj (BoundedFormula.orderedPairFormula (old p) (v 0) (v 1))
-    (.conj (BoundedFormula.orderedPairFormula (old y) (v 2) (v 5))
-      (.conj (BoundedFormula.orderedPairFormula (v 5) (v 3) (v 4))
-        (.conj (BoundedFormula.pairMembershipFormula (v 2) (old p) (old upperOrder))
-          (BoundedFormula.pairMembershipFormula (v 2) (v 6) (old cutGraph)))))
-
-variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-variable (unions : Realize M.sets SetFormula.union Fin.elim0)
-variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-
-private noncomputable def transitionBody {n}
-    (p y upperOrder cutGraph meet omega C E : Fin n) (fields : Fin 15 → Fin n) : SetFormula (n + 8) :=
-  let old := suffixIndex n 8
-  let v := prefixIndex n 8
-  .conj (transitionShape p y upperOrder cutGraph).toFormula
-    (.conj (SetFormula.reindex (extend (v 7) (extend (v 1) (fun j => old (fields j))))
-      (M.definable_storedPreparationRequests pairing unions powers separation).formula)
-      (preparedCertificateFamilyFormula (old (fields 7)) (old (fields 8)) (v 6)
-        (old (fields 10)) (old (fields 11)) (old meet) (old (fields 14))
-        (old (fields 13)) (old (fields 9)) (old omega) (v 7) (old C) (old E) (v 3) (v 4)))
-
-noncomputable def storedPreparationFormula {n}
-    (p y upperOrder cutGraph meet omega C E : Fin n) (fields : Fin 15 → Fin n) : SetFormula n :=
-  exBlock 8 (transitionBody M pairing unions powers separation p y upperOrder cutGraph meet omega C E fields)
-
-theorem realize_storedPreparationFormula {n}
-    (p y upperOrder cutGraph meet omega C E : Fin n) (fields : Fin 15 → Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
-    (meetCode : MeetOrderCode (env (fields 10)) (env (fields 11)) (env meet)) :
-    Realize M.sets (M.storedPreparationFormula pairing unions powers separation
-      p y upperOrder cutGraph meet omega C E fields) env ↔
-    M.StoredPreparationCode (env upperOrder) (env cutGraph) (env meet) (env omega)
-      (env C) (env E) (fun j => env (fields j)) (env p) (env y) := by
-  unfold storedPreparationFormula
-  rw [realize_exBlock]
-  have actual (w : Fin 8 → ZFSet.{u}) (ground : ∀ j, w j ∈ M.sets) :
-      Realize M.sets (transitionBody M pairing unions powers separation
-        p y upperOrder cutGraph meet omega C E fields) (extendMany 8 w env) ↔
-      (env p = ZFSet.pair (w 0) (w 1) ∧ env y = ZFSet.pair (w 2) (w 5) ∧
-        w 5 = ZFSet.pair (w 3) (w 4) ∧ ZFSet.pair (w 2) (env p) ∈ env upperOrder ∧
-        ZFSet.pair (w 2) (w 6) ∈ env cutGraph) ∧
-      w 7 = M.storedPreparationRequests (w 1) (fun j => env (fields j)) ∧
-      PreparedCertificateFamilyCode M (env (fields 7)) (env (fields 8)) (w 6)
-        (env (fields 10)) (env (fields 11)) (env meet) (env (fields 14))
-        (env (fields 13)) (env (fields 9)) (env omega) (w 7) (env C) (env E) (w 3) (w 4) := by
-    have allGround := extendMany_members 8 w env ground members
-    dsimp only [transitionBody]
-    rw [Realize, Realize, BoundedFormula.realize_toFormula M _ _ allGround]
-    have request : Realize M.sets (SetFormula.reindex
-        (extend (prefixIndex n 8 7) (extend (prefixIndex n 8 1)
-          (fun j => suffixIndex n 8 (fields j))))
-        (M.definable_storedPreparationRequests pairing unions powers separation).formula)
-        (extendMany 8 w env) ↔
-        w 7 = M.storedPreparationRequests (w 1) (fun j => env (fields j)) := by
-      rw [realize_reindex, map_extend, map_extend]
-      simp only [extendMany_prefix, extendMany_suffix]
-      exact (M.definable_storedPreparationRequests pairing unions powers separation).correct
-        (extend (w 1) (fun j => env (fields j)))
-        (Fin.cases (ground 1) (fun j => members (fields j))) (w 7) (ground 7)
-    rw [request, M.realize_preparedCertificateFamilyFormula _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
-      _ allGround (by simpa only [extendMany_suffix] using meetCode)]
-    simp only [transitionShape, BoundedFormula.Truth, BoundedFormula.truth_orderedPairFormula,
-      BoundedFormula.truth_pairMembershipFormula, extendMany_prefix, extendMany_suffix]
-  constructor
-  · rintro ⟨w, ground, body⟩
-    obtain ⟨⟨input, output, tail, below, cut⟩, requests, prepared⟩ := (actual w ground).1 body
-    exact ⟨w 0, w 1, w 2, w 3, w 4, w 6, input, tail ▸ output, below, cut, requests ▸ prepared⟩
-  · rintro ⟨row, A, r, k, enumerations, q, input, output, below, cut, prepared⟩
-    have hp := input ▸ members p
-    have hy := output ▸ members y
-    have hTail := M.pair_right hy
-    have hq := M.pair_right (M.transitive (members cutGraph) cut)
-    let J := M.storedPreparationRequests A (fun j => env (fields j))
-    have hJ := M.storedPreparationRequests_mem pairing unions powers separation (M.pair_right hp)
-      (fun j => env (fields j)) (fun j => members (fields j))
-    let w : Fin 8 → ZFSet.{u} := ![row, A, r, k, enumerations, ZFSet.pair k enumerations, q, J]
-    have ground : ∀ j, w j ∈ M.sets := Fin.cases (M.pair_left hp)
-      (Fin.cases (M.pair_right hp) (Fin.cases (M.pair_left hy)
-        (Fin.cases (M.pair_left hTail) (Fin.cases (M.pair_right hTail)
-          (Fin.cases hTail (Fin.cases hq (Fin.cases hJ (fun j => Fin.elim0 j))))))))
-    exact ⟨w, ground, (actual w ground).2 ⟨⟨input, output, rfl, below, cut⟩, rfl, prepared⟩⟩
-
-end PartitionPilot.Forcing.TransitiveGround
-
-
-
-
-namespace PartitionPilot.Forcing.TransitiveGround
-open SetFormula
-universe u
-variable (M : TransitiveGround.{u})
-
-noncomputable def storedPreparationRelation
-    (Q upperOrder nodes T levels alpha meet : ZFSet.{u}) (fields : Fin 15 → ZFSet.{u}) : ZFSet.{u} :=
-  let W := M.groundRelations T Q
-  let C := M.supportedEqualityCertificateBound nodes W
-  let E := M.synchronizedEnumerationBound nodes W
-  let cut := rowAssignmentCutGraph Q (fields 7) levels alpha
-  ZFSet.sep (fun z => ∃ p y, z = ZFSet.pair p y ∧
-    M.StoredPreparationCode upperOrder cut meet ZFSet.omega C E fields p y)
-    (ZFSet.prod Q (M.preparationWitnessBound nodes T Q))
-
-theorem pair_mem_storedPreparationRelation
-    (Q upperOrder nodes T levels alpha meet : ZFSet.{u}) (fields : Fin 15 → ZFSet.{u})
-    (p y : ZFSet.{u}) :
-    ZFSet.pair p y ∈ M.storedPreparationRelation Q upperOrder nodes T levels alpha meet fields ↔
-    p ∈ Q ∧ y ∈ M.preparationWitnessBound nodes T Q ∧
-      M.StoredPreparationCode upperOrder (rowAssignmentCutGraph Q (fields 7) levels alpha)
-        meet ZFSet.omega (M.supportedEqualityCertificateBound nodes (M.groundRelations T Q))
-        (M.synchronizedEnumerationBound nodes (M.groundRelations T Q)) fields p y := by
-  rw [storedPreparationRelation, ZFSet.mem_sep, ZFSet.pair_mem_prod]
-  constructor
-  · rintro ⟨⟨hp, hy⟩, p', y', eq, code⟩
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 eq
-    exact ⟨hp, hy, code⟩
-  · rintro ⟨hp, hy, code⟩
-    exact ⟨⟨hp, hy⟩, p, y, rfl, code⟩
-
-variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-variable (unions : Realize M.sets SetFormula.union Fin.elim0)
-variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-
-private noncomputable def preparationEntryFormula {n}
-    (z upperOrder cutGraph meet omega C E : Fin n) (fields : Fin 15 → Fin n) : SetFormula n :=
-  let old := suffixIndex n 2
-  let v := prefixIndex n 2
-  exBlock 2 (.conj (BoundedFormula.orderedPairFormula (old z) (v 0) (v 1)).toFormula
-    (M.storedPreparationFormula pairing unions powers separation
-      (v 0) (v 1) (old upperOrder) (old cutGraph) (old meet) (old omega) (old C) (old E)
-      (fun j => old (fields j))))
-
-private theorem realize_preparationEntryFormula {n}
-    (z upperOrder cutGraph meet omega C E : Fin n) (fields : Fin 15 → Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
-    (meetCode : MeetOrderCode (env (fields 10)) (env (fields 11)) (env meet)) :
-    Realize M.sets (preparationEntryFormula M pairing unions powers separation
-      z upperOrder cutGraph meet omega C E fields) env ↔
-      ∃ p y, env z = ZFSet.pair p y ∧
-        M.StoredPreparationCode (env upperOrder) (env cutGraph) (env meet) (env omega)
-          (env C) (env E) (fun j => env (fields j)) p y := by
-  unfold preparationEntryFormula
-  rw [realize_exBlock]
-  have actual (w : Fin 2 → ZFSet.{u}) (ground : ∀ j, w j ∈ M.sets) :
-      Realize M.sets (.conj
-        (BoundedFormula.orderedPairFormula (suffixIndex n 2 z)
-          (prefixIndex n 2 0) (prefixIndex n 2 1)).toFormula
-        (M.storedPreparationFormula pairing unions powers separation
-          (prefixIndex n 2 0) (prefixIndex n 2 1) (suffixIndex n 2 upperOrder)
-          (suffixIndex n 2 cutGraph) (suffixIndex n 2 meet) (suffixIndex n 2 omega)
-          (suffixIndex n 2 C) (suffixIndex n 2 E) (fun j => suffixIndex n 2 (fields j))))
-        (extendMany 2 w env) ↔
-      env z = ZFSet.pair (w 0) (w 1) ∧
-        M.StoredPreparationCode (env upperOrder) (env cutGraph) (env meet) (env omega)
-          (env C) (env E) (fun j => env (fields j)) (w 0) (w 1) := by
-    have allGround := extendMany_members 2 w env ground members
-    rw [Realize, BoundedFormula.realize_toFormula M _ _ allGround,
-      BoundedFormula.truth_orderedPairFormula,
-      M.realize_storedPreparationFormula pairing unions powers separation
-        _ _ _ _ _ _ _ _ _ _ allGround (by simpa only [extendMany_suffix] using meetCode)]
-    simp only [extendMany_prefix, extendMany_suffix]
-  constructor
-  · rintro ⟨w, ground, body⟩
-    exact ⟨w 0, w 1, (actual w ground).1 body⟩
-  · rintro ⟨p, y, equal, code⟩
-    have hp := M.pair_left (equal ▸ members z)
-    have hy := M.pair_right (equal ▸ members z)
-    exact ⟨![p, y], Fin.cases hp (Fin.cases hy (fun j => Fin.elim0 j)),
-      (actual ![p, y] (Fin.cases hp (Fin.cases hy (fun j => Fin.elim0 j)))).2 ⟨equal, code⟩⟩
-
-include pairing unions powers separation in
-theorem storedPreparationRelation_mem
-    {Q upperOrder nodes T levels alpha meet : ZFSet.{u}}
-    (hQ : Q ∈ M.sets) (hOrder : upperOrder ∈ M.sets) (hNodes : nodes ∈ M.sets)
-    (hT : T ∈ M.sets) (hLevels : levels ∈ M.sets) (hAlpha : alpha ∈ M.sets)
-    (hMeet : meet ∈ M.sets) (omega : ZFSet.omega ∈ M.sets)
-    (fields : Fin 15 → ZFSet.{u}) (members : ∀ j, fields j ∈ M.sets)
-    (meetCode : MeetOrderCode (fields 10) (fields 11) meet) :
-    M.storedPreparationRelation Q upperOrder nodes T levels alpha meet fields ∈ M.sets := by
-  let W := M.groundRelations T Q
-  let C := M.supportedEqualityCertificateBound nodes W
-  let E := M.synchronizedEnumerationBound nodes W
-  let cut := rowAssignmentCutGraph Q (fields 7) levels alpha
-  have hW := M.groundRelations_mem pairing unions powers separation hT hQ
-  have hC := M.supportedEqualityCertificateBound_mem pairing unions powers separation hNodes hW omega
-  have hE := M.synchronizedEnumerationBound_mem pairing unions powers separation hNodes hW omega
-  have hCut := M.rowAssignmentCutGraph_mem pairing unions powers separation hQ (members 7) hLevels hAlpha
-  let params : Fin 21 → ZFSet.{u} :=
-    extend upperOrder (extend cut (extend meet (extend ZFSet.omega (extend C (extend E fields)))))
-  have ground : ∀ j, params j ∈ M.sets := Fin.cases hOrder (Fin.cases hCut
-    (Fin.cases hMeet (Fin.cases omega (Fin.cases hC (Fin.cases hE members)))))
-  let slots : Fin 15 → Fin 22 := fun j => j.succ.succ.succ.succ.succ.succ.succ
-  let formula := preparationEntryFormula M pairing unions powers separation 0 1 2 3 4 5 6 slots
-  have bound := M.prod_mem pairing unions powers separation hQ
-    (M.preparationWitnessBound_mem pairing unions powers separation hNodes hT hQ omega)
-  have selected := M.separation_mem separation formula params ground bound
-  have equal : ZFSet.sep (fun z => Realize M.sets formula (extend z params))
-      (ZFSet.prod Q (M.preparationWitnessBound nodes T Q)) =
-      M.storedPreparationRelation Q upperOrder nodes T levels alpha meet fields := by
-    apply ZFSet.ext
-    intro z
-    rw [ZFSet.mem_sep, storedPreparationRelation, ZFSet.mem_sep]
-    apply and_congr_right
-    intro hz
-    exact realize_preparationEntryFormula M pairing unions powers separation 0 1 2 3 4 5 6 slots
-      (extend z params) (Fin.cases (M.transitive bound hz) ground) meetCode
-  exact equal ▸ selected
-
-end PartitionPilot.Forcing.TransitiveGround
-
-
-
-
-namespace PartitionPilot.Forcing.TransitiveGround
-open SetFormula
-universe u
-variable (M : TransitiveGround.{u})
-
-def VaryingPreparationCode (packed Q upperOrder nodes T levels omega C E z : ZFSet.{u}) : Prop :=
-  ∃ alpha p y, ∃ fields : Fin 15 → ZFSet.{u},
-    z = ZFSet.pair (ZFSet.pair alpha p) y ∧
-    ZFSet.pair alpha (refinementFormulaDataCode fields) ∈ packed ∧
-    fields 6 = T ∧ fields 10 = nodes ∧
-    MeetOrderCode (fields 10) (fields 11) (canonicalMeetGraph (fields 10) (fields 11)) ∧
-    M.StoredPreparationCode upperOrder (rowAssignmentCutGraph Q (fields 7) levels alpha)
-      (canonicalMeetGraph (fields 10) (fields 11)) omega C E fields p y
-
-theorem varyingPreparationCode_pair_iff (packed Q upperOrder nodes T levels omega C E alpha p y : ZFSet.{u}) :
-    M.VaryingPreparationCode packed Q upperOrder nodes T levels omega C E
-      (ZFSet.pair (ZFSet.pair alpha p) y) ↔
-    ∃ fields : Fin 15 → ZFSet.{u},
-      ZFSet.pair alpha (refinementFormulaDataCode fields) ∈ packed ∧
-      fields 6 = T ∧ fields 10 = nodes ∧
-      MeetOrderCode (fields 10) (fields 11) (canonicalMeetGraph (fields 10) (fields 11)) ∧
-      M.StoredPreparationCode upperOrder (rowAssignmentCutGraph Q (fields 7) levels alpha)
-        (canonicalMeetGraph (fields 10) (fields 11)) omega C E fields p y := by
-  constructor
-  · rintro ⟨alpha', p', y', fields, equal, rest⟩
-    obtain ⟨input, rfl⟩ := ZFSet.pair_inj.1 equal
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 input
-    exact ⟨fields, rest⟩
-  · rintro ⟨fields, rest⟩
-    exact ⟨alpha, p, y, fields, rfl, rest⟩
-
-private def varyingShape {n} (z packed nodes T : Fin n) : BoundedFormula (n + 22) :=
-  let old := suffixIndex n 22
-  let v := prefixIndex n 22
-  let f := fun j : Fin 15 => v j.succ.succ.succ.succ.succ.succ.succ
-  .conj (BoundedFormula.orderedPairFormula (old z) (v 3) (v 2))
-    (.conj (BoundedFormula.orderedPairFormula (v 3) (v 0) (v 1))
-      (.conj (BoundedFormula.nonemptyTupleFormula 14 (v 4) f)
-        (.conj (BoundedFormula.pairMembershipFormula (v 0) (v 4) (old packed))
-          (.conj (.equal (f 6) (old T)) (.equal (f 10) (old nodes))))))
-
-variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-variable (unions : Realize M.sets SetFormula.union Fin.elim0)
-variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-
-private noncomputable def varyingBody {n}
-    (z packed Q upperOrder nodes T levels omega C E : Fin n) : SetFormula (n + 22) :=
-  let old := suffixIndex n 22
-  let v := prefixIndex n 22
-  let f := fun j : Fin 15 => v j.succ.succ.succ.succ.succ.succ.succ
-  .conj (varyingShape z packed nodes T).toFormula
-    (.conj (BoundedFormula.meetOrderFormula (f 10) (f 11) (v 5)).toFormula
-      (.conj (rowAssignmentCutGraphFormula (v 6) (old Q) (f 7) (old levels) (v 0))
-        (M.storedPreparationFormula pairing unions powers separation
-          (v 1) (v 2) (old upperOrder) (v 6) (v 5) (old omega) (old C) (old E) f)))
-
-noncomputable def varyingPreparationFormula {n}
-    (z packed Q upperOrder nodes T levels omega C E : Fin n) : SetFormula n :=
-  exBlock 22 (varyingBody M pairing unions powers separation z packed Q upperOrder nodes T levels omega C E)
-
-theorem realize_varyingPreparationFormula {n}
-    (z packed Q upperOrder nodes T levels omega C E : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets) :
-    Realize M.sets (M.varyingPreparationFormula pairing unions powers separation
-      z packed Q upperOrder nodes T levels omega C E) env ↔
-    M.VaryingPreparationCode (env packed) (env Q) (env upperOrder) (env nodes) (env T)
-      (env levels) (env omega) (env C) (env E) (env z) := by
-  unfold varyingPreparationFormula
-  rw [realize_exBlock]
-  let fs := fun w : Fin 22 → ZFSet.{u} => fun j : Fin 15 =>
-    w j.succ.succ.succ.succ.succ.succ.succ
-  have actual (w : Fin 22 → ZFSet.{u}) (ground : ∀ j, w j ∈ M.sets) :
-      Realize M.sets (varyingBody M pairing unions powers separation
-        z packed Q upperOrder nodes T levels omega C E) (extendMany 22 w env) ↔
-      (env z = ZFSet.pair (w 3) (w 2) ∧ w 3 = ZFSet.pair (w 0) (w 1) ∧
-        w 4 = refinementFormulaDataCode (fs w) ∧ ZFSet.pair (w 0) (w 4) ∈ env packed ∧
-        fs w 6 = env T ∧ fs w 10 = env nodes) ∧
-      MeetOrderCode (fs w 10) (fs w 11) (w 5) ∧
-      w 6 = rowAssignmentCutGraph (env Q) (fs w 7) (env levels) (w 0) ∧
-      M.StoredPreparationCode (env upperOrder) (w 6) (w 5) (env omega)
-        (env C) (env E) (fs w) (w 1) (w 2) := by
-    have allGround := extendMany_members 22 w env ground members
-    dsimp only [varyingBody]
-    rw [Realize, Realize, Realize,
-      BoundedFormula.realize_toFormula M _ _ allGround,
-      BoundedFormula.realize_toFormula M _ _ allGround,
-      BoundedFormula.truth_meetOrderFormula,
-      M.realize_rowAssignmentCutGraphFormula pairing unions powers separation _ _ _ _ _ _ allGround]
-    simp only [varyingShape, BoundedFormula.Truth, BoundedFormula.truth_orderedPairFormula,
-      BoundedFormula.truth_nonemptyTupleFormula, BoundedFormula.truth_pairMembershipFormula,
-      extendMany_prefix, extendMany_suffix]
-    apply and_congr_right
-    intro _shape
-    apply and_congr_right
-    intro meet
-    apply and_congr_right
-    intro _cut
-    simpa only [extendMany_prefix, extendMany_suffix] using
-      (M.realize_storedPreparationFormula pairing unions powers separation
-        (prefixIndex n 22 1) (prefixIndex n 22 2) (suffixIndex n 22 upperOrder)
-        (prefixIndex n 22 6) (prefixIndex n 22 5) (suffixIndex n 22 omega)
-        (suffixIndex n 22 C) (suffixIndex n 22 E)
-        (fun j : Fin 15 => prefixIndex n 22 j.succ.succ.succ.succ.succ.succ.succ)
-        (extendMany 22 w env) allGround (by simpa only [extendMany_prefix] using meet))
-  constructor
-  · rintro ⟨w, ground, body⟩
-    obtain ⟨⟨outer, input, tuple, stored, terms, nodesEq⟩, meet, cut, prepared⟩ :=
-      (actual w ground).1 body
-    have canonical := meet.eq_canonicalMeetGraph
-    refine ⟨w 0, w 1, w 2, fs w, input ▸ outer, tuple ▸ stored, terms, nodesEq,
-      canonical ▸ meet, ?_⟩
-    rw [canonical, cut] at prepared
-    exact prepared
-  · rintro ⟨alpha, p, y, fields, outer, stored, terms, nodesEq, meet, prepared⟩
-    have hInput := M.pair_left (outer ▸ members z)
-    have hAlpha := M.pair_left hInput
-    have hp := M.pair_right hInput
-    have hy := M.pair_right (outer ▸ members z)
-    have hRecord := M.pair_right (M.transitive (members packed) stored)
-    have hFields := M.refinementFormulaDataCode_fields_mem fields hRecord
-    let mu := canonicalMeetGraph (fields 10) (fields 11)
-    let cut := rowAssignmentCutGraph (env Q) (fields 7) (env levels) alpha
-    have hMu := M.canonicalMeetGraph_mem pairing unions powers separation (hFields 10) (hFields 11)
-    have hCut := M.rowAssignmentCutGraph_mem pairing unions powers separation
-      (members Q) (hFields 7) (members levels) hAlpha
-    let w : Fin 22 → ZFSet.{u} := extend alpha (extend p (extend y
-      (extend (ZFSet.pair alpha p) (extend (refinementFormulaDataCode fields)
-        (extend mu (extend cut fields))))))
-    have ground : ∀ j, w j ∈ M.sets := Fin.cases hAlpha (Fin.cases hp (Fin.cases hy
-      (Fin.cases hInput (Fin.cases hRecord (Fin.cases hMu (Fin.cases hCut hFields))))))
-    exact ⟨w, ground, (actual w ground).2
-      ⟨⟨outer, rfl, rfl, stored, terms, nodesEq⟩, meet, rfl, prepared⟩⟩
-
-end PartitionPilot.Forcing.TransitiveGround
-
-
-
-
-namespace PartitionPilot.Forcing.TransitiveGround
-open SetFormula
-universe u
-variable (M : TransitiveGround.{u})
-
-noncomputable def varyingPreparationRelation
-    (stages packed Q upperOrder nodes T : ZFSet.{u}) : ZFSet.{u} :=
-  let W := M.groundRelations T Q
-  let C := M.supportedEqualityCertificateBound nodes W
-  let E := M.synchronizedEnumerationBound nodes W
-  let levels := refinementDataHistoryLevels stages packed T
-  ZFSet.sep (M.VaryingPreparationCode packed Q upperOrder nodes T levels ZFSet.omega C E)
-    (ZFSet.prod (ZFSet.prod stages Q) (M.preparationWitnessBound nodes T Q))
-
-theorem pair_mem_varyingPreparationRelation
-    (stages packed Q upperOrder nodes T alpha p y : ZFSet.{u}) :
-    ZFSet.pair (ZFSet.pair alpha p) y ∈
-      M.varyingPreparationRelation stages packed Q upperOrder nodes T ↔
-    alpha ∈ stages ∧ p ∈ Q ∧ y ∈ M.preparationWitnessBound nodes T Q ∧
-      ∃ fields : Fin 15 → ZFSet.{u},
-        ZFSet.pair alpha (refinementFormulaDataCode fields) ∈ packed ∧
-        fields 6 = T ∧ fields 10 = nodes ∧
-        MeetOrderCode (fields 10) (fields 11) (canonicalMeetGraph (fields 10) (fields 11)) ∧
-        M.StoredPreparationCode upperOrder
-          (rowAssignmentCutGraph Q (fields 7) (refinementDataHistoryLevels stages packed T) alpha)
-          (canonicalMeetGraph (fields 10) (fields 11)) ZFSet.omega
-          (M.supportedEqualityCertificateBound nodes (M.groundRelations T Q))
-          (M.synchronizedEnumerationBound nodes (M.groundRelations T Q)) fields p y := by
-  simp only [varyingPreparationRelation, ZFSet.mem_sep, ZFSet.pair_mem_prod,
-    M.varyingPreparationCode_pair_iff, and_assoc]
-
-include M in
- theorem varyingPreparationRelation_mem
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    {stages packed Q upperOrder nodes T : ZFSet.{u}}
-    (hStages : stages ∈ M.sets) (hPacked : packed ∈ M.sets)
-    (hQ : Q ∈ M.sets) (hOrder : upperOrder ∈ M.sets)
-    (hNodes : nodes ∈ M.sets) (hT : T ∈ M.sets) (omega : ZFSet.omega ∈ M.sets) :
-    M.varyingPreparationRelation stages packed Q upperOrder nodes T ∈ M.sets := by
-  let W := M.groundRelations T Q
-  let C := M.supportedEqualityCertificateBound nodes W
-  let E := M.synchronizedEnumerationBound nodes W
-  let levels := refinementDataHistoryLevels stages packed T
-  have hW := M.groundRelations_mem pairing unions powers separation hT hQ
-  have hC := M.supportedEqualityCertificateBound_mem pairing unions powers separation hNodes hW omega
-  have hE := M.synchronizedEnumerationBound_mem pairing unions powers separation hNodes hW omega
-  have hLevels := M.refinementDataHistoryLevels_mem pairing unions powers separation hStages hPacked hT
-  let params : Fin 9 → ZFSet.{u} := ![packed, Q, upperOrder, nodes, T, levels, ZFSet.omega, C, E]
-  have ground : ∀ j, params j ∈ M.sets := Fin.cases hPacked (Fin.cases hQ
-    (Fin.cases hOrder (Fin.cases hNodes (Fin.cases hT (Fin.cases hLevels
-      (Fin.cases omega (Fin.cases hC (Fin.cases hE (fun j => Fin.elim0 j)))))))))
-  let formula : SetFormula 10 :=
-    M.varyingPreparationFormula pairing unions powers separation 0 1 2 3 4 5 6 7 8 9
-  have bound := M.prod_mem pairing unions powers separation
-    (M.prod_mem pairing unions powers separation hStages hQ)
-    (M.preparationWitnessBound_mem pairing unions powers separation hNodes hT hQ omega)
-  have selected := M.separation_mem separation formula params ground bound
-  have equal : ZFSet.sep (fun z => Realize M.sets formula (extend z params))
-      (ZFSet.prod (ZFSet.prod stages Q) (M.preparationWitnessBound nodes T Q)) =
-      M.varyingPreparationRelation stages packed Q upperOrder nodes T := by
-    apply ZFSet.ext
-    intro z
-    rw [ZFSet.mem_sep, varyingPreparationRelation, ZFSet.mem_sep]
-    apply and_congr_right
-    intro hz
-    exact M.realize_varyingPreparationFormula pairing unions powers separation
-      0 1 2 3 4 5 6 7 8 9 (extend z params) (Fin.cases (M.transitive bound hz) ground)
-  exact equal ▸ selected
-
-end PartitionPilot.Forcing.TransitiveGround
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Forcing.GroundNicePreparationWitnessBounds
+import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundStructuralHistoryTestUnions
+
+namespace OAI
+
+
+
+namespace PartitionPilot.Forcing.TransitiveGround
+open SetFormula
+universe u
+variable (M : TransitiveGround.{u})
+
+def StoredPreparationCode (upperOrder cutGraph meet omega C E : ZFSet.{u})
+    (fields : Fin 15 → ZFSet.{u}) (p y : ZFSet.{u}) : Prop :=
+  ∃ row A r k enumerations q,
+    p = ZFSet.pair row A ∧ y = ZFSet.pair r (ZFSet.pair k enumerations) ∧
+    ZFSet.pair r p ∈ upperOrder ∧ ZFSet.pair r q ∈ cutGraph ∧
+    PreparedCertificateFamilyCode M (fields 7) (fields 8) q (fields 10) (fields 11)
+      meet (fields 14) (fields 13) (fields 9) omega (M.storedPreparationRequests A fields)
+      C E k enumerations
+
+private def transitionShape {n} (p y upperOrder cutGraph : Fin n) : BoundedFormula (n + 8) :=
+  let old := suffixIndex n 8
+  let v := prefixIndex n 8
+  .conj (BoundedFormula.orderedPairFormula (old p) (v 0) (v 1))
+    (.conj (BoundedFormula.orderedPairFormula (old y) (v 2) (v 5))
+      (.conj (BoundedFormula.orderedPairFormula (v 5) (v 3) (v 4))
+        (.conj (BoundedFormula.pairMembershipFormula (v 2) (old p) (old upperOrder))
+          (BoundedFormula.pairMembershipFormula (v 2) (v 6) (old cutGraph)))))
+
+variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+variable (unions : Realize M.sets SetFormula.union Fin.elim0)
+variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+
+private noncomputable def transitionBody {n}
+    (p y upperOrder cutGraph meet omega C E : Fin n) (fields : Fin 15 → Fin n) : SetFormula (n + 8) :=
+  let old := suffixIndex n 8
+  let v := prefixIndex n 8
+  .conj (transitionShape p y upperOrder cutGraph).toFormula
+    (.conj (SetFormula.reindex (extend (v 7) (extend (v 1) (fun j => old (fields j))))
+      (M.definable_storedPreparationRequests pairing unions powers separation).formula)
+      (preparedCertificateFamilyFormula (old (fields 7)) (old (fields 8)) (v 6)
+        (old (fields 10)) (old (fields 11)) (old meet) (old (fields 14))
+        (old (fields 13)) (old (fields 9)) (old omega) (v 7) (old C) (old E) (v 3) (v 4)))
+
+noncomputable def storedPreparationFormula {n}
+    (p y upperOrder cutGraph meet omega C E : Fin n) (fields : Fin 15 → Fin n) : SetFormula n :=
+  exBlock 8 (transitionBody M pairing unions powers separation p y upperOrder cutGraph meet omega C E fields)
+
+theorem realize_storedPreparationFormula {n}
+    (p y upperOrder cutGraph meet omega C E : Fin n) (fields : Fin 15 → Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
+    (meetCode : MeetOrderCode (env (fields 10)) (env (fields 11)) (env meet)) :
+    Realize M.sets (M.storedPreparationFormula pairing unions powers separation
+      p y upperOrder cutGraph meet omega C E fields) env ↔
+    M.StoredPreparationCode (env upperOrder) (env cutGraph) (env meet) (env omega)
+      (env C) (env E) (fun j => env (fields j)) (env p) (env y) := by
+  unfold storedPreparationFormula
+  rw [realize_exBlock]
+  have actual (w : Fin 8 → ZFSet.{u}) (ground : ∀ j, w j ∈ M.sets) :
+      Realize M.sets (transitionBody M pairing unions powers separation
+        p y upperOrder cutGraph meet omega C E fields) (extendMany 8 w env) ↔
+      (env p = ZFSet.pair (w 0) (w 1) ∧ env y = ZFSet.pair (w 2) (w 5) ∧
+        w 5 = ZFSet.pair (w 3) (w 4) ∧ ZFSet.pair (w 2) (env p) ∈ env upperOrder ∧
+        ZFSet.pair (w 2) (w 6) ∈ env cutGraph) ∧
+      w 7 = M.storedPreparationRequests (w 1) (fun j => env (fields j)) ∧
+      PreparedCertificateFamilyCode M (env (fields 7)) (env (fields 8)) (w 6)
+        (env (fields 10)) (env (fields 11)) (env meet) (env (fields 14))
+        (env (fields 13)) (env (fields 9)) (env omega) (w 7) (env C) (env E) (w 3) (w 4) := by
+    have allGround := extendMany_members 8 w env ground members
+    dsimp only [transitionBody]
+    rw [Realize, Realize, BoundedFormula.realize_toFormula M _ _ allGround]
+    have request : Realize M.sets (SetFormula.reindex
+        (extend (prefixIndex n 8 7) (extend (prefixIndex n 8 1)
+          (fun j => suffixIndex n 8 (fields j))))
+        (M.definable_storedPreparationRequests pairing unions powers separation).formula)
+        (extendMany 8 w env) ↔
+        w 7 = M.storedPreparationRequests (w 1) (fun j => env (fields j)) := by
+      rw [realize_reindex, map_extend, map_extend]
+      simp only [extendMany_prefix, extendMany_suffix]
+      exact (M.definable_storedPreparationRequests pairing unions powers separation).correct
+        (extend (w 1) (fun j => env (fields j)))
+        (Fin.cases (ground 1) (fun j => members (fields j))) (w 7) (ground 7)
+    rw [request, M.realize_preparedCertificateFamilyFormula _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+      _ allGround (by simpa only [extendMany_suffix] using meetCode)]
+    simp only [transitionShape, BoundedFormula.Truth, BoundedFormula.truth_orderedPairFormula,
+      BoundedFormula.truth_pairMembershipFormula, extendMany_prefix, extendMany_suffix]
+  constructor
+  · rintro ⟨w, ground, body⟩
+    obtain ⟨⟨input, output, tail, below, cut⟩, requests, prepared⟩ := (actual w ground).1 body
+    exact ⟨w 0, w 1, w 2, w 3, w 4, w 6, input, tail ▸ output, below, cut, requests ▸ prepared⟩
+  · rintro ⟨row, A, r, k, enumerations, q, input, output, below, cut, prepared⟩
+    have hp := input ▸ members p
+    have hy := output ▸ members y
+    have hTail := M.pair_right hy
+    have hq := M.pair_right (M.transitive (members cutGraph) cut)
+    let J := M.storedPreparationRequests A (fun j => env (fields j))
+    have hJ := M.storedPreparationRequests_mem pairing unions powers separation (M.pair_right hp)
+      (fun j => env (fields j)) (fun j => members (fields j))
+    let w : Fin 8 → ZFSet.{u} := ![row, A, r, k, enumerations, ZFSet.pair k enumerations, q, J]
+    have ground : ∀ j, w j ∈ M.sets := Fin.cases (M.pair_left hp)
+      (Fin.cases (M.pair_right hp) (Fin.cases (M.pair_left hy)
+        (Fin.cases (M.pair_left hTail) (Fin.cases (M.pair_right hTail)
+          (Fin.cases hTail (Fin.cases hq (Fin.cases hJ (fun j => Fin.elim0 j))))))))
+    exact ⟨w, ground, (actual w ground).2 ⟨⟨input, output, rfl, below, cut⟩, rfl, prepared⟩⟩
+
+end PartitionPilot.Forcing.TransitiveGround
+
+
+
+
+namespace PartitionPilot.Forcing.TransitiveGround
+open SetFormula
+universe u
+variable (M : TransitiveGround.{u})
+
+noncomputable def storedPreparationRelation
+    (Q upperOrder nodes T levels alpha meet : ZFSet.{u}) (fields : Fin 15 → ZFSet.{u}) : ZFSet.{u} :=
+  let W := M.groundRelations T Q
+  let C := M.supportedEqualityCertificateBound nodes W
+  let E := M.synchronizedEnumerationBound nodes W
+  let cut := rowAssignmentCutGraph Q (fields 7) levels alpha
+  ZFSet.sep (fun z => ∃ p y, z = ZFSet.pair p y ∧
+    M.StoredPreparationCode upperOrder cut meet ZFSet.omega C E fields p y)
+    (ZFSet.prod Q (M.preparationWitnessBound nodes T Q))
+
+theorem pair_mem_storedPreparationRelation
+    (Q upperOrder nodes T levels alpha meet : ZFSet.{u}) (fields : Fin 15 → ZFSet.{u})
+    (p y : ZFSet.{u}) :
+    ZFSet.pair p y ∈ M.storedPreparationRelation Q upperOrder nodes T levels alpha meet fields ↔
+    p ∈ Q ∧ y ∈ M.preparationWitnessBound nodes T Q ∧
+      M.StoredPreparationCode upperOrder (rowAssignmentCutGraph Q (fields 7) levels alpha)
+        meet ZFSet.omega (M.supportedEqualityCertificateBound nodes (M.groundRelations T Q))
+        (M.synchronizedEnumerationBound nodes (M.groundRelations T Q)) fields p y := by
+  rw [storedPreparationRelation, ZFSet.mem_sep, ZFSet.pair_mem_prod]
+  constructor
+  · rintro ⟨⟨hp, hy⟩, p', y', eq, code⟩
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 eq
+    exact ⟨hp, hy, code⟩
+  · rintro ⟨hp, hy, code⟩
+    exact ⟨⟨hp, hy⟩, p, y, rfl, code⟩
+
+variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+variable (unions : Realize M.sets SetFormula.union Fin.elim0)
+variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+
+private noncomputable def preparationEntryFormula {n}
+    (z upperOrder cutGraph meet omega C E : Fin n) (fields : Fin 15 → Fin n) : SetFormula n :=
+  let old := suffixIndex n 2
+  let v := prefixIndex n 2
+  exBlock 2 (.conj (BoundedFormula.orderedPairFormula (old z) (v 0) (v 1)).toFormula
+    (M.storedPreparationFormula pairing unions powers separation
+      (v 0) (v 1) (old upperOrder) (old cutGraph) (old meet) (old omega) (old C) (old E)
+      (fun j => old (fields j))))
+
+private theorem realize_preparationEntryFormula {n}
+    (z upperOrder cutGraph meet omega C E : Fin n) (fields : Fin 15 → Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
+    (meetCode : MeetOrderCode (env (fields 10)) (env (fields 11)) (env meet)) :
+    Realize M.sets (preparationEntryFormula M pairing unions powers separation
+      z upperOrder cutGraph meet omega C E fields) env ↔
+      ∃ p y, env z = ZFSet.pair p y ∧
+        M.StoredPreparationCode (env upperOrder) (env cutGraph) (env meet) (env omega)
+          (env C) (env E) (fun j => env (fields j)) p y := by
+  unfold preparationEntryFormula
+  rw [realize_exBlock]
+  have actual (w : Fin 2 → ZFSet.{u}) (ground : ∀ j, w j ∈ M.sets) :
+      Realize M.sets (.conj
+        (BoundedFormula.orderedPairFormula (suffixIndex n 2 z)
+          (prefixIndex n 2 0) (prefixIndex n 2 1)).toFormula
+        (M.storedPreparationFormula pairing unions powers separation
+          (prefixIndex n 2 0) (prefixIndex n 2 1) (suffixIndex n 2 upperOrder)
+          (suffixIndex n 2 cutGraph) (suffixIndex n 2 meet) (suffixIndex n 2 omega)
+          (suffixIndex n 2 C) (suffixIndex n 2 E) (fun j => suffixIndex n 2 (fields j))))
+        (extendMany 2 w env) ↔
+      env z = ZFSet.pair (w 0) (w 1) ∧
+        M.StoredPreparationCode (env upperOrder) (env cutGraph) (env meet) (env omega)
+          (env C) (env E) (fun j => env (fields j)) (w 0) (w 1) := by
+    have allGround := extendMany_members 2 w env ground members
+    rw [Realize, BoundedFormula.realize_toFormula M _ _ allGround,
+      BoundedFormula.truth_orderedPairFormula,
+      M.realize_storedPreparationFormula pairing unions powers separation
+        _ _ _ _ _ _ _ _ _ _ allGround (by simpa only [extendMany_suffix] using meetCode)]
+    simp only [extendMany_prefix, extendMany_suffix]
+  constructor
+  · rintro ⟨w, ground, body⟩
+    exact ⟨w 0, w 1, (actual w ground).1 body⟩
+  · rintro ⟨p, y, equal, code⟩
+    have hp := M.pair_left (equal ▸ members z)
+    have hy := M.pair_right (equal ▸ members z)
+    exact ⟨![p, y], Fin.cases hp (Fin.cases hy (fun j => Fin.elim0 j)),
+      (actual ![p, y] (Fin.cases hp (Fin.cases hy (fun j => Fin.elim0 j)))).2 ⟨equal, code⟩⟩
+
+include pairing unions powers separation in
+theorem storedPreparationRelation_mem
+    {Q upperOrder nodes T levels alpha meet : ZFSet.{u}}
+    (hQ : Q ∈ M.sets) (hOrder : upperOrder ∈ M.sets) (hNodes : nodes ∈ M.sets)
+    (hT : T ∈ M.sets) (hLevels : levels ∈ M.sets) (hAlpha : alpha ∈ M.sets)
+    (hMeet : meet ∈ M.sets) (omega : ZFSet.omega ∈ M.sets)
+    (fields : Fin 15 → ZFSet.{u}) (members : ∀ j, fields j ∈ M.sets)
+    (meetCode : MeetOrderCode (fields 10) (fields 11) meet) :
+    M.storedPreparationRelation Q upperOrder nodes T levels alpha meet fields ∈ M.sets := by
+  let W := M.groundRelations T Q
+  let C := M.supportedEqualityCertificateBound nodes W
+  let E := M.synchronizedEnumerationBound nodes W
+  let cut := rowAssignmentCutGraph Q (fields 7) levels alpha
+  have hW := M.groundRelations_mem pairing unions powers separation hT hQ
+  have hC := M.supportedEqualityCertificateBound_mem pairing unions powers separation hNodes hW omega
+  have hE := M.synchronizedEnumerationBound_mem pairing unions powers separation hNodes hW omega
+  have hCut := M.rowAssignmentCutGraph_mem pairing unions powers separation hQ (members 7) hLevels hAlpha
+  let params : Fin 21 → ZFSet.{u} :=
+    extend upperOrder (extend cut (extend meet (extend ZFSet.omega (extend C (extend E fields)))))
+  have ground : ∀ j, params j ∈ M.sets := Fin.cases hOrder (Fin.cases hCut
+    (Fin.cases hMeet (Fin.cases omega (Fin.cases hC (Fin.cases hE members)))))
+  let slots : Fin 15 → Fin 22 := fun j => j.succ.succ.succ.succ.succ.succ.succ
+  let formula := preparationEntryFormula M pairing unions powers separation 0 1 2 3 4 5 6 slots
+  have bound := M.prod_mem pairing unions powers separation hQ
+    (M.preparationWitnessBound_mem pairing unions powers separation hNodes hT hQ omega)
+  have selected := M.separation_mem separation formula params ground bound
+  have equal : ZFSet.sep (fun z => Realize M.sets formula (extend z params))
+      (ZFSet.prod Q (M.preparationWitnessBound nodes T Q)) =
+      M.storedPreparationRelation Q upperOrder nodes T levels alpha meet fields := by
+    apply ZFSet.ext
+    intro z
+    rw [ZFSet.mem_sep, storedPreparationRelation, ZFSet.mem_sep]
+    apply and_congr_right
+    intro hz
+    exact realize_preparationEntryFormula M pairing unions powers separation 0 1 2 3 4 5 6 slots
+      (extend z params) (Fin.cases (M.transitive bound hz) ground) meetCode
+  exact equal ▸ selected
+
+end PartitionPilot.Forcing.TransitiveGround
+
+
+
+
+namespace PartitionPilot.Forcing.TransitiveGround
+open SetFormula
+universe u
+variable (M : TransitiveGround.{u})
+
+def VaryingPreparationCode (packed Q upperOrder nodes T levels omega C E z : ZFSet.{u}) : Prop :=
+  ∃ alpha p y, ∃ fields : Fin 15 → ZFSet.{u},
+    z = ZFSet.pair (ZFSet.pair alpha p) y ∧
+    ZFSet.pair alpha (refinementFormulaDataCode fields) ∈ packed ∧
+    fields 6 = T ∧ fields 10 = nodes ∧
+    MeetOrderCode (fields 10) (fields 11) (canonicalMeetGraph (fields 10) (fields 11)) ∧
+    M.StoredPreparationCode upperOrder (rowAssignmentCutGraph Q (fields 7) levels alpha)
+      (canonicalMeetGraph (fields 10) (fields 11)) omega C E fields p y
+
+theorem varyingPreparationCode_pair_iff (packed Q upperOrder nodes T levels omega C E alpha p y : ZFSet.{u}) :
+    M.VaryingPreparationCode packed Q upperOrder nodes T levels omega C E
+      (ZFSet.pair (ZFSet.pair alpha p) y) ↔
+    ∃ fields : Fin 15 → ZFSet.{u},
+      ZFSet.pair alpha (refinementFormulaDataCode fields) ∈ packed ∧
+      fields 6 = T ∧ fields 10 = nodes ∧
+      MeetOrderCode (fields 10) (fields 11) (canonicalMeetGraph (fields 10) (fields 11)) ∧
+      M.StoredPreparationCode upperOrder (rowAssignmentCutGraph Q (fields 7) levels alpha)
+        (canonicalMeetGraph (fields 10) (fields 11)) omega C E fields p y := by
+  constructor
+  · rintro ⟨alpha', p', y', fields, equal, rest⟩
+    obtain ⟨input, rfl⟩ := ZFSet.pair_inj.1 equal
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 input
+    exact ⟨fields, rest⟩
+  · rintro ⟨fields, rest⟩
+    exact ⟨alpha, p, y, fields, rfl, rest⟩
+
+private def varyingShape {n} (z packed nodes T : Fin n) : BoundedFormula (n + 22) :=
+  let old := suffixIndex n 22
+  let v := prefixIndex n 22
+  let f := fun j : Fin 15 => v j.succ.succ.succ.succ.succ.succ.succ
+  .conj (BoundedFormula.orderedPairFormula (old z) (v 3) (v 2))
+    (.conj (BoundedFormula.orderedPairFormula (v 3) (v 0) (v 1))
+      (.conj (BoundedFormula.nonemptyTupleFormula 14 (v 4) f)
+        (.conj (BoundedFormula.pairMembershipFormula (v 0) (v 4) (old packed))
+          (.conj (.equal (f 6) (old T)) (.equal (f 10) (old nodes))))))
+
+variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+variable (unions : Realize M.sets SetFormula.union Fin.elim0)
+variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+
+private noncomputable def varyingBody {n}
+    (z packed Q upperOrder nodes T levels omega C E : Fin n) : SetFormula (n + 22) :=
+  let old := suffixIndex n 22
+  let v := prefixIndex n 22
+  let f := fun j : Fin 15 => v j.succ.succ.succ.succ.succ.succ.succ
+  .conj (varyingShape z packed nodes T).toFormula
+    (.conj (BoundedFormula.meetOrderFormula (f 10) (f 11) (v 5)).toFormula
+      (.conj (rowAssignmentCutGraphFormula (v 6) (old Q) (f 7) (old levels) (v 0))
+        (M.storedPreparationFormula pairing unions powers separation
+          (v 1) (v 2) (old upperOrder) (v 6) (v 5) (old omega) (old C) (old E) f)))
+
+noncomputable def varyingPreparationFormula {n}
+    (z packed Q upperOrder nodes T levels omega C E : Fin n) : SetFormula n :=
+  exBlock 22 (varyingBody M pairing unions powers separation z packed Q upperOrder nodes T levels omega C E)
+
+theorem realize_varyingPreparationFormula {n}
+    (z packed Q upperOrder nodes T levels omega C E : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets) :
+    Realize M.sets (M.varyingPreparationFormula pairing unions powers separation
+      z packed Q upperOrder nodes T levels omega C E) env ↔
+    M.VaryingPreparationCode (env packed) (env Q) (env upperOrder) (env nodes) (env T)
+      (env levels) (env omega) (env C) (env E) (env z) := by
+  unfold varyingPreparationFormula
+  rw [realize_exBlock]
+  let fs := fun w : Fin 22 → ZFSet.{u} => fun j : Fin 15 =>
+    w j.succ.succ.succ.succ.succ.succ.succ
+  have actual (w : Fin 22 → ZFSet.{u}) (ground : ∀ j, w j ∈ M.sets) :
+      Realize M.sets (varyingBody M pairing unions powers separation
+        z packed Q upperOrder nodes T levels omega C E) (extendMany 22 w env) ↔
+      (env z = ZFSet.pair (w 3) (w 2) ∧ w 3 = ZFSet.pair (w 0) (w 1) ∧
+        w 4 = refinementFormulaDataCode (fs w) ∧ ZFSet.pair (w 0) (w 4) ∈ env packed ∧
+        fs w 6 = env T ∧ fs w 10 = env nodes) ∧
+      MeetOrderCode (fs w 10) (fs w 11) (w 5) ∧
+      w 6 = rowAssignmentCutGraph (env Q) (fs w 7) (env levels) (w 0) ∧
+      M.StoredPreparationCode (env upperOrder) (w 6) (w 5) (env omega)
+        (env C) (env E) (fs w) (w 1) (w 2) := by
+    have allGround := extendMany_members 22 w env ground members
+    dsimp only [varyingBody]
+    rw [Realize, Realize, Realize,
+      BoundedFormula.realize_toFormula M _ _ allGround,
+      BoundedFormula.realize_toFormula M _ _ allGround,
+      BoundedFormula.truth_meetOrderFormula,
+      M.realize_rowAssignmentCutGraphFormula pairing unions powers separation _ _ _ _ _ _ allGround]
+    simp only [varyingShape, BoundedFormula.Truth, BoundedFormula.truth_orderedPairFormula,
+      BoundedFormula.truth_nonemptyTupleFormula, BoundedFormula.truth_pairMembershipFormula,
+      extendMany_prefix, extendMany_suffix]
+    apply and_congr_right
+    intro _shape
+    apply and_congr_right
+    intro meet
+    apply and_congr_right
+    intro _cut
+    simpa only [extendMany_prefix, extendMany_suffix] using
+      (M.realize_storedPreparationFormula pairing unions powers separation
+        (prefixIndex n 22 1) (prefixIndex n 22 2) (suffixIndex n 22 upperOrder)
+        (prefixIndex n 22 6) (prefixIndex n 22 5) (suffixIndex n 22 omega)
+        (suffixIndex n 22 C) (suffixIndex n 22 E)
+        (fun j : Fin 15 => prefixIndex n 22 j.succ.succ.succ.succ.succ.succ.succ)
+        (extendMany 22 w env) allGround (by simpa only [extendMany_prefix] using meet))
+  constructor
+  · rintro ⟨w, ground, body⟩
+    obtain ⟨⟨outer, input, tuple, stored, terms, nodesEq⟩, meet, cut, prepared⟩ :=
+      (actual w ground).1 body
+    have canonical := meet.eq_canonicalMeetGraph
+    refine ⟨w 0, w 1, w 2, fs w, input ▸ outer, tuple ▸ stored, terms, nodesEq,
+      canonical ▸ meet, ?_⟩
+    rw [canonical, cut] at prepared
+    exact prepared
+  · rintro ⟨alpha, p, y, fields, outer, stored, terms, nodesEq, meet, prepared⟩
+    have hInput := M.pair_left (outer ▸ members z)
+    have hAlpha := M.pair_left hInput
+    have hp := M.pair_right hInput
+    have hy := M.pair_right (outer ▸ members z)
+    have hRecord := M.pair_right (M.transitive (members packed) stored)
+    have hFields := M.refinementFormulaDataCode_fields_mem fields hRecord
+    let mu := canonicalMeetGraph (fields 10) (fields 11)
+    let cut := rowAssignmentCutGraph (env Q) (fields 7) (env levels) alpha
+    have hMu := M.canonicalMeetGraph_mem pairing unions powers separation (hFields 10) (hFields 11)
+    have hCut := M.rowAssignmentCutGraph_mem pairing unions powers separation
+      (members Q) (hFields 7) (members levels) hAlpha
+    let w : Fin 22 → ZFSet.{u} := extend alpha (extend p (extend y
+      (extend (ZFSet.pair alpha p) (extend (refinementFormulaDataCode fields)
+        (extend mu (extend cut fields))))))
+    have ground : ∀ j, w j ∈ M.sets := Fin.cases hAlpha (Fin.cases hp (Fin.cases hy
+      (Fin.cases hInput (Fin.cases hRecord (Fin.cases hMu (Fin.cases hCut hFields))))))
+    exact ⟨w, ground, (actual w ground).2
+      ⟨⟨outer, rfl, rfl, stored, terms, nodesEq⟩, meet, rfl, prepared⟩⟩
+
+end PartitionPilot.Forcing.TransitiveGround
+
+
+
+
+namespace PartitionPilot.Forcing.TransitiveGround
+open SetFormula
+universe u
+variable (M : TransitiveGround.{u})
+
+noncomputable def varyingPreparationRelation
+    (stages packed Q upperOrder nodes T : ZFSet.{u}) : ZFSet.{u} :=
+  let W := M.groundRelations T Q
+  let C := M.supportedEqualityCertificateBound nodes W
+  let E := M.synchronizedEnumerationBound nodes W
+  let levels := refinementDataHistoryLevels stages packed T
+  ZFSet.sep (M.VaryingPreparationCode packed Q upperOrder nodes T levels ZFSet.omega C E)
+    (ZFSet.prod (ZFSet.prod stages Q) (M.preparationWitnessBound nodes T Q))
+
+theorem pair_mem_varyingPreparationRelation
+    (stages packed Q upperOrder nodes T alpha p y : ZFSet.{u}) :
+    ZFSet.pair (ZFSet.pair alpha p) y ∈
+      M.varyingPreparationRelation stages packed Q upperOrder nodes T ↔
+    alpha ∈ stages ∧ p ∈ Q ∧ y ∈ M.preparationWitnessBound nodes T Q ∧
+      ∃ fields : Fin 15 → ZFSet.{u},
+        ZFSet.pair alpha (refinementFormulaDataCode fields) ∈ packed ∧
+        fields 6 = T ∧ fields 10 = nodes ∧
+        MeetOrderCode (fields 10) (fields 11) (canonicalMeetGraph (fields 10) (fields 11)) ∧
+        M.StoredPreparationCode upperOrder
+          (rowAssignmentCutGraph Q (fields 7) (refinementDataHistoryLevels stages packed T) alpha)
+          (canonicalMeetGraph (fields 10) (fields 11)) ZFSet.omega
+          (M.supportedEqualityCertificateBound nodes (M.groundRelations T Q))
+          (M.synchronizedEnumerationBound nodes (M.groundRelations T Q)) fields p y := by
+  simp only [varyingPreparationRelation, ZFSet.mem_sep, ZFSet.pair_mem_prod,
+    M.varyingPreparationCode_pair_iff, and_assoc]
+
+include M in
+ theorem varyingPreparationRelation_mem
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    {stages packed Q upperOrder nodes T : ZFSet.{u}}
+    (hStages : stages ∈ M.sets) (hPacked : packed ∈ M.sets)
+    (hQ : Q ∈ M.sets) (hOrder : upperOrder ∈ M.sets)
+    (hNodes : nodes ∈ M.sets) (hT : T ∈ M.sets) (omega : ZFSet.omega ∈ M.sets) :
+    M.varyingPreparationRelation stages packed Q upperOrder nodes T ∈ M.sets := by
+  let W := M.groundRelations T Q
+  let C := M.supportedEqualityCertificateBound nodes W
+  let E := M.synchronizedEnumerationBound nodes W
+  let levels := refinementDataHistoryLevels stages packed T
+  have hW := M.groundRelations_mem pairing unions powers separation hT hQ
+  have hC := M.supportedEqualityCertificateBound_mem pairing unions powers separation hNodes hW omega
+  have hE := M.synchronizedEnumerationBound_mem pairing unions powers separation hNodes hW omega
+  have hLevels := M.refinementDataHistoryLevels_mem pairing unions powers separation hStages hPacked hT
+  let params : Fin 9 → ZFSet.{u} := ![packed, Q, upperOrder, nodes, T, levels, ZFSet.omega, C, E]
+  have ground : ∀ j, params j ∈ M.sets := Fin.cases hPacked (Fin.cases hQ
+    (Fin.cases hOrder (Fin.cases hNodes (Fin.cases hT (Fin.cases hLevels
+      (Fin.cases omega (Fin.cases hC (Fin.cases hE (fun j => Fin.elim0 j)))))))))
+  let formula : SetFormula 10 :=
+    M.varyingPreparationFormula pairing unions powers separation 0 1 2 3 4 5 6 7 8 9
+  have bound := M.prod_mem pairing unions powers separation
+    (M.prod_mem pairing unions powers separation hStages hQ)
+    (M.preparationWitnessBound_mem pairing unions powers separation hNodes hT hQ omega)
+  have selected := M.separation_mem separation formula params ground bound
+  have equal : ZFSet.sep (fun z => Realize M.sets formula (extend z params))
+      (ZFSet.prod (ZFSet.prod stages Q) (M.preparationWitnessBound nodes T Q)) =
+      M.varyingPreparationRelation stages packed Q upperOrder nodes T := by
+    apply ZFSet.ext
+    intro z
+    rw [ZFSet.mem_sep, varyingPreparationRelation, ZFSet.mem_sep]
+    apply and_congr_right
+    intro hz
+    exact M.realize_varyingPreparationFormula pairing unions powers separation
+      0 1 2 3 4 5 6 7 8 9 (extend z params) (Fin.cases (M.transitive bound hz) ground)
+  exact equal ▸ selected
+
+end PartitionPilot.Forcing.TransitiveGround
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/HistoryFieldFormulas.lean

@@ -1,124 +1,124 @@
-import OAI.SetTheory.PartitionPrinciple.Transfinite.RecursiveStateFieldEnvironments
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing
-
-universe u
-namespace SetFormula
-
-def stateFieldFormula {n} (code value : Fin n) (j : Fin 13) : SetFormula n :=
-  exBlock 13 (.conj
-    (BoundedFormula.nonemptyTupleFormula 12 (suffixIndex n 13 code) (prefixIndex n 13)).toFormula
-    (.equal (suffixIndex n 13 value) (prefixIndex n 13 j)))
-
-def historyFieldValueFormula {n} (index value history : Fin n) (j : Fin 13) : SetFormula n :=
-  ex (.conj (BoundedFormula.pairMembershipFormula index.succ 0 history.succ).toFormula
-    (stateFieldFormula 0 value.succ j))
-
-def historyFieldPairFormula {n} (index output history : Fin n) (j : Fin 13) : SetFormula n :=
-  ex (.conj (historyFieldValueFormula index.succ 0 history.succ j)
-    (BoundedFormula.orderedPairFormula output.succ index.succ 0).toFormula)
-
-end SetFormula
-
-namespace TransitiveGround
-open SetFormula
-variable (M : TransitiveGround.{u})
-
-theorem realize_stateFieldFormula {n} (code value : Fin n) (j : Fin 13)
-    (env : Fin n → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets)
-    (state : RecursiveStateData.{u}) (coded : env code = state.code) :
-    Realize M.sets (stateFieldFormula code value j) env ↔ env value = state.field j := by
-  rw [stateFieldFormula, realize_exBlock]
-  constructor
-  · rintro ⟨fields, fieldMembers, tuple, entry⟩
-    have equal := (BoundedFormula.truth_nonemptyTupleFormula 12 (suffixIndex n 13 code)
-      (prefixIndex n 13) _).1
-      ((BoundedFormula.realize_toFormula M _ _ (extendMany_members 13 fields env fieldMembers members)).1 tuple)
-    simp only [extendMany_suffix, extendMany_prefix] at equal
-    have fieldsEqual : fields = state.field :=
-      nonemptyTupleCode_injective 12 (equal.symm.trans coded)
-    change extendMany 13 fields env (suffixIndex n 13 value) =
-      extendMany 13 fields env (prefixIndex n 13 j) at entry
-    simpa only [extendMany_suffix, extendMany_prefix, fieldsEqual] using entry
-  · intro equal
-    have fieldMembers := M.recursiveStateData_field_mem state (coded ▸ members code)
-    refine ⟨state.field, fieldMembers, ?_, ?_⟩
-    · apply (BoundedFormula.realize_toFormula M _ _
-        (extendMany_members 13 state.field env fieldMembers members)).2
-      apply (BoundedFormula.truth_nonemptyTupleFormula 12 (suffixIndex n 13 code)
-        (prefixIndex n 13) _).2
-      simp only [extendMany_suffix, extendMany_prefix]
-      exact coded
-    · change extendMany 13 state.field env (suffixIndex n 13 value) =
-        extendMany 13 state.field env (prefixIndex n 13 j)
-      simpa only [extendMany_suffix, extendMany_prefix] using equal
-
-theorem realize_historyFieldValueFormula {k} (index value history : Fin k) (j : Fin 13)
-    (env : Fin k → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets)
-    (states : Nat → RecursiveStateData.{u})
-    (entries : ∀ n y, ZFSet.pair (natSetCode n) y ∈ env history ↔ y = (states n).code)
-    (n : Nat) (indexEq : env index = natSetCode n) :
-    Realize M.sets (historyFieldValueFormula index value history j) env ↔
-      env value = (states n).field j := by
-  rw [historyFieldValueFormula, realize_ex]
-  constructor
-  · rintro ⟨code, hcode, entry, projected⟩
-    have extended : ∀ i, extend code env i ∈ M.sets := Fin.cases hcode members
-    have actual := (BoundedFormula.truth_pairMembershipFormula index.succ 0 history.succ _).1
-      ((BoundedFormula.realize_toFormula M _ _ extended).1 entry)
-    change ZFSet.pair (env index) code ∈ env history at actual
-    rw [indexEq] at actual
-    exact (M.realize_stateFieldFormula 0 value.succ j (extend code env) extended
-      (states n) ((entries n code).1 actual)).1 projected
-  · intro equal
-    have entry : ZFSet.pair (natSetCode n) (states n).code ∈ env history :=
-      (entries n _).2 rfl
-    have hcode := M.pair_right (M.transitive (members history) entry)
-    have extended : ∀ i, extend (states n).code env i ∈ M.sets := Fin.cases hcode members
-    refine ⟨(states n).code, hcode, ?_, ?_⟩
-    · apply (BoundedFormula.realize_toFormula M _ _ extended).2
-      apply (BoundedFormula.truth_pairMembershipFormula index.succ 0 history.succ _).2
-      change ZFSet.pair (env index) (states n).code ∈ env history
-      exact indexEq.symm ▸ entry
-    · exact (M.realize_stateFieldFormula 0 value.succ j _ extended (states n) rfl).2 equal
-
-theorem realize_historyFieldPairFormula {k} (index output history : Fin k) (j : Fin 13)
-    (env : Fin k → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets)
-    (states : Nat → RecursiveStateData.{u})
-    (entries : ∀ n y, ZFSet.pair (natSetCode n) y ∈ env history ↔ y = (states n).code)
-    (n : Nat) (indexEq : env index = natSetCode n) :
-    Realize M.sets (historyFieldPairFormula index output history j) env ↔
-      env output = ZFSet.pair (natSetCode n) ((states n).field j) := by
-  rw [historyFieldPairFormula, realize_ex]
-  constructor
-  · rintro ⟨value, hvalue, specified, pair⟩
-    have extended : ∀ i, extend value env i ∈ M.sets := Fin.cases hvalue members
-    have valueEq := (M.realize_historyFieldValueFormula index.succ 0 history.succ j
-      (extend value env) extended states entries n indexEq).1 specified
-    have pairEq := (BoundedFormula.truth_orderedPairFormula output.succ index.succ 0 _).1
-      ((BoundedFormula.realize_toFormula M _ _ extended).1 pair)
-    change env output = ZFSet.pair (env index) value at pairEq
-    exact pairEq.trans (congrArg₂ ZFSet.pair indexEq valueEq)
-  · intro equal
-    have codeM := M.pair_right (M.transitive (members history) ((entries n _).2 rfl))
-    have valueM := M.recursiveStateData_field_mem (states n) codeM j
-    have extended : ∀ i, extend ((states n).field j) env i ∈ M.sets := Fin.cases valueM members
-    refine ⟨(states n).field j, valueM, ?_, ?_⟩
-    · exact (M.realize_historyFieldValueFormula index.succ 0 history.succ j _ extended
-        states entries n indexEq).2 rfl
-    · apply (BoundedFormula.realize_toFormula M _ _ extended).2
-      apply (BoundedFormula.truth_orderedPairFormula output.succ index.succ 0 _).2
-      change env output = ZFSet.pair (env index) ((states n).field j)
-      exact equal.trans (congrArg (fun x => ZFSet.pair x ((states n).field j)) indexEq.symm)
-
-end TransitiveGround
-
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Transfinite.RecursiveStateFieldEnvironments
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing
+
+universe u
+namespace SetFormula
+
+def stateFieldFormula {n} (code value : Fin n) (j : Fin 13) : SetFormula n :=
+  exBlock 13 (.conj
+    (BoundedFormula.nonemptyTupleFormula 12 (suffixIndex n 13 code) (prefixIndex n 13)).toFormula
+    (.equal (suffixIndex n 13 value) (prefixIndex n 13 j)))
+
+def historyFieldValueFormula {n} (index value history : Fin n) (j : Fin 13) : SetFormula n :=
+  ex (.conj (BoundedFormula.pairMembershipFormula index.succ 0 history.succ).toFormula
+    (stateFieldFormula 0 value.succ j))
+
+def historyFieldPairFormula {n} (index output history : Fin n) (j : Fin 13) : SetFormula n :=
+  ex (.conj (historyFieldValueFormula index.succ 0 history.succ j)
+    (BoundedFormula.orderedPairFormula output.succ index.succ 0).toFormula)
+
+end SetFormula
+
+namespace TransitiveGround
+open SetFormula
+variable (M : TransitiveGround.{u})
+
+theorem realize_stateFieldFormula {n} (code value : Fin n) (j : Fin 13)
+    (env : Fin n → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets)
+    (state : RecursiveStateData.{u}) (coded : env code = state.code) :
+    Realize M.sets (stateFieldFormula code value j) env ↔ env value = state.field j := by
+  rw [stateFieldFormula, realize_exBlock]
+  constructor
+  · rintro ⟨fields, fieldMembers, tuple, entry⟩
+    have equal := (BoundedFormula.truth_nonemptyTupleFormula 12 (suffixIndex n 13 code)
+      (prefixIndex n 13) _).1
+      ((BoundedFormula.realize_toFormula M _ _ (extendMany_members 13 fields env fieldMembers members)).1 tuple)
+    simp only [extendMany_suffix, extendMany_prefix] at equal
+    have fieldsEqual : fields = state.field :=
+      nonemptyTupleCode_injective 12 (equal.symm.trans coded)
+    change extendMany 13 fields env (suffixIndex n 13 value) =
+      extendMany 13 fields env (prefixIndex n 13 j) at entry
+    simpa only [extendMany_suffix, extendMany_prefix, fieldsEqual] using entry
+  · intro equal
+    have fieldMembers := M.recursiveStateData_field_mem state (coded ▸ members code)
+    refine ⟨state.field, fieldMembers, ?_, ?_⟩
+    · apply (BoundedFormula.realize_toFormula M _ _
+        (extendMany_members 13 state.field env fieldMembers members)).2
+      apply (BoundedFormula.truth_nonemptyTupleFormula 12 (suffixIndex n 13 code)
+        (prefixIndex n 13) _).2
+      simp only [extendMany_suffix, extendMany_prefix]
+      exact coded
+    · change extendMany 13 state.field env (suffixIndex n 13 value) =
+        extendMany 13 state.field env (prefixIndex n 13 j)
+      simpa only [extendMany_suffix, extendMany_prefix] using equal
+
+theorem realize_historyFieldValueFormula {k} (index value history : Fin k) (j : Fin 13)
+    (env : Fin k → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets)
+    (states : Nat → RecursiveStateData.{u})
+    (entries : ∀ n y, ZFSet.pair (natSetCode n) y ∈ env history ↔ y = (states n).code)
+    (n : Nat) (indexEq : env index = natSetCode n) :
+    Realize M.sets (historyFieldValueFormula index value history j) env ↔
+      env value = (states n).field j := by
+  rw [historyFieldValueFormula, realize_ex]
+  constructor
+  · rintro ⟨code, hcode, entry, projected⟩
+    have extended : ∀ i, extend code env i ∈ M.sets := Fin.cases hcode members
+    have actual := (BoundedFormula.truth_pairMembershipFormula index.succ 0 history.succ _).1
+      ((BoundedFormula.realize_toFormula M _ _ extended).1 entry)
+    change ZFSet.pair (env index) code ∈ env history at actual
+    rw [indexEq] at actual
+    exact (M.realize_stateFieldFormula 0 value.succ j (extend code env) extended
+      (states n) ((entries n code).1 actual)).1 projected
+  · intro equal
+    have entry : ZFSet.pair (natSetCode n) (states n).code ∈ env history :=
+      (entries n _).2 rfl
+    have hcode := M.pair_right (M.transitive (members history) entry)
+    have extended : ∀ i, extend (states n).code env i ∈ M.sets := Fin.cases hcode members
+    refine ⟨(states n).code, hcode, ?_, ?_⟩
+    · apply (BoundedFormula.realize_toFormula M _ _ extended).2
+      apply (BoundedFormula.truth_pairMembershipFormula index.succ 0 history.succ _).2
+      change ZFSet.pair (env index) (states n).code ∈ env history
+      exact indexEq.symm ▸ entry
+    · exact (M.realize_stateFieldFormula 0 value.succ j _ extended (states n) rfl).2 equal
+
+theorem realize_historyFieldPairFormula {k} (index output history : Fin k) (j : Fin 13)
+    (env : Fin k → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets)
+    (states : Nat → RecursiveStateData.{u})
+    (entries : ∀ n y, ZFSet.pair (natSetCode n) y ∈ env history ↔ y = (states n).code)
+    (n : Nat) (indexEq : env index = natSetCode n) :
+    Realize M.sets (historyFieldPairFormula index output history j) env ↔
+      env output = ZFSet.pair (natSetCode n) ((states n).field j) := by
+  rw [historyFieldPairFormula, realize_ex]
+  constructor
+  · rintro ⟨value, hvalue, specified, pair⟩
+    have extended : ∀ i, extend value env i ∈ M.sets := Fin.cases hvalue members
+    have valueEq := (M.realize_historyFieldValueFormula index.succ 0 history.succ j
+      (extend value env) extended states entries n indexEq).1 specified
+    have pairEq := (BoundedFormula.truth_orderedPairFormula output.succ index.succ 0 _).1
+      ((BoundedFormula.realize_toFormula M _ _ extended).1 pair)
+    change env output = ZFSet.pair (env index) value at pairEq
+    exact pairEq.trans (congrArg₂ ZFSet.pair indexEq valueEq)
+  · intro equal
+    have codeM := M.pair_right (M.transitive (members history) ((entries n _).2 rfl))
+    have valueM := M.recursiveStateData_field_mem (states n) codeM j
+    have extended : ∀ i, extend ((states n).field j) env i ∈ M.sets := Fin.cases valueM members
+    refine ⟨(states n).field j, valueM, ?_, ?_⟩
+    · exact (M.realize_historyFieldValueFormula index.succ 0 history.succ j _ extended
+        states entries n indexEq).2 rfl
+    · apply (BoundedFormula.realize_toFormula M _ _ extended).2
+      apply (BoundedFormula.truth_orderedPairFormula output.succ index.succ 0 _).2
+      change env output = ZFSet.pair (env index) ((states n).field j)
+      exact equal.trans (congrArg (fun x => ZFSet.pair x ((states n).field j)) indexEq.symm)
+
+end TransitiveGround
+
+end PartitionPilot.Forcing
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/IndexedAttachmentCodes.lean

@@ -1,228 +1,228 @@
-import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundMainStageFromCodes
-
-namespace OAI
-
-open scoped ZFSet
-
-namespace PartitionPilot.Forcing
-
-universe u
-
-noncomputable def attachmentIdeal (Q rQ a : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun q => ZFSet.pair q a ∈ rQ) Q
-
-noncomputable def freshPart (Q rQ a : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun q => ZFSet.pair q a ∉ rQ) Q
-
-theorem mem_attachmentIdeal (Q rQ a q : ZFSet.{u}) :
-    q ∈ attachmentIdeal Q rQ a ↔ q ∈ Q ∧ ZFSet.pair q a ∈ rQ :=
-  ZFSet.mem_sep
-
-theorem mem_freshPart (Q rQ a q : ZFSet.{u}) :
-    q ∈ freshPart Q rQ a ↔ q ∈ Q ∧ ZFSet.pair q a ∉ rQ :=
-  ZFSet.mem_sep
-
-theorem attachmentIdeal_union_freshPart (Q rQ a : ZFSet.{u}) :
-    attachmentIdeal Q rQ a ∪ freshPart Q rQ a = Q := by
-  classical
-  apply ZFSet.ext
-  intro q
-  simp only [ZFSet.mem_union, mem_attachmentIdeal, mem_freshPart]
-  exact ⟨fun h => h.elim And.left And.left, fun h =>
-    (Classical.em (ZFSet.pair q a ∈ rQ)).elim
-      (fun rel => Or.inl ⟨h, rel⟩) (fun rel => Or.inr ⟨h, rel⟩)⟩
-
-theorem attachmentIdeal_not_freshPart {Q rQ a q : ZFSet.{u}}
-    (hq : q ∈ attachmentIdeal Q rQ a) : q ∉ freshPart Q rQ a := by
-  intro fresh
-  exact ((mem_freshPart Q rQ a q).1 fresh).2 ((mem_attachmentIdeal Q rQ a q).1 hq).2
-
-noncomputable def attachmentShadowGraph (Q P μQ ell a : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => ∃ q ∈ Q, ∃ p ∈ P, z = ZFSet.pair q p ∧
-    ∃ c ∈ Q, ZFSet.pair (ZFSet.pair q a) c ∈ μQ ∧ ZFSet.pair c p ∈ ell)
-    (ZFSet.prod Q P)
-
-theorem mem_attachmentShadowGraph (Q P μQ ell a z : ZFSet.{u}) :
-    z ∈ attachmentShadowGraph Q P μQ ell a ↔
-      ∃ q ∈ Q, ∃ p ∈ P, z = ZFSet.pair q p ∧
-        ∃ c ∈ Q, ZFSet.pair (ZFSet.pair q a) c ∈ μQ ∧ ZFSet.pair c p ∈ ell := by
-  rw [attachmentShadowGraph, ZFSet.mem_sep]
-  exact ⟨And.right, fun h => ⟨by
-    obtain ⟨q, hq, p, hp, rfl, _⟩ := h
-    exact ZFSet.pair_mem_prod.2 ⟨hq, hp⟩, h⟩⟩
-
-theorem pair_mem_attachmentShadowGraph (Q P μQ ell a q p : ZFSet.{u}) :
-    ZFSet.pair q p ∈ attachmentShadowGraph Q P μQ ell a ↔
-      q ∈ Q ∧ p ∈ P ∧
-        ∃ c ∈ Q, ZFSet.pair (ZFSet.pair q a) c ∈ μQ ∧ ZFSet.pair c p ∈ ell := by
-  rw [mem_attachmentShadowGraph]
-  constructor
-  · rintro ⟨q', hq, p', hp, equal, c, hc, meet, image⟩
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
-    exact ⟨hq, hp, c, hc, meet, image⟩
-  · rintro ⟨hq, hp, c, hc, meet, image⟩
-    exact ⟨q, hq, p, hp, rfl, c, hc, meet, image⟩
-
-theorem meet_entry_in_attachmentIdeal {Q rQ μQ a q c : ZFSet.{u}}
-    (meet : MeetOrderCode Q rQ μQ)
-    (entry : ZFSet.pair (ZFSet.pair q a) c ∈ μQ) :
-    c ∈ attachmentIdeal Q rQ a :=
-  (mem_attachmentIdeal Q rQ a c).2
-    ⟨(ZFSet.pair_mem_prod.1 (meet.operation.1 entry)).2, meet.lower_right q a c entry⟩
-
-theorem meet_entry_eq_of_attachmentIdeal {Q rQ μQ a q c : ZFSet.{u}}
-    (meet : MeetOrderCode Q rQ μQ) (hq : q ∈ attachmentIdeal Q rQ a)
-    (entry : ZFSet.pair (ZFSet.pair q a) c ∈ μQ) : c = q := by
-  have inIdeal := (mem_attachmentIdeal Q rQ a q).1 hq
-  have hc := (ZFSet.pair_mem_prod.1 (meet.operation.1 entry)).2
-  exact meet.order.antisymm c hc q inIdeal.1 (meet.lower_left q a c entry)
-    (meet.greatest q a c q inIdeal.1 entry (meet.order.refl q inIdeal.1) inIdeal.2)
-
-theorem attachmentShadowGraph_function {Q P rQ μQ ell a : ZFSet.{u}}
-    (meet : MeetOrderCode Q rQ μQ) (ha : a ∈ Q)
-    (ellFunc : ZFSet.IsFunc (attachmentIdeal Q rQ a) P ell) :
-    ZFSet.IsFunc Q P (attachmentShadowGraph Q P μQ ell a) := by
-  refine ⟨fun _ hz => (ZFSet.mem_sep.1 hz).1, ?_⟩
-  intro q hq
-  obtain ⟨c, entry, meetUnique⟩ := meet.operation.2 (ZFSet.pair q a)
-    (ZFSet.pair_mem_prod.2 ⟨hq, ha⟩)
-  have hc := meet_entry_in_attachmentIdeal meet entry
-  obtain ⟨p, image, imageUnique⟩ := ellFunc.2 c hc
-  have hp := (ZFSet.pair_mem_prod.1 (ellFunc.1 image)).2
-  refine ⟨p, (pair_mem_attachmentShadowGraph Q P μQ ell a q p).2
-    ⟨hq, hp, c, ((mem_attachmentIdeal Q rQ a c).1 hc).1, entry, image⟩, ?_⟩
-  intro p' shadow
-  obtain ⟨_, _, c', _, entry', image'⟩ :=
-    (pair_mem_attachmentShadowGraph Q P μQ ell a q p').1 shadow
-  have equal := meetUnique c' entry'
-  subst c'
-  exact imageUnique p' image'
-
-theorem attachmentShadowGraph_on_ideal {Q P rQ μQ ell a q p : ZFSet.{u}}
-    (meet : MeetOrderCode Q rQ μQ) (ha : a ∈ Q)
-    (ellFunc : ZFSet.IsFunc (attachmentIdeal Q rQ a) P ell)
-    (hq : q ∈ attachmentIdeal Q rQ a) :
-    ZFSet.pair q p ∈ attachmentShadowGraph Q P μQ ell a ↔ ZFSet.pair q p ∈ ell := by
-  constructor
-  · intro shadow
-    obtain ⟨_, _, c, _, entry, image⟩ :=
-      (pair_mem_attachmentShadowGraph Q P μQ ell a q p).1 shadow
-    exact meet_entry_eq_of_attachmentIdeal meet hq entry ▸ image
-  · intro image
-    have qQ := ((mem_attachmentIdeal Q rQ a q).1 hq).1
-    obtain ⟨c, entry, _⟩ := meet.operation.2 (ZFSet.pair q a)
-      (ZFSet.pair_mem_prod.2 ⟨qQ, ha⟩)
-    have equal := meet_entry_eq_of_attachmentIdeal meet hq entry
-    subst c
-    exact (pair_mem_attachmentShadowGraph Q P μQ ell a q p).2
-      ⟨qQ, (ZFSet.pair_mem_prod.1 (ellFunc.1 image)).2, q, qQ, entry, image⟩
-
-def familyPointBound (Qs : ZFSet.{u}) : ZFSet.{u} := ⋃₀ ⋃₀ ⋃₀ Qs
-
-theorem mem_familyPointBound_of_entry {Qs i Q q : ZFSet.{u}}
-    (entry : ZFSet.pair i Q ∈ Qs) (hq : q ∈ Q) : q ∈ familyPointBound Qs :=
-  ZFSet.mem_sUnion.2 ⟨Q, pair_second_mem_doubleUnion entry, hq⟩
-
-noncomputable def indexedAttachmentDomain (I Qs : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => ∃ i ∈ I, ∃ Q ∈ ⋃₀ ⋃₀ Qs, ∃ q ∈ Q,
-    ZFSet.pair i Q ∈ Qs ∧ z = ZFSet.pair i q)
-    (ZFSet.prod I (familyPointBound Qs))
-
-noncomputable def indexedAttachmentFresh (I Qs rs anchors : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => ∃ i ∈ I, ∃ Q ∈ ⋃₀ ⋃₀ Qs, ∃ r ∈ ⋃₀ ⋃₀ rs,
-    ∃ a ∈ ⋃₀ ⋃₀ anchors, ∃ q ∈ Q,
-      ZFSet.pair i Q ∈ Qs ∧ ZFSet.pair i r ∈ rs ∧ ZFSet.pair i a ∈ anchors ∧
-      z = ZFSet.pair i q ∧ ZFSet.pair q a ∉ r)
-    (indexedAttachmentDomain I Qs)
-
-theorem indexedAttachmentDomain_subset (I Qs : ZFSet.{u}) :
-    indexedAttachmentDomain I Qs ⊆ ZFSet.prod I (familyPointBound Qs) :=
-  fun _ hz => (ZFSet.mem_sep.1 hz).1
-
-theorem indexedAttachmentFresh_subset (I Qs rs anchors : ZFSet.{u}) :
-    indexedAttachmentFresh I Qs rs anchors ⊆ indexedAttachmentDomain I Qs :=
-  fun _ hz => (ZFSet.mem_sep.1 hz).1
-
-theorem mem_indexedAttachmentDomain (I Qs z : ZFSet.{u}) :
-    z ∈ indexedAttachmentDomain I Qs ↔
-      ∃ i ∈ I, ∃ q, z = ZFSet.pair i q ∧ ∃ Q, ZFSet.pair i Q ∈ Qs ∧ q ∈ Q := by
-  constructor
-  · intro hz
-    obtain ⟨i, hi, Q, _, q, hq, entry, equal⟩ := (ZFSet.mem_sep.1 hz).2
-    exact ⟨i, hi, q, equal, Q, entry, hq⟩
-  · rintro ⟨i, hi, q, rfl, Q, entry, hq⟩
-    exact ZFSet.mem_sep.2
-      ⟨ZFSet.pair_mem_prod.2 ⟨hi, mem_familyPointBound_of_entry entry hq⟩,
-        i, hi, Q, pair_second_mem_doubleUnion entry, q, hq, entry, rfl⟩
-
-theorem pair_mem_indexedAttachmentDomain (I Qs i q : ZFSet.{u}) :
-    ZFSet.pair i q ∈ indexedAttachmentDomain I Qs ↔
-      i ∈ I ∧ ∃ Q, ZFSet.pair i Q ∈ Qs ∧ q ∈ Q := by
-  rw [mem_indexedAttachmentDomain]
-  constructor
-  · rintro ⟨j, hj, p, equal, Q, entry, hq⟩
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
-    exact ⟨hj, Q, entry, hq⟩
-  · rintro ⟨hi, Q, entry, hq⟩
-    exact ⟨i, hi, q, rfl, Q, entry, hq⟩
-
-theorem mem_indexedAttachmentFresh (I Qs rs anchors z : ZFSet.{u}) :
-    z ∈ indexedAttachmentFresh I Qs rs anchors ↔
-      ∃ i ∈ I, ∃ q, z = ZFSet.pair i q ∧ ∃ Q r a,
-        ZFSet.pair i Q ∈ Qs ∧ ZFSet.pair i r ∈ rs ∧ ZFSet.pair i a ∈ anchors ∧
-        q ∈ Q ∧ ZFSet.pair q a ∉ r := by
-  constructor
-  · intro hz
-    obtain ⟨i, hi, Q, _, r, _, a, _, q, hq, entryQ, entryR, entryA, equal, fresh⟩ :=
-      (ZFSet.mem_sep.1 hz).2
-    exact ⟨i, hi, q, equal, Q, r, a, entryQ, entryR, entryA, hq, fresh⟩
-  · rintro ⟨i, hi, q, rfl, Q, r, a, entryQ, entryR, entryA, hq, fresh⟩
-    exact ZFSet.mem_sep.2
-      ⟨(pair_mem_indexedAttachmentDomain I Qs i q).2 ⟨hi, Q, entryQ, hq⟩,
-        i, hi, Q, pair_second_mem_doubleUnion entryQ, r, pair_second_mem_doubleUnion entryR,
-        a, pair_second_mem_doubleUnion entryA, q, hq, entryQ, entryR, entryA, rfl, fresh⟩
-
-theorem pair_mem_indexedAttachmentFresh (I Qs rs anchors i q : ZFSet.{u}) :
-    ZFSet.pair i q ∈ indexedAttachmentFresh I Qs rs anchors ↔
-      i ∈ I ∧ ∃ Q r a, ZFSet.pair i Q ∈ Qs ∧ ZFSet.pair i r ∈ rs ∧
-        ZFSet.pair i a ∈ anchors ∧ q ∈ Q ∧ ZFSet.pair q a ∉ r := by
-  rw [mem_indexedAttachmentFresh]
-  constructor
-  · rintro ⟨j, hj, p, equal, Q, r, a, entryQ, entryR, entryA, hq, fresh⟩
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
-    exact ⟨hj, Q, r, a, entryQ, entryR, entryA, hq, fresh⟩
-  · rintro ⟨hi, Q, r, a, entryQ, entryR, entryA, hq, fresh⟩
-    exact ⟨i, hi, q, rfl, Q, r, a, entryQ, entryR, entryA, hq, fresh⟩
-
-theorem pair_mem_indexedAttachmentDomain_of_entry {I Qs i q Q : ZFSet.{u}}
-    (family : FunctionGraphOn I Qs) (entry : ZFSet.pair i Q ∈ Qs) :
-    ZFSet.pair i q ∈ indexedAttachmentDomain I Qs ↔ q ∈ Q := by
-  rw [pair_mem_indexedAttachmentDomain]
-  constructor
-  · rintro ⟨_, R, other, hq⟩
-    exact family.unique other entry ▸ hq
-  · intro hq
-    exact ⟨family.pair_source entry, Q, entry, hq⟩
-
-theorem pair_mem_indexedAttachmentFresh_of_entries
-    {I Qs rs anchors i q Q r a : ZFSet.{u}}
-    (spaces : FunctionGraphOn I Qs) (orders : FunctionGraphOn I rs)
-    (points : FunctionGraphOn I anchors) (entryQ : ZFSet.pair i Q ∈ Qs)
-    (entryR : ZFSet.pair i r ∈ rs) (entryA : ZFSet.pair i a ∈ anchors) :
-    ZFSet.pair i q ∈ indexedAttachmentFresh I Qs rs anchors ↔ q ∈ freshPart Q r a := by
-  rw [pair_mem_indexedAttachmentFresh, mem_freshPart]
-  constructor
-  · rintro ⟨_, Q', r', a', otherQ, otherR, otherA, hq, fresh⟩
-    have equalQ := spaces.unique otherQ entryQ
-    have equalR := orders.unique otherR entryR
-    have equalA := points.unique otherA entryA
-    subst Q'
-    subst r'
-    subst a'
-    exact ⟨hq, fresh⟩
-  · rintro ⟨hq, fresh⟩
-    exact ⟨spaces.pair_source entryQ, Q, r, a, entryQ, entryR, entryA, hq, fresh⟩
-
-end PartitionPilot.Forcing
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundMainStageFromCodes
+
+namespace OAI
+
+open scoped ZFSet
+
+namespace PartitionPilot.Forcing
+
+universe u
+
+noncomputable def attachmentIdeal (Q rQ a : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun q => ZFSet.pair q a ∈ rQ) Q
+
+noncomputable def freshPart (Q rQ a : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun q => ZFSet.pair q a ∉ rQ) Q
+
+theorem mem_attachmentIdeal (Q rQ a q : ZFSet.{u}) :
+    q ∈ attachmentIdeal Q rQ a ↔ q ∈ Q ∧ ZFSet.pair q a ∈ rQ :=
+  ZFSet.mem_sep
+
+theorem mem_freshPart (Q rQ a q : ZFSet.{u}) :
+    q ∈ freshPart Q rQ a ↔ q ∈ Q ∧ ZFSet.pair q a ∉ rQ :=
+  ZFSet.mem_sep
+
+theorem attachmentIdeal_union_freshPart (Q rQ a : ZFSet.{u}) :
+    attachmentIdeal Q rQ a ∪ freshPart Q rQ a = Q := by
+  classical
+  apply ZFSet.ext
+  intro q
+  simp only [ZFSet.mem_union, mem_attachmentIdeal, mem_freshPart]
+  exact ⟨fun h => h.elim And.left And.left, fun h =>
+    (Classical.em (ZFSet.pair q a ∈ rQ)).elim
+      (fun rel => Or.inl ⟨h, rel⟩) (fun rel => Or.inr ⟨h, rel⟩)⟩
+
+theorem attachmentIdeal_not_freshPart {Q rQ a q : ZFSet.{u}}
+    (hq : q ∈ attachmentIdeal Q rQ a) : q ∉ freshPart Q rQ a := by
+  intro fresh
+  exact ((mem_freshPart Q rQ a q).1 fresh).2 ((mem_attachmentIdeal Q rQ a q).1 hq).2
+
+noncomputable def attachmentShadowGraph (Q P μQ ell a : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => ∃ q ∈ Q, ∃ p ∈ P, z = ZFSet.pair q p ∧
+    ∃ c ∈ Q, ZFSet.pair (ZFSet.pair q a) c ∈ μQ ∧ ZFSet.pair c p ∈ ell)
+    (ZFSet.prod Q P)
+
+theorem mem_attachmentShadowGraph (Q P μQ ell a z : ZFSet.{u}) :
+    z ∈ attachmentShadowGraph Q P μQ ell a ↔
+      ∃ q ∈ Q, ∃ p ∈ P, z = ZFSet.pair q p ∧
+        ∃ c ∈ Q, ZFSet.pair (ZFSet.pair q a) c ∈ μQ ∧ ZFSet.pair c p ∈ ell := by
+  rw [attachmentShadowGraph, ZFSet.mem_sep]
+  exact ⟨And.right, fun h => ⟨by
+    obtain ⟨q, hq, p, hp, rfl, _⟩ := h
+    exact ZFSet.pair_mem_prod.2 ⟨hq, hp⟩, h⟩⟩
+
+theorem pair_mem_attachmentShadowGraph (Q P μQ ell a q p : ZFSet.{u}) :
+    ZFSet.pair q p ∈ attachmentShadowGraph Q P μQ ell a ↔
+      q ∈ Q ∧ p ∈ P ∧
+        ∃ c ∈ Q, ZFSet.pair (ZFSet.pair q a) c ∈ μQ ∧ ZFSet.pair c p ∈ ell := by
+  rw [mem_attachmentShadowGraph]
+  constructor
+  · rintro ⟨q', hq, p', hp, equal, c, hc, meet, image⟩
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
+    exact ⟨hq, hp, c, hc, meet, image⟩
+  · rintro ⟨hq, hp, c, hc, meet, image⟩
+    exact ⟨q, hq, p, hp, rfl, c, hc, meet, image⟩
+
+theorem meet_entry_in_attachmentIdeal {Q rQ μQ a q c : ZFSet.{u}}
+    (meet : MeetOrderCode Q rQ μQ)
+    (entry : ZFSet.pair (ZFSet.pair q a) c ∈ μQ) :
+    c ∈ attachmentIdeal Q rQ a :=
+  (mem_attachmentIdeal Q rQ a c).2
+    ⟨(ZFSet.pair_mem_prod.1 (meet.operation.1 entry)).2, meet.lower_right q a c entry⟩
+
+theorem meet_entry_eq_of_attachmentIdeal {Q rQ μQ a q c : ZFSet.{u}}
+    (meet : MeetOrderCode Q rQ μQ) (hq : q ∈ attachmentIdeal Q rQ a)
+    (entry : ZFSet.pair (ZFSet.pair q a) c ∈ μQ) : c = q := by
+  have inIdeal := (mem_attachmentIdeal Q rQ a q).1 hq
+  have hc := (ZFSet.pair_mem_prod.1 (meet.operation.1 entry)).2
+  exact meet.order.antisymm c hc q inIdeal.1 (meet.lower_left q a c entry)
+    (meet.greatest q a c q inIdeal.1 entry (meet.order.refl q inIdeal.1) inIdeal.2)
+
+theorem attachmentShadowGraph_function {Q P rQ μQ ell a : ZFSet.{u}}
+    (meet : MeetOrderCode Q rQ μQ) (ha : a ∈ Q)
+    (ellFunc : ZFSet.IsFunc (attachmentIdeal Q rQ a) P ell) :
+    ZFSet.IsFunc Q P (attachmentShadowGraph Q P μQ ell a) := by
+  refine ⟨fun _ hz => (ZFSet.mem_sep.1 hz).1, ?_⟩
+  intro q hq
+  obtain ⟨c, entry, meetUnique⟩ := meet.operation.2 (ZFSet.pair q a)
+    (ZFSet.pair_mem_prod.2 ⟨hq, ha⟩)
+  have hc := meet_entry_in_attachmentIdeal meet entry
+  obtain ⟨p, image, imageUnique⟩ := ellFunc.2 c hc
+  have hp := (ZFSet.pair_mem_prod.1 (ellFunc.1 image)).2
+  refine ⟨p, (pair_mem_attachmentShadowGraph Q P μQ ell a q p).2
+    ⟨hq, hp, c, ((mem_attachmentIdeal Q rQ a c).1 hc).1, entry, image⟩, ?_⟩
+  intro p' shadow
+  obtain ⟨_, _, c', _, entry', image'⟩ :=
+    (pair_mem_attachmentShadowGraph Q P μQ ell a q p').1 shadow
+  have equal := meetUnique c' entry'
+  subst c'
+  exact imageUnique p' image'
+
+theorem attachmentShadowGraph_on_ideal {Q P rQ μQ ell a q p : ZFSet.{u}}
+    (meet : MeetOrderCode Q rQ μQ) (ha : a ∈ Q)
+    (ellFunc : ZFSet.IsFunc (attachmentIdeal Q rQ a) P ell)
+    (hq : q ∈ attachmentIdeal Q rQ a) :
+    ZFSet.pair q p ∈ attachmentShadowGraph Q P μQ ell a ↔ ZFSet.pair q p ∈ ell := by
+  constructor
+  · intro shadow
+    obtain ⟨_, _, c, _, entry, image⟩ :=
+      (pair_mem_attachmentShadowGraph Q P μQ ell a q p).1 shadow
+    exact meet_entry_eq_of_attachmentIdeal meet hq entry ▸ image
+  · intro image
+    have qQ := ((mem_attachmentIdeal Q rQ a q).1 hq).1
+    obtain ⟨c, entry, _⟩ := meet.operation.2 (ZFSet.pair q a)
+      (ZFSet.pair_mem_prod.2 ⟨qQ, ha⟩)
+    have equal := meet_entry_eq_of_attachmentIdeal meet hq entry
+    subst c
+    exact (pair_mem_attachmentShadowGraph Q P μQ ell a q p).2
+      ⟨qQ, (ZFSet.pair_mem_prod.1 (ellFunc.1 image)).2, q, qQ, entry, image⟩
+
+def familyPointBound (Qs : ZFSet.{u}) : ZFSet.{u} := ⋃₀ ⋃₀ ⋃₀ Qs
+
+theorem mem_familyPointBound_of_entry {Qs i Q q : ZFSet.{u}}
+    (entry : ZFSet.pair i Q ∈ Qs) (hq : q ∈ Q) : q ∈ familyPointBound Qs :=
+  ZFSet.mem_sUnion.2 ⟨Q, pair_second_mem_doubleUnion entry, hq⟩
+
+noncomputable def indexedAttachmentDomain (I Qs : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => ∃ i ∈ I, ∃ Q ∈ ⋃₀ ⋃₀ Qs, ∃ q ∈ Q,
+    ZFSet.pair i Q ∈ Qs ∧ z = ZFSet.pair i q)
+    (ZFSet.prod I (familyPointBound Qs))
+
+noncomputable def indexedAttachmentFresh (I Qs rs anchors : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => ∃ i ∈ I, ∃ Q ∈ ⋃₀ ⋃₀ Qs, ∃ r ∈ ⋃₀ ⋃₀ rs,
+    ∃ a ∈ ⋃₀ ⋃₀ anchors, ∃ q ∈ Q,
+      ZFSet.pair i Q ∈ Qs ∧ ZFSet.pair i r ∈ rs ∧ ZFSet.pair i a ∈ anchors ∧
+      z = ZFSet.pair i q ∧ ZFSet.pair q a ∉ r)
+    (indexedAttachmentDomain I Qs)
+
+theorem indexedAttachmentDomain_subset (I Qs : ZFSet.{u}) :
+    indexedAttachmentDomain I Qs ⊆ ZFSet.prod I (familyPointBound Qs) :=
+  fun _ hz => (ZFSet.mem_sep.1 hz).1
+
+theorem indexedAttachmentFresh_subset (I Qs rs anchors : ZFSet.{u}) :
+    indexedAttachmentFresh I Qs rs anchors ⊆ indexedAttachmentDomain I Qs :=
+  fun _ hz => (ZFSet.mem_sep.1 hz).1
+
+theorem mem_indexedAttachmentDomain (I Qs z : ZFSet.{u}) :
+    z ∈ indexedAttachmentDomain I Qs ↔
+      ∃ i ∈ I, ∃ q, z = ZFSet.pair i q ∧ ∃ Q, ZFSet.pair i Q ∈ Qs ∧ q ∈ Q := by
+  constructor
+  · intro hz
+    obtain ⟨i, hi, Q, _, q, hq, entry, equal⟩ := (ZFSet.mem_sep.1 hz).2
+    exact ⟨i, hi, q, equal, Q, entry, hq⟩
+  · rintro ⟨i, hi, q, rfl, Q, entry, hq⟩
+    exact ZFSet.mem_sep.2
+      ⟨ZFSet.pair_mem_prod.2 ⟨hi, mem_familyPointBound_of_entry entry hq⟩,
+        i, hi, Q, pair_second_mem_doubleUnion entry, q, hq, entry, rfl⟩
+
+theorem pair_mem_indexedAttachmentDomain (I Qs i q : ZFSet.{u}) :
+    ZFSet.pair i q ∈ indexedAttachmentDomain I Qs ↔
+      i ∈ I ∧ ∃ Q, ZFSet.pair i Q ∈ Qs ∧ q ∈ Q := by
+  rw [mem_indexedAttachmentDomain]
+  constructor
+  · rintro ⟨j, hj, p, equal, Q, entry, hq⟩
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
+    exact ⟨hj, Q, entry, hq⟩
+  · rintro ⟨hi, Q, entry, hq⟩
+    exact ⟨i, hi, q, rfl, Q, entry, hq⟩
+
+theorem mem_indexedAttachmentFresh (I Qs rs anchors z : ZFSet.{u}) :
+    z ∈ indexedAttachmentFresh I Qs rs anchors ↔
+      ∃ i ∈ I, ∃ q, z = ZFSet.pair i q ∧ ∃ Q r a,
+        ZFSet.pair i Q ∈ Qs ∧ ZFSet.pair i r ∈ rs ∧ ZFSet.pair i a ∈ anchors ∧
+        q ∈ Q ∧ ZFSet.pair q a ∉ r := by
+  constructor
+  · intro hz
+    obtain ⟨i, hi, Q, _, r, _, a, _, q, hq, entryQ, entryR, entryA, equal, fresh⟩ :=
+      (ZFSet.mem_sep.1 hz).2
+    exact ⟨i, hi, q, equal, Q, r, a, entryQ, entryR, entryA, hq, fresh⟩
+  · rintro ⟨i, hi, q, rfl, Q, r, a, entryQ, entryR, entryA, hq, fresh⟩
+    exact ZFSet.mem_sep.2
+      ⟨(pair_mem_indexedAttachmentDomain I Qs i q).2 ⟨hi, Q, entryQ, hq⟩,
+        i, hi, Q, pair_second_mem_doubleUnion entryQ, r, pair_second_mem_doubleUnion entryR,
+        a, pair_second_mem_doubleUnion entryA, q, hq, entryQ, entryR, entryA, rfl, fresh⟩
+
+theorem pair_mem_indexedAttachmentFresh (I Qs rs anchors i q : ZFSet.{u}) :
+    ZFSet.pair i q ∈ indexedAttachmentFresh I Qs rs anchors ↔
+      i ∈ I ∧ ∃ Q r a, ZFSet.pair i Q ∈ Qs ∧ ZFSet.pair i r ∈ rs ∧
+        ZFSet.pair i a ∈ anchors ∧ q ∈ Q ∧ ZFSet.pair q a ∉ r := by
+  rw [mem_indexedAttachmentFresh]
+  constructor
+  · rintro ⟨j, hj, p, equal, Q, r, a, entryQ, entryR, entryA, hq, fresh⟩
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
+    exact ⟨hj, Q, r, a, entryQ, entryR, entryA, hq, fresh⟩
+  · rintro ⟨hi, Q, r, a, entryQ, entryR, entryA, hq, fresh⟩
+    exact ⟨i, hi, q, rfl, Q, r, a, entryQ, entryR, entryA, hq, fresh⟩
+
+theorem pair_mem_indexedAttachmentDomain_of_entry {I Qs i q Q : ZFSet.{u}}
+    (family : FunctionGraphOn I Qs) (entry : ZFSet.pair i Q ∈ Qs) :
+    ZFSet.pair i q ∈ indexedAttachmentDomain I Qs ↔ q ∈ Q := by
+  rw [pair_mem_indexedAttachmentDomain]
+  constructor
+  · rintro ⟨_, R, other, hq⟩
+    exact family.unique other entry ▸ hq
+  · intro hq
+    exact ⟨family.pair_source entry, Q, entry, hq⟩
+
+theorem pair_mem_indexedAttachmentFresh_of_entries
+    {I Qs rs anchors i q Q r a : ZFSet.{u}}
+    (spaces : FunctionGraphOn I Qs) (orders : FunctionGraphOn I rs)
+    (points : FunctionGraphOn I anchors) (entryQ : ZFSet.pair i Q ∈ Qs)
+    (entryR : ZFSet.pair i r ∈ rs) (entryA : ZFSet.pair i a ∈ anchors) :
+    ZFSet.pair i q ∈ indexedAttachmentFresh I Qs rs anchors ↔ q ∈ freshPart Q r a := by
+  rw [pair_mem_indexedAttachmentFresh, mem_freshPart]
+  constructor
+  · rintro ⟨_, Q', r', a', otherQ, otherR, otherA, hq, fresh⟩
+    have equalQ := spaces.unique otherQ entryQ
+    have equalR := orders.unique otherR entryR
+    have equalA := points.unique otherA entryA
+    subst Q'
+    subst r'
+    subst a'
+    exact ⟨hq, fresh⟩
+  · rintro ⟨hq, fresh⟩
+    exact ⟨spaces.pair_source entryQ, Q, r, a, entryQ, entryR, entryA, hq, fresh⟩
+
+end PartitionPilot.Forcing
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/IndexedMixedOperationLiftCodes.lean

@@ -1,58 +1,58 @@
-import OAI.SetTheory.PartitionPrinciple.Definability.PresentedGroupCodes
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing
-open SetRealization
-universe u
-
-noncomputable def indexedMixedBinaryLift (T UG UP G P A JG JP : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun w => ∃ g ∈ G, ∃ p ∈ P, ∃ q ∈ P, ∃ i ∈ T,
-    ∃ a ∈ ZFSet.sUnion (ZFSet.sUnion A),
-      ∃ eG ∈ ZFSet.sUnion (ZFSet.sUnion JG), ∃ eP ∈ ZFSet.sUnion (ZFSet.sUnion JP),
-      ∃ u ∈ UG, ∃ x ∈ UP, ∃ y ∈ UP,
-        w = ZFSet.pair (ZFSet.pair g p) q ∧
-          ZFSet.pair i a ∈ A ∧ ZFSet.pair i eG ∈ JG ∧ ZFSet.pair i eP ∈ JP ∧
-          ZFSet.pair u g ∈ eG ∧ ZFSet.pair x p ∈ eP ∧ ZFSet.pair y q ∈ eP ∧
-          ZFSet.pair (ZFSet.pair u x) y ∈ a) (ZFSet.prod (ZFSet.prod G P) P)
-
-theorem indexedMixedBinaryLift_subset (T UG UP G P A JG JP : ZFSet.{u}) :
-    indexedMixedBinaryLift T UG UP G P A JG JP ⊆ ZFSet.prod (ZFSet.prod G P) P :=
-  fun _ hz => (ZFSet.mem_sep.1 hz).1
-
-theorem triple_mem_indexedMixedBinaryLift (T UG UP G P A JG JP g p q : ZFSet.{u}) :
-    ZFSet.pair (ZFSet.pair g p) q ∈ indexedMixedBinaryLift T UG UP G P A JG JP ↔
-      g ∈ G ∧ p ∈ P ∧ q ∈ P ∧ ∃ i ∈ T, ∃ a eG eP,
-        ∃ u ∈ UG, ∃ x ∈ UP, ∃ y ∈ UP,
-          ZFSet.pair i a ∈ A ∧ ZFSet.pair i eG ∈ JG ∧ ZFSet.pair i eP ∈ JP ∧
-          ZFSet.pair u g ∈ eG ∧ ZFSet.pair x p ∈ eP ∧ ZFSet.pair y q ∈ eP ∧
-          ZFSet.pair (ZFSet.pair u x) y ∈ a := by
-  rw [indexedMixedBinaryLift, ZFSet.mem_sep]
-  constructor
-  · rintro ⟨_, g', hg, p', hp, q', hq, i, hi, a, _, eG, _, eP, _,
-      u, hu, x, hx, y, hy, equal, action, actors, points, actor, first, second, source⟩
-    obtain ⟨gp, rfl⟩ := ZFSet.pair_inj.1 equal
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 gp
-    exact ⟨hg, hp, hq, i, hi, a, eG, eP, u, hu, x, hx, y, hy,
-      action, actors, points, actor, first, second, source⟩
-  · rintro ⟨hg, hp, hq, i, hi, a, eG, eP, u, hu, x, hx, y, hy,
-      action, actors, points, actor, first, second, source⟩
-    exact ⟨ZFSet.pair_mem_prod.2 ⟨ZFSet.pair_mem_prod.2 ⟨hg, hp⟩, hq⟩,
-      g, hg, p, hp, q, hq, i, hi, a, pair_second_mem_doubleUnion action,
-      eG, pair_second_mem_doubleUnion actors, eP, pair_second_mem_doubleUnion points,
-      u, hu, x, hx, y, hy, rfl, action, actors, points, actor, first, second, source⟩
-
-theorem indexedMixedBinaryLift_rank_lt {o : Ordinal.{u}} (limit : Order.IsSuccLimit o)
-    (T UG UP A JG JP : ZFSet.{u}) {G P : ZFSet.{u}}
-    (actors : ZFSet.rank G < o) (points : ZFSet.rank P < o) :
-    ZFSet.rank (indexedMixedBinaryLift T UG UP G P A JG JP) < o :=
-  (ZFSet.rank_mono (indexedMixedBinaryLift_subset T UG UP G P A JG JP)).trans_lt
-    (rank_product_lt limit (rank_product_lt limit actors points) points)
-
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Definability.PresentedGroupCodes
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing
+open SetRealization
+universe u
+
+noncomputable def indexedMixedBinaryLift (T UG UP G P A JG JP : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun w => ∃ g ∈ G, ∃ p ∈ P, ∃ q ∈ P, ∃ i ∈ T,
+    ∃ a ∈ ZFSet.sUnion (ZFSet.sUnion A),
+      ∃ eG ∈ ZFSet.sUnion (ZFSet.sUnion JG), ∃ eP ∈ ZFSet.sUnion (ZFSet.sUnion JP),
+      ∃ u ∈ UG, ∃ x ∈ UP, ∃ y ∈ UP,
+        w = ZFSet.pair (ZFSet.pair g p) q ∧
+          ZFSet.pair i a ∈ A ∧ ZFSet.pair i eG ∈ JG ∧ ZFSet.pair i eP ∈ JP ∧
+          ZFSet.pair u g ∈ eG ∧ ZFSet.pair x p ∈ eP ∧ ZFSet.pair y q ∈ eP ∧
+          ZFSet.pair (ZFSet.pair u x) y ∈ a) (ZFSet.prod (ZFSet.prod G P) P)
+
+theorem indexedMixedBinaryLift_subset (T UG UP G P A JG JP : ZFSet.{u}) :
+    indexedMixedBinaryLift T UG UP G P A JG JP ⊆ ZFSet.prod (ZFSet.prod G P) P :=
+  fun _ hz => (ZFSet.mem_sep.1 hz).1
+
+theorem triple_mem_indexedMixedBinaryLift (T UG UP G P A JG JP g p q : ZFSet.{u}) :
+    ZFSet.pair (ZFSet.pair g p) q ∈ indexedMixedBinaryLift T UG UP G P A JG JP ↔
+      g ∈ G ∧ p ∈ P ∧ q ∈ P ∧ ∃ i ∈ T, ∃ a eG eP,
+        ∃ u ∈ UG, ∃ x ∈ UP, ∃ y ∈ UP,
+          ZFSet.pair i a ∈ A ∧ ZFSet.pair i eG ∈ JG ∧ ZFSet.pair i eP ∈ JP ∧
+          ZFSet.pair u g ∈ eG ∧ ZFSet.pair x p ∈ eP ∧ ZFSet.pair y q ∈ eP ∧
+          ZFSet.pair (ZFSet.pair u x) y ∈ a := by
+  rw [indexedMixedBinaryLift, ZFSet.mem_sep]
+  constructor
+  · rintro ⟨_, g', hg, p', hp, q', hq, i, hi, a, _, eG, _, eP, _,
+      u, hu, x, hx, y, hy, equal, action, actors, points, actor, first, second, source⟩
+    obtain ⟨gp, rfl⟩ := ZFSet.pair_inj.1 equal
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 gp
+    exact ⟨hg, hp, hq, i, hi, a, eG, eP, u, hu, x, hx, y, hy,
+      action, actors, points, actor, first, second, source⟩
+  · rintro ⟨hg, hp, hq, i, hi, a, eG, eP, u, hu, x, hx, y, hy,
+      action, actors, points, actor, first, second, source⟩
+    exact ⟨ZFSet.pair_mem_prod.2 ⟨ZFSet.pair_mem_prod.2 ⟨hg, hp⟩, hq⟩,
+      g, hg, p, hp, q, hq, i, hi, a, pair_second_mem_doubleUnion action,
+      eG, pair_second_mem_doubleUnion actors, eP, pair_second_mem_doubleUnion points,
+      u, hu, x, hx, y, hy, rfl, action, actors, points, actor, first, second, source⟩
+
+theorem indexedMixedBinaryLift_rank_lt {o : Ordinal.{u}} (limit : Order.IsSuccLimit o)
+    (T UG UP A JG JP : ZFSet.{u}) {G P : ZFSet.{u}}
+    (actors : ZFSet.rank G < o) (points : ZFSet.rank P < o) :
+    ZFSet.rank (indexedMixedBinaryLift T UG UP G P A JG JP) < o :=
+  (ZFSet.rank_mono (indexedMixedBinaryLift_subset T UG UP G P A JG JP)).trans_lt
+    (rank_product_lt limit (rank_product_lt limit actors points) points)
+
+end PartitionPilot.Forcing
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/IndexedOperationLiftCodes.lean

@@ -1,86 +1,86 @@
-import OAI.SetTheory.PartitionPrinciple.Definability.PresentedGroupCodes
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing
-open SetRealization
-open scoped ZFSet
-universe u
-
-noncomputable def indexedRelationLift (T U Q R J : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => ∃ p ∈ Q, ∃ q ∈ Q, ∃ i ∈ T,
-    ∃ r ∈ ⋃₀ ⋃₀ R, ∃ e ∈ ⋃₀ ⋃₀ J, ∃ x ∈ U, ∃ y ∈ U,
-      z = ZFSet.pair p q ∧ ZFSet.pair i r ∈ R ∧ ZFSet.pair i e ∈ J ∧
-        ZFSet.pair x p ∈ e ∧ ZFSet.pair y q ∈ e ∧ ZFSet.pair x y ∈ r)
-    (ZFSet.prod Q Q)
-
-theorem indexedRelationLift_subset (T U Q R J : ZFSet.{u}) :
-    indexedRelationLift T U Q R J ⊆ ZFSet.prod Q Q :=
-  fun _ hz => (ZFSet.mem_sep.1 hz).1
-
-theorem pair_mem_indexedRelationLift (T U Q R J p q : ZFSet.{u}) :
-    ZFSet.pair p q ∈ indexedRelationLift T U Q R J ↔
-      p ∈ Q ∧ q ∈ Q ∧ ∃ i ∈ T, ∃ r e, ∃ x ∈ U, ∃ y ∈ U,
-        ZFSet.pair i r ∈ R ∧ ZFSet.pair i e ∈ J ∧
-          ZFSet.pair x p ∈ e ∧ ZFSet.pair y q ∈ e ∧ ZFSet.pair x y ∈ r := by
-  rw [indexedRelationLift, ZFSet.mem_sep]
-  constructor
-  · rintro ⟨_, p', hp, q', hq, i, hi, r, _, e, _, x, hx, y, hy, equal, relation, inclusion, first, second, source⟩
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
-    exact ⟨hp, hq, i, hi, r, e, x, hx, y, hy, relation, inclusion, first, second, source⟩
-  · rintro ⟨hp, hq, i, hi, r, e, x, hx, y, hy, relation, inclusion, first, second, source⟩
-    exact ⟨ZFSet.pair_mem_prod.2 ⟨hp, hq⟩, p, hp, q, hq, i, hi,
-      r, pair_second_mem_doubleUnion relation, e, pair_second_mem_doubleUnion inclusion,
-      x, hx, y, hy, rfl, relation, inclusion, first, second, source⟩
-
-noncomputable def indexedBinaryLift (T U Q B J : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun w => ∃ p ∈ Q, ∃ q ∈ Q, ∃ v ∈ Q, ∃ i ∈ T,
-    ∃ b ∈ ⋃₀ ⋃₀ B, ∃ e ∈ ⋃₀ ⋃₀ J, ∃ x ∈ U, ∃ y ∈ U, ∃ z ∈ U,
-      w = ZFSet.pair (ZFSet.pair p q) v ∧ ZFSet.pair i b ∈ B ∧ ZFSet.pair i e ∈ J ∧
-        ZFSet.pair x p ∈ e ∧ ZFSet.pair y q ∈ e ∧ ZFSet.pair z v ∈ e ∧
-          ZFSet.pair (ZFSet.pair x y) z ∈ b) (ZFSet.prod (ZFSet.prod Q Q) Q)
-
-theorem indexedBinaryLift_subset (T U Q B J : ZFSet.{u}) :
-    indexedBinaryLift T U Q B J ⊆ ZFSet.prod (ZFSet.prod Q Q) Q :=
-  fun _ hz => (ZFSet.mem_sep.1 hz).1
-
-theorem triple_mem_indexedBinaryLift (T U Q B J p q v : ZFSet.{u}) :
-    ZFSet.pair (ZFSet.pair p q) v ∈ indexedBinaryLift T U Q B J ↔
-      p ∈ Q ∧ q ∈ Q ∧ v ∈ Q ∧ ∃ i ∈ T, ∃ b e, ∃ x ∈ U, ∃ y ∈ U, ∃ z ∈ U,
-        ZFSet.pair i b ∈ B ∧ ZFSet.pair i e ∈ J ∧
-          ZFSet.pair x p ∈ e ∧ ZFSet.pair y q ∈ e ∧ ZFSet.pair z v ∈ e ∧
-            ZFSet.pair (ZFSet.pair x y) z ∈ b := by
-  rw [indexedBinaryLift, ZFSet.mem_sep]
-  constructor
-  · rintro ⟨_, p', hp, q', hq, v', hv, i, hi, b, _, e, _, x, hx, y, hy, z, hz,
-      equal, operation, inclusion, first, second, third, source⟩
-    obtain ⟨pq, rfl⟩ := ZFSet.pair_inj.1 equal
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 pq
-    exact ⟨hp, hq, hv, i, hi, b, e, x, hx, y, hy, z, hz,
-      operation, inclusion, first, second, third, source⟩
-  · rintro ⟨hp, hq, hv, i, hi, b, e, x, hx, y, hy, z, hz,
-      operation, inclusion, first, second, third, source⟩
-    exact ⟨ZFSet.pair_mem_prod.2 ⟨ZFSet.pair_mem_prod.2 ⟨hp, hq⟩, hv⟩,
-      p, hp, q, hq, v, hv, i, hi, b, pair_second_mem_doubleUnion operation,
-      e, pair_second_mem_doubleUnion inclusion, x, hx, y, hy, z, hz,
-      rfl, operation, inclusion, first, second, third, source⟩
-
-theorem indexedRelationLift_rank_lt {o : Ordinal.{u}} (limit : Order.IsSuccLimit o)
-    (T U R J : ZFSet.{u}) {Q : ZFSet.{u}} (rank : ZFSet.rank Q < o) :
-    ZFSet.rank (indexedRelationLift T U Q R J) < o :=
-  (ZFSet.rank_mono (indexedRelationLift_subset T U Q R J)).trans_lt
-    (rank_product_lt limit rank rank)
-
-theorem indexedBinaryLift_rank_lt {o : Ordinal.{u}} (limit : Order.IsSuccLimit o)
-    (T U B J : ZFSet.{u}) {Q : ZFSet.{u}} (rank : ZFSet.rank Q < o) :
-    ZFSet.rank (indexedBinaryLift T U Q B J) < o :=
-  (ZFSet.rank_mono (indexedBinaryLift_subset T U Q B J)).trans_lt
-    (rank_product_lt limit (rank_product_lt limit rank rank) rank)
-
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Definability.PresentedGroupCodes
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing
+open SetRealization
+open scoped ZFSet
+universe u
+
+noncomputable def indexedRelationLift (T U Q R J : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => ∃ p ∈ Q, ∃ q ∈ Q, ∃ i ∈ T,
+    ∃ r ∈ ⋃₀ ⋃₀ R, ∃ e ∈ ⋃₀ ⋃₀ J, ∃ x ∈ U, ∃ y ∈ U,
+      z = ZFSet.pair p q ∧ ZFSet.pair i r ∈ R ∧ ZFSet.pair i e ∈ J ∧
+        ZFSet.pair x p ∈ e ∧ ZFSet.pair y q ∈ e ∧ ZFSet.pair x y ∈ r)
+    (ZFSet.prod Q Q)
+
+theorem indexedRelationLift_subset (T U Q R J : ZFSet.{u}) :
+    indexedRelationLift T U Q R J ⊆ ZFSet.prod Q Q :=
+  fun _ hz => (ZFSet.mem_sep.1 hz).1
+
+theorem pair_mem_indexedRelationLift (T U Q R J p q : ZFSet.{u}) :
+    ZFSet.pair p q ∈ indexedRelationLift T U Q R J ↔
+      p ∈ Q ∧ q ∈ Q ∧ ∃ i ∈ T, ∃ r e, ∃ x ∈ U, ∃ y ∈ U,
+        ZFSet.pair i r ∈ R ∧ ZFSet.pair i e ∈ J ∧
+          ZFSet.pair x p ∈ e ∧ ZFSet.pair y q ∈ e ∧ ZFSet.pair x y ∈ r := by
+  rw [indexedRelationLift, ZFSet.mem_sep]
+  constructor
+  · rintro ⟨_, p', hp, q', hq, i, hi, r, _, e, _, x, hx, y, hy, equal, relation, inclusion, first, second, source⟩
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
+    exact ⟨hp, hq, i, hi, r, e, x, hx, y, hy, relation, inclusion, first, second, source⟩
+  · rintro ⟨hp, hq, i, hi, r, e, x, hx, y, hy, relation, inclusion, first, second, source⟩
+    exact ⟨ZFSet.pair_mem_prod.2 ⟨hp, hq⟩, p, hp, q, hq, i, hi,
+      r, pair_second_mem_doubleUnion relation, e, pair_second_mem_doubleUnion inclusion,
+      x, hx, y, hy, rfl, relation, inclusion, first, second, source⟩
+
+noncomputable def indexedBinaryLift (T U Q B J : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun w => ∃ p ∈ Q, ∃ q ∈ Q, ∃ v ∈ Q, ∃ i ∈ T,
+    ∃ b ∈ ⋃₀ ⋃₀ B, ∃ e ∈ ⋃₀ ⋃₀ J, ∃ x ∈ U, ∃ y ∈ U, ∃ z ∈ U,
+      w = ZFSet.pair (ZFSet.pair p q) v ∧ ZFSet.pair i b ∈ B ∧ ZFSet.pair i e ∈ J ∧
+        ZFSet.pair x p ∈ e ∧ ZFSet.pair y q ∈ e ∧ ZFSet.pair z v ∈ e ∧
+          ZFSet.pair (ZFSet.pair x y) z ∈ b) (ZFSet.prod (ZFSet.prod Q Q) Q)
+
+theorem indexedBinaryLift_subset (T U Q B J : ZFSet.{u}) :
+    indexedBinaryLift T U Q B J ⊆ ZFSet.prod (ZFSet.prod Q Q) Q :=
+  fun _ hz => (ZFSet.mem_sep.1 hz).1
+
+theorem triple_mem_indexedBinaryLift (T U Q B J p q v : ZFSet.{u}) :
+    ZFSet.pair (ZFSet.pair p q) v ∈ indexedBinaryLift T U Q B J ↔
+      p ∈ Q ∧ q ∈ Q ∧ v ∈ Q ∧ ∃ i ∈ T, ∃ b e, ∃ x ∈ U, ∃ y ∈ U, ∃ z ∈ U,
+        ZFSet.pair i b ∈ B ∧ ZFSet.pair i e ∈ J ∧
+          ZFSet.pair x p ∈ e ∧ ZFSet.pair y q ∈ e ∧ ZFSet.pair z v ∈ e ∧
+            ZFSet.pair (ZFSet.pair x y) z ∈ b := by
+  rw [indexedBinaryLift, ZFSet.mem_sep]
+  constructor
+  · rintro ⟨_, p', hp, q', hq, v', hv, i, hi, b, _, e, _, x, hx, y, hy, z, hz,
+      equal, operation, inclusion, first, second, third, source⟩
+    obtain ⟨pq, rfl⟩ := ZFSet.pair_inj.1 equal
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 pq
+    exact ⟨hp, hq, hv, i, hi, b, e, x, hx, y, hy, z, hz,
+      operation, inclusion, first, second, third, source⟩
+  · rintro ⟨hp, hq, hv, i, hi, b, e, x, hx, y, hy, z, hz,
+      operation, inclusion, first, second, third, source⟩
+    exact ⟨ZFSet.pair_mem_prod.2 ⟨ZFSet.pair_mem_prod.2 ⟨hp, hq⟩, hv⟩,
+      p, hp, q, hq, v, hv, i, hi, b, pair_second_mem_doubleUnion operation,
+      e, pair_second_mem_doubleUnion inclusion, x, hx, y, hy, z, hz,
+      rfl, operation, inclusion, first, second, third, source⟩
+
+theorem indexedRelationLift_rank_lt {o : Ordinal.{u}} (limit : Order.IsSuccLimit o)
+    (T U R J : ZFSet.{u}) {Q : ZFSet.{u}} (rank : ZFSet.rank Q < o) :
+    ZFSet.rank (indexedRelationLift T U Q R J) < o :=
+  (ZFSet.rank_mono (indexedRelationLift_subset T U Q R J)).trans_lt
+    (rank_product_lt limit rank rank)
+
+theorem indexedBinaryLift_rank_lt {o : Ordinal.{u}} (limit : Order.IsSuccLimit o)
+    (T U B J : ZFSet.{u}) {Q : ZFSet.{u}} (rank : ZFSet.rank Q < o) :
+    ZFSet.rank (indexedBinaryLift T U Q B J) < o :=
+  (ZFSet.rank_mono (indexedBinaryLift_subset T U Q B J)).trans_lt
+    (rank_product_lt limit (rank_product_lt limit rank rank) rank)
+
+end PartitionPilot.Forcing
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/IndexedSubstructureCodes.lean

@@ -1,122 +1,122 @@
-import OAI.SetTheory.PartitionPrinciple.Geometry.SeparationTileCodes
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing
-open SetFormula
-universe u
-
-def indexedSuborderGraph (I B R domains : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => ∃ i ∈ I, ∃ v ∈ R, ∃ x ∈ B, ∃ y ∈ B,
-    z = ZFSet.pair i v ∧ v = ZFSet.pair x y ∧
-      ZFSet.pair i x ∈ domains ∧ ZFSet.pair i y ∈ domains) (ZFSet.prod I R)
-
-def indexedSubmeetGraph (I B μ domains : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => ∃ i ∈ I, ∃ v ∈ μ, ∃ x ∈ B, ∃ y ∈ B, ∃ w ∈ B,
-    z = ZFSet.pair i v ∧ v = ZFSet.pair (ZFSet.pair x y) w ∧
-      ZFSet.pair i x ∈ domains ∧ ZFSet.pair i y ∈ domains ∧ ZFSet.pair i w ∈ domains)
-    (ZFSet.prod I μ)
-
-theorem pair_mem_indexedSuborderGraph (I B R domains i v : ZFSet.{u}) :
-    ZFSet.pair i v ∈ indexedSuborderGraph I B R domains ↔
-      i ∈ I ∧ v ∈ R ∧ ∃ x ∈ relationFiber B domains i, ∃ y ∈ relationFiber B domains i,
-        v = ZFSet.pair x y := by
-  rw [indexedSuborderGraph, ZFSet.mem_sep]
-  constructor
-  · rintro ⟨_, j, hj, w, hw, x, hx, y, hy, equal, value, first, second⟩
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
-    exact ⟨hj, hw, x, (mem_relationFiber _ _ _ _).2 ⟨hx, first⟩,
-      y, (mem_relationFiber _ _ _ _).2 ⟨hy, second⟩, value⟩
-  · rintro ⟨hi, hv, x, hx, y, hy, equal⟩
-    obtain ⟨hx, first⟩ := (mem_relationFiber _ _ _ _).1 hx
-    obtain ⟨hy, second⟩ := (mem_relationFiber _ _ _ _).1 hy
-    exact ⟨ZFSet.pair_mem_prod.2 ⟨hi, hv⟩, i, hi, v, hv, x, hx, y, hy, rfl, equal, first, second⟩
-
-theorem pair_mem_indexedSubmeetGraph (I B μ domains i v : ZFSet.{u}) :
-    ZFSet.pair i v ∈ indexedSubmeetGraph I B μ domains ↔
-      i ∈ I ∧ v ∈ μ ∧ ∃ x ∈ relationFiber B domains i, ∃ y ∈ relationFiber B domains i,
-        ∃ w ∈ relationFiber B domains i, v = ZFSet.pair (ZFSet.pair x y) w := by
-  rw [indexedSubmeetGraph, ZFSet.mem_sep]
-  constructor
-  · rintro ⟨_, j, hj, v', hv, x, hx, y, hy, w, hw, equal, value, first, second, third⟩
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
-    exact ⟨hj, hv, x, (mem_relationFiber _ _ _ _).2 ⟨hx, first⟩,
-      y, (mem_relationFiber _ _ _ _).2 ⟨hy, second⟩,
-      w, (mem_relationFiber _ _ _ _).2 ⟨hw, third⟩, value⟩
-  · rintro ⟨hi, hv, x, hx, y, hy, w, hw, equal⟩
-    obtain ⟨hx, first⟩ := (mem_relationFiber _ _ _ _).1 hx
-    obtain ⟨hy, second⟩ := (mem_relationFiber _ _ _ _).1 hy
-    obtain ⟨hw, third⟩ := (mem_relationFiber _ _ _ _).1 hw
-    exact ⟨ZFSet.pair_mem_prod.2 ⟨hi, hv⟩, i, hi, v, hv, x, hx, y, hy,
-      w, hw, rfl, equal, first, second, third⟩
-
-theorem suborderFiber_pair_iff {I B R domains i x y : ZFSet.{u}} (hi : i ∈ I) :
-    ZFSet.pair x y ∈ relationFiber R (indexedSuborderGraph I B R domains) i ↔
-      ZFSet.pair x y ∈ R ∧ x ∈ relationFiber B domains i ∧ y ∈ relationFiber B domains i := by
-  rw [mem_relationFiber, pair_mem_indexedSuborderGraph]
-  constructor
-  · rintro ⟨hxy, _, _, a, ha, b, hb, equal⟩
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
-    exact ⟨hxy, ha, hb⟩
-  · rintro ⟨hxy, hx, hy⟩
-    exact ⟨hxy, hi, hxy, x, hx, y, hy, rfl⟩
-
-theorem submeetFiber_triple_iff {I B μ domains i x y w : ZFSet.{u}} (hi : i ∈ I) :
-    ZFSet.pair (ZFSet.pair x y) w ∈ relationFiber μ (indexedSubmeetGraph I B μ domains) i ↔
-      ZFSet.pair (ZFSet.pair x y) w ∈ μ ∧ x ∈ relationFiber B domains i ∧
-        y ∈ relationFiber B domains i ∧ w ∈ relationFiber B domains i := by
-  rw [mem_relationFiber, pair_mem_indexedSubmeetGraph]
-  constructor
-  · rintro ⟨hxy, _, _, a, ha, b, hb, c, hc, equal⟩
-    obtain ⟨ab, rfl⟩ := ZFSet.pair_inj.1 equal
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 ab
-    exact ⟨hxy, ha, hb, hc⟩
-  · rintro ⟨hxy, hx, hy, hw⟩
-    exact ⟨hxy, hi, hxy, x, hx, y, hy, w, hw, rfl⟩
-
-namespace BoundedFormula
-def indexedSuborderEntryFormula {n} (z I B R domains : Fin n) : BoundedFormula n :=
-  exMem I (exMem R.succ (exMem B.succ.succ (exMem B.succ.succ.succ
-    (.conj (orderedPairFormula z.succ.succ.succ.succ 3 2)
-      (.conj (orderedPairFormula 2 1 0)
-        (.conj (pairMembershipFormula 3 1 domains.succ.succ.succ.succ)
-          (pairMembershipFormula 3 0 domains.succ.succ.succ.succ)))))))
-
-def indexedSubmeetEntryFormula {n} (z I B μ domains : Fin n) : BoundedFormula n :=
-  exMem I (exMem μ.succ (exMem B.succ.succ (exMem B.succ.succ.succ (exMem B.succ.succ.succ.succ
-    (.conj (orderedPairFormula z.succ.succ.succ.succ.succ 4 3)
-      (.conj (orderedTripleFormula 3 2 1 0)
-        (.conj (pairMembershipFormula 4 2 domains.succ.succ.succ.succ.succ)
-          (.conj (pairMembershipFormula 4 1 domains.succ.succ.succ.succ.succ)
-            (pairMembershipFormula 4 0 domains.succ.succ.succ.succ.succ)))))))))
-
-theorem truth_indexedSuborderEntryFormula {n} (z I B R domains : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (indexedSuborderEntryFormula z I B R domains) env ↔
-      env z ∈ indexedSuborderGraph (env I) (env B) (env R) (env domains) := by
-  simp only [indexedSuborderEntryFormula, truth_exMem, Truth,
-    truth_orderedPairFormula, truth_pairMembershipFormula, indexedSuborderGraph, ZFSet.mem_sep]
-  refine ⟨fun h => ⟨?_, h⟩, And.right⟩
-  obtain ⟨i, hi, v, hv, _, _, _, _, equal, _⟩ := h
-  change env z = ZFSet.pair i v at equal
-  rw [equal]
-  exact ZFSet.pair_mem_prod.2 ⟨hi, hv⟩
-
-theorem truth_indexedSubmeetEntryFormula {n} (z I B μ domains : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (indexedSubmeetEntryFormula z I B μ domains) env ↔
-      env z ∈ indexedSubmeetGraph (env I) (env B) (env μ) (env domains) := by
-  simp only [indexedSubmeetEntryFormula, truth_exMem, Truth, truth_orderedPairFormula,
-    truth_orderedTripleFormula, truth_pairMembershipFormula, indexedSubmeetGraph, ZFSet.mem_sep]
-  refine ⟨fun h => ⟨?_, h⟩, And.right⟩
-  obtain ⟨i, hi, v, hv, _, _, _, _, _, _, equal, _⟩ := h
-  change env z = ZFSet.pair i v at equal
-  rw [equal]
-  exact ZFSet.pair_mem_prod.2 ⟨hi, hv⟩
-end BoundedFormula
-
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Geometry.SeparationTileCodes
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing
+open SetFormula
+universe u
+
+def indexedSuborderGraph (I B R domains : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => ∃ i ∈ I, ∃ v ∈ R, ∃ x ∈ B, ∃ y ∈ B,
+    z = ZFSet.pair i v ∧ v = ZFSet.pair x y ∧
+      ZFSet.pair i x ∈ domains ∧ ZFSet.pair i y ∈ domains) (ZFSet.prod I R)
+
+def indexedSubmeetGraph (I B μ domains : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => ∃ i ∈ I, ∃ v ∈ μ, ∃ x ∈ B, ∃ y ∈ B, ∃ w ∈ B,
+    z = ZFSet.pair i v ∧ v = ZFSet.pair (ZFSet.pair x y) w ∧
+      ZFSet.pair i x ∈ domains ∧ ZFSet.pair i y ∈ domains ∧ ZFSet.pair i w ∈ domains)
+    (ZFSet.prod I μ)
+
+theorem pair_mem_indexedSuborderGraph (I B R domains i v : ZFSet.{u}) :
+    ZFSet.pair i v ∈ indexedSuborderGraph I B R domains ↔
+      i ∈ I ∧ v ∈ R ∧ ∃ x ∈ relationFiber B domains i, ∃ y ∈ relationFiber B domains i,
+        v = ZFSet.pair x y := by
+  rw [indexedSuborderGraph, ZFSet.mem_sep]
+  constructor
+  · rintro ⟨_, j, hj, w, hw, x, hx, y, hy, equal, value, first, second⟩
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
+    exact ⟨hj, hw, x, (mem_relationFiber _ _ _ _).2 ⟨hx, first⟩,
+      y, (mem_relationFiber _ _ _ _).2 ⟨hy, second⟩, value⟩
+  · rintro ⟨hi, hv, x, hx, y, hy, equal⟩
+    obtain ⟨hx, first⟩ := (mem_relationFiber _ _ _ _).1 hx
+    obtain ⟨hy, second⟩ := (mem_relationFiber _ _ _ _).1 hy
+    exact ⟨ZFSet.pair_mem_prod.2 ⟨hi, hv⟩, i, hi, v, hv, x, hx, y, hy, rfl, equal, first, second⟩
+
+theorem pair_mem_indexedSubmeetGraph (I B μ domains i v : ZFSet.{u}) :
+    ZFSet.pair i v ∈ indexedSubmeetGraph I B μ domains ↔
+      i ∈ I ∧ v ∈ μ ∧ ∃ x ∈ relationFiber B domains i, ∃ y ∈ relationFiber B domains i,
+        ∃ w ∈ relationFiber B domains i, v = ZFSet.pair (ZFSet.pair x y) w := by
+  rw [indexedSubmeetGraph, ZFSet.mem_sep]
+  constructor
+  · rintro ⟨_, j, hj, v', hv, x, hx, y, hy, w, hw, equal, value, first, second, third⟩
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
+    exact ⟨hj, hv, x, (mem_relationFiber _ _ _ _).2 ⟨hx, first⟩,
+      y, (mem_relationFiber _ _ _ _).2 ⟨hy, second⟩,
+      w, (mem_relationFiber _ _ _ _).2 ⟨hw, third⟩, value⟩
+  · rintro ⟨hi, hv, x, hx, y, hy, w, hw, equal⟩
+    obtain ⟨hx, first⟩ := (mem_relationFiber _ _ _ _).1 hx
+    obtain ⟨hy, second⟩ := (mem_relationFiber _ _ _ _).1 hy
+    obtain ⟨hw, third⟩ := (mem_relationFiber _ _ _ _).1 hw
+    exact ⟨ZFSet.pair_mem_prod.2 ⟨hi, hv⟩, i, hi, v, hv, x, hx, y, hy,
+      w, hw, rfl, equal, first, second, third⟩
+
+theorem suborderFiber_pair_iff {I B R domains i x y : ZFSet.{u}} (hi : i ∈ I) :
+    ZFSet.pair x y ∈ relationFiber R (indexedSuborderGraph I B R domains) i ↔
+      ZFSet.pair x y ∈ R ∧ x ∈ relationFiber B domains i ∧ y ∈ relationFiber B domains i := by
+  rw [mem_relationFiber, pair_mem_indexedSuborderGraph]
+  constructor
+  · rintro ⟨hxy, _, _, a, ha, b, hb, equal⟩
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
+    exact ⟨hxy, ha, hb⟩
+  · rintro ⟨hxy, hx, hy⟩
+    exact ⟨hxy, hi, hxy, x, hx, y, hy, rfl⟩
+
+theorem submeetFiber_triple_iff {I B μ domains i x y w : ZFSet.{u}} (hi : i ∈ I) :
+    ZFSet.pair (ZFSet.pair x y) w ∈ relationFiber μ (indexedSubmeetGraph I B μ domains) i ↔
+      ZFSet.pair (ZFSet.pair x y) w ∈ μ ∧ x ∈ relationFiber B domains i ∧
+        y ∈ relationFiber B domains i ∧ w ∈ relationFiber B domains i := by
+  rw [mem_relationFiber, pair_mem_indexedSubmeetGraph]
+  constructor
+  · rintro ⟨hxy, _, _, a, ha, b, hb, c, hc, equal⟩
+    obtain ⟨ab, rfl⟩ := ZFSet.pair_inj.1 equal
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 ab
+    exact ⟨hxy, ha, hb, hc⟩
+  · rintro ⟨hxy, hx, hy, hw⟩
+    exact ⟨hxy, hi, hxy, x, hx, y, hy, w, hw, rfl⟩
+
+namespace BoundedFormula
+def indexedSuborderEntryFormula {n} (z I B R domains : Fin n) : BoundedFormula n :=
+  exMem I (exMem R.succ (exMem B.succ.succ (exMem B.succ.succ.succ
+    (.conj (orderedPairFormula z.succ.succ.succ.succ 3 2)
+      (.conj (orderedPairFormula 2 1 0)
+        (.conj (pairMembershipFormula 3 1 domains.succ.succ.succ.succ)
+          (pairMembershipFormula 3 0 domains.succ.succ.succ.succ)))))))
+
+def indexedSubmeetEntryFormula {n} (z I B μ domains : Fin n) : BoundedFormula n :=
+  exMem I (exMem μ.succ (exMem B.succ.succ (exMem B.succ.succ.succ (exMem B.succ.succ.succ.succ
+    (.conj (orderedPairFormula z.succ.succ.succ.succ.succ 4 3)
+      (.conj (orderedTripleFormula 3 2 1 0)
+        (.conj (pairMembershipFormula 4 2 domains.succ.succ.succ.succ.succ)
+          (.conj (pairMembershipFormula 4 1 domains.succ.succ.succ.succ.succ)
+            (pairMembershipFormula 4 0 domains.succ.succ.succ.succ.succ)))))))))
+
+theorem truth_indexedSuborderEntryFormula {n} (z I B R domains : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (indexedSuborderEntryFormula z I B R domains) env ↔
+      env z ∈ indexedSuborderGraph (env I) (env B) (env R) (env domains) := by
+  simp only [indexedSuborderEntryFormula, truth_exMem, Truth,
+    truth_orderedPairFormula, truth_pairMembershipFormula, indexedSuborderGraph, ZFSet.mem_sep]
+  refine ⟨fun h => ⟨?_, h⟩, And.right⟩
+  obtain ⟨i, hi, v, hv, _, _, _, _, equal, _⟩ := h
+  change env z = ZFSet.pair i v at equal
+  rw [equal]
+  exact ZFSet.pair_mem_prod.2 ⟨hi, hv⟩
+
+theorem truth_indexedSubmeetEntryFormula {n} (z I B μ domains : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (indexedSubmeetEntryFormula z I B μ domains) env ↔
+      env z ∈ indexedSubmeetGraph (env I) (env B) (env μ) (env domains) := by
+  simp only [indexedSubmeetEntryFormula, truth_exMem, Truth, truth_orderedPairFormula,
+    truth_orderedTripleFormula, truth_pairMembershipFormula, indexedSubmeetGraph, ZFSet.mem_sep]
+  refine ⟨fun h => ⟨?_, h⟩, And.right⟩
+  obtain ⟨i, hi, v, hv, _, _, _, _, _, _, equal, _⟩ := h
+  change env z = ZFSet.pair i v at equal
+  rw [equal]
+  exact ZFSet.pair_mem_prod.2 ⟨hi, hv⟩
+end BoundedFormula
+
+end PartitionPilot.Forcing
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/IndexedValueLiftCodes.lean

@@ -1,60 +1,60 @@
-import OAI.SetTheory.PartitionPrinciple.Geometry.GroundEligibleCaps
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing
-universe u
-
-noncomputable def indexedValueLift (T U Q V F J : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => ∃ i ∈ T, ∃ f ∈ ZFSet.sUnion (ZFSet.sUnion F),
-    ∃ e ∈ ZFSet.sUnion (ZFSet.sUnion J),
-    ∃ x ∈ U, ∃ q ∈ Q, ∃ v ∈ V,
-      z = ZFSet.pair q v ∧ ZFSet.pair i f ∈ F ∧ ZFSet.pair i e ∈ J ∧
-      ZFSet.pair x q ∈ e ∧ ZFSet.pair x v ∈ f) (ZFSet.prod Q V)
-
-theorem indexedValueLift_subset (T U Q V F J : ZFSet.{u}) :
-    indexedValueLift T U Q V F J ⊆ ZFSet.prod Q V := fun _ hz => (ZFSet.mem_sep.1 hz).1
-
-theorem pair_mem_indexedValueLift (T U Q V F J q v : ZFSet.{u}) :
-    ZFSet.pair q v ∈ indexedValueLift T U Q V F J ↔
-      q ∈ Q ∧ v ∈ V ∧ ∃ i ∈ T, ∃ f e, ∃ x ∈ U,
-        ZFSet.pair i f ∈ F ∧ ZFSet.pair i e ∈ J ∧
-        ZFSet.pair x q ∈ e ∧ ZFSet.pair x v ∈ f := by
-  rw [indexedValueLift, ZFSet.mem_sep]
-  constructor
-  · rintro ⟨_, i, hi, f, _, e, _, x, hx, p, hp, w, hw, equal, value, inclusion, image, entry⟩
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
-    exact ⟨hp, hw, i, hi, f, e, x, hx, value, inclusion, image, entry⟩
-  · rintro ⟨hq, hv, i, hi, f, e, x, hx, value, inclusion, image, entry⟩
-    exact ⟨ZFSet.pair_mem_prod.2 ⟨hq, hv⟩,
-      i, hi, f, pair_second_mem_doubleUnion value, e, pair_second_mem_doubleUnion inclusion,
-      x, hx, q, hq, v, hv, rfl, value, inclusion, image, entry⟩
-
-namespace BoundedFormula
-open SetFormula
-
-def indexedValueLiftEntryFormula : BoundedFormula 9 :=
-  exMem 1 (exMem 8 (exMem 10 (exMem 5 (exMem 7 (exMem 9
-    (.conj (orderedPairFormula 6 1 0)
-      (.conj (pairMembershipFormula 5 4 11)
-        (.conj (pairMembershipFormula 5 3 12)
-          (.conj (pairMembershipFormula 2 1 3) (pairMembershipFormula 2 0 4))))))))))
-
-theorem truth_indexedValueLiftEntryFormula (env : Fin 9 → ZFSet.{u}) :
-    Truth indexedValueLiftEntryFormula env ↔
-      ∃ i ∈ env 1, ∃ f ∈ env 7, ∃ e ∈ env 8, ∃ x ∈ env 2, ∃ q ∈ env 3, ∃ v ∈ env 4,
-        env 0 = ZFSet.pair q v ∧ ZFSet.pair i f ∈ env 5 ∧ ZFSet.pair i e ∈ env 6 ∧
-        ZFSet.pair x q ∈ e ∧ ZFSet.pair x v ∈ f := by
-  simp only [indexedValueLiftEntryFormula, truth_exMem, Truth,
-    truth_orderedPairFormula, truth_pairMembershipFormula]
-  rfl
-
-end BoundedFormula
-
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Geometry.GroundEligibleCaps
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing
+universe u
+
+noncomputable def indexedValueLift (T U Q V F J : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => ∃ i ∈ T, ∃ f ∈ ZFSet.sUnion (ZFSet.sUnion F),
+    ∃ e ∈ ZFSet.sUnion (ZFSet.sUnion J),
+    ∃ x ∈ U, ∃ q ∈ Q, ∃ v ∈ V,
+      z = ZFSet.pair q v ∧ ZFSet.pair i f ∈ F ∧ ZFSet.pair i e ∈ J ∧
+      ZFSet.pair x q ∈ e ∧ ZFSet.pair x v ∈ f) (ZFSet.prod Q V)
+
+theorem indexedValueLift_subset (T U Q V F J : ZFSet.{u}) :
+    indexedValueLift T U Q V F J ⊆ ZFSet.prod Q V := fun _ hz => (ZFSet.mem_sep.1 hz).1
+
+theorem pair_mem_indexedValueLift (T U Q V F J q v : ZFSet.{u}) :
+    ZFSet.pair q v ∈ indexedValueLift T U Q V F J ↔
+      q ∈ Q ∧ v ∈ V ∧ ∃ i ∈ T, ∃ f e, ∃ x ∈ U,
+        ZFSet.pair i f ∈ F ∧ ZFSet.pair i e ∈ J ∧
+        ZFSet.pair x q ∈ e ∧ ZFSet.pair x v ∈ f := by
+  rw [indexedValueLift, ZFSet.mem_sep]
+  constructor
+  · rintro ⟨_, i, hi, f, _, e, _, x, hx, p, hp, w, hw, equal, value, inclusion, image, entry⟩
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
+    exact ⟨hp, hw, i, hi, f, e, x, hx, value, inclusion, image, entry⟩
+  · rintro ⟨hq, hv, i, hi, f, e, x, hx, value, inclusion, image, entry⟩
+    exact ⟨ZFSet.pair_mem_prod.2 ⟨hq, hv⟩,
+      i, hi, f, pair_second_mem_doubleUnion value, e, pair_second_mem_doubleUnion inclusion,
+      x, hx, q, hq, v, hv, rfl, value, inclusion, image, entry⟩
+
+namespace BoundedFormula
+open SetFormula
+
+def indexedValueLiftEntryFormula : BoundedFormula 9 :=
+  exMem 1 (exMem 8 (exMem 10 (exMem 5 (exMem 7 (exMem 9
+    (.conj (orderedPairFormula 6 1 0)
+      (.conj (pairMembershipFormula 5 4 11)
+        (.conj (pairMembershipFormula 5 3 12)
+          (.conj (pairMembershipFormula 2 1 3) (pairMembershipFormula 2 0 4))))))))))
+
+theorem truth_indexedValueLiftEntryFormula (env : Fin 9 → ZFSet.{u}) :
+    Truth indexedValueLiftEntryFormula env ↔
+      ∃ i ∈ env 1, ∃ f ∈ env 7, ∃ e ∈ env 8, ∃ x ∈ env 2, ∃ q ∈ env 3, ∃ v ∈ env 4,
+        env 0 = ZFSet.pair q v ∧ ZFSet.pair i f ∈ env 5 ∧ ZFSet.pair i e ∈ env 6 ∧
+        ZFSet.pair x q ∈ e ∧ ZFSet.pair x v ∈ f := by
+  simp only [indexedValueLiftEntryFormula, truth_exMem, Truth,
+    truth_orderedPairFormula, truth_pairMembershipFormula]
+  rfl
+
+end BoundedFormula
+
+end PartitionPilot.Forcing
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/InitialMainAlgebraCodes.lean

@@ -1,202 +1,202 @@
-import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundMainStageFromCodes
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing.InitialMainAlgebra
-universe u
-
-def carrier : ZFSet.{u} := natSetCode 2
-def actors : ZFSet.{u} := natSetCode 1
-def bottom : ZFSet.{u} := natSetCode 0
-def top : ZFSet.{u} := natSetCode 1
-def identity : ZFSet.{u} := bottom
-def order : ZFSet.{u} :=
-  {ZFSet.pair bottom bottom, ZFSet.pair bottom top, ZFSet.pair top top}
-def meetGraph : ZFSet.{u} :=
-  {ZFSet.pair (ZFSet.pair bottom bottom) bottom,
-    ZFSet.pair (ZFSet.pair bottom top) bottom,
-    ZFSet.pair (ZFSet.pair top bottom) bottom,
-    ZFSet.pair (ZFSet.pair top top) top}
-def multiplication : ZFSet.{u} := {ZFSet.pair (ZFSet.pair identity identity) identity}
-def inverse : ZFSet.{u} := {ZFSet.pair identity identity}
-def action : ZFSet.{u} :=
-  {ZFSet.pair (ZFSet.pair identity bottom) bottom, ZFSet.pair (ZFSet.pair identity top) top}
-
-theorem bottom_ne_top : (bottom : ZFSet.{u}) ≠ top := by
-  intro equal
-  have := natSetCode_injective equal
-  exact Nat.zero_ne_one this
-
-theorem mem_carrier (x : ZFSet.{u}) : x ∈ carrier ↔ x = bottom ∨ x = top := by
-  change x ∈ insert (natSetCode 1) (insert (natSetCode 0) ∅) ↔ _
-  simp only [ZFSet.mem_insert_iff, ZFSet.notMem_empty, or_false]
-  exact or_comm
-
-theorem mem_actors (x : ZFSet.{u}) : x ∈ actors ↔ x = identity := by
-  change x ∈ insert (natSetCode 0) ∅ ↔ _
-  simp only [ZFSet.mem_insert_iff, ZFSet.notMem_empty, or_false]
-  rfl
-
-theorem bottom_mem : (bottom : ZFSet.{u}) ∈ carrier := (mem_carrier _).2 (Or.inl rfl)
-theorem top_mem : (top : ZFSet.{u}) ∈ carrier := (mem_carrier _).2 (Or.inr rfl)
-theorem identity_mem : (identity : ZFSet.{u}) ∈ actors := (mem_actors _).2 rfl
-
-theorem pair_mem_order (x y : ZFSet.{u}) : ZFSet.pair x y ∈ order ↔
-    (x = bottom ∧ y = bottom) ∨ (x = bottom ∧ y = top) ∨ (x = top ∧ y = top) := by
-  simp only [order, ZFSet.mem_insert_iff, ZFSet.mem_singleton, ZFSet.pair_inj]
-
-theorem pair_mem_meetGraph (x y z : ZFSet.{u}) : ZFSet.pair (ZFSet.pair x y) z ∈ meetGraph ↔
-    ((x = bottom ∧ y = bottom) ∧ z = bottom) ∨
-      ((x = bottom ∧ y = top) ∧ z = bottom) ∨
-        ((x = top ∧ y = bottom) ∧ z = bottom) ∨ ((x = top ∧ y = top) ∧ z = top) := by
-  simp only [meetGraph, ZFSet.mem_insert_iff, ZFSet.mem_singleton, ZFSet.pair_inj]
-
-theorem pair_mem_multiplication (x y z : ZFSet.{u}) :
-    ZFSet.pair (ZFSet.pair x y) z ∈ multiplication ↔ (x = identity ∧ y = identity) ∧ z = identity := by
-  simp only [multiplication, ZFSet.mem_singleton, ZFSet.pair_inj]
-
-theorem pair_mem_inverse (x y : ZFSet.{u}) : ZFSet.pair x y ∈ inverse ↔ x = identity ∧ y = identity := by
-  simp only [inverse, ZFSet.mem_singleton, ZFSet.pair_inj]
-
-theorem pair_mem_action (g x y : ZFSet.{u}) : ZFSet.pair (ZFSet.pair g x) y ∈ action ↔
-    ((g = identity ∧ x = bottom) ∧ y = bottom) ∨ ((g = identity ∧ x = top) ∧ y = top) := by
-  simp only [action, ZFSet.mem_pair, ZFSet.pair_inj]
-
-theorem least (x : ZFSet.{u}) (hx : x ∈ carrier) : ZFSet.pair bottom x ∈ order := by
-  rcases (mem_carrier x).1 hx with rfl | rfl <;> simp [pair_mem_order]
-
-theorem greatest (x : ZFSet.{u}) (hx : x ∈ carrier) : ZFSet.pair x top ∈ order := by
-  rcases (mem_carrier x).1 hx with rfl | rfl <;> simp [pair_mem_order]
-
-theorem meet_function : ZFSet.IsFunc (ZFSet.prod carrier carrier) carrier (meetGraph : ZFSet.{u}) := by
-  constructor
-  · intro z hz
-    simp only [meetGraph, ZFSet.mem_insert_iff, ZFSet.mem_singleton] at hz
-    rcases hz with rfl | rfl | rfl | rfl
-    · exact ZFSet.pair_mem_prod.2 ⟨ZFSet.pair_mem_prod.2 ⟨bottom_mem, bottom_mem⟩, bottom_mem⟩
-    · exact ZFSet.pair_mem_prod.2 ⟨ZFSet.pair_mem_prod.2 ⟨bottom_mem, top_mem⟩, bottom_mem⟩
-    · exact ZFSet.pair_mem_prod.2 ⟨ZFSet.pair_mem_prod.2 ⟨top_mem, bottom_mem⟩, bottom_mem⟩
-    · exact ZFSet.pair_mem_prod.2 ⟨ZFSet.pair_mem_prod.2 ⟨top_mem, top_mem⟩, top_mem⟩
-  · intro z hz
-    obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 hz
-    rcases (mem_carrier x).1 hx with rfl | rfl <;>
-      rcases (mem_carrier y).1 hy with rfl | rfl <;>
-        simp [pair_mem_meetGraph, bottom_ne_top, Ne.symm bottom_ne_top]
-
-theorem meet_code : MeetOrderCode carrier order (meetGraph : ZFSet.{u}) where
-  order := {
-    relation := by
-      intro z hz
-      simp only [order, ZFSet.mem_insert_iff, ZFSet.mem_singleton] at hz
-      rcases hz with rfl | rfl | rfl <;> simp [mem_carrier]
-    refl := by
-      intro x hx
-      rcases (mem_carrier x).1 hx with rfl | rfl <;> simp [pair_mem_order]
-    antisymm := by
-      intro x hx y hy xy yx
-      rcases (mem_carrier x).1 hx with rfl | rfl <;>
-        rcases (mem_carrier y).1 hy with rfl | rfl <;>
-          simp_all [pair_mem_order, bottom_ne_top, Ne.symm bottom_ne_top]
-    trans := by
-      intro x hx y hy z hz xy yz
-      rcases (mem_carrier x).1 hx with rfl | rfl <;>
-        rcases (mem_carrier y).1 hy with rfl | rfl <;>
-          rcases (mem_carrier z).1 hz with rfl | rfl <;>
-            simp_all [pair_mem_order, bottom_ne_top, Ne.symm bottom_ne_top] }
-  operation := meet_function
-  lower_left := by
-    intro x y z entry
-    rcases (pair_mem_meetGraph x y z).1 entry with
-      ⟨⟨rfl, rfl⟩, rfl⟩ | ⟨⟨rfl, rfl⟩, rfl⟩ | ⟨⟨rfl, rfl⟩, rfl⟩ | ⟨⟨rfl, rfl⟩, rfl⟩ <;>
-        simp [pair_mem_order]
-  lower_right := by
-    intro x y z entry
-    rcases (pair_mem_meetGraph x y z).1 entry with
-      ⟨⟨rfl, rfl⟩, rfl⟩ | ⟨⟨rfl, rfl⟩, rfl⟩ | ⟨⟨rfl, rfl⟩, rfl⟩ | ⟨⟨rfl, rfl⟩, rfl⟩ <;>
-        simp [pair_mem_order]
-  greatest := by
-    intro x y z w hw entry wx wy
-    rcases (pair_mem_meetGraph x y z).1 entry with
-      ⟨⟨rfl, rfl⟩, rfl⟩ | ⟨⟨rfl, rfl⟩, rfl⟩ | ⟨⟨rfl, rfl⟩, rfl⟩ | ⟨⟨rfl, rfl⟩, rfl⟩ <;>
-        rcases (mem_carrier w).1 hw with rfl | rfl <;>
-          simp_all [pair_mem_order, bottom_ne_top, Ne.symm bottom_ne_top]
-
-theorem group_code : GroupCode actors multiplication inverse (identity : ZFSet.{u}) where
-  mul_function := by
-    constructor
-    · intro z hz
-      rw [multiplication, ZFSet.mem_singleton] at hz
-      rw [hz]
-      simp [mem_actors]
-    · intro z hz
-      obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 hz
-      obtain rfl := (mem_actors x).1 hx
-      obtain rfl := (mem_actors y).1 hy
-      simp [pair_mem_multiplication]
-  inv_function := by
-    constructor
-    · intro z hz
-      rw [inverse, ZFSet.mem_singleton] at hz
-      rw [hz]
-      simp [mem_actors]
-    · intro x hx
-      obtain rfl := (mem_actors x).1 hx
-      simp [pair_mem_inverse]
-  identity_mem := identity_mem
-  one_mul := by
-    intro x hx
-    obtain rfl := (mem_actors x).1 hx
-    simp [pair_mem_multiplication]
-  mul_one := by
-    intro x hx
-    obtain rfl := (mem_actors x).1 hx
-    simp [pair_mem_multiplication]
-  inv_mul := by
-    intro x hx y hy entry
-    obtain rfl := (mem_actors x).1 hx
-    obtain rfl := (mem_actors y).1 hy
-    simp [pair_mem_multiplication]
-  mul_assoc := by
-    intro x hx y hy z hz a ha b hb c hc xy yz az
-    obtain rfl := (mem_actors x).1 hx
-    obtain rfl := (mem_actors y).1 hy
-    obtain rfl := (mem_actors z).1 hz
-    obtain rfl := (mem_actors a).1 ha
-    obtain rfl := (mem_actors b).1 hb
-    obtain rfl := (mem_actors c).1 hc
-    simp [pair_mem_multiplication]
-
-theorem action_code : PosetActionCode actors carrier multiplication identity order (action : ZFSet.{u}) where
-  function := by
-    constructor
-    · intro z hz
-      simp only [action, ZFSet.mem_pair] at hz
-      rcases hz with rfl | rfl <;> simp [mem_actors, mem_carrier]
-    · intro z hz
-      obtain ⟨g, hg, x, hx, rfl⟩ := ZFSet.mem_prod.1 hz
-      obtain rfl := (mem_actors g).1 hg
-      rcases (mem_carrier x).1 hx with rfl | rfl <;>
-        simp [pair_mem_action, bottom_ne_top, Ne.symm bottom_ne_top]
-  one := by
-    intro x hx
-    rcases (mem_carrier x).1 hx with rfl | rfl <;> simp [pair_mem_action]
-  mul := by
-    intro g hg h hh k hk x hx y hy z hz gh hxY gyZ
-    obtain rfl := (mem_actors g).1 hg
-    obtain rfl := (mem_actors h).1 hh
-    obtain rfl := (mem_actors k).1 hk
-    rcases (pair_mem_action identity x y).1 hxY with ⟨⟨_, rfl⟩, rfl⟩ | ⟨⟨_, rfl⟩, rfl⟩ <;>
-      simpa only using gyZ
-  monotone := by
-    intro g hg x hx y hy z hz w hw gxZ gyW xy
-    rcases (pair_mem_action g x z).1 gxZ with ⟨⟨rfl, rfl⟩, rfl⟩ | ⟨⟨rfl, rfl⟩, rfl⟩ <;>
-      rcases (pair_mem_action identity y w).1 gyW with ⟨⟨_, rfl⟩, rfl⟩ | ⟨⟨_, rfl⟩, rfl⟩ <;>
-        exact xy
-
-end PartitionPilot.Forcing.InitialMainAlgebra
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundMainStageFromCodes
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing.InitialMainAlgebra
+universe u
+
+def carrier : ZFSet.{u} := natSetCode 2
+def actors : ZFSet.{u} := natSetCode 1
+def bottom : ZFSet.{u} := natSetCode 0
+def top : ZFSet.{u} := natSetCode 1
+def identity : ZFSet.{u} := bottom
+def order : ZFSet.{u} :=
+  {ZFSet.pair bottom bottom, ZFSet.pair bottom top, ZFSet.pair top top}
+def meetGraph : ZFSet.{u} :=
+  {ZFSet.pair (ZFSet.pair bottom bottom) bottom,
+    ZFSet.pair (ZFSet.pair bottom top) bottom,
+    ZFSet.pair (ZFSet.pair top bottom) bottom,
+    ZFSet.pair (ZFSet.pair top top) top}
+def multiplication : ZFSet.{u} := {ZFSet.pair (ZFSet.pair identity identity) identity}
+def inverse : ZFSet.{u} := {ZFSet.pair identity identity}
+def action : ZFSet.{u} :=
+  {ZFSet.pair (ZFSet.pair identity bottom) bottom, ZFSet.pair (ZFSet.pair identity top) top}
+
+theorem bottom_ne_top : (bottom : ZFSet.{u}) ≠ top := by
+  intro equal
+  have := natSetCode_injective equal
+  exact Nat.zero_ne_one this
+
+theorem mem_carrier (x : ZFSet.{u}) : x ∈ carrier ↔ x = bottom ∨ x = top := by
+  change x ∈ insert (natSetCode 1) (insert (natSetCode 0) ∅) ↔ _
+  simp only [ZFSet.mem_insert_iff, ZFSet.notMem_empty, or_false]
+  exact or_comm
+
+theorem mem_actors (x : ZFSet.{u}) : x ∈ actors ↔ x = identity := by
+  change x ∈ insert (natSetCode 0) ∅ ↔ _
+  simp only [ZFSet.mem_insert_iff, ZFSet.notMem_empty, or_false]
+  rfl
+
+theorem bottom_mem : (bottom : ZFSet.{u}) ∈ carrier := (mem_carrier _).2 (Or.inl rfl)
+theorem top_mem : (top : ZFSet.{u}) ∈ carrier := (mem_carrier _).2 (Or.inr rfl)
+theorem identity_mem : (identity : ZFSet.{u}) ∈ actors := (mem_actors _).2 rfl
+
+theorem pair_mem_order (x y : ZFSet.{u}) : ZFSet.pair x y ∈ order ↔
+    (x = bottom ∧ y = bottom) ∨ (x = bottom ∧ y = top) ∨ (x = top ∧ y = top) := by
+  simp only [order, ZFSet.mem_insert_iff, ZFSet.mem_singleton, ZFSet.pair_inj]
+
+theorem pair_mem_meetGraph (x y z : ZFSet.{u}) : ZFSet.pair (ZFSet.pair x y) z ∈ meetGraph ↔
+    ((x = bottom ∧ y = bottom) ∧ z = bottom) ∨
+      ((x = bottom ∧ y = top) ∧ z = bottom) ∨
+        ((x = top ∧ y = bottom) ∧ z = bottom) ∨ ((x = top ∧ y = top) ∧ z = top) := by
+  simp only [meetGraph, ZFSet.mem_insert_iff, ZFSet.mem_singleton, ZFSet.pair_inj]
+
+theorem pair_mem_multiplication (x y z : ZFSet.{u}) :
+    ZFSet.pair (ZFSet.pair x y) z ∈ multiplication ↔ (x = identity ∧ y = identity) ∧ z = identity := by
+  simp only [multiplication, ZFSet.mem_singleton, ZFSet.pair_inj]
+
+theorem pair_mem_inverse (x y : ZFSet.{u}) : ZFSet.pair x y ∈ inverse ↔ x = identity ∧ y = identity := by
+  simp only [inverse, ZFSet.mem_singleton, ZFSet.pair_inj]
+
+theorem pair_mem_action (g x y : ZFSet.{u}) : ZFSet.pair (ZFSet.pair g x) y ∈ action ↔
+    ((g = identity ∧ x = bottom) ∧ y = bottom) ∨ ((g = identity ∧ x = top) ∧ y = top) := by
+  simp only [action, ZFSet.mem_pair, ZFSet.pair_inj]
+
+theorem least (x : ZFSet.{u}) (hx : x ∈ carrier) : ZFSet.pair bottom x ∈ order := by
+  rcases (mem_carrier x).1 hx with rfl | rfl <;> simp [pair_mem_order]
+
+theorem greatest (x : ZFSet.{u}) (hx : x ∈ carrier) : ZFSet.pair x top ∈ order := by
+  rcases (mem_carrier x).1 hx with rfl | rfl <;> simp [pair_mem_order]
+
+theorem meet_function : ZFSet.IsFunc (ZFSet.prod carrier carrier) carrier (meetGraph : ZFSet.{u}) := by
+  constructor
+  · intro z hz
+    simp only [meetGraph, ZFSet.mem_insert_iff, ZFSet.mem_singleton] at hz
+    rcases hz with rfl | rfl | rfl | rfl
+    · exact ZFSet.pair_mem_prod.2 ⟨ZFSet.pair_mem_prod.2 ⟨bottom_mem, bottom_mem⟩, bottom_mem⟩
+    · exact ZFSet.pair_mem_prod.2 ⟨ZFSet.pair_mem_prod.2 ⟨bottom_mem, top_mem⟩, bottom_mem⟩
+    · exact ZFSet.pair_mem_prod.2 ⟨ZFSet.pair_mem_prod.2 ⟨top_mem, bottom_mem⟩, bottom_mem⟩
+    · exact ZFSet.pair_mem_prod.2 ⟨ZFSet.pair_mem_prod.2 ⟨top_mem, top_mem⟩, top_mem⟩
+  · intro z hz
+    obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 hz
+    rcases (mem_carrier x).1 hx with rfl | rfl <;>
+      rcases (mem_carrier y).1 hy with rfl | rfl <;>
+        simp [pair_mem_meetGraph, bottom_ne_top, Ne.symm bottom_ne_top]
+
+theorem meet_code : MeetOrderCode carrier order (meetGraph : ZFSet.{u}) where
+  order := {
+    relation := by
+      intro z hz
+      simp only [order, ZFSet.mem_insert_iff, ZFSet.mem_singleton] at hz
+      rcases hz with rfl | rfl | rfl <;> simp [mem_carrier]
+    refl := by
+      intro x hx
+      rcases (mem_carrier x).1 hx with rfl | rfl <;> simp [pair_mem_order]
+    antisymm := by
+      intro x hx y hy xy yx
+      rcases (mem_carrier x).1 hx with rfl | rfl <;>
+        rcases (mem_carrier y).1 hy with rfl | rfl <;>
+          simp_all [pair_mem_order, bottom_ne_top, Ne.symm bottom_ne_top]
+    trans := by
+      intro x hx y hy z hz xy yz
+      rcases (mem_carrier x).1 hx with rfl | rfl <;>
+        rcases (mem_carrier y).1 hy with rfl | rfl <;>
+          rcases (mem_carrier z).1 hz with rfl | rfl <;>
+            simp_all [pair_mem_order, bottom_ne_top, Ne.symm bottom_ne_top] }
+  operation := meet_function
+  lower_left := by
+    intro x y z entry
+    rcases (pair_mem_meetGraph x y z).1 entry with
+      ⟨⟨rfl, rfl⟩, rfl⟩ | ⟨⟨rfl, rfl⟩, rfl⟩ | ⟨⟨rfl, rfl⟩, rfl⟩ | ⟨⟨rfl, rfl⟩, rfl⟩ <;>
+        simp [pair_mem_order]
+  lower_right := by
+    intro x y z entry
+    rcases (pair_mem_meetGraph x y z).1 entry with
+      ⟨⟨rfl, rfl⟩, rfl⟩ | ⟨⟨rfl, rfl⟩, rfl⟩ | ⟨⟨rfl, rfl⟩, rfl⟩ | ⟨⟨rfl, rfl⟩, rfl⟩ <;>
+        simp [pair_mem_order]
+  greatest := by
+    intro x y z w hw entry wx wy
+    rcases (pair_mem_meetGraph x y z).1 entry with
+      ⟨⟨rfl, rfl⟩, rfl⟩ | ⟨⟨rfl, rfl⟩, rfl⟩ | ⟨⟨rfl, rfl⟩, rfl⟩ | ⟨⟨rfl, rfl⟩, rfl⟩ <;>
+        rcases (mem_carrier w).1 hw with rfl | rfl <;>
+          simp_all [pair_mem_order, bottom_ne_top, Ne.symm bottom_ne_top]
+
+theorem group_code : GroupCode actors multiplication inverse (identity : ZFSet.{u}) where
+  mul_function := by
+    constructor
+    · intro z hz
+      rw [multiplication, ZFSet.mem_singleton] at hz
+      rw [hz]
+      simp [mem_actors]
+    · intro z hz
+      obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 hz
+      obtain rfl := (mem_actors x).1 hx
+      obtain rfl := (mem_actors y).1 hy
+      simp [pair_mem_multiplication]
+  inv_function := by
+    constructor
+    · intro z hz
+      rw [inverse, ZFSet.mem_singleton] at hz
+      rw [hz]
+      simp [mem_actors]
+    · intro x hx
+      obtain rfl := (mem_actors x).1 hx
+      simp [pair_mem_inverse]
+  identity_mem := identity_mem
+  one_mul := by
+    intro x hx
+    obtain rfl := (mem_actors x).1 hx
+    simp [pair_mem_multiplication]
+  mul_one := by
+    intro x hx
+    obtain rfl := (mem_actors x).1 hx
+    simp [pair_mem_multiplication]
+  inv_mul := by
+    intro x hx y hy entry
+    obtain rfl := (mem_actors x).1 hx
+    obtain rfl := (mem_actors y).1 hy
+    simp [pair_mem_multiplication]
+  mul_assoc := by
+    intro x hx y hy z hz a ha b hb c hc xy yz az
+    obtain rfl := (mem_actors x).1 hx
+    obtain rfl := (mem_actors y).1 hy
+    obtain rfl := (mem_actors z).1 hz
+    obtain rfl := (mem_actors a).1 ha
+    obtain rfl := (mem_actors b).1 hb
+    obtain rfl := (mem_actors c).1 hc
+    simp [pair_mem_multiplication]
+
+theorem action_code : PosetActionCode actors carrier multiplication identity order (action : ZFSet.{u}) where
+  function := by
+    constructor
+    · intro z hz
+      simp only [action, ZFSet.mem_pair] at hz
+      rcases hz with rfl | rfl <;> simp [mem_actors, mem_carrier]
+    · intro z hz
+      obtain ⟨g, hg, x, hx, rfl⟩ := ZFSet.mem_prod.1 hz
+      obtain rfl := (mem_actors g).1 hg
+      rcases (mem_carrier x).1 hx with rfl | rfl <;>
+        simp [pair_mem_action, bottom_ne_top, Ne.symm bottom_ne_top]
+  one := by
+    intro x hx
+    rcases (mem_carrier x).1 hx with rfl | rfl <;> simp [pair_mem_action]
+  mul := by
+    intro g hg h hh k hk x hx y hy z hz gh hxY gyZ
+    obtain rfl := (mem_actors g).1 hg
+    obtain rfl := (mem_actors h).1 hh
+    obtain rfl := (mem_actors k).1 hk
+    rcases (pair_mem_action identity x y).1 hxY with ⟨⟨_, rfl⟩, rfl⟩ | ⟨⟨_, rfl⟩, rfl⟩ <;>
+      simpa only using gyZ
+  monotone := by
+    intro g hg x hx y hy z hz w hw gxZ gyW xy
+    rcases (pair_mem_action g x z).1 gxZ with ⟨⟨rfl, rfl⟩, rfl⟩ | ⟨⟨rfl, rfl⟩, rfl⟩ <;>
+      rcases (pair_mem_action identity y w).1 gyW with ⟨⟨_, rfl⟩, rfl⟩ | ⟨⟨_, rfl⟩, rfl⟩ <;>
+        exact xy
+
+end PartitionPilot.Forcing.InitialMainAlgebra
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/IntervalEmbeddingFormulas.lean

@@ -1,67 +1,67 @@
-import OAI.SetTheory.PartitionPrinciple.Geometry.IntervalEmbeddingFamilyCodes
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing.BoundedFormula
-
-open SetFormula
-universe u
-
-def intervalEmbeddingFormula {n} (A D rA rD lo hi f : Fin n) : BoundedFormula n :=
-  let lift (i : Fin n) : Fin (n + 4) := i.succ.succ.succ.succ
-  let order : BoundedFormula n :=
-    .allMem A (.allMem A.succ (.allMem D.succ.succ (.allMem D.succ.succ.succ
-      (imp (pairMembershipFormula 3 1 (lift f))
-        (imp (pairMembershipFormula 2 0 (lift f))
-          (iffFormula (pairMembershipFormula 3 2 (lift rA))
-            (pairMembershipFormula 1 0 (lift rD))))))))
-  let inside : BoundedFormula n :=
-    .allMem A (.allMem D.succ (imp (pairMembershipFormula 1 0 f.succ.succ)
-      (.conj (pairMembershipFormula lo.succ.succ 0 rD.succ.succ)
-        (pairMembershipFormula 0 hi.succ.succ rD.succ.succ))))
-  .conj (injectionFormula A D f) (.conj order inside)
-
-theorem truth_intervalEmbeddingFormula {n} (A D rA rD lo hi f : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (intervalEmbeddingFormula A D rA rD lo hi f) env ↔
-      IntervalEmbeddingCode (env A) (env D) (env rA) (env rD) (env lo) (env hi) (env f) := by
-  simp only [intervalEmbeddingFormula, Truth, truth_injectionFormula,
-    truth_imp, truth_pairMembershipFormula, truth_iffFormula]
-  change (InjectionCode (env A) (env D) (env f) ∧
-    (∀ a ∈ env A, ∀ b ∈ env A, ∀ q ∈ env D, ∀ z ∈ env D,
-      ZFSet.pair a q ∈ env f → ZFSet.pair b z ∈ env f →
-        (ZFSet.pair a b ∈ env rA ↔ ZFSet.pair q z ∈ env rD)) ∧
-    (∀ a ∈ env A, ∀ q ∈ env D, ZFSet.pair a q ∈ env f →
-      ZFSet.pair (env lo) q ∈ env rD ∧ ZFSet.pair q (env hi) ∈ env rD)) ↔ _
-  constructor
-  · rintro ⟨injection, order, inside⟩
-    refine ⟨injection, ?_, ?_⟩
-    · intro a b q z first second
-      have aq := ZFSet.pair_mem_prod.1 (injection.function.1 first)
-      have bz := ZFSet.pair_mem_prod.1 (injection.function.1 second)
-      exact order a aq.1 b bz.1 q aq.2 z bz.2 first second
-    · intro a q entry
-      have aq := ZFSet.pair_mem_prod.1 (injection.function.1 entry)
-      exact inside a aq.1 q aq.2 entry
-  · intro code
-    refine ⟨code.injection, ?_, ?_⟩
-    · intro a _ b _ q _ z _ first second
-      exact code.order a b q z first second
-    · intro a _ q _ entry
-      exact code.inside a q entry
-
-theorem realize_intervalEmbeddingFormula (M : TransitiveGround.{u}) {n}
-    (A D rA rD lo hi f : Fin n) (env : Fin n → ZFSet.{u})
-    (members : ∀ i, env i ∈ M.sets) :
-    Realize M.sets (intervalEmbeddingFormula A D rA rD lo hi f).toFormula env ↔
-      IntervalEmbeddingCode (env A) (env D) (env rA) (env rD) (env lo) (env hi) (env f) :=
-  (realize_toFormula M _ env members).trans
-    (truth_intervalEmbeddingFormula A D rA rD lo hi f env)
-
-end PartitionPilot.Forcing.BoundedFormula
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Geometry.IntervalEmbeddingFamilyCodes
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing.BoundedFormula
+
+open SetFormula
+universe u
+
+def intervalEmbeddingFormula {n} (A D rA rD lo hi f : Fin n) : BoundedFormula n :=
+  let lift (i : Fin n) : Fin (n + 4) := i.succ.succ.succ.succ
+  let order : BoundedFormula n :=
+    .allMem A (.allMem A.succ (.allMem D.succ.succ (.allMem D.succ.succ.succ
+      (imp (pairMembershipFormula 3 1 (lift f))
+        (imp (pairMembershipFormula 2 0 (lift f))
+          (iffFormula (pairMembershipFormula 3 2 (lift rA))
+            (pairMembershipFormula 1 0 (lift rD))))))))
+  let inside : BoundedFormula n :=
+    .allMem A (.allMem D.succ (imp (pairMembershipFormula 1 0 f.succ.succ)
+      (.conj (pairMembershipFormula lo.succ.succ 0 rD.succ.succ)
+        (pairMembershipFormula 0 hi.succ.succ rD.succ.succ))))
+  .conj (injectionFormula A D f) (.conj order inside)
+
+theorem truth_intervalEmbeddingFormula {n} (A D rA rD lo hi f : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (intervalEmbeddingFormula A D rA rD lo hi f) env ↔
+      IntervalEmbeddingCode (env A) (env D) (env rA) (env rD) (env lo) (env hi) (env f) := by
+  simp only [intervalEmbeddingFormula, Truth, truth_injectionFormula,
+    truth_imp, truth_pairMembershipFormula, truth_iffFormula]
+  change (InjectionCode (env A) (env D) (env f) ∧
+    (∀ a ∈ env A, ∀ b ∈ env A, ∀ q ∈ env D, ∀ z ∈ env D,
+      ZFSet.pair a q ∈ env f → ZFSet.pair b z ∈ env f →
+        (ZFSet.pair a b ∈ env rA ↔ ZFSet.pair q z ∈ env rD)) ∧
+    (∀ a ∈ env A, ∀ q ∈ env D, ZFSet.pair a q ∈ env f →
+      ZFSet.pair (env lo) q ∈ env rD ∧ ZFSet.pair q (env hi) ∈ env rD)) ↔ _
+  constructor
+  · rintro ⟨injection, order, inside⟩
+    refine ⟨injection, ?_, ?_⟩
+    · intro a b q z first second
+      have aq := ZFSet.pair_mem_prod.1 (injection.function.1 first)
+      have bz := ZFSet.pair_mem_prod.1 (injection.function.1 second)
+      exact order a aq.1 b bz.1 q aq.2 z bz.2 first second
+    · intro a q entry
+      have aq := ZFSet.pair_mem_prod.1 (injection.function.1 entry)
+      exact inside a aq.1 q aq.2 entry
+  · intro code
+    refine ⟨code.injection, ?_, ?_⟩
+    · intro a _ b _ q _ z _ first second
+      exact code.order a b q z first second
+    · intro a _ q _ entry
+      exact code.inside a q entry
+
+theorem realize_intervalEmbeddingFormula (M : TransitiveGround.{u}) {n}
+    (A D rA rD lo hi f : Fin n) (env : Fin n → ZFSet.{u})
+    (members : ∀ i, env i ∈ M.sets) :
+    Realize M.sets (intervalEmbeddingFormula A D rA rD lo hi f).toFormula env ↔
+      IntervalEmbeddingCode (env A) (env D) (env rA) (env rD) (env lo) (env hi) (env f) :=
+  (realize_toFormula M _ env members).trans
+    (truth_intervalEmbeddingFormula A D rA rD lo hi f env)
+
+end PartitionPilot.Forcing.BoundedFormula
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/IntervalHeightFormulas.lean

@@ -1,62 +1,62 @@
-import OAI.SetTheory.PartitionPrinciple.Geometry.GroundCodedBinaryHeights
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing.BoundedFormula
-open SetFormula
-universe u
-
-def intervalHeightFormula {n} (L r D rD lo hi f : Fin n) : BoundedFormula n :=
-  let lift (i : Fin n) : Fin (n + 4) := i.succ.succ.succ.succ
-  let strict : BoundedFormula n :=
-    .allMem L (.allMem L.succ (.allMem D.succ.succ (.allMem D.succ.succ.succ
-      (imp (.neg (.equal 3 2)) (imp (pairMembershipFormula 3 2 (lift r))
-        (imp (pairMembershipFormula 3 1 (lift f))
-          (imp (pairMembershipFormula 2 0 (lift f)) (pairMembershipFormula 1 0 (lift rD)))))))))
-  let inside : BoundedFormula n :=
-    .allMem L (.allMem D.succ (imp (pairMembershipFormula 1 0 f.succ.succ)
-      (.conj (pairMembershipFormula lo.succ.succ 0 rD.succ.succ)
-        (pairMembershipFormula 0 hi.succ.succ rD.succ.succ))))
-  .conj (functionFormula L D f) (.conj strict inside)
-
-theorem truth_intervalHeightFormula {n} (L r D rD lo hi f : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (intervalHeightFormula L r D rD lo hi f) env ↔
-      IntervalHeightCode (env L) (env r) (env D) (env rD) (env lo) (env hi) (env f) := by
-  simp only [intervalHeightFormula, Truth, truth_functionFormula,
-    truth_imp, truth_pairMembershipFormula]
-  change (ZFSet.IsFunc (env L) (env D) (env f) ∧
-    (∀ x ∈ env L, ∀ y ∈ env L, ∀ a ∈ env D, ∀ b ∈ env D,
-      x ≠ y → ZFSet.pair x y ∈ env r → ZFSet.pair x a ∈ env f →
-        ZFSet.pair y b ∈ env f → ZFSet.pair a b ∈ env rD) ∧
-    (∀ x ∈ env L, ∀ a ∈ env D, ZFSet.pair x a ∈ env f →
-      ZFSet.pair (env lo) a ∈ env rD ∧ ZFSet.pair a (env hi) ∈ env rD)) ↔ _
-  constructor
-  · rintro ⟨function, strict, inside⟩
-    refine ⟨⟨function, ?_⟩, ?_⟩
-    · intro x hx y hy different lower a b first second
-      exact strict x hx y hy a (ZFSet.pair_mem_prod.1 (function.1 first)).2
-        b (ZFSet.pair_mem_prod.1 (function.1 second)).2 different lower first second
-    · intro x a entry
-      have bounds := ZFSet.pair_mem_prod.1 (function.1 entry)
-      exact inside x bounds.1 a bounds.2 entry
-  · intro code
-    refine ⟨code.function, ?_, ?_⟩
-    · intro x hx y hy a _ b _ different lower first second
-      exact code.strict x hx y hy different lower a b first second
-    · intro x _ a _ entry
-      exact code.inside x a entry
-
-theorem realize_intervalHeightFormula (M : TransitiveGround.{u}) {n}
-    (L r D rD lo hi f : Fin n) (env : Fin n → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets) :
-    Realize M.sets (intervalHeightFormula L r D rD lo hi f).toFormula env ↔
-      IntervalHeightCode (env L) (env r) (env D) (env rD) (env lo) (env hi) (env f) :=
-  (realize_toFormula M _ env members).trans (truth_intervalHeightFormula L r D rD lo hi f env)
-
-end PartitionPilot.Forcing.BoundedFormula
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Geometry.GroundCodedBinaryHeights
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing.BoundedFormula
+open SetFormula
+universe u
+
+def intervalHeightFormula {n} (L r D rD lo hi f : Fin n) : BoundedFormula n :=
+  let lift (i : Fin n) : Fin (n + 4) := i.succ.succ.succ.succ
+  let strict : BoundedFormula n :=
+    .allMem L (.allMem L.succ (.allMem D.succ.succ (.allMem D.succ.succ.succ
+      (imp (.neg (.equal 3 2)) (imp (pairMembershipFormula 3 2 (lift r))
+        (imp (pairMembershipFormula 3 1 (lift f))
+          (imp (pairMembershipFormula 2 0 (lift f)) (pairMembershipFormula 1 0 (lift rD)))))))))
+  let inside : BoundedFormula n :=
+    .allMem L (.allMem D.succ (imp (pairMembershipFormula 1 0 f.succ.succ)
+      (.conj (pairMembershipFormula lo.succ.succ 0 rD.succ.succ)
+        (pairMembershipFormula 0 hi.succ.succ rD.succ.succ))))
+  .conj (functionFormula L D f) (.conj strict inside)
+
+theorem truth_intervalHeightFormula {n} (L r D rD lo hi f : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (intervalHeightFormula L r D rD lo hi f) env ↔
+      IntervalHeightCode (env L) (env r) (env D) (env rD) (env lo) (env hi) (env f) := by
+  simp only [intervalHeightFormula, Truth, truth_functionFormula,
+    truth_imp, truth_pairMembershipFormula]
+  change (ZFSet.IsFunc (env L) (env D) (env f) ∧
+    (∀ x ∈ env L, ∀ y ∈ env L, ∀ a ∈ env D, ∀ b ∈ env D,
+      x ≠ y → ZFSet.pair x y ∈ env r → ZFSet.pair x a ∈ env f →
+        ZFSet.pair y b ∈ env f → ZFSet.pair a b ∈ env rD) ∧
+    (∀ x ∈ env L, ∀ a ∈ env D, ZFSet.pair x a ∈ env f →
+      ZFSet.pair (env lo) a ∈ env rD ∧ ZFSet.pair a (env hi) ∈ env rD)) ↔ _
+  constructor
+  · rintro ⟨function, strict, inside⟩
+    refine ⟨⟨function, ?_⟩, ?_⟩
+    · intro x hx y hy different lower a b first second
+      exact strict x hx y hy a (ZFSet.pair_mem_prod.1 (function.1 first)).2
+        b (ZFSet.pair_mem_prod.1 (function.1 second)).2 different lower first second
+    · intro x a entry
+      have bounds := ZFSet.pair_mem_prod.1 (function.1 entry)
+      exact inside x bounds.1 a bounds.2 entry
+  · intro code
+    refine ⟨code.function, ?_, ?_⟩
+    · intro x hx y hy a _ b _ different lower first second
+      exact code.strict x hx y hy different lower a b first second
+    · intro x _ a _ entry
+      exact code.inside x a entry
+
+theorem realize_intervalHeightFormula (M : TransitiveGround.{u}) {n}
+    (L r D rD lo hi f : Fin n) (env : Fin n → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets) :
+    Realize M.sets (intervalHeightFormula L r D rD lo hi f).toFormula env ↔
+      IntervalHeightCode (env L) (env r) (env D) (env rD) (env lo) (env hi) (env f) :=
+  (realize_toFormula M _ env members).trans (truth_intervalHeightFormula L r D rD lo hi f env)
+
+end PartitionPilot.Forcing.BoundedFormula
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/IntervalSequenceFormulas.lean

@@ -1,277 +1,277 @@
-import OAI.SetTheory.PartitionPrinciple.Geometry.GroundIntervalSelection
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing
-
-universe u
-
-structure IntervalSequenceCode (N A D rA rD e lo hi t : ZFSet.{u}) : Prop where
-  function : ZFSet.IsFunc N D t
-  inside : ∀ i q, ZFSet.pair i q ∈ t → ZFSet.pair lo q ∈ rD ∧ ZFSet.pair q hi ∈ rD
-  agree : ∀ i j a b q z, ZFSet.pair i a ∈ e → ZFSet.pair j b ∈ e →
-    ZFSet.pair i q ∈ t → ZFSet.pair j z ∈ t → (a = b ↔ q = z)
-  order : ∀ i j a b q z, ZFSet.pair i a ∈ e → ZFSet.pair j b ∈ e →
-    ZFSet.pair i q ∈ t → ZFSet.pair j z ∈ t →
-      (ZFSet.pair a b ∈ rA ↔ ZFSet.pair q z ∈ rD)
-
-def intervalNextCandidate (N A D rA rD e lo hi p y : ZFSet.{u}) : Prop :=
-  y ∈ D ∧ ZFSet.pair lo y ∈ rD ∧ ZFSet.pair y hi ∈ rD ∧
-    ∀ i ∈ N, ∀ a ∈ A, ∀ b ∈ A, ∀ z ∈ D,
-      ZFSet.pair i a ∈ e → ZFSet.pair N b ∈ e → ZFSet.pair i z ∈ p →
-        ((a = b ↔ z = y) ∧ (ZFSet.pair a b ∈ rA ↔ ZFSet.pair z y ∈ rD) ∧
-          (ZFSet.pair b a ∈ rA ↔ ZFSet.pair y z ∈ rD))
-
-theorem pair_mem_intervalSequenceInsert (N p y i q : ZFSet.{u}) :
-    ZFSet.pair i q ∈ insert (ZFSet.pair N y) p ↔
-      (i = N ∧ q = y) ∨ ZFSet.pair i q ∈ p := by
-  rw [ZFSet.mem_insert_iff, ZFSet.pair_inj]
-
-namespace IntervalSequenceCode
-
-theorem empty (A D rA rD e lo hi : ZFSet.{u}) : IntervalSequenceCode ∅ A D rA rD e lo hi ∅ := by
-  refine ⟨⟨ZFSet.empty_subset _, fun i hi => False.elim (ZFSet.notMem_empty i hi)⟩, ?_, ?_, ?_⟩
-  · intro i q h
-    exact False.elim (ZFSet.notMem_empty _ h)
-  · intro i j a b q z _ _ h _
-    exact False.elim (ZFSet.notMem_empty _ h)
-  · intro i j a b q z _ _ h _
-    exact False.elim (ZFSet.notMem_empty _ h)
-
-theorem restrict {N A D rA rD e lo hi t B : ZFSet.{u}}
-    (code : IntervalSequenceCode N A D rA rD e lo hi t) (subset : B ⊆ N) :
-    IntervalSequenceCode B A D rA rD e lo hi (graphRestriction B t) := by
-  have function : FunctionGraphOn N t := ⟨D, code.function⟩
-  refine ⟨⟨?_, (function.restrict subset).to_isFunc.2⟩, ?_, ?_, ?_⟩
-  · intro z hz
-    obtain ⟨i, hi, q, rfl, entry⟩ := mem_graphRestriction.1 hz
-    exact ZFSet.pair_mem_prod.2 ⟨hi, (ZFSet.pair_mem_prod.1 (code.function.1 entry)).2⟩
-  · intro i q entry
-    exact code.inside i q (pair_mem_graphRestriction.1 entry).1
-  · intro i j a b q z ea eb qi zj
-    exact code.agree i j a b q z ea eb
-      (pair_mem_graphRestriction.1 qi).1 (pair_mem_graphRestriction.1 zj).1
-  · intro i j a b q z ea eb qi zj
-    exact code.order i j a b q z ea eb
-      (pair_mem_graphRestriction.1 qi).1 (pair_mem_graphRestriction.1 zj).1
-
-theorem insert {N A D rA rD e lo hi p y : ZFSet.{u}}
-    (code : IntervalSequenceCode N A D rA rD e lo hi p)
-    (enumeration : ZFSet.IsFunc ZFSet.omega A e)
-    (source : StrictLinearOrderCode A rA) (target : StrictLinearOrderCode D rD)
-    (candidate : intervalNextCandidate N A D rA rD e lo hi p y) :
-    IntervalSequenceCode (Insert.insert N N) A D rA rD e lo hi (Insert.insert (ZFSet.pair N y) p) := by
-  have function : FunctionGraphOn N p := ⟨D, code.function⟩
-  have enumFunction : FunctionGraphOn ZFSet.omega e := ⟨A, enumeration⟩
-  have cross (i a b q : ZFSet.{u}) (ea : ZFSet.pair i a ∈ e) (eb : ZFSet.pair N b ∈ e)
-      (qi : ZFSet.pair i q ∈ p) :
-      (a = b ↔ q = y) ∧ (ZFSet.pair a b ∈ rA ↔ ZFSet.pair q y ∈ rD) ∧
-        (ZFSet.pair b a ∈ rA ↔ ZFSet.pair y q ∈ rD) :=
-    candidate.2.2.2 i (ZFSet.pair_mem_prod.1 (code.function.1 qi)).1
-      a (ZFSet.pair_mem_prod.1 (enumeration.1 ea)).2
-      b (ZFSet.pair_mem_prod.1 (enumeration.1 eb)).2
-      q (ZFSet.pair_mem_prod.1 (code.function.1 qi)).2 ea eb qi
-  refine ⟨⟨?_, (function.successor y).to_isFunc.2⟩, ?_, ?_, ?_⟩
-  · intro z hz
-    rcases ZFSet.mem_insert_iff.1 hz with rfl | hz
-    · exact ZFSet.pair_mem_prod.2 ⟨ZFSet.mem_insert _ _, candidate.1⟩
-    · obtain ⟨i, hi, q, hq, rfl⟩ := ZFSet.mem_prod.1 (code.function.1 hz)
-      exact ZFSet.pair_mem_prod.2 ⟨ZFSet.mem_insert_of_mem _ hi, hq⟩
-  · intro i q entry
-    rcases (pair_mem_intervalSequenceInsert N p y i q).1 entry with ⟨rfl, rfl⟩ | entry
-    · exact ⟨candidate.2.1, candidate.2.2.1⟩
-    · exact code.inside i q entry
-  · intro i j a b q z ea eb qi zj
-    rcases (pair_mem_intervalSequenceInsert N p y i q).1 qi with ⟨hi, hq⟩ | qi
-    · subst i
-      subst q
-      rcases (pair_mem_intervalSequenceInsert N p y j z).1 zj with ⟨hj, hz⟩ | zj
-      · subst j
-        subst z
-        have equal := enumFunction.unique ea eb
-        exact ⟨fun _ => rfl, fun _ => equal⟩
-      · have relation := (cross j b a z eb ea zj).1
-        exact ⟨fun h => (relation.1 h.symm).symm, fun h => (relation.2 h.symm).symm⟩
-    · rcases (pair_mem_intervalSequenceInsert N p y j z).1 zj with ⟨hj, hz⟩ | zj
-      · subst j
-        subst z
-        exact (cross i a b q ea eb qi).1
-      · exact code.agree i j a b q z ea eb qi zj
-  · intro i j a b q z ea eb qi zj
-    rcases (pair_mem_intervalSequenceInsert N p y i q).1 qi with ⟨hi, hq⟩ | qi
-    · subst i
-      subst q
-      rcases (pair_mem_intervalSequenceInsert N p y j z).1 zj with ⟨hj, hz⟩ | zj
-      · subst j
-        subst z
-        have equal := enumFunction.unique ea eb
-        subst b
-        exact iff_of_false (source.irrefl a (ZFSet.pair_mem_prod.1 (enumeration.1 ea)).2)
-          (target.irrefl y candidate.1)
-      · exact (cross j b a z eb ea zj).2.2
-    · rcases (pair_mem_intervalSequenceInsert N p y j z).1 zj with ⟨hj, hz⟩ | zj
-      · subst j
-        subst z
-        exact (cross i a b q ea eb qi).2.1
-      · exact code.order i j a b q z ea eb qi zj
-
-end IntervalSequenceCode
-
-end PartitionPilot.Forcing
-
-
-
-namespace PartitionPilot.Forcing
-
-universe u
-
-def leastIntervalNextCandidate (N A D rA rD e lo hi p c y : ZFSet.{u}) : Prop :=
-  intervalNextCandidate N A D rA rD e lo hi p y ∧
-    ∃ n ∈ ZFSet.omega, ZFSet.pair y n ∈ c ∧
-      ∀ z ∈ D, intervalNextCandidate N A D rA rD e lo hi p z →
-        ∀ m ∈ n, ZFSet.pair z m ∉ c
-
-theorem leastIntervalNextCandidate_unique {N A D rA rD e lo hi p c x y : ZFSet.{u}}
-    (injection : InjectionCode D ZFSet.omega c)
-    (hx : leastIntervalNextCandidate N A D rA rD e lo hi p c x)
-    (hy : leastIntervalNextCandidate N A D rA rD e lo hi p c y) : x = y := by
-  obtain ⟨xValid, n, hn, xn, leastX⟩ := hx
-  obtain ⟨yValid, m, hm, ym, leastY⟩ := hy
-  obtain ⟨k, rfl⟩ := (mem_omega_iff_natSetCode n).1 hn
-  obtain ⟨l, rfl⟩ := (mem_omega_iff_natSetCode m).1 hm
-  rcases lt_trichotomy k l with smaller | equal | larger
-  · exact False.elim (leastY x xValid.1 xValid (natSetCode k)
-      ((natSetCode_mem_iff k l).2 smaller) xn)
-  · subst l
-    exact injection.injective x y (natSetCode k) xn ym
-  · exact False.elim (leastX y yValid.1 yValid (natSetCode l)
-      ((natSetCode_mem_iff l k).2 larger) ym)
-
-theorem leastIntervalNextCandidate_exists_unique {N A D rA rD e lo hi p c : ZFSet.{u}}
-    (injection : InjectionCode D ZFSet.omega c)
-    (candidate : ∃ y, intervalNextCandidate N A D rA rD e lo hi p y) :
-    ∃! y, leastIntervalNextCandidate N A D rA rD e lo hi p c y := by
-  classical
-  let valid : Nat → Prop := fun n => ∃ y, intervalNextCandidate N A D rA rD e lo hi p y ∧
-    ZFSet.pair y (natSetCode n) ∈ c
-  have existsValid : ∃ n, valid n := by
-    obtain ⟨y, hy⟩ := candidate
-    obtain ⟨a, entry, _⟩ := injection.function.2 y hy.1
-    have aNat := (ZFSet.pair_mem_prod.1 (injection.function.1 entry)).2
-    obtain ⟨n, rfl⟩ := (mem_omega_iff_natSetCode a).1 aNat
-    exact ⟨n, y, hy, entry⟩
-  obtain ⟨y, hy, entry⟩ := Nat.find_spec existsValid
-  have selected : leastIntervalNextCandidate N A D rA rD e lo hi p c y := by
-    refine ⟨hy, natSetCode (Nat.find existsValid), natSetCode_mem_omega _, entry, ?_⟩
-    intro z _ hz m hm smaller
-    obtain ⟨k, lower, equal⟩ := (mem_natSetCode m (Nat.find existsValid)).1 hm
-    have validK : valid k := ⟨z, hz, equal ▸ smaller⟩
-    exact Nat.not_lt_of_ge (Nat.find_min' existsValid validK) lower
-  exact ⟨y, selected, fun z hz => leastIntervalNextCandidate_unique injection hz selected⟩
-
-namespace BoundedFormula
-
-open SetFormula
-
-def iffFormula {n} (φ ψ : BoundedFormula n) : BoundedFormula n :=
-  .conj (imp φ ψ) (imp ψ φ)
-
-theorem truth_iffFormula {n} (φ ψ : BoundedFormula n) (env : Fin n → ZFSet.{u}) :
-    Truth (iffFormula φ ψ) env ↔ (Truth φ env ↔ Truth ψ env) := by
-  simp only [iffFormula, Truth, truth_imp]
-  exact ⟨fun h => ⟨h.1, h.2⟩, fun h => ⟨h.mp, h.mpr⟩⟩
-
-def intervalNextCandidateFormula {n} (N A D rA rD e lo hi p y : Fin n) : BoundedFormula n :=
-  let lift (i : Fin n) : Fin (n + 4) := i.succ.succ.succ.succ
-  .conj (.mem y D) (.conj (pairMembershipFormula lo y rD)
-    (.conj (pairMembershipFormula y hi rD)
-      (.allMem N (.allMem A.succ (.allMem A.succ.succ (.allMem D.succ.succ.succ
-        (imp (pairMembershipFormula 3 2 (lift e))
-          (imp (pairMembershipFormula (lift N) 1 (lift e))
-            (imp (pairMembershipFormula 3 0 (lift p))
-              (.conj (iffFormula (.equal 2 1) (.equal 0 (lift y)))
-                (.conj (iffFormula (pairMembershipFormula 2 1 (lift rA))
-                    (pairMembershipFormula 0 (lift y) (lift rD)))
-                  (iffFormula (pairMembershipFormula 1 2 (lift rA))
-                    (pairMembershipFormula (lift y) 0 (lift rD))))))))))))))
-
-theorem truth_intervalNextCandidateFormula {n} (N A D rA rD e lo hi p y : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (intervalNextCandidateFormula N A D rA rD e lo hi p y) env ↔
-      intervalNextCandidate (env N) (env A) (env D) (env rA) (env rD) (env e)
-        (env lo) (env hi) (env p) (env y) := by
-  simp only [intervalNextCandidateFormula, Truth, truth_pairMembershipFormula,
-    truth_imp, truth_iffFormula]
-  rfl
-
-def leastIntervalNextCandidateFormula {n} (N A D rA rD e lo hi p c y omega : Fin n) : BoundedFormula n :=
-  .conj (intervalNextCandidateFormula N A D rA rD e lo hi p y)
-    (exMem omega (.conj (pairMembershipFormula y.succ 0 c.succ)
-      (.allMem D.succ (imp
-        (intervalNextCandidateFormula N.succ.succ A.succ.succ D.succ.succ rA.succ.succ
-          rD.succ.succ e.succ.succ lo.succ.succ hi.succ.succ p.succ.succ 0)
-        (.allMem 1 (.neg (pairMembershipFormula 1 0 c.succ.succ.succ)))))))
-
-theorem truth_leastIntervalNextCandidateFormula {n} (N A D rA rD e lo hi p c y omega : Fin n)
-    (env : Fin n → ZFSet.{u}) (hOmega : env omega = ZFSet.omega) :
-    Truth (leastIntervalNextCandidateFormula N A D rA rD e lo hi p c y omega) env ↔
-      leastIntervalNextCandidate (env N) (env A) (env D) (env rA) (env rD) (env e)
-        (env lo) (env hi) (env p) (env c) (env y) := by
-  simp only [leastIntervalNextCandidateFormula, Truth, truth_exMem, truth_imp,
-    truth_pairMembershipFormula, truth_intervalNextCandidateFormula]
-  change (intervalNextCandidate (env N) (env A) (env D) (env rA) (env rD) (env e)
-      (env lo) (env hi) (env p) (env y) ∧
-    ∃ k ∈ env omega, ZFSet.pair (env y) k ∈ env c ∧
-      ∀ z ∈ env D, intervalNextCandidate (env N) (env A) (env D) (env rA) (env rD) (env e)
-        (env lo) (env hi) (env p) z → ∀ m ∈ k, ZFSet.pair z m ∉ env c) ↔ _
-  rw [hOmega]
-  rfl
-
-theorem realize_leastIntervalNextCandidateFormula (M : TransitiveGround.{u}) {n}
-    (N A D rA rD e lo hi p c y omega : Fin n) (env : Fin n → ZFSet.{u})
-    (members : ∀ i, env i ∈ M.sets) (hOmega : env omega = ZFSet.omega) :
-    Realize M.sets (leastIntervalNextCandidateFormula N A D rA rD e lo hi p c y omega).toFormula env ↔
-      leastIntervalNextCandidate (env N) (env A) (env D) (env rA) (env rD) (env e)
-        (env lo) (env hi) (env p) (env c) (env y) :=
-  (realize_toFormula M _ env members).trans
-    (truth_leastIntervalNextCandidateFormula N A D rA rD e lo hi p c y omega env hOmega)
-
-end BoundedFormula
-
-namespace SetFormula
-
-def intervalSequenceStepFormula : SetFormula 12 :=
-  (BoundedFormula.leastIntervalNextCandidateFormula 0 3 4 5 6 7 8 9 1 10 2 11).toFormula
-
-end SetFormula
-
-namespace TransitiveGround
-
-open SetFormula
-
-theorem realize_intervalSequenceStepFormula (M : TransitiveGround.{u})
-    (env : Fin 12 → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets)
-    (hOmega : env 11 = ZFSet.omega) :
-    Realize M.sets intervalSequenceStepFormula env ↔
-      leastIntervalNextCandidate (env 0) (env 3) (env 4) (env 5) (env 6) (env 7)
-        (env 8) (env 9) (env 1) (env 10) (env 2) :=
-  BoundedFormula.realize_leastIntervalNextCandidateFormula M 0 3 4 5 6 7 8 9 1 10 2 11
-    env members hOmega
-
-theorem exists_unique_ground_intervalNext (M : TransitiveGround.{u})
-    {N A D rA rD e lo hi p c : ZFSet.{u}} (hD : D ∈ M.sets)
-    (injection : InjectionCode D ZFSet.omega c)
-    (candidate : ∃ y, intervalNextCandidate N A D rA rD e lo hi p y) :
-    ∃! y, y ∈ M.sets ∧ leastIntervalNextCandidate N A D rA rD e lo hi p c y := by
-  obtain ⟨y, selected, unique⟩ := leastIntervalNextCandidate_exists_unique injection candidate
-  exact ⟨y, ⟨M.transitive hD selected.1.1, selected⟩, fun z hz => unique z hz.2⟩
-
-end TransitiveGround
-
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Geometry.GroundIntervalSelection
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing
+
+universe u
+
+structure IntervalSequenceCode (N A D rA rD e lo hi t : ZFSet.{u}) : Prop where
+  function : ZFSet.IsFunc N D t
+  inside : ∀ i q, ZFSet.pair i q ∈ t → ZFSet.pair lo q ∈ rD ∧ ZFSet.pair q hi ∈ rD
+  agree : ∀ i j a b q z, ZFSet.pair i a ∈ e → ZFSet.pair j b ∈ e →
+    ZFSet.pair i q ∈ t → ZFSet.pair j z ∈ t → (a = b ↔ q = z)
+  order : ∀ i j a b q z, ZFSet.pair i a ∈ e → ZFSet.pair j b ∈ e →
+    ZFSet.pair i q ∈ t → ZFSet.pair j z ∈ t →
+      (ZFSet.pair a b ∈ rA ↔ ZFSet.pair q z ∈ rD)
+
+def intervalNextCandidate (N A D rA rD e lo hi p y : ZFSet.{u}) : Prop :=
+  y ∈ D ∧ ZFSet.pair lo y ∈ rD ∧ ZFSet.pair y hi ∈ rD ∧
+    ∀ i ∈ N, ∀ a ∈ A, ∀ b ∈ A, ∀ z ∈ D,
+      ZFSet.pair i a ∈ e → ZFSet.pair N b ∈ e → ZFSet.pair i z ∈ p →
+        ((a = b ↔ z = y) ∧ (ZFSet.pair a b ∈ rA ↔ ZFSet.pair z y ∈ rD) ∧
+          (ZFSet.pair b a ∈ rA ↔ ZFSet.pair y z ∈ rD))
+
+theorem pair_mem_intervalSequenceInsert (N p y i q : ZFSet.{u}) :
+    ZFSet.pair i q ∈ insert (ZFSet.pair N y) p ↔
+      (i = N ∧ q = y) ∨ ZFSet.pair i q ∈ p := by
+  rw [ZFSet.mem_insert_iff, ZFSet.pair_inj]
+
+namespace IntervalSequenceCode
+
+theorem empty (A D rA rD e lo hi : ZFSet.{u}) : IntervalSequenceCode ∅ A D rA rD e lo hi ∅ := by
+  refine ⟨⟨ZFSet.empty_subset _, fun i hi => False.elim (ZFSet.notMem_empty i hi)⟩, ?_, ?_, ?_⟩
+  · intro i q h
+    exact False.elim (ZFSet.notMem_empty _ h)
+  · intro i j a b q z _ _ h _
+    exact False.elim (ZFSet.notMem_empty _ h)
+  · intro i j a b q z _ _ h _
+    exact False.elim (ZFSet.notMem_empty _ h)
+
+theorem restrict {N A D rA rD e lo hi t B : ZFSet.{u}}
+    (code : IntervalSequenceCode N A D rA rD e lo hi t) (subset : B ⊆ N) :
+    IntervalSequenceCode B A D rA rD e lo hi (graphRestriction B t) := by
+  have function : FunctionGraphOn N t := ⟨D, code.function⟩
+  refine ⟨⟨?_, (function.restrict subset).to_isFunc.2⟩, ?_, ?_, ?_⟩
+  · intro z hz
+    obtain ⟨i, hi, q, rfl, entry⟩ := mem_graphRestriction.1 hz
+    exact ZFSet.pair_mem_prod.2 ⟨hi, (ZFSet.pair_mem_prod.1 (code.function.1 entry)).2⟩
+  · intro i q entry
+    exact code.inside i q (pair_mem_graphRestriction.1 entry).1
+  · intro i j a b q z ea eb qi zj
+    exact code.agree i j a b q z ea eb
+      (pair_mem_graphRestriction.1 qi).1 (pair_mem_graphRestriction.1 zj).1
+  · intro i j a b q z ea eb qi zj
+    exact code.order i j a b q z ea eb
+      (pair_mem_graphRestriction.1 qi).1 (pair_mem_graphRestriction.1 zj).1
+
+theorem insert {N A D rA rD e lo hi p y : ZFSet.{u}}
+    (code : IntervalSequenceCode N A D rA rD e lo hi p)
+    (enumeration : ZFSet.IsFunc ZFSet.omega A e)
+    (source : StrictLinearOrderCode A rA) (target : StrictLinearOrderCode D rD)
+    (candidate : intervalNextCandidate N A D rA rD e lo hi p y) :
+    IntervalSequenceCode (Insert.insert N N) A D rA rD e lo hi (Insert.insert (ZFSet.pair N y) p) := by
+  have function : FunctionGraphOn N p := ⟨D, code.function⟩
+  have enumFunction : FunctionGraphOn ZFSet.omega e := ⟨A, enumeration⟩
+  have cross (i a b q : ZFSet.{u}) (ea : ZFSet.pair i a ∈ e) (eb : ZFSet.pair N b ∈ e)
+      (qi : ZFSet.pair i q ∈ p) :
+      (a = b ↔ q = y) ∧ (ZFSet.pair a b ∈ rA ↔ ZFSet.pair q y ∈ rD) ∧
+        (ZFSet.pair b a ∈ rA ↔ ZFSet.pair y q ∈ rD) :=
+    candidate.2.2.2 i (ZFSet.pair_mem_prod.1 (code.function.1 qi)).1
+      a (ZFSet.pair_mem_prod.1 (enumeration.1 ea)).2
+      b (ZFSet.pair_mem_prod.1 (enumeration.1 eb)).2
+      q (ZFSet.pair_mem_prod.1 (code.function.1 qi)).2 ea eb qi
+  refine ⟨⟨?_, (function.successor y).to_isFunc.2⟩, ?_, ?_, ?_⟩
+  · intro z hz
+    rcases ZFSet.mem_insert_iff.1 hz with rfl | hz
+    · exact ZFSet.pair_mem_prod.2 ⟨ZFSet.mem_insert _ _, candidate.1⟩
+    · obtain ⟨i, hi, q, hq, rfl⟩ := ZFSet.mem_prod.1 (code.function.1 hz)
+      exact ZFSet.pair_mem_prod.2 ⟨ZFSet.mem_insert_of_mem _ hi, hq⟩
+  · intro i q entry
+    rcases (pair_mem_intervalSequenceInsert N p y i q).1 entry with ⟨rfl, rfl⟩ | entry
+    · exact ⟨candidate.2.1, candidate.2.2.1⟩
+    · exact code.inside i q entry
+  · intro i j a b q z ea eb qi zj
+    rcases (pair_mem_intervalSequenceInsert N p y i q).1 qi with ⟨hi, hq⟩ | qi
+    · subst i
+      subst q
+      rcases (pair_mem_intervalSequenceInsert N p y j z).1 zj with ⟨hj, hz⟩ | zj
+      · subst j
+        subst z
+        have equal := enumFunction.unique ea eb
+        exact ⟨fun _ => rfl, fun _ => equal⟩
+      · have relation := (cross j b a z eb ea zj).1
+        exact ⟨fun h => (relation.1 h.symm).symm, fun h => (relation.2 h.symm).symm⟩
+    · rcases (pair_mem_intervalSequenceInsert N p y j z).1 zj with ⟨hj, hz⟩ | zj
+      · subst j
+        subst z
+        exact (cross i a b q ea eb qi).1
+      · exact code.agree i j a b q z ea eb qi zj
+  · intro i j a b q z ea eb qi zj
+    rcases (pair_mem_intervalSequenceInsert N p y i q).1 qi with ⟨hi, hq⟩ | qi
+    · subst i
+      subst q
+      rcases (pair_mem_intervalSequenceInsert N p y j z).1 zj with ⟨hj, hz⟩ | zj
+      · subst j
+        subst z
+        have equal := enumFunction.unique ea eb
+        subst b
+        exact iff_of_false (source.irrefl a (ZFSet.pair_mem_prod.1 (enumeration.1 ea)).2)
+          (target.irrefl y candidate.1)
+      · exact (cross j b a z eb ea zj).2.2
+    · rcases (pair_mem_intervalSequenceInsert N p y j z).1 zj with ⟨hj, hz⟩ | zj
+      · subst j
+        subst z
+        exact (cross i a b q ea eb qi).2.1
+      · exact code.order i j a b q z ea eb qi zj
+
+end IntervalSequenceCode
+
+end PartitionPilot.Forcing
+
+
+
+namespace PartitionPilot.Forcing
+
+universe u
+
+def leastIntervalNextCandidate (N A D rA rD e lo hi p c y : ZFSet.{u}) : Prop :=
+  intervalNextCandidate N A D rA rD e lo hi p y ∧
+    ∃ n ∈ ZFSet.omega, ZFSet.pair y n ∈ c ∧
+      ∀ z ∈ D, intervalNextCandidate N A D rA rD e lo hi p z →
+        ∀ m ∈ n, ZFSet.pair z m ∉ c
+
+theorem leastIntervalNextCandidate_unique {N A D rA rD e lo hi p c x y : ZFSet.{u}}
+    (injection : InjectionCode D ZFSet.omega c)
+    (hx : leastIntervalNextCandidate N A D rA rD e lo hi p c x)
+    (hy : leastIntervalNextCandidate N A D rA rD e lo hi p c y) : x = y := by
+  obtain ⟨xValid, n, hn, xn, leastX⟩ := hx
+  obtain ⟨yValid, m, hm, ym, leastY⟩ := hy
+  obtain ⟨k, rfl⟩ := (mem_omega_iff_natSetCode n).1 hn
+  obtain ⟨l, rfl⟩ := (mem_omega_iff_natSetCode m).1 hm
+  rcases lt_trichotomy k l with smaller | equal | larger
+  · exact False.elim (leastY x xValid.1 xValid (natSetCode k)
+      ((natSetCode_mem_iff k l).2 smaller) xn)
+  · subst l
+    exact injection.injective x y (natSetCode k) xn ym
+  · exact False.elim (leastX y yValid.1 yValid (natSetCode l)
+      ((natSetCode_mem_iff l k).2 larger) ym)
+
+theorem leastIntervalNextCandidate_exists_unique {N A D rA rD e lo hi p c : ZFSet.{u}}
+    (injection : InjectionCode D ZFSet.omega c)
+    (candidate : ∃ y, intervalNextCandidate N A D rA rD e lo hi p y) :
+    ∃! y, leastIntervalNextCandidate N A D rA rD e lo hi p c y := by
+  classical
+  let valid : Nat → Prop := fun n => ∃ y, intervalNextCandidate N A D rA rD e lo hi p y ∧
+    ZFSet.pair y (natSetCode n) ∈ c
+  have existsValid : ∃ n, valid n := by
+    obtain ⟨y, hy⟩ := candidate
+    obtain ⟨a, entry, _⟩ := injection.function.2 y hy.1
+    have aNat := (ZFSet.pair_mem_prod.1 (injection.function.1 entry)).2
+    obtain ⟨n, rfl⟩ := (mem_omega_iff_natSetCode a).1 aNat
+    exact ⟨n, y, hy, entry⟩
+  obtain ⟨y, hy, entry⟩ := Nat.find_spec existsValid
+  have selected : leastIntervalNextCandidate N A D rA rD e lo hi p c y := by
+    refine ⟨hy, natSetCode (Nat.find existsValid), natSetCode_mem_omega _, entry, ?_⟩
+    intro z _ hz m hm smaller
+    obtain ⟨k, lower, equal⟩ := (mem_natSetCode m (Nat.find existsValid)).1 hm
+    have validK : valid k := ⟨z, hz, equal ▸ smaller⟩
+    exact Nat.not_lt_of_ge (Nat.find_min' existsValid validK) lower
+  exact ⟨y, selected, fun z hz => leastIntervalNextCandidate_unique injection hz selected⟩
+
+namespace BoundedFormula
+
+open SetFormula
+
+def iffFormula {n} (φ ψ : BoundedFormula n) : BoundedFormula n :=
+  .conj (imp φ ψ) (imp ψ φ)
+
+theorem truth_iffFormula {n} (φ ψ : BoundedFormula n) (env : Fin n → ZFSet.{u}) :
+    Truth (iffFormula φ ψ) env ↔ (Truth φ env ↔ Truth ψ env) := by
+  simp only [iffFormula, Truth, truth_imp]
+  exact ⟨fun h => ⟨h.1, h.2⟩, fun h => ⟨h.mp, h.mpr⟩⟩
+
+def intervalNextCandidateFormula {n} (N A D rA rD e lo hi p y : Fin n) : BoundedFormula n :=
+  let lift (i : Fin n) : Fin (n + 4) := i.succ.succ.succ.succ
+  .conj (.mem y D) (.conj (pairMembershipFormula lo y rD)
+    (.conj (pairMembershipFormula y hi rD)
+      (.allMem N (.allMem A.succ (.allMem A.succ.succ (.allMem D.succ.succ.succ
+        (imp (pairMembershipFormula 3 2 (lift e))
+          (imp (pairMembershipFormula (lift N) 1 (lift e))
+            (imp (pairMembershipFormula 3 0 (lift p))
+              (.conj (iffFormula (.equal 2 1) (.equal 0 (lift y)))
+                (.conj (iffFormula (pairMembershipFormula 2 1 (lift rA))
+                    (pairMembershipFormula 0 (lift y) (lift rD)))
+                  (iffFormula (pairMembershipFormula 1 2 (lift rA))
+                    (pairMembershipFormula (lift y) 0 (lift rD))))))))))))))
+
+theorem truth_intervalNextCandidateFormula {n} (N A D rA rD e lo hi p y : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (intervalNextCandidateFormula N A D rA rD e lo hi p y) env ↔
+      intervalNextCandidate (env N) (env A) (env D) (env rA) (env rD) (env e)
+        (env lo) (env hi) (env p) (env y) := by
+  simp only [intervalNextCandidateFormula, Truth, truth_pairMembershipFormula,
+    truth_imp, truth_iffFormula]
+  rfl
+
+def leastIntervalNextCandidateFormula {n} (N A D rA rD e lo hi p c y omega : Fin n) : BoundedFormula n :=
+  .conj (intervalNextCandidateFormula N A D rA rD e lo hi p y)
+    (exMem omega (.conj (pairMembershipFormula y.succ 0 c.succ)
+      (.allMem D.succ (imp
+        (intervalNextCandidateFormula N.succ.succ A.succ.succ D.succ.succ rA.succ.succ
+          rD.succ.succ e.succ.succ lo.succ.succ hi.succ.succ p.succ.succ 0)
+        (.allMem 1 (.neg (pairMembershipFormula 1 0 c.succ.succ.succ)))))))
+
+theorem truth_leastIntervalNextCandidateFormula {n} (N A D rA rD e lo hi p c y omega : Fin n)
+    (env : Fin n → ZFSet.{u}) (hOmega : env omega = ZFSet.omega) :
+    Truth (leastIntervalNextCandidateFormula N A D rA rD e lo hi p c y omega) env ↔
+      leastIntervalNextCandidate (env N) (env A) (env D) (env rA) (env rD) (env e)
+        (env lo) (env hi) (env p) (env c) (env y) := by
+  simp only [leastIntervalNextCandidateFormula, Truth, truth_exMem, truth_imp,
+    truth_pairMembershipFormula, truth_intervalNextCandidateFormula]
+  change (intervalNextCandidate (env N) (env A) (env D) (env rA) (env rD) (env e)
+      (env lo) (env hi) (env p) (env y) ∧
+    ∃ k ∈ env omega, ZFSet.pair (env y) k ∈ env c ∧
+      ∀ z ∈ env D, intervalNextCandidate (env N) (env A) (env D) (env rA) (env rD) (env e)
+        (env lo) (env hi) (env p) z → ∀ m ∈ k, ZFSet.pair z m ∉ env c) ↔ _
+  rw [hOmega]
+  rfl
+
+theorem realize_leastIntervalNextCandidateFormula (M : TransitiveGround.{u}) {n}
+    (N A D rA rD e lo hi p c y omega : Fin n) (env : Fin n → ZFSet.{u})
+    (members : ∀ i, env i ∈ M.sets) (hOmega : env omega = ZFSet.omega) :
+    Realize M.sets (leastIntervalNextCandidateFormula N A D rA rD e lo hi p c y omega).toFormula env ↔
+      leastIntervalNextCandidate (env N) (env A) (env D) (env rA) (env rD) (env e)
+        (env lo) (env hi) (env p) (env c) (env y) :=
+  (realize_toFormula M _ env members).trans
+    (truth_leastIntervalNextCandidateFormula N A D rA rD e lo hi p c y omega env hOmega)
+
+end BoundedFormula
+
+namespace SetFormula
+
+def intervalSequenceStepFormula : SetFormula 12 :=
+  (BoundedFormula.leastIntervalNextCandidateFormula 0 3 4 5 6 7 8 9 1 10 2 11).toFormula
+
+end SetFormula
+
+namespace TransitiveGround
+
+open SetFormula
+
+theorem realize_intervalSequenceStepFormula (M : TransitiveGround.{u})
+    (env : Fin 12 → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets)
+    (hOmega : env 11 = ZFSet.omega) :
+    Realize M.sets intervalSequenceStepFormula env ↔
+      leastIntervalNextCandidate (env 0) (env 3) (env 4) (env 5) (env 6) (env 7)
+        (env 8) (env 9) (env 1) (env 10) (env 2) :=
+  BoundedFormula.realize_leastIntervalNextCandidateFormula M 0 3 4 5 6 7 8 9 1 10 2 11
+    env members hOmega
+
+theorem exists_unique_ground_intervalNext (M : TransitiveGround.{u})
+    {N A D rA rD e lo hi p c : ZFSet.{u}} (hD : D ∈ M.sets)
+    (injection : InjectionCode D ZFSet.omega c)
+    (candidate : ∃ y, intervalNextCandidate N A D rA rD e lo hi p y) :
+    ∃! y, y ∈ M.sets ∧ leastIntervalNextCandidate N A D rA rD e lo hi p c y := by
+  obtain ⟨y, selected, unique⟩ := leastIntervalNextCandidate_exists_unique injection candidate
+  exact ⟨y, ⟨M.transitive hD selected.1.1, selected⟩, fun z hz => unique z hz.2⟩
+
+end TransitiveGround
+
+end PartitionPilot.Forcing
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/LeastSlotOwnerCodes.lean

@@ -1,248 +1,248 @@
-import OAI.SetTheory.PartitionPrinciple.Geometry.TileStarIncomingCodes
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing
-open SetFormula SetRealization
-universe u
-
-def LeastSupportCode (V omega depths supports x v : ZFSet.{u}) : Prop :=
-  ZFSet.pair v x ∈ supports ∧ ∃ n ∈ omega, ZFSet.pair v n ∈ depths ∧
-    ∀ w ∈ V, ∀ m ∈ omega, ZFSet.pair w x ∈ supports → ZFSet.pair w m ∈ depths → m ∉ n
-
-noncomputable def leastSupportGraph (V Q depths supports : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => ∃ x ∈ Q, ∃ v ∈ V, z = ZFSet.pair x v ∧
-    LeastSupportCode V ZFSet.omega depths supports x v) (ZFSet.prod Q V)
-
-theorem pair_mem_leastSupportGraph (V Q depths supports x v : ZFSet.{u}) :
-    ZFSet.pair x v ∈ leastSupportGraph V Q depths supports ↔
-      x ∈ Q ∧ v ∈ V ∧ LeastSupportCode V ZFSet.omega depths supports x v := by
-  rw [leastSupportGraph, ZFSet.mem_sep]
-  constructor
-  · rintro ⟨_, x', hx, v', hv, equal, body⟩
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
-    exact ⟨hx, hv, body⟩
-  · rintro ⟨hx, hv, body⟩
-    exact ⟨ZFSet.pair_mem_prod.2 ⟨hx, hv⟩, x, hx, v, hv, rfl, body⟩
-
-namespace BoundedFormula
-def leastSupportFormula {k} (V omega depths supports x v : Fin k) : BoundedFormula k :=
-  .conj (pairMembershipFormula v x supports)
-    (exMem omega (.conj (pairMembershipFormula v.succ 0 depths.succ)
-      (allMem V.succ (allMem omega.succ.succ
-        (.imp (pairMembershipFormula 1 x.succ.succ.succ supports.succ.succ.succ)
-          (.imp (pairMembershipFormula 1 0 depths.succ.succ.succ) (.neg (.mem 0 2))))))))
-
-theorem truth_leastSupportFormula {k} (V omega depths supports x v : Fin k) (env : Fin k → ZFSet.{u}) :
-    Truth (leastSupportFormula V omega depths supports x v) env ↔
-      LeastSupportCode (env V) (env omega) (env depths) (env supports) (env x) (env v) := by
-  simp only [leastSupportFormula, Truth, truth_exMem, truth_imp, truth_pairMembershipFormula]
-  rfl
-
-def leastSupportEntryFormula {k} (z V Q omega depths supports : Fin k) : BoundedFormula k :=
-  exMem Q (exMem V.succ (.conj (orderedPairFormula z.succ.succ 1 0)
-    (leastSupportFormula V.succ.succ omega.succ.succ depths.succ.succ supports.succ.succ 1 0)))
-
-theorem truth_leastSupportEntryFormula {k} (z V Q omega depths supports : Fin k) (env : Fin k → ZFSet.{u}) :
-    Truth (leastSupportEntryFormula z V Q omega depths supports) env ↔
-      ∃ x ∈ env Q, ∃ v ∈ env V, env z = ZFSet.pair x v ∧
-        LeastSupportCode (env V) (env omega) (env depths) (env supports) x v := by
-  simp only [leastSupportEntryFormula, truth_exMem, Truth, truth_orderedPairFormula, truth_leastSupportFormula]
-  rfl
-end BoundedFormula
-
-namespace TransitiveGround
-theorem leastSupportGraph_mem (M : TransitiveGround.{u})
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    (infinite : Realize M.sets infinity Fin.elim0)
-    {V Q depths supports : ZFSet.{u}} (hV : V ∈ M.sets) (hQ : Q ∈ M.sets)
-    (hDepths : depths ∈ M.sets) (hSupports : supports ∈ M.sets) :
-    leastSupportGraph V Q depths supports ∈ M.sets := by
-  have hOmega := M.omega_mem separation infinite
-  let params := extend V (extend Q (extend ZFSet.omega (extend depths (extend supports Fin.elim0))))
-  have selected := M.bounded_separation_mem separation (BoundedFormula.leastSupportEntryFormula 0 1 2 3 4 5)
-    params (Fin.cases hV (Fin.cases hQ (Fin.cases hOmega (Fin.cases hDepths
-      (Fin.cases hSupports (fun i => Fin.elim0 i)))))) (M.prod_mem pairing unions powers separation hQ hV)
-  have equal : ZFSet.sep (fun z => BoundedFormula.Truth (BoundedFormula.leastSupportEntryFormula 0 1 2 3 4 5)
-      (extend z params)) (ZFSet.prod Q V) = leastSupportGraph V Q depths supports := by
-    apply ZFSet.ext
-    intro z
-    rw [leastSupportGraph, ZFSet.mem_sep, ZFSet.mem_sep]
-    exact and_congr Iff.rfl (BoundedFormula.truth_leastSupportEntryFormula _ _ _ _ _ _ _)
-  exact equal ▸ selected
-end TransitiveGround
-
-variable {V X : Type u} (s : Presentation V) (q : Presentation X) (depth : V → Nat)
-variable {depths supports : ZFSet.{u}} (supported : V → X → Prop)
-variable (depthEntries : ∀ v n, ZFSet.pair (s.encode v) (natSetCode n) ∈ depths ↔ n = depth v)
-variable (supportEntries : ∀ v x, ZFSet.pair (s.encode v) (q.encode x) ∈ supports ↔ supported v x)
-include depthEntries supportEntries
-
-theorem leastSupportCode_iff (x : X) (v : V) :
-    LeastSupportCode s.carrier ZFSet.omega depths supports (q.encode x) (s.encode v) ↔
-      supported v x ∧ ∀ w, supported w x → depth v ≤ depth w := by
-  constructor
-  · rintro ⟨support, n, hn, entry, least⟩
-    obtain ⟨n, rfl⟩ := (mem_omega_iff_natSetCode n).1 hn
-    have equal := (depthEntries v n).1 entry
-    subst n
-    refine ⟨(supportEntries v x).1 support, ?_⟩
-    intro w hw
-    have noLower := least (s.encode w) (s.encode_mem w) (natSetCode (depth w))
-      (natSetCode_mem_omega _) ((supportEntries w x).2 hw) ((depthEntries w _).2 rfl)
-    exact Nat.le_of_not_lt (fun lower => noLower ((natSetCode_mem_iff _ _).2 lower))
-  · rintro ⟨support, minimal⟩
-    refine ⟨(supportEntries v x).2 support, natSetCode (depth v), natSetCode_mem_omega _,
-      (depthEntries v _).2 rfl, ?_⟩
-    intro w hw m hm member entry lower
-    obtain ⟨w, rfl⟩ := (s.mem_carrier w).1 hw
-    obtain ⟨m, rfl⟩ := (mem_omega_iff_natSetCode m).1 hm
-    have equal := (depthEntries w m).1 entry
-    subst m
-    exact Nat.not_lt_of_ge (minimal w ((supportEntries w x).1 member)) ((natSetCode_mem_iff _ _).1 lower)
-
-theorem leastSupportGraph_entry (x : X) (v : V) :
-    ZFSet.pair (q.encode x) (s.encode v) ∈ leastSupportGraph s.carrier q.carrier depths supports ↔
-      supported v x ∧ ∀ w, supported w x → depth v ≤ depth w := by
-  rw [pair_mem_leastSupportGraph, leastSupportCode_iff s q depth supported depthEntries supportEntries]
-  exact ⟨fun h => h.2.2, fun h => ⟨q.encode_mem x, s.encode_mem v, h⟩⟩
-
-theorem leastSupportGraph_function
-    (unique : ∀ x, ∃! v, supported v x ∧ ∀ w, supported w x → depth v ≤ depth w) :
-    ZFSet.IsFunc q.carrier s.carrier (leastSupportGraph s.carrier q.carrier depths supports) := by
-  refine ⟨fun _ hz => (ZFSet.mem_sep.1 hz).1, ?_⟩
-  intro x hx
-  obtain ⟨x, rfl⟩ := (q.mem_carrier x).1 hx
-  obtain ⟨v, good, only⟩ := unique x
-  refine ⟨s.encode v, (leastSupportGraph_entry s q depth supported depthEntries supportEntries x v).2 good, ?_⟩
-  intro w hw
-  have member := (pair_mem_leastSupportGraph _ _ _ _ _ _).1 hw
-  obtain ⟨w, rfl⟩ := (s.mem_carrier w).1 member.2.1
-  exact congrArg s.encode (only w ((leastSupportGraph_entry s q depth supported depthEntries supportEntries x w).1 hw))
-
-end PartitionPilot.Forcing
-
-
-
-namespace PartitionPilot.Forcing
-open SetFormula
-universe u
-
-def LeastSlotCode (supports v x j : ZFSet.{u}) : Prop :=
-  ZFSet.pair (ZFSet.pair v j) x ∈ supports ∧
-    ∀ k ∈ j, ZFSet.pair (ZFSet.pair v k) x ∉ supports
-
-theorem LeastSlotCode.le {supports v x j k : ZFSet.{u}}
-    (code : LeastSlotCode supports v x j) (hj : j ∈ natSetCode 3) (hk : k ∈ natSetCode 3)
-    (supported : ZFSet.pair (ZFSet.pair v k) x ∈ supports) : j = k ∨ j ∈ k := by
-  obtain ⟨n, _, rfl⟩ := (mem_natSetCode j 3).1 hj
-  obtain ⟨m, _, rfl⟩ := (mem_natSetCode k 3).1 hk
-  rcases Nat.lt_trichotomy n m with less | same | greater
-  · exact Or.inr ((natSetCode_mem_iff _ _).2 less)
-  · exact Or.inl (congrArg natSetCode same)
-  · exact False.elim (code.2 _ ((natSetCode_mem_iff _ _).2 greater) supported)
-
-theorem LeastSlotCode.unique {supports v x j k : ZFSet.{u}}
-    (first : LeastSlotCode supports v x j) (second : LeastSlotCode supports v x k)
-    (hj : j ∈ natSetCode 3) (hk : k ∈ natSetCode 3) : j = k := by
-  rcases first.le hj hk second.1 with same | less
-  · exact same
-  · exact False.elim (second.2 _ less first.1)
-
-theorem exists_leastSlotCode {supports v x : ZFSet.{u}}
-    (cover : ∃ j ∈ natSetCode 3, ZFSet.pair (ZFSet.pair v j) x ∈ supports) :
-    ∃ j ∈ natSetCode 3, LeastSlotCode supports v x j := by
-  classical
-  have candidates : ∃ n : Nat, n < 3 ∧ ZFSet.pair (ZFSet.pair v (natSetCode n)) x ∈ supports := by
-    obtain ⟨j, hj, supported⟩ := cover
-    obtain ⟨n, hn, rfl⟩ := (mem_natSetCode j 3).1 hj
-    exact ⟨n, hn, supported⟩
-  refine ⟨natSetCode (Nat.find candidates), (natSetCode_mem_iff _ _).2 (Nat.find_spec candidates).1,
-    (Nat.find_spec candidates).2, ?_⟩
-  intro k hk supported
-  obtain ⟨k, lower, rfl⟩ := (mem_natSetCode k (Nat.find candidates)).1 hk
-  exact Nat.find_min candidates lower ⟨Nat.lt_trans lower (Nat.find_spec candidates).1, supported⟩
-
-noncomputable def leastSlotOwnerGraph (P B V owner supports : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => ∃ x ∈ B, ∃ j ∈ natSetCode 3, ∃ v ∈ V,
-    z = ZFSet.pair x j ∧ x ∉ P ∧ ZFSet.pair x v ∈ owner ∧ LeastSlotCode supports v x j)
-    (ZFSet.prod B (natSetCode 3))
-
-theorem pair_mem_leastSlotOwnerGraph (P B V owner supports x j : ZFSet.{u}) :
-    ZFSet.pair x j ∈ leastSlotOwnerGraph P B V owner supports ↔
-      x ∈ B ∧ j ∈ natSetCode 3 ∧ x ∉ P ∧ ∃ v ∈ V,
-        ZFSet.pair x v ∈ owner ∧ LeastSlotCode supports v x j := by
-  rw [leastSlotOwnerGraph, ZFSet.mem_sep]
-  constructor
-  · rintro ⟨_, x', hx, j', hj, v, hv, equal, fresh, owned, code⟩
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
-    exact ⟨hx, hj, fresh, v, hv, owned, code⟩
-  · rintro ⟨hx, hj, fresh, v, hv, owned, code⟩
-    exact ⟨ZFSet.pair_mem_prod.2 ⟨hx, hj⟩, x, hx, j, hj, v, hv, rfl, fresh, owned, code⟩
-
-theorem pair_mem_leastSlotOwnerGraph_of_owner {P B V owner supports x j v : ZFSet.{u}}
-    (function : ZFSet.IsFunc B V owner) (owned : ZFSet.pair x v ∈ owner) :
-    ZFSet.pair x j ∈ leastSlotOwnerGraph P B V owner supports ↔
-      j ∈ natSetCode 3 ∧ x ∉ P ∧ LeastSlotCode supports v x j := by
-  have shape := ZFSet.pair_mem_prod.1 (function.1 owned)
-  rw [pair_mem_leastSlotOwnerGraph]
-  constructor
-  · rintro ⟨_, hj, fresh, v', _, owned', code⟩
-    have equal := (show FunctionGraphOn B owner from ⟨V, function⟩).unique owned' owned
-    exact ⟨hj, fresh, equal ▸ code⟩
-  · rintro ⟨hj, fresh, code⟩
-    exact ⟨shape.1, hj, fresh, v, shape.2, owned, code⟩
-
-theorem leastSlotOwnerGraph_partial {P B V owner supports : ZFSet.{u}}
-    (function : ZFSet.IsFunc B V owner) :
-    PartialFunctionCode B (natSetCode 3) (leastSlotOwnerGraph P B V owner supports) := by
-  refine ⟨fun _ hz => (ZFSet.mem_sep.1 hz).1, ?_⟩
-  intro x j k first second
-  obtain ⟨_, hj, _, v, _, owned, code⟩ := (pair_mem_leastSlotOwnerGraph _ _ _ _ _ _ _).1 first
-  have other := (pair_mem_leastSlotOwnerGraph_of_owner function owned).1 second
-  exact code.unique other.2.2 hj other.1
-
-theorem leastSlotOwnerGraph_function {P B V owner supports : ZFSet.{u}}
-    (function : ZFSet.IsFunc B V owner)
-    (cover : ∀ x ∈ B, x ∉ P → ∀ v, ZFSet.pair x v ∈ owner →
-      ∃ j ∈ natSetCode 3, ZFSet.pair (ZFSet.pair v j) x ∈ supports) :
-    ZFSet.IsFunc (ZFSet.sep (fun x => x ∉ P) B) (natSetCode 3)
-      (leastSlotOwnerGraph P B V owner supports) := by
-  refine ⟨?_, ?_⟩
-  · intro z hz
-    have shape := (ZFSet.mem_sep.1 hz).1
-    obtain ⟨x, hx, j, hj, rfl⟩ := ZFSet.mem_prod.1 shape
-    have fresh := ((pair_mem_leastSlotOwnerGraph _ _ _ _ _ _ _).1 hz).2.2.1
-    exact ZFSet.pair_mem_prod.2 ⟨ZFSet.mem_sep.2 ⟨hx, fresh⟩, hj⟩
-  · intro x hx
-    obtain ⟨hx, fresh⟩ := ZFSet.mem_sep.1 hx
-    obtain ⟨v, owned, _⟩ := function.2 x hx
-    obtain ⟨j, hj, code⟩ := exists_leastSlotCode (cover x hx fresh v owned)
-    refine ⟨j, (pair_mem_leastSlotOwnerGraph_of_owner function owned).2 ⟨hj, fresh, code⟩, ?_⟩
-    intro k other
-    exact (leastSlotOwnerGraph_partial function).unique x k j other
-      ((pair_mem_leastSlotOwnerGraph_of_owner function owned).2 ⟨hj, fresh, code⟩)
-
-theorem leastSlotOwnerGraph_monotone {P B V owner supports order x y j k : ZFSet.{u}}
-    (first : ZFSet.pair x j ∈ leastSlotOwnerGraph P B V owner supports)
-    (second : ZFSet.pair y k ∈ leastSlotOwnerGraph P B V owner supports)
-    (sameOwner : ∀ v w, ZFSet.pair x v ∈ owner → ZFSet.pair y w ∈ owner → v = w)
-    (ideals : ∀ v ∈ V, ∀ t ∈ natSetCode 3, ∀ a ∈ B, ∀ b ∈ B,
-      ZFSet.pair a b ∈ order → ZFSet.pair (ZFSet.pair v t) b ∈ supports →
-        ZFSet.pair (ZFSet.pair v t) a ∈ supports)
-    (lower : ZFSet.pair x y ∈ order) : j = k ∨ j ∈ k := by
-  obtain ⟨hx, hj, _, v, hv, owned, code⟩ := (pair_mem_leastSlotOwnerGraph _ _ _ _ _ _ _).1 first
-  obtain ⟨hy, hk, _, w, _, owned', code'⟩ := (pair_mem_leastSlotOwnerGraph _ _ _ _ _ _ _).1 second
-  have equal := sameOwner v w owned owned'
-  subst w
-  exact code.le hj hk (ideals v hv k hk x hx y hy lower code'.1)
-
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Geometry.TileStarIncomingCodes
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing
+open SetFormula SetRealization
+universe u
+
+def LeastSupportCode (V omega depths supports x v : ZFSet.{u}) : Prop :=
+  ZFSet.pair v x ∈ supports ∧ ∃ n ∈ omega, ZFSet.pair v n ∈ depths ∧
+    ∀ w ∈ V, ∀ m ∈ omega, ZFSet.pair w x ∈ supports → ZFSet.pair w m ∈ depths → m ∉ n
+
+noncomputable def leastSupportGraph (V Q depths supports : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => ∃ x ∈ Q, ∃ v ∈ V, z = ZFSet.pair x v ∧
+    LeastSupportCode V ZFSet.omega depths supports x v) (ZFSet.prod Q V)
+
+theorem pair_mem_leastSupportGraph (V Q depths supports x v : ZFSet.{u}) :
+    ZFSet.pair x v ∈ leastSupportGraph V Q depths supports ↔
+      x ∈ Q ∧ v ∈ V ∧ LeastSupportCode V ZFSet.omega depths supports x v := by
+  rw [leastSupportGraph, ZFSet.mem_sep]
+  constructor
+  · rintro ⟨_, x', hx, v', hv, equal, body⟩
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
+    exact ⟨hx, hv, body⟩
+  · rintro ⟨hx, hv, body⟩
+    exact ⟨ZFSet.pair_mem_prod.2 ⟨hx, hv⟩, x, hx, v, hv, rfl, body⟩
+
+namespace BoundedFormula
+def leastSupportFormula {k} (V omega depths supports x v : Fin k) : BoundedFormula k :=
+  .conj (pairMembershipFormula v x supports)
+    (exMem omega (.conj (pairMembershipFormula v.succ 0 depths.succ)
+      (allMem V.succ (allMem omega.succ.succ
+        (.imp (pairMembershipFormula 1 x.succ.succ.succ supports.succ.succ.succ)
+          (.imp (pairMembershipFormula 1 0 depths.succ.succ.succ) (.neg (.mem 0 2))))))))
+
+theorem truth_leastSupportFormula {k} (V omega depths supports x v : Fin k) (env : Fin k → ZFSet.{u}) :
+    Truth (leastSupportFormula V omega depths supports x v) env ↔
+      LeastSupportCode (env V) (env omega) (env depths) (env supports) (env x) (env v) := by
+  simp only [leastSupportFormula, Truth, truth_exMem, truth_imp, truth_pairMembershipFormula]
+  rfl
+
+def leastSupportEntryFormula {k} (z V Q omega depths supports : Fin k) : BoundedFormula k :=
+  exMem Q (exMem V.succ (.conj (orderedPairFormula z.succ.succ 1 0)
+    (leastSupportFormula V.succ.succ omega.succ.succ depths.succ.succ supports.succ.succ 1 0)))
+
+theorem truth_leastSupportEntryFormula {k} (z V Q omega depths supports : Fin k) (env : Fin k → ZFSet.{u}) :
+    Truth (leastSupportEntryFormula z V Q omega depths supports) env ↔
+      ∃ x ∈ env Q, ∃ v ∈ env V, env z = ZFSet.pair x v ∧
+        LeastSupportCode (env V) (env omega) (env depths) (env supports) x v := by
+  simp only [leastSupportEntryFormula, truth_exMem, Truth, truth_orderedPairFormula, truth_leastSupportFormula]
+  rfl
+end BoundedFormula
+
+namespace TransitiveGround
+theorem leastSupportGraph_mem (M : TransitiveGround.{u})
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    (infinite : Realize M.sets infinity Fin.elim0)
+    {V Q depths supports : ZFSet.{u}} (hV : V ∈ M.sets) (hQ : Q ∈ M.sets)
+    (hDepths : depths ∈ M.sets) (hSupports : supports ∈ M.sets) :
+    leastSupportGraph V Q depths supports ∈ M.sets := by
+  have hOmega := M.omega_mem separation infinite
+  let params := extend V (extend Q (extend ZFSet.omega (extend depths (extend supports Fin.elim0))))
+  have selected := M.bounded_separation_mem separation (BoundedFormula.leastSupportEntryFormula 0 1 2 3 4 5)
+    params (Fin.cases hV (Fin.cases hQ (Fin.cases hOmega (Fin.cases hDepths
+      (Fin.cases hSupports (fun i => Fin.elim0 i)))))) (M.prod_mem pairing unions powers separation hQ hV)
+  have equal : ZFSet.sep (fun z => BoundedFormula.Truth (BoundedFormula.leastSupportEntryFormula 0 1 2 3 4 5)
+      (extend z params)) (ZFSet.prod Q V) = leastSupportGraph V Q depths supports := by
+    apply ZFSet.ext
+    intro z
+    rw [leastSupportGraph, ZFSet.mem_sep, ZFSet.mem_sep]
+    exact and_congr Iff.rfl (BoundedFormula.truth_leastSupportEntryFormula _ _ _ _ _ _ _)
+  exact equal ▸ selected
+end TransitiveGround
+
+variable {V X : Type u} (s : Presentation V) (q : Presentation X) (depth : V → Nat)
+variable {depths supports : ZFSet.{u}} (supported : V → X → Prop)
+variable (depthEntries : ∀ v n, ZFSet.pair (s.encode v) (natSetCode n) ∈ depths ↔ n = depth v)
+variable (supportEntries : ∀ v x, ZFSet.pair (s.encode v) (q.encode x) ∈ supports ↔ supported v x)
+include depthEntries supportEntries
+
+theorem leastSupportCode_iff (x : X) (v : V) :
+    LeastSupportCode s.carrier ZFSet.omega depths supports (q.encode x) (s.encode v) ↔
+      supported v x ∧ ∀ w, supported w x → depth v ≤ depth w := by
+  constructor
+  · rintro ⟨support, n, hn, entry, least⟩
+    obtain ⟨n, rfl⟩ := (mem_omega_iff_natSetCode n).1 hn
+    have equal := (depthEntries v n).1 entry
+    subst n
+    refine ⟨(supportEntries v x).1 support, ?_⟩
+    intro w hw
+    have noLower := least (s.encode w) (s.encode_mem w) (natSetCode (depth w))
+      (natSetCode_mem_omega _) ((supportEntries w x).2 hw) ((depthEntries w _).2 rfl)
+    exact Nat.le_of_not_lt (fun lower => noLower ((natSetCode_mem_iff _ _).2 lower))
+  · rintro ⟨support, minimal⟩
+    refine ⟨(supportEntries v x).2 support, natSetCode (depth v), natSetCode_mem_omega _,
+      (depthEntries v _).2 rfl, ?_⟩
+    intro w hw m hm member entry lower
+    obtain ⟨w, rfl⟩ := (s.mem_carrier w).1 hw
+    obtain ⟨m, rfl⟩ := (mem_omega_iff_natSetCode m).1 hm
+    have equal := (depthEntries w m).1 entry
+    subst m
+    exact Nat.not_lt_of_ge (minimal w ((supportEntries w x).1 member)) ((natSetCode_mem_iff _ _).1 lower)
+
+theorem leastSupportGraph_entry (x : X) (v : V) :
+    ZFSet.pair (q.encode x) (s.encode v) ∈ leastSupportGraph s.carrier q.carrier depths supports ↔
+      supported v x ∧ ∀ w, supported w x → depth v ≤ depth w := by
+  rw [pair_mem_leastSupportGraph, leastSupportCode_iff s q depth supported depthEntries supportEntries]
+  exact ⟨fun h => h.2.2, fun h => ⟨q.encode_mem x, s.encode_mem v, h⟩⟩
+
+theorem leastSupportGraph_function
+    (unique : ∀ x, ∃! v, supported v x ∧ ∀ w, supported w x → depth v ≤ depth w) :
+    ZFSet.IsFunc q.carrier s.carrier (leastSupportGraph s.carrier q.carrier depths supports) := by
+  refine ⟨fun _ hz => (ZFSet.mem_sep.1 hz).1, ?_⟩
+  intro x hx
+  obtain ⟨x, rfl⟩ := (q.mem_carrier x).1 hx
+  obtain ⟨v, good, only⟩ := unique x
+  refine ⟨s.encode v, (leastSupportGraph_entry s q depth supported depthEntries supportEntries x v).2 good, ?_⟩
+  intro w hw
+  have member := (pair_mem_leastSupportGraph _ _ _ _ _ _).1 hw
+  obtain ���w, rfl⟩ := (s.mem_carrier w).1 member.2.1
+  exact congrArg s.encode (only w ((leastSupportGraph_entry s q depth supported depthEntries supportEntries x w).1 hw))
+
+end PartitionPilot.Forcing
+
+
+
+namespace PartitionPilot.Forcing
+open SetFormula
+universe u
+
+def LeastSlotCode (supports v x j : ZFSet.{u}) : Prop :=
+  ZFSet.pair (ZFSet.pair v j) x ∈ supports ∧
+    ∀ k ∈ j, ZFSet.pair (ZFSet.pair v k) x ∉ supports
+
+theorem LeastSlotCode.le {supports v x j k : ZFSet.{u}}
+    (code : LeastSlotCode supports v x j) (hj : j ∈ natSetCode 3) (hk : k ∈ natSetCode 3)
+    (supported : ZFSet.pair (ZFSet.pair v k) x ∈ supports) : j = k ∨ j ∈ k := by
+  obtain ⟨n, _, rfl⟩ := (mem_natSetCode j 3).1 hj
+  obtain ⟨m, _, rfl⟩ := (mem_natSetCode k 3).1 hk
+  rcases Nat.lt_trichotomy n m with less | same | greater
+  · exact Or.inr ((natSetCode_mem_iff _ _).2 less)
+  · exact Or.inl (congrArg natSetCode same)
+  · exact False.elim (code.2 _ ((natSetCode_mem_iff _ _).2 greater) supported)
+
+theorem LeastSlotCode.unique {supports v x j k : ZFSet.{u}}
+    (first : LeastSlotCode supports v x j) (second : LeastSlotCode supports v x k)
+    (hj : j ∈ natSetCode 3) (hk : k ∈ natSetCode 3) : j = k := by
+  rcases first.le hj hk second.1 with same | less
+  · exact same
+  · exact False.elim (second.2 _ less first.1)
+
+theorem exists_leastSlotCode {supports v x : ZFSet.{u}}
+    (cover : ∃ j ∈ natSetCode 3, ZFSet.pair (ZFSet.pair v j) x ∈ supports) :
+    ∃ j ∈ natSetCode 3, LeastSlotCode supports v x j := by
+  classical
+  have candidates : ∃ n : Nat, n < 3 ∧ ZFSet.pair (ZFSet.pair v (natSetCode n)) x ∈ supports := by
+    obtain ⟨j, hj, supported⟩ := cover
+    obtain ⟨n, hn, rfl⟩ := (mem_natSetCode j 3).1 hj
+    exact ⟨n, hn, supported⟩
+  refine ⟨natSetCode (Nat.find candidates), (natSetCode_mem_iff _ _).2 (Nat.find_spec candidates).1,
+    (Nat.find_spec candidates).2, ?_⟩
+  intro k hk supported
+  obtain ⟨k, lower, rfl⟩ := (mem_natSetCode k (Nat.find candidates)).1 hk
+  exact Nat.find_min candidates lower ⟨Nat.lt_trans lower (Nat.find_spec candidates).1, supported⟩
+
+noncomputable def leastSlotOwnerGraph (P B V owner supports : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => ∃ x ∈ B, ∃ j ∈ natSetCode 3, ∃ v ∈ V,
+    z = ZFSet.pair x j ∧ x ∉ P ∧ ZFSet.pair x v ∈ owner ∧ LeastSlotCode supports v x j)
+    (ZFSet.prod B (natSetCode 3))
+
+theorem pair_mem_leastSlotOwnerGraph (P B V owner supports x j : ZFSet.{u}) :
+    ZFSet.pair x j ∈ leastSlotOwnerGraph P B V owner supports ↔
+      x ∈ B ∧ j ∈ natSetCode 3 ∧ x ∉ P ∧ ∃ v ∈ V,
+        ZFSet.pair x v ∈ owner ∧ LeastSlotCode supports v x j := by
+  rw [leastSlotOwnerGraph, ZFSet.mem_sep]
+  constructor
+  · rintro ⟨_, x', hx, j', hj, v, hv, equal, fresh, owned, code⟩
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
+    exact ⟨hx, hj, fresh, v, hv, owned, code⟩
+  · rintro ⟨hx, hj, fresh, v, hv, owned, code⟩
+    exact ⟨ZFSet.pair_mem_prod.2 ⟨hx, hj⟩, x, hx, j, hj, v, hv, rfl, fresh, owned, code⟩
+
+theorem pair_mem_leastSlotOwnerGraph_of_owner {P B V owner supports x j v : ZFSet.{u}}
+    (function : ZFSet.IsFunc B V owner) (owned : ZFSet.pair x v ∈ owner) :
+    ZFSet.pair x j ∈ leastSlotOwnerGraph P B V owner supports ↔
+      j ∈ natSetCode 3 ∧ x ∉ P ∧ LeastSlotCode supports v x j := by
+  have shape := ZFSet.pair_mem_prod.1 (function.1 owned)
+  rw [pair_mem_leastSlotOwnerGraph]
+  constructor
+  · rintro ⟨_, hj, fresh, v', _, owned', code⟩
+    have equal := (show FunctionGraphOn B owner from ⟨V, function⟩).unique owned' owned
+    exact ⟨hj, fresh, equal ▸ code⟩
+  · rintro ⟨hj, fresh, code⟩
+    exact ⟨shape.1, hj, fresh, v, shape.2, owned, code⟩
+
+theorem leastSlotOwnerGraph_partial {P B V owner supports : ZFSet.{u}}
+    (function : ZFSet.IsFunc B V owner) :
+    PartialFunctionCode B (natSetCode 3) (leastSlotOwnerGraph P B V owner supports) := by
+  refine ⟨fun _ hz => (ZFSet.mem_sep.1 hz).1, ?_⟩
+  intro x j k first second
+  obtain ⟨_, hj, _, v, _, owned, code⟩ := (pair_mem_leastSlotOwnerGraph _ _ _ _ _ _ _).1 first
+  have other := (pair_mem_leastSlotOwnerGraph_of_owner function owned).1 second
+  exact code.unique other.2.2 hj other.1
+
+theorem leastSlotOwnerGraph_function {P B V owner supports : ZFSet.{u}}
+    (function : ZFSet.IsFunc B V owner)
+    (cover : ∀ x ∈ B, x ∉ P → ∀ v, ZFSet.pair x v ∈ owner →
+      ∃ j ∈ natSetCode 3, ZFSet.pair (ZFSet.pair v j) x ∈ supports) :
+    ZFSet.IsFunc (ZFSet.sep (fun x => x ∉ P) B) (natSetCode 3)
+      (leastSlotOwnerGraph P B V owner supports) := by
+  refine ⟨?_, ?_⟩
+  · intro z hz
+    have shape := (ZFSet.mem_sep.1 hz).1
+    obtain ⟨x, hx, j, hj, rfl⟩ := ZFSet.mem_prod.1 shape
+    have fresh := ((pair_mem_leastSlotOwnerGraph _ _ _ _ _ _ _).1 hz).2.2.1
+    exact ZFSet.pair_mem_prod.2 ⟨ZFSet.mem_sep.2 ⟨hx, fresh⟩, hj⟩
+  · intro x hx
+    obtain ⟨hx, fresh⟩ := ZFSet.mem_sep.1 hx
+    obtain ⟨v, owned, _⟩ := function.2 x hx
+    obtain ⟨j, hj, code⟩ := exists_leastSlotCode (cover x hx fresh v owned)
+    refine ⟨j, (pair_mem_leastSlotOwnerGraph_of_owner function owned).2 ⟨hj, fresh, code⟩, ?_⟩
+    intro k other
+    exact (leastSlotOwnerGraph_partial function).unique x k j other
+      ((pair_mem_leastSlotOwnerGraph_of_owner function owned).2 ⟨hj, fresh, code⟩)
+
+theorem leastSlotOwnerGraph_monotone {P B V owner supports order x y j k : ZFSet.{u}}
+    (first : ZFSet.pair x j ∈ leastSlotOwnerGraph P B V owner supports)
+    (second : ZFSet.pair y k ∈ leastSlotOwnerGraph P B V owner supports)
+    (sameOwner : ∀ v w, ZFSet.pair x v ∈ owner → ZFSet.pair y w ∈ owner → v = w)
+    (ideals : ∀ v ∈ V, ∀ t ∈ natSetCode 3, ∀ a ∈ B, ∀ b ∈ B,
+      ZFSet.pair a b ∈ order → ZFSet.pair (ZFSet.pair v t) b ∈ supports →
+        ZFSet.pair (ZFSet.pair v t) a ∈ supports)
+    (lower : ZFSet.pair x y ∈ order) : j = k ∨ j ∈ k := by
+  obtain ⟨hx, hj, _, v, hv, owned, code⟩ := (pair_mem_leastSlotOwnerGraph _ _ _ _ _ _ _).1 first
+  obtain ⟨hy, hk, _, w, _, owned', code'⟩ := (pair_mem_leastSlotOwnerGraph _ _ _ _ _ _ _).1 second
+  have equal := sameOwner v w owned owned'
+  subst w
+  exact code.le hj hk (ideals v hv k hk x hx y hy lower code'.1)
+
+end PartitionPilot.Forcing
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/LiftedCompressionFormulas.lean

@@ -1,118 +1,118 @@
-import OAI.SetTheory.PartitionPrinciple.Geometry.LiftedCompressionFunctions
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing.BoundedFormula
-
-open SetFormula
-universe u
-
-def rightTripleFormula {n} (z a b c : Fin n) : BoundedFormula n :=
-  exMem z (exMem 0 (.conj (orderedPairFormula 0 b.succ.succ c.succ.succ)
-    (orderedPairFormula z.succ.succ a.succ.succ 0)))
-
-theorem truth_rightTripleFormula {n} (z a b c : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (rightTripleFormula z a b c) env ↔
-      env z = ZFSet.pair (env a) (ZFSet.pair (env b) (env c)) := by
-  simp only [rightTripleFormula, truth_exMem, Truth, truth_orderedPairFormula]
-  change (∃ s ∈ env z, ∃ t ∈ s, t = ZFSet.pair (env b) (env c) ∧
-    env z = ZFSet.pair (env a) t) ↔ _
-  constructor
-  · rintro ⟨_, _, _, _, rfl, equal⟩
-    exact equal
-  · intro equal
-    refine ⟨{env a, ZFSet.pair (env b) (env c)}, ?_, ZFSet.pair (env b) (env c),
-      ZFSet.mem_pair.2 (Or.inr rfl), rfl, equal⟩
-    rw [equal]
-    exact ZFSet.mem_pair.2 (Or.inr rfl)
-
-def taggedPairTripleFormula {n} (z l i j q : Fin n) : BoundedFormula n :=
-  exMem z (exMem 0 (.conj (orderedTripleFormula 0 i.succ.succ j.succ.succ q.succ.succ)
-    (orderedPairFormula z.succ.succ l.succ.succ 0)))
-
-theorem truth_taggedPairTripleFormula {n} (z l i j q : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (taggedPairTripleFormula z l i j q) env ↔
-      env z = ZFSet.pair (env l) (ZFSet.pair (ZFSet.pair (env i) (env j)) (env q)) := by
-  simp only [taggedPairTripleFormula, truth_exMem, Truth, truth_orderedTripleFormula,
-    truth_orderedPairFormula]
-  change (∃ s ∈ env z, ∃ t ∈ s, t = ZFSet.pair (ZFSet.pair (env i) (env j)) (env q) ∧
-    env z = ZFSet.pair (env l) t) ↔ _
-  constructor
-  · rintro ⟨_, _, _, _, rfl, equal⟩
-    exact equal
-  · intro equal
-    refine ⟨{env l, ZFSet.pair (ZFSet.pair (env i) (env j)) (env q)}, ?_,
-      ZFSet.pair (ZFSet.pair (env i) (env j)) (env q),
-      ZFSet.mem_pair.2 (Or.inr rfl), rfl, equal⟩
-    rw [equal]
-    exact ZFSet.mem_pair.2 (Or.inr rfl)
-
-def liftOldEntryFormula {n} (d maps bound i x y : Fin n) : BoundedFormula n :=
-  .conj (.mem x d) (exMem bound (.conj (pairMembershipFormula i.succ 0 maps.succ)
-    (pairMembershipFormula x.succ y.succ 0)))
-
-theorem truth_liftOldEntryFormula {n} (d maps bound i x y : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (liftOldEntryFormula d maps bound i x y) env ↔
-      env x ∈ env d ∧ ∃ S ∈ env bound,
-        ZFSet.pair (env i) S ∈ env maps ∧ ZFSet.pair (env x) (env y) ∈ S := by
-  simp only [liftOldEntryFormula, Truth, truth_exMem, truth_pairMembershipFormula]
-  rfl
-
-def liftFreshEntryFormula {n} (d l j b ns sources fs bound reps g action i x y : Fin n) : BoundedFormula n :=
-  let up (t : Fin n) := t.succ.succ.succ.succ
-  exMem j (exMem b.succ (exMem d.succ.succ (exMem bound.succ.succ.succ
-    (.conj (rightTripleFormula (up x) (up d) 3 2)
-      (.conj (pairMembershipFormula 3 2 (up ns))
-        (.conj (pairMembershipFormula (up i) 1 (up sources))
-          (.conj (pairMembershipFormula 3 0 (up fs))
-            (disj (.conj (.mem 1 0) (exMem (up g)
-              (.conj (pairMembershipFormula (up i).succ 0 (up reps).succ)
-                (tripleMembershipFormula 0 (up x).succ (up y).succ (up action).succ))))
-              (.conj (.neg (.mem 1 0)) (taggedPairTripleFormula (up y) (up l) (up i) 3 2))))))))))
-
-theorem truth_liftFreshEntryFormula {n} (d l j b ns sources fs bound reps g action i x y : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (liftFreshEntryFormula d l j b ns sources fs bound reps g action i x y) env ↔
-      ∃ h ∈ env j, ∃ q ∈ env b, ∃ a ∈ env d, ∃ F ∈ env bound,
-        env x = ZFSet.pair (env d) (ZFSet.pair h q) ∧ ZFSet.pair h q ∈ env ns ∧
-        ZFSet.pair (env i) a ∈ env sources ∧ ZFSet.pair h F ∈ env fs ∧
-        ((a ∈ F ∧ ∃ actor ∈ env g, ZFSet.pair (env i) actor ∈ env reps ∧
-          ZFSet.pair (ZFSet.pair actor (env x)) (env y) ∈ env action) ∨
-          (a ∉ F ∧ env y = ZFSet.pair (env l) (ZFSet.pair (ZFSet.pair (env i) h) q))) := by
-  simp only [liftFreshEntryFormula, truth_exMem, Truth, truth_disj,
-    truth_rightTripleFormula, truth_pairMembershipFormula, truth_tripleMembershipFormula,
-    truth_taggedPairTripleFormula]
-  rfl
-
-def liftedCompressionEntryFormula {n} (z i j d l c ns b maps sources fs reps g action v w : Fin n) :
-    BoundedFormula n :=
-  let up (t : Fin n) := t.succ.succ.succ
-  exMem i (exMem l.succ (exMem c.succ.succ
-    (.conj (orderedTripleFormula (up z) 2 1 0)
-      (disj (liftOldEntryFormula (up d) (up maps) (up v) 2 1 0)
-        (liftFreshEntryFormula (up d) (up l) (up j) (up b) (up ns)
-          (up sources) (up fs) (up w) (up reps) (up g) (up action) 2 1 0)))))
-
-theorem truth_liftedCompressionEntryFormula {n} (z i j d l c ns b maps sources fs reps g action v w : Fin n)
-    (env : Fin n → ZFSet.{u}) (mapsBound : env v = ZFSet.sUnion (ZFSet.sUnion (env maps)))
-    (filterBound : env w = ZFSet.sUnion (ZFSet.sUnion (env fs))) :
-    Truth (liftedCompressionEntryFormula z i j d l c ns b maps sources fs reps g action v w) env ↔
-      ∃ task ∈ env i, ∃ x ∈ env l, ∃ y ∈ env c,
-        env z = ZFSet.pair (ZFSet.pair task x) y ∧
-          (liftOldEntry (env d) (env maps) task x y ∨
-            liftFreshEntry (env d) (env l) (env j) (env b) (env ns)
-              (env sources) (env fs) (env reps) (env g) (env action) task x y) := by
-  simp only [liftedCompressionEntryFormula, truth_exMem, Truth, truth_disj,
-    truth_orderedTripleFormula, truth_liftOldEntryFormula, truth_liftFreshEntryFormula]
-  simp only [liftOldEntry, liftFreshEntry, extend, Fin.cases_succ, Fin.cases_zero,
-    mapsBound, filterBound]
-  rfl
-
-end PartitionPilot.Forcing.BoundedFormula
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Geometry.LiftedCompressionFunctions
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing.BoundedFormula
+
+open SetFormula
+universe u
+
+def rightTripleFormula {n} (z a b c : Fin n) : BoundedFormula n :=
+  exMem z (exMem 0 (.conj (orderedPairFormula 0 b.succ.succ c.succ.succ)
+    (orderedPairFormula z.succ.succ a.succ.succ 0)))
+
+theorem truth_rightTripleFormula {n} (z a b c : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (rightTripleFormula z a b c) env ↔
+      env z = ZFSet.pair (env a) (ZFSet.pair (env b) (env c)) := by
+  simp only [rightTripleFormula, truth_exMem, Truth, truth_orderedPairFormula]
+  change (∃ s ∈ env z, ∃ t ∈ s, t = ZFSet.pair (env b) (env c) ∧
+    env z = ZFSet.pair (env a) t) ↔ _
+  constructor
+  · rintro ⟨_, _, _, _, rfl, equal⟩
+    exact equal
+  · intro equal
+    refine ⟨{env a, ZFSet.pair (env b) (env c)}, ?_, ZFSet.pair (env b) (env c),
+      ZFSet.mem_pair.2 (Or.inr rfl), rfl, equal⟩
+    rw [equal]
+    exact ZFSet.mem_pair.2 (Or.inr rfl)
+
+def taggedPairTripleFormula {n} (z l i j q : Fin n) : BoundedFormula n :=
+  exMem z (exMem 0 (.conj (orderedTripleFormula 0 i.succ.succ j.succ.succ q.succ.succ)
+    (orderedPairFormula z.succ.succ l.succ.succ 0)))
+
+theorem truth_taggedPairTripleFormula {n} (z l i j q : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (taggedPairTripleFormula z l i j q) env ↔
+      env z = ZFSet.pair (env l) (ZFSet.pair (ZFSet.pair (env i) (env j)) (env q)) := by
+  simp only [taggedPairTripleFormula, truth_exMem, Truth, truth_orderedTripleFormula,
+    truth_orderedPairFormula]
+  change (∃ s ∈ env z, ∃ t ∈ s, t = ZFSet.pair (ZFSet.pair (env i) (env j)) (env q) ∧
+    env z = ZFSet.pair (env l) t) ↔ _
+  constructor
+  · rintro ⟨_, _, _, _, rfl, equal⟩
+    exact equal
+  · intro equal
+    refine ⟨{env l, ZFSet.pair (ZFSet.pair (env i) (env j)) (env q)}, ?_,
+      ZFSet.pair (ZFSet.pair (env i) (env j)) (env q),
+      ZFSet.mem_pair.2 (Or.inr rfl), rfl, equal⟩
+    rw [equal]
+    exact ZFSet.mem_pair.2 (Or.inr rfl)
+
+def liftOldEntryFormula {n} (d maps bound i x y : Fin n) : BoundedFormula n :=
+  .conj (.mem x d) (exMem bound (.conj (pairMembershipFormula i.succ 0 maps.succ)
+    (pairMembershipFormula x.succ y.succ 0)))
+
+theorem truth_liftOldEntryFormula {n} (d maps bound i x y : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (liftOldEntryFormula d maps bound i x y) env ↔
+      env x ∈ env d ∧ ∃ S ∈ env bound,
+        ZFSet.pair (env i) S ∈ env maps ∧ ZFSet.pair (env x) (env y) ∈ S := by
+  simp only [liftOldEntryFormula, Truth, truth_exMem, truth_pairMembershipFormula]
+  rfl
+
+def liftFreshEntryFormula {n} (d l j b ns sources fs bound reps g action i x y : Fin n) : BoundedFormula n :=
+  let up (t : Fin n) := t.succ.succ.succ.succ
+  exMem j (exMem b.succ (exMem d.succ.succ (exMem bound.succ.succ.succ
+    (.conj (rightTripleFormula (up x) (up d) 3 2)
+      (.conj (pairMembershipFormula 3 2 (up ns))
+        (.conj (pairMembershipFormula (up i) 1 (up sources))
+          (.conj (pairMembershipFormula 3 0 (up fs))
+            (disj (.conj (.mem 1 0) (exMem (up g)
+              (.conj (pairMembershipFormula (up i).succ 0 (up reps).succ)
+                (tripleMembershipFormula 0 (up x).succ (up y).succ (up action).succ))))
+              (.conj (.neg (.mem 1 0)) (taggedPairTripleFormula (up y) (up l) (up i) 3 2))))))))))
+
+theorem truth_liftFreshEntryFormula {n} (d l j b ns sources fs bound reps g action i x y : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (liftFreshEntryFormula d l j b ns sources fs bound reps g action i x y) env ↔
+      ∃ h ∈ env j, ∃ q ∈ env b, ∃ a ∈ env d, ∃ F ∈ env bound,
+        env x = ZFSet.pair (env d) (ZFSet.pair h q) ∧ ZFSet.pair h q ∈ env ns ∧
+        ZFSet.pair (env i) a ∈ env sources ∧ ZFSet.pair h F ∈ env fs ∧
+        ((a ∈ F ∧ ∃ actor ∈ env g, ZFSet.pair (env i) actor ∈ env reps ∧
+          ZFSet.pair (ZFSet.pair actor (env x)) (env y) ∈ env action) ∨
+          (a ∉ F ∧ env y = ZFSet.pair (env l) (ZFSet.pair (ZFSet.pair (env i) h) q))) := by
+  simp only [liftFreshEntryFormula, truth_exMem, Truth, truth_disj,
+    truth_rightTripleFormula, truth_pairMembershipFormula, truth_tripleMembershipFormula,
+    truth_taggedPairTripleFormula]
+  rfl
+
+def liftedCompressionEntryFormula {n} (z i j d l c ns b maps sources fs reps g action v w : Fin n) :
+    BoundedFormula n :=
+  let up (t : Fin n) := t.succ.succ.succ
+  exMem i (exMem l.succ (exMem c.succ.succ
+    (.conj (orderedTripleFormula (up z) 2 1 0)
+      (disj (liftOldEntryFormula (up d) (up maps) (up v) 2 1 0)
+        (liftFreshEntryFormula (up d) (up l) (up j) (up b) (up ns)
+          (up sources) (up fs) (up w) (up reps) (up g) (up action) 2 1 0)))))
+
+theorem truth_liftedCompressionEntryFormula {n} (z i j d l c ns b maps sources fs reps g action v w : Fin n)
+    (env : Fin n → ZFSet.{u}) (mapsBound : env v = ZFSet.sUnion (ZFSet.sUnion (env maps)))
+    (filterBound : env w = ZFSet.sUnion (ZFSet.sUnion (env fs))) :
+    Truth (liftedCompressionEntryFormula z i j d l c ns b maps sources fs reps g action v w) env ↔
+      ∃ task ∈ env i, ∃ x ∈ env l, ∃ y ∈ env c,
+        env z = ZFSet.pair (ZFSet.pair task x) y ∧
+          (liftOldEntry (env d) (env maps) task x y ∨
+            liftFreshEntry (env d) (env l) (env j) (env b) (env ns)
+              (env sources) (env fs) (env reps) (env g) (env action) task x y) := by
+  simp only [liftedCompressionEntryFormula, truth_exMem, Truth, truth_disj,
+    truth_orderedTripleFormula, truth_liftOldEntryFormula, truth_liftFreshEntryFormula]
+  simp only [liftOldEntry, liftFreshEntry, extend, Fin.cases_succ, Fin.cases_zero,
+    mapsBound, filterBound]
+  rfl
+
+end PartitionPilot.Forcing.BoundedFormula
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/LinkedMainInvariantCodes.lean

@@ -1,68 +1,68 @@
-import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundMainStageInvariant
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing
-open SetFormula
-universe u
-
-def LinkedMainInvariantCode (M : TransitiveGround.{u})
-    (K Labels C D P G cutoff serial : ZFSet.{u}) : Prop :=
-  GroundBelow M P K ∧ GroundBelow M G K ∧ GroundBelow M Labels K ∧
-    ZFSet.rank P < ZFSet.rank K ∧ ZFSet.rank G < ZFSet.rank K ∧
-    ZFSet.rank Labels < ZFSet.rank K ∧ cutoff ∈ K ∧
-    ZFSet.rank C < ZFSet.rank K ∧ ZFSet.rank D < ZFSet.rank K ∧
-    ZFSet.rank serial < ZFSet.rank K
-
-namespace SetFormula
-
-def linkedMainInvariantFormula {n} (K Labels C D P G cutoff serial : Fin n) : SetFormula n :=
-  .conj (groundBelowFormula P K) (.conj (groundBelowFormula G K)
-    (.conj (groundBelowFormula Labels K) (.conj (cumulativeRankLtFormula P K)
-      (.conj (cumulativeRankLtFormula G K) (.conj (cumulativeRankLtFormula Labels K)
-        (.conj (.mem cutoff K) (.conj (cumulativeRankLtFormula C K)
-          (.conj (cumulativeRankLtFormula D K) (cumulativeRankLtFormula serial K)))))))))
-end SetFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-
-theorem realize_linkedMainInvariantFormula
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    (collection : CollectionSchema M.sets) {n}
-    (K Labels C D P G cutoff serial : Fin n) (env : Fin n → ZFSet.{u})
-    (members : ∀ i, env i ∈ M.sets) (ordinal : ordinalSetProperty (env K)) :
-    Realize M.sets (linkedMainInvariantFormula K Labels C D P G cutoff serial) env ↔
-      LinkedMainInvariantCode M (env K) (env Labels) (env C) (env D)
-        (env P) (env G) (env cutoff) (env serial) := by
-  change (Realize M.sets (groundBelowFormula P K) env ∧
-    Realize M.sets (groundBelowFormula G K) env ∧
-    Realize M.sets (groundBelowFormula Labels K) env ∧
-    Realize M.sets (cumulativeRankLtFormula P K) env ∧
-    Realize M.sets (cumulativeRankLtFormula G K) env ∧
-    Realize M.sets (cumulativeRankLtFormula Labels K) env ∧ env cutoff ∈ env K ∧
-    Realize M.sets (cumulativeRankLtFormula C K) env ∧
-    Realize M.sets (cumulativeRankLtFormula D K) env ∧
-    Realize M.sets (cumulativeRankLtFormula serial K) env) ↔ _
-  rw [M.realize_groundBelowFormula P K env members,
-    M.realize_groundBelowFormula G K env members,
-    M.realize_groundBelowFormula Labels K env members,
-    M.realize_cumulativeRankLtFormula pairing unions powers separation collection P K env members ordinal,
-    M.realize_cumulativeRankLtFormula pairing unions powers separation collection G K env members ordinal,
-    M.realize_cumulativeRankLtFormula pairing unions powers separation collection Labels K env members ordinal,
-    M.realize_cumulativeRankLtFormula pairing unions powers separation collection C K env members ordinal,
-    M.realize_cumulativeRankLtFormula pairing unions powers separation collection D K env members ordinal,
-    M.realize_cumulativeRankLtFormula pairing unions powers separation collection serial K env members ordinal]
-  rfl
-
-end TransitiveGround
-
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundMainStageInvariant
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing
+open SetFormula
+universe u
+
+def LinkedMainInvariantCode (M : TransitiveGround.{u})
+    (K Labels C D P G cutoff serial : ZFSet.{u}) : Prop :=
+  GroundBelow M P K ∧ GroundBelow M G K ∧ GroundBelow M Labels K ∧
+    ZFSet.rank P < ZFSet.rank K ∧ ZFSet.rank G < ZFSet.rank K ∧
+    ZFSet.rank Labels < ZFSet.rank K ∧ cutoff ∈ K ∧
+    ZFSet.rank C < ZFSet.rank K ∧ ZFSet.rank D < ZFSet.rank K ∧
+    ZFSet.rank serial < ZFSet.rank K
+
+namespace SetFormula
+
+def linkedMainInvariantFormula {n} (K Labels C D P G cutoff serial : Fin n) : SetFormula n :=
+  .conj (groundBelowFormula P K) (.conj (groundBelowFormula G K)
+    (.conj (groundBelowFormula Labels K) (.conj (cumulativeRankLtFormula P K)
+      (.conj (cumulativeRankLtFormula G K) (.conj (cumulativeRankLtFormula Labels K)
+        (.conj (.mem cutoff K) (.conj (cumulativeRankLtFormula C K)
+          (.conj (cumulativeRankLtFormula D K) (cumulativeRankLtFormula serial K)))))))))
+end SetFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+
+theorem realize_linkedMainInvariantFormula
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    (collection : CollectionSchema M.sets) {n}
+    (K Labels C D P G cutoff serial : Fin n) (env : Fin n → ZFSet.{u})
+    (members : ∀ i, env i ∈ M.sets) (ordinal : ordinalSetProperty (env K)) :
+    Realize M.sets (linkedMainInvariantFormula K Labels C D P G cutoff serial) env ↔
+      LinkedMainInvariantCode M (env K) (env Labels) (env C) (env D)
+        (env P) (env G) (env cutoff) (env serial) := by
+  change (Realize M.sets (groundBelowFormula P K) env ∧
+    Realize M.sets (groundBelowFormula G K) env ∧
+    Realize M.sets (groundBelowFormula Labels K) env ∧
+    Realize M.sets (cumulativeRankLtFormula P K) env ∧
+    Realize M.sets (cumulativeRankLtFormula G K) env ∧
+    Realize M.sets (cumulativeRankLtFormula Labels K) env ∧ env cutoff ∈ env K ∧
+    Realize M.sets (cumulativeRankLtFormula C K) env ∧
+    Realize M.sets (cumulativeRankLtFormula D K) env ∧
+    Realize M.sets (cumulativeRankLtFormula serial K) env) ↔ _
+  rw [M.realize_groundBelowFormula P K env members,
+    M.realize_groundBelowFormula G K env members,
+    M.realize_groundBelowFormula Labels K env members,
+    M.realize_cumulativeRankLtFormula pairing unions powers separation collection P K env members ordinal,
+    M.realize_cumulativeRankLtFormula pairing unions powers separation collection G K env members ordinal,
+    M.realize_cumulativeRankLtFormula pairing unions powers separation collection Labels K env members ordinal,
+    M.realize_cumulativeRankLtFormula pairing unions powers separation collection C K env members ordinal,
+    M.realize_cumulativeRankLtFormula pairing unions powers separation collection D K env members ordinal,
+    M.realize_cumulativeRankLtFormula pairing unions powers separation collection serial K env members ordinal]
+  rfl
+
+end TransitiveGround
+
+end PartitionPilot.Forcing
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/LinkedMainTransitionRawCodes.lean

@@ -1,177 +1,177 @@
-import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundLinkedMainStageCodeLaws
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing.BoundedFormula
-open SetFormula
-universe u
-
-def chronologicalMainTransitionFormula {n}
-    (z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth : Fin n)
-    (sourceGraphs targetGraphs : Fin 5 → Fin n) : BoundedFormula n :=
-  .conj (validMainTransitionCodeFormula z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors)
-    (chronologicalTransitionExtraFormula P Q points sourceCutoff targetCutoff sourceBirth targetBirth
-      sourceGraphs targetGraphs)
-
-theorem truth_chronologicalMainTransitionFormula {n}
-    (z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth : Fin n)
-    (sourceGraphs targetGraphs : Fin 5 → Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (chronologicalMainTransitionFormula z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth sourceGraphs targetGraphs) env ↔
-      env z = ZFSet.pair (env points) (env actors) ∧
-      MainTransitionLaws (env P) (env Q) (env rP) (env rQ) (env μP) (env μQ) (env G) (env H) (env mG) (env mH) (env oneG) (env oneH) (env AP) (env AQ) (env bP) (env bQ) (env heightP) (env heightQ) (env points) (env actors) ∧
-      ChronologicalTransitionLaws (env points) (env sourceCutoff) (env targetCutoff)
-        (env sourceBirth) (env targetBirth) (fun j => env (sourceGraphs j))
-          (fun j => env (targetGraphs j)) := by
-  change (Truth (validMainTransitionCodeFormula z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors) env ∧
-    Truth (chronologicalTransitionExtraFormula P Q points sourceCutoff targetCutoff sourceBirth targetBirth
-      sourceGraphs targetGraphs) env) ↔ _
-  rw [truth_validMainTransitionCodeFormula]
-  constructor
-  · rintro ⟨⟨encoded, laws⟩, chronological⟩
-    exact ⟨encoded, laws, (truth_chronologicalTransitionExtraFormula P Q points sourceCutoff targetCutoff
-      sourceBirth targetBirth sourceGraphs targetGraphs env laws.point_embedding.injection.function.1).1 chronological⟩
-  · rintro ⟨encoded, laws, chronological⟩
-    exact ⟨⟨encoded, laws⟩, (truth_chronologicalTransitionExtraFormula P Q points sourceCutoff targetCutoff
-      sourceBirth targetBirth sourceGraphs targetGraphs env laws.point_embedding.injection.function.1).2 chronological⟩
-
-theorem realize_chronologicalMainTransitionFormula (M : TransitiveGround.{u}) {n}
-    (z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth : Fin n)
-    (sourceGraphs targetGraphs : Fin 5 → Fin n) (env : Fin n → ZFSet.{u})
-    (members : ∀ i, env i ∈ M.sets) :
-    Realize M.sets (chronologicalMainTransitionFormula z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth
-      sourceGraphs targetGraphs).toFormula env ↔
-      env z = ZFSet.pair (env points) (env actors) ∧
-      MainTransitionLaws (env P) (env Q) (env rP) (env rQ) (env μP) (env μQ) (env G) (env H) (env mG) (env mH) (env oneG) (env oneH) (env AP) (env AQ) (env bP) (env bQ) (env heightP) (env heightQ) (env points) (env actors) ∧
-      ChronologicalTransitionLaws (env points) (env sourceCutoff) (env targetCutoff)
-        (env sourceBirth) (env targetBirth) (fun j => env (sourceGraphs j))
-          (fun j => env (targetGraphs j)) :=
-  (realize_toFormula M _ env members).trans
-    (truth_chronologicalMainTransitionFormula z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth sourceGraphs targetGraphs env)
-
-def coveredChronologicalMainTransitionFormula {n}
-    (z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth : Fin n)
-    (sourceGraphs targetGraphs : Fin 5 → Fin n) : BoundedFormula n :=
-  .conj (chronologicalMainTransitionFormula z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth sourceGraphs targetGraphs)
-    (oldBirthFiberCoverageFormula P points targetBirth sourceCutoff)
-
-theorem truth_coveredChronologicalMainTransitionFormula {n}
-    (z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth : Fin n)
-    (sourceGraphs targetGraphs : Fin 5 → Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (coveredChronologicalMainTransitionFormula z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth sourceGraphs targetGraphs) env ↔
-      (env z = ZFSet.pair (env points) (env actors) ∧
-      MainTransitionLaws (env P) (env Q) (env rP) (env rQ) (env μP) (env μQ) (env G) (env H) (env mG) (env mH) (env oneG) (env oneH) (env AP) (env AQ) (env bP) (env bQ) (env heightP) (env heightQ) (env points) (env actors) ∧
-      ChronologicalTransitionLaws (env points) (env sourceCutoff) (env targetCutoff)
-        (env sourceBirth) (env targetBirth) (fun j => env (sourceGraphs j))
-          (fun j => env (targetGraphs j))) ∧
-      OldBirthFiberCoverageCode (env P) (env points) (env targetBirth) (env sourceCutoff) := by
-  simp only [coveredChronologicalMainTransitionFormula, Truth,
-    truth_chronologicalMainTransitionFormula, truth_oldBirthFiberCoverageFormula]
-
-theorem realize_coveredChronologicalMainTransitionFormula (M : TransitiveGround.{u}) {n}
-    (z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth : Fin n)
-    (sourceGraphs targetGraphs : Fin 5 → Fin n) (env : Fin n → ZFSet.{u})
-    (members : ∀ i, env i ∈ M.sets) :
-    Realize M.sets (coveredChronologicalMainTransitionFormula z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth
-      sourceGraphs targetGraphs).toFormula env ↔
-      (env z = ZFSet.pair (env points) (env actors) ∧
-      MainTransitionLaws (env P) (env Q) (env rP) (env rQ) (env μP) (env μQ) (env G) (env H) (env mG) (env mH) (env oneG) (env oneH) (env AP) (env AQ) (env bP) (env bQ) (env heightP) (env heightQ) (env points) (env actors) ∧
-      ChronologicalTransitionLaws (env points) (env sourceCutoff) (env targetCutoff)
-        (env sourceBirth) (env targetBirth) (fun j => env (sourceGraphs j))
-          (fun j => env (targetGraphs j))) ∧
-      OldBirthFiberCoverageCode (env P) (env points) (env targetBirth) (env sourceCutoff) :=
-  (realize_toFormula M _ env members).trans
-    (truth_coveredChronologicalMainTransitionFormula z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth sourceGraphs targetGraphs env)
-
-end PartitionPilot.Forcing.BoundedFormula
-
-
-
-namespace PartitionPilot.Forcing
-open SetFormula
-universe u
-
-def LinkedTransitionLawsCode (z points actors sourceBirth targetBirth : ZFSet.{u})
-    (source target : Fin 24 → ZFSet.{u}) : Prop :=
-  ZFSet.pair (source 11) sourceBirth ∈ source 17 ∧
-  ZFSet.pair (target 11) targetBirth ∈ target 17 ∧
-  (z = ZFSet.pair points actors ∧
-    MainTransitionLaws (source 0) (target 0) (source 1) (target 1) (source 2) (target 2) (source 3) (target 3) (source 4) (target 4) (source 6) (target 6) (source 7) (target 7) (source 8) (target 8) (source 10) (target 10) points actors ∧
-    ChronologicalTransitionLaws points (source 11) (target 11) sourceBirth targetBirth
-      (linkedChronologyGraphs source) (linkedChronologyGraphs target)) ∧
-  OldBirthFiberCoverageCode (source 0) points targetBirth (source 11)
-
-def LinkedMainTransitionRawCode (M : TransitiveGround.{u})
-    (K Labels C D rD N sourceCode targetCode z points actors sourceBirth targetBirth : ZFSet.{u})
-    (source target : Fin 24 → ZFSet.{u}) : Prop :=
-  LinkedMainStageRawCode M K Labels C D rD N sourceCode source ∧
-  LinkedMainStageRawCode M K Labels C D rD N targetCode target ∧
-  LinkedTransitionLawsCode z points actors sourceBirth targetBirth source target
-
-namespace BoundedFormula
-
-def linkedTransitionLawsFormula {n} (z points actors sourceBirth targetBirth : Fin n)
-    (f g : Fin 24 → Fin n) : BoundedFormula n :=
-  .conj (pairMembershipFormula (f 11) sourceBirth (f 17))
-    (.conj (pairMembershipFormula (g 11) targetBirth (g 17))
-      (coveredChronologicalMainTransitionFormula z (f 0) (g 0) (f 1) (g 1) (f 2) (g 2) (f 3) (g 3) (f 4) (g 4) (f 6) (g 6) (f 7) (g 7) (f 8) (g 8) (f 10) (g 10)
-        points actors (f 11) (g 11) sourceBirth targetBirth
-          (linkedChronologyGraphs f) (linkedChronologyGraphs g)))
-
-theorem truth_linkedTransitionLawsFormula {n} (z points actors sourceBirth targetBirth : Fin n)
-    (f g : Fin 24 → Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (linkedTransitionLawsFormula z points actors sourceBirth targetBirth f g) env ↔
-      LinkedTransitionLawsCode (env z) (env points) (env actors) (env sourceBirth) (env targetBirth)
-        (fun j => env (f j)) (fun j => env (g j)) := by
-  have map (h : Fin 24 → Fin n) : (fun j => env (linkedChronologyGraphs h j)) =
-      linkedChronologyGraphs (fun j => env (h j)) := by
-    funext j
-    exact Fin.cases rfl (Fin.cases rfl (Fin.cases rfl (Fin.cases rfl (fun _ => rfl)))) j
-  simp only [linkedTransitionLawsFormula, Truth, truth_pairMembershipFormula,
-    truth_coveredChronologicalMainTransitionFormula, map, LinkedTransitionLawsCode]
-
-end BoundedFormula
-
-namespace SetFormula
-
-def linkedMainTransitionRawFormula {n}
-    (K Labels C D rD N sourceCode targetCode z points actors sourceBirth targetBirth : Fin n)
-    (source target : Fin 24 → Fin n) : SetFormula n :=
-  .conj (linkedMainStageRawFormula K Labels C D rD N sourceCode source)
-    (.conj (linkedMainStageRawFormula K Labels C D rD N targetCode target)
-      (BoundedFormula.linkedTransitionLawsFormula z points actors sourceBirth targetBirth source target).toFormula)
-
-end SetFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-
-theorem realize_linkedMainTransitionRawFormula
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    (collection : CollectionSchema M.sets) {n}
-    (K Labels C D rD N sourceCode targetCode z points actors sourceBirth targetBirth : Fin n)
-    (source target : Fin 24 → Fin n) (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
-    (omega : env N = ZFSet.omega) (ordinal : ordinalSetProperty (env K)) :
-    Realize M.sets (linkedMainTransitionRawFormula K Labels C D rD N sourceCode targetCode z
-      points actors sourceBirth targetBirth source target) env ↔
-      LinkedMainTransitionRawCode M (env K) (env Labels) (env C) (env D) (env rD) (env N)
-        (env sourceCode) (env targetCode) (env z) (env points) (env actors) (env sourceBirth) (env targetBirth)
-          (fun j => env (source j)) (fun j => env (target j)) := by
-  have first := M.realize_linkedMainStageRawFormula pairing unions powers separation collection
-    K Labels C D rD N sourceCode source env members omega ordinal
-  have second := M.realize_linkedMainStageRawFormula pairing unions powers separation collection
-    K Labels C D rD N targetCode target env members omega ordinal
-  have laws := (BoundedFormula.realize_toFormula M _ env members).trans
-    (BoundedFormula.truth_linkedTransitionLawsFormula z points actors sourceBirth targetBirth source target env)
-  exact and_congr first (and_congr second laws)
-
-end TransitiveGround
-
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundLinkedMainStageCodeLaws
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing.BoundedFormula
+open SetFormula
+universe u
+
+def chronologicalMainTransitionFormula {n}
+    (z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth : Fin n)
+    (sourceGraphs targetGraphs : Fin 5 → Fin n) : BoundedFormula n :=
+  .conj (validMainTransitionCodeFormula z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors)
+    (chronologicalTransitionExtraFormula P Q points sourceCutoff targetCutoff sourceBirth targetBirth
+      sourceGraphs targetGraphs)
+
+theorem truth_chronologicalMainTransitionFormula {n}
+    (z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth : Fin n)
+    (sourceGraphs targetGraphs : Fin 5 → Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (chronologicalMainTransitionFormula z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth sourceGraphs targetGraphs) env ↔
+      env z = ZFSet.pair (env points) (env actors) ∧
+      MainTransitionLaws (env P) (env Q) (env rP) (env rQ) (env μP) (env μQ) (env G) (env H) (env mG) (env mH) (env oneG) (env oneH) (env AP) (env AQ) (env bP) (env bQ) (env heightP) (env heightQ) (env points) (env actors) ∧
+      ChronologicalTransitionLaws (env points) (env sourceCutoff) (env targetCutoff)
+        (env sourceBirth) (env targetBirth) (fun j => env (sourceGraphs j))
+          (fun j => env (targetGraphs j)) := by
+  change (Truth (validMainTransitionCodeFormula z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors) env ∧
+    Truth (chronologicalTransitionExtraFormula P Q points sourceCutoff targetCutoff sourceBirth targetBirth
+      sourceGraphs targetGraphs) env) ↔ _
+  rw [truth_validMainTransitionCodeFormula]
+  constructor
+  · rintro ⟨⟨encoded, laws⟩, chronological⟩
+    exact ⟨encoded, laws, (truth_chronologicalTransitionExtraFormula P Q points sourceCutoff targetCutoff
+      sourceBirth targetBirth sourceGraphs targetGraphs env laws.point_embedding.injection.function.1).1 chronological⟩
+  · rintro ⟨encoded, laws, chronological⟩
+    exact ⟨⟨encoded, laws⟩, (truth_chronologicalTransitionExtraFormula P Q points sourceCutoff targetCutoff
+      sourceBirth targetBirth sourceGraphs targetGraphs env laws.point_embedding.injection.function.1).2 chronological⟩
+
+theorem realize_chronologicalMainTransitionFormula (M : TransitiveGround.{u}) {n}
+    (z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth : Fin n)
+    (sourceGraphs targetGraphs : Fin 5 → Fin n) (env : Fin n → ZFSet.{u})
+    (members : ∀ i, env i ∈ M.sets) :
+    Realize M.sets (chronologicalMainTransitionFormula z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth
+      sourceGraphs targetGraphs).toFormula env ↔
+      env z = ZFSet.pair (env points) (env actors) ∧
+      MainTransitionLaws (env P) (env Q) (env rP) (env rQ) (env μP) (env μQ) (env G) (env H) (env mG) (env mH) (env oneG) (env oneH) (env AP) (env AQ) (env bP) (env bQ) (env heightP) (env heightQ) (env points) (env actors) ∧
+      ChronologicalTransitionLaws (env points) (env sourceCutoff) (env targetCutoff)
+        (env sourceBirth) (env targetBirth) (fun j => env (sourceGraphs j))
+          (fun j => env (targetGraphs j)) :=
+  (realize_toFormula M _ env members).trans
+    (truth_chronologicalMainTransitionFormula z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth sourceGraphs targetGraphs env)
+
+def coveredChronologicalMainTransitionFormula {n}
+    (z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth : Fin n)
+    (sourceGraphs targetGraphs : Fin 5 → Fin n) : BoundedFormula n :=
+  .conj (chronologicalMainTransitionFormula z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth sourceGraphs targetGraphs)
+    (oldBirthFiberCoverageFormula P points targetBirth sourceCutoff)
+
+theorem truth_coveredChronologicalMainTransitionFormula {n}
+    (z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth : Fin n)
+    (sourceGraphs targetGraphs : Fin 5 → Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (coveredChronologicalMainTransitionFormula z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth sourceGraphs targetGraphs) env ↔
+      (env z = ZFSet.pair (env points) (env actors) ∧
+      MainTransitionLaws (env P) (env Q) (env rP) (env rQ) (env μP) (env μQ) (env G) (env H) (env mG) (env mH) (env oneG) (env oneH) (env AP) (env AQ) (env bP) (env bQ) (env heightP) (env heightQ) (env points) (env actors) ∧
+      ChronologicalTransitionLaws (env points) (env sourceCutoff) (env targetCutoff)
+        (env sourceBirth) (env targetBirth) (fun j => env (sourceGraphs j))
+          (fun j => env (targetGraphs j))) ∧
+      OldBirthFiberCoverageCode (env P) (env points) (env targetBirth) (env sourceCutoff) := by
+  simp only [coveredChronologicalMainTransitionFormula, Truth,
+    truth_chronologicalMainTransitionFormula, truth_oldBirthFiberCoverageFormula]
+
+theorem realize_coveredChronologicalMainTransitionFormula (M : TransitiveGround.{u}) {n}
+    (z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth : Fin n)
+    (sourceGraphs targetGraphs : Fin 5 → Fin n) (env : Fin n → ZFSet.{u})
+    (members : ∀ i, env i ∈ M.sets) :
+    Realize M.sets (coveredChronologicalMainTransitionFormula z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth
+      sourceGraphs targetGraphs).toFormula env ↔
+      (env z = ZFSet.pair (env points) (env actors) ∧
+      MainTransitionLaws (env P) (env Q) (env rP) (env rQ) (env μP) (env μQ) (env G) (env H) (env mG) (env mH) (env oneG) (env oneH) (env AP) (env AQ) (env bP) (env bQ) (env heightP) (env heightQ) (env points) (env actors) ∧
+      ChronologicalTransitionLaws (env points) (env sourceCutoff) (env targetCutoff)
+        (env sourceBirth) (env targetBirth) (fun j => env (sourceGraphs j))
+          (fun j => env (targetGraphs j))) ∧
+      OldBirthFiberCoverageCode (env P) (env points) (env targetBirth) (env sourceCutoff) :=
+  (realize_toFormula M _ env members).trans
+    (truth_coveredChronologicalMainTransitionFormula z P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors sourceCutoff targetCutoff sourceBirth targetBirth sourceGraphs targetGraphs env)
+
+end PartitionPilot.Forcing.BoundedFormula
+
+
+
+namespace PartitionPilot.Forcing
+open SetFormula
+universe u
+
+def LinkedTransitionLawsCode (z points actors sourceBirth targetBirth : ZFSet.{u})
+    (source target : Fin 24 → ZFSet.{u}) : Prop :=
+  ZFSet.pair (source 11) sourceBirth ∈ source 17 ∧
+  ZFSet.pair (target 11) targetBirth ∈ target 17 ∧
+  (z = ZFSet.pair points actors ∧
+    MainTransitionLaws (source 0) (target 0) (source 1) (target 1) (source 2) (target 2) (source 3) (target 3) (source 4) (target 4) (source 6) (target 6) (source 7) (target 7) (source 8) (target 8) (source 10) (target 10) points actors ∧
+    ChronologicalTransitionLaws points (source 11) (target 11) sourceBirth targetBirth
+      (linkedChronologyGraphs source) (linkedChronologyGraphs target)) ∧
+  OldBirthFiberCoverageCode (source 0) points targetBirth (source 11)
+
+def LinkedMainTransitionRawCode (M : TransitiveGround.{u})
+    (K Labels C D rD N sourceCode targetCode z points actors sourceBirth targetBirth : ZFSet.{u})
+    (source target : Fin 24 → ZFSet.{u}) : Prop :=
+  LinkedMainStageRawCode M K Labels C D rD N sourceCode source ∧
+  LinkedMainStageRawCode M K Labels C D rD N targetCode target ∧
+  LinkedTransitionLawsCode z points actors sourceBirth targetBirth source target
+
+namespace BoundedFormula
+
+def linkedTransitionLawsFormula {n} (z points actors sourceBirth targetBirth : Fin n)
+    (f g : Fin 24 → Fin n) : BoundedFormula n :=
+  .conj (pairMembershipFormula (f 11) sourceBirth (f 17))
+    (.conj (pairMembershipFormula (g 11) targetBirth (g 17))
+      (coveredChronologicalMainTransitionFormula z (f 0) (g 0) (f 1) (g 1) (f 2) (g 2) (f 3) (g 3) (f 4) (g 4) (f 6) (g 6) (f 7) (g 7) (f 8) (g 8) (f 10) (g 10)
+        points actors (f 11) (g 11) sourceBirth targetBirth
+          (linkedChronologyGraphs f) (linkedChronologyGraphs g)))
+
+theorem truth_linkedTransitionLawsFormula {n} (z points actors sourceBirth targetBirth : Fin n)
+    (f g : Fin 24 → Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (linkedTransitionLawsFormula z points actors sourceBirth targetBirth f g) env ↔
+      LinkedTransitionLawsCode (env z) (env points) (env actors) (env sourceBirth) (env targetBirth)
+        (fun j => env (f j)) (fun j => env (g j)) := by
+  have map (h : Fin 24 → Fin n) : (fun j => env (linkedChronologyGraphs h j)) =
+      linkedChronologyGraphs (fun j => env (h j)) := by
+    funext j
+    exact Fin.cases rfl (Fin.cases rfl (Fin.cases rfl (Fin.cases rfl (fun _ => rfl)))) j
+  simp only [linkedTransitionLawsFormula, Truth, truth_pairMembershipFormula,
+    truth_coveredChronologicalMainTransitionFormula, map, LinkedTransitionLawsCode]
+
+end BoundedFormula
+
+namespace SetFormula
+
+def linkedMainTransitionRawFormula {n}
+    (K Labels C D rD N sourceCode targetCode z points actors sourceBirth targetBirth : Fin n)
+    (source target : Fin 24 → Fin n) : SetFormula n :=
+  .conj (linkedMainStageRawFormula K Labels C D rD N sourceCode source)
+    (.conj (linkedMainStageRawFormula K Labels C D rD N targetCode target)
+      (BoundedFormula.linkedTransitionLawsFormula z points actors sourceBirth targetBirth source target).toFormula)
+
+end SetFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+
+theorem realize_linkedMainTransitionRawFormula
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    (collection : CollectionSchema M.sets) {n}
+    (K Labels C D rD N sourceCode targetCode z points actors sourceBirth targetBirth : Fin n)
+    (source target : Fin 24 → Fin n) (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
+    (omega : env N = ZFSet.omega) (ordinal : ordinalSetProperty (env K)) :
+    Realize M.sets (linkedMainTransitionRawFormula K Labels C D rD N sourceCode targetCode z
+      points actors sourceBirth targetBirth source target) env ↔
+      LinkedMainTransitionRawCode M (env K) (env Labels) (env C) (env D) (env rD) (env N)
+        (env sourceCode) (env targetCode) (env z) (env points) (env actors) (env sourceBirth) (env targetBirth)
+          (fun j => env (source j)) (fun j => env (target j)) := by
+  have first := M.realize_linkedMainStageRawFormula pairing unions powers separation collection
+    K Labels C D rD N sourceCode source env members omega ordinal
+  have second := M.realize_linkedMainStageRawFormula pairing unions powers separation collection
+    K Labels C D rD N targetCode target env members omega ordinal
+  have laws := (BoundedFormula.realize_toFormula M _ env members).trans
+    (BoundedFormula.truth_linkedTransitionLawsFormula z points actors sourceBirth targetBirth source target env)
+  exact and_congr first (and_congr second laws)
+
+end TransitiveGround
+
+end PartitionPilot.Forcing
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/LinkedProfileTransitionRawCodes.lean

@@ -1,113 +1,113 @@
-import OAI.SetTheory.PartitionPrinciple.Geometry.GroundLinkedProfilePreservation
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing
-open SetFormula
-universe u
-
-def LinkedProfilePreservingTransitionRawCode (M : TransitiveGround.{u})
-    (K Labels C D rD N sourceCode targetCode z points actors sourceBirth targetBirth Families : ZFSet.{u})
-    (source target : Fin 24 → ZFSet.{u}) : Prop :=
-  LinkedMainTransitionRawCode M K Labels C D rD N sourceCode targetCode z points actors
-    sourceBirth targetBirth source target ∧
-  Families = M.groundPower (source 0) ∧
-  OldProfilePreservationCode (source 0) (source 1) (source 2)
-    (target 0) (target 1) (target 2) points Families
-
-namespace SetFormula
-def linkedProfilePreservingTransitionRawFormula {n}
-    (K Labels C D rD N sourceCode targetCode z points actors sourceBirth targetBirth Families : Fin n)
-    (source target : Fin 24 → Fin n) : SetFormula n :=
-  .conj (linkedMainTransitionRawFormula K Labels C D rD N sourceCode targetCode z points actors
-    sourceBirth targetBirth source target)
-    (.conj (relativePowerFormula (source 0) Families)
-      (BoundedFormula.oldProfilePreservationFormula (source 0) (source 1) (source 2)
-        (target 0) (target 1) (target 2) points Families).toFormula)
-
-end SetFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-theorem realize_linkedProfilePreservingTransitionRawFormula
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    (collection : CollectionSchema M.sets) {n}
-    (K Labels C D rD N sourceCode targetCode z points actors sourceBirth targetBirth Families : Fin n)
-    (source target : Fin 24 → Fin n) (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
-    (omega : env N = ZFSet.omega) (ordinal : ordinalSetProperty (env K)) :
-    Realize M.sets (linkedProfilePreservingTransitionRawFormula K Labels C D rD N sourceCode targetCode z
-      points actors sourceBirth targetBirth Families source target) env ↔
-    LinkedProfilePreservingTransitionRawCode M (env K) (env Labels) (env C) (env D) (env rD)
-      (env N) (env sourceCode) (env targetCode) (env z) (env points) (env actors)
-      (env sourceBirth) (env targetBirth) (env Families)
-      (fun j => env (source j)) (fun j => env (target j)) :=
-  (M.realize_linkedMainTransitionRawFormula pairing unions powers separation collection
-    K Labels C D rD N sourceCode targetCode z points actors sourceBirth targetBirth source target
-    env members omega ordinal).and
-    ((M.realize_relativePowerFormula (source 0) Families env members).and
-      (BoundedFormula.realize_oldProfilePreservationFormula M (source 0) (source 1) (source 2)
-        (target 0) (target 1) (target 2) points Families env members))
-
-end TransitiveGround
-
-namespace LinkedProfilePreservingTransitionRawCode
-variable {M : TransitiveGround.{u}}
-variable {K Labels C D rD N sourceCode targetCode z points actors sourceBirth targetBirth Families : ZFSet.{u}}
-variable {source target : Fin 24 → ZFSet.{u}}
-
-theorem exists_transition
-    (raw : LinkedProfilePreservingTransitionRawCode M K Labels C D rD N sourceCode targetCode z
-      points actors sourceBirth targetBirth Families source target)
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    (sourceGround : ∀ j, source j ∈ M.sets) (targetGround : ∀ j, target j ∈ M.sets)
-    (hPoints : points ∈ M.sets) (hActors : actors ∈ M.sets)
-    (hC : C ∈ M.sets) (hD : D ∈ M.sets) (hrD : rD ∈ M.sets) (omega : N = ZFSet.omega) :
-    LinkedProfilePreservingTransitionCode M K Labels C D rD sourceCode targetCode z := by
-  rw [omega] at raw
-  obtain ⟨s, t, sourceEqual, targetEqual, transition, equal, covered⟩ :=
-    raw.1.exists_transition pairing unions powers separation sourceGround targetGround
-      hPoints hActors hC hD hrD rfl
-  have sourceCode := s.rawFields_code
-  have targetCode := t.rawFields_code
-  rw [sourceEqual] at sourceCode
-  rw [targetEqual] at targetCode
-  have sourceFields := sourceCode.fields_unique raw.1.1
-  have targetFields := targetCode.fields_unique raw.1.2.1
-  have mapEqual : ZFSet.pair transition.map.points transition.map.actors = ZFSet.pair points actors :=
-    equal.trans raw.1.2.2.2.2.1.1
-  have pointsEqual := (ZFSet.pair_inj.1 mapEqual).1
-  have preservation := raw.2.2
-  rw [raw.2.1, ← sourceFields, ← targetFields] at preservation
-  refine ⟨s, t, sourceEqual, targetEqual, transition, equal, covered, ?_⟩
-  change OldProfilePreservationCode s.main.stage.carrier s.main.stage.order s.main.stage.meetGraph
-    t.main.stage.carrier t.main.stage.order t.main.stage.meetGraph
-    transition.map.points (M.groundPower s.main.stage.carrier)
-  rw [pointsEqual]
-  exact preservation
-
-end LinkedProfilePreservingTransitionRawCode
-
-namespace GroundLinkedMainStage
-variable {M : TransitiveGround.{u}} {K Labels C D rD : ZFSet.{u}}
-variable (source target : GroundLinkedMainStage M K Labels C D rD)
-theorem profileTransition_rawFields
-    (transition : GroundChronologicalMainTransition source.main target.main)
-    (covered : transition.CoversOldBirths) (preserved : transition.PreservesOldProfiles) :
-    LinkedProfilePreservingTransitionRawCode M K Labels C D rD ZFSet.omega source.code target.code
-      transition.map.code transition.map.points transition.map.actors source.main.birth target.main.birth
-      (M.groundPower source.main.stage.carrier) source.rawFields target.rawFields :=
-  ⟨source.transition_rawFields target transition covered, rfl, preserved⟩
-
-end GroundLinkedMainStage
-
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Geometry.GroundLinkedProfilePreservation
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing
+open SetFormula
+universe u
+
+def LinkedProfilePreservingTransitionRawCode (M : TransitiveGround.{u})
+    (K Labels C D rD N sourceCode targetCode z points actors sourceBirth targetBirth Families : ZFSet.{u})
+    (source target : Fin 24 → ZFSet.{u}) : Prop :=
+  LinkedMainTransitionRawCode M K Labels C D rD N sourceCode targetCode z points actors
+    sourceBirth targetBirth source target ∧
+  Families = M.groundPower (source 0) ∧
+  OldProfilePreservationCode (source 0) (source 1) (source 2)
+    (target 0) (target 1) (target 2) points Families
+
+namespace SetFormula
+def linkedProfilePreservingTransitionRawFormula {n}
+    (K Labels C D rD N sourceCode targetCode z points actors sourceBirth targetBirth Families : Fin n)
+    (source target : Fin 24 → Fin n) : SetFormula n :=
+  .conj (linkedMainTransitionRawFormula K Labels C D rD N sourceCode targetCode z points actors
+    sourceBirth targetBirth source target)
+    (.conj (relativePowerFormula (source 0) Families)
+      (BoundedFormula.oldProfilePreservationFormula (source 0) (source 1) (source 2)
+        (target 0) (target 1) (target 2) points Families).toFormula)
+
+end SetFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+theorem realize_linkedProfilePreservingTransitionRawFormula
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    (collection : CollectionSchema M.sets) {n}
+    (K Labels C D rD N sourceCode targetCode z points actors sourceBirth targetBirth Families : Fin n)
+    (source target : Fin 24 → Fin n) (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
+    (omega : env N = ZFSet.omega) (ordinal : ordinalSetProperty (env K)) :
+    Realize M.sets (linkedProfilePreservingTransitionRawFormula K Labels C D rD N sourceCode targetCode z
+      points actors sourceBirth targetBirth Families source target) env ↔
+    LinkedProfilePreservingTransitionRawCode M (env K) (env Labels) (env C) (env D) (env rD)
+      (env N) (env sourceCode) (env targetCode) (env z) (env points) (env actors)
+      (env sourceBirth) (env targetBirth) (env Families)
+      (fun j => env (source j)) (fun j => env (target j)) :=
+  (M.realize_linkedMainTransitionRawFormula pairing unions powers separation collection
+    K Labels C D rD N sourceCode targetCode z points actors sourceBirth targetBirth source target
+    env members omega ordinal).and
+    ((M.realize_relativePowerFormula (source 0) Families env members).and
+      (BoundedFormula.realize_oldProfilePreservationFormula M (source 0) (source 1) (source 2)
+        (target 0) (target 1) (target 2) points Families env members))
+
+end TransitiveGround
+
+namespace LinkedProfilePreservingTransitionRawCode
+variable {M : TransitiveGround.{u}}
+variable {K Labels C D rD N sourceCode targetCode z points actors sourceBirth targetBirth Families : ZFSet.{u}}
+variable {source target : Fin 24 → ZFSet.{u}}
+
+theorem exists_transition
+    (raw : LinkedProfilePreservingTransitionRawCode M K Labels C D rD N sourceCode targetCode z
+      points actors sourceBirth targetBirth Families source target)
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    (sourceGround : ∀ j, source j ∈ M.sets) (targetGround : ∀ j, target j ∈ M.sets)
+    (hPoints : points ∈ M.sets) (hActors : actors ∈ M.sets)
+    (hC : C ∈ M.sets) (hD : D ∈ M.sets) (hrD : rD ∈ M.sets) (omega : N = ZFSet.omega) :
+    LinkedProfilePreservingTransitionCode M K Labels C D rD sourceCode targetCode z := by
+  rw [omega] at raw
+  obtain ⟨s, t, sourceEqual, targetEqual, transition, equal, covered⟩ :=
+    raw.1.exists_transition pairing unions powers separation sourceGround targetGround
+      hPoints hActors hC hD hrD rfl
+  have sourceCode := s.rawFields_code
+  have targetCode := t.rawFields_code
+  rw [sourceEqual] at sourceCode
+  rw [targetEqual] at targetCode
+  have sourceFields := sourceCode.fields_unique raw.1.1
+  have targetFields := targetCode.fields_unique raw.1.2.1
+  have mapEqual : ZFSet.pair transition.map.points transition.map.actors = ZFSet.pair points actors :=
+    equal.trans raw.1.2.2.2.2.1.1
+  have pointsEqual := (ZFSet.pair_inj.1 mapEqual).1
+  have preservation := raw.2.2
+  rw [raw.2.1, ← sourceFields, ← targetFields] at preservation
+  refine ⟨s, t, sourceEqual, targetEqual, transition, equal, covered, ?_⟩
+  change OldProfilePreservationCode s.main.stage.carrier s.main.stage.order s.main.stage.meetGraph
+    t.main.stage.carrier t.main.stage.order t.main.stage.meetGraph
+    transition.map.points (M.groundPower s.main.stage.carrier)
+  rw [pointsEqual]
+  exact preservation
+
+end LinkedProfilePreservingTransitionRawCode
+
+namespace GroundLinkedMainStage
+variable {M : TransitiveGround.{u}} {K Labels C D rD : ZFSet.{u}}
+variable (source target : GroundLinkedMainStage M K Labels C D rD)
+theorem profileTransition_rawFields
+    (transition : GroundChronologicalMainTransition source.main target.main)
+    (covered : transition.CoversOldBirths) (preserved : transition.PreservesOldProfiles) :
+    LinkedProfilePreservingTransitionRawCode M K Labels C D rD ZFSet.omega source.code target.code
+      transition.map.code transition.map.points transition.map.actors source.main.birth target.main.birth
+      (M.groundPower source.main.stage.carrier) source.rawFields target.rawFields :=
+  ⟨source.transition_rawFields target transition covered, rfl, preserved⟩
+
+end GroundLinkedMainStage
+
+end PartitionPilot.Forcing
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/MainLimitCoverageFormulas.lean

@@ -1,559 +1,559 @@
-import OAI.SetTheory.PartitionPrinciple.Definability.ForcingHistoryOutputFormulas
-import OAI.SetTheory.PartitionPrinciple.Forcing.GreedyAntichainTraces
-import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundMainPrefixLimitCoverageGraph
-
-namespace OAI
-
-
-namespace PartitionPilot.Forcing.BoundedFormula
-open SetFormula
-universe u
-
-def orderAntichainFormula {n} (Q order A : Fin n) : BoundedFormula n :=
-  .conj (.allMem A (.mem 0 Q.succ))
-    (.allMem A (.allMem A.succ (.allMem Q.succ.succ
-      (imp (.conj (pairMembershipFormula 0 2 order.succ.succ.succ)
-        (pairMembershipFormula 0 1 order.succ.succ.succ)) (.equal 2 1)))))
-
-theorem truth_orderAntichainFormula {n} (Q order A : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (orderAntichainFormula Q order A) env ↔ OrderAntichainCode (env Q) (env order) (env A) := by
-  simp only [orderAntichainFormula, Truth, truth_imp, truth_pairMembershipFormula]
-  constructor
-  · rintro ⟨subset, law⟩
-    exact ⟨subset, fun p hp q hq r hr first second => law p hp q hq r hr ⟨first, second⟩⟩
-  · rintro ⟨subset, law⟩
-    exact ⟨subset, fun p hp q hq r hr both => law p hp q hq r hr both.1 both.2⟩
-
-def relativeMaximalAntichainFormula {n} (Q order D A : Fin n) : BoundedFormula n :=
-  .conj (.allMem A (.mem 0 D.succ)) (.conj (orderAntichainFormula Q order A)
-    (.allMem D (exMem A.succ (exMem Q.succ.succ
-      (.conj (pairMembershipFormula 0 2 order.succ.succ.succ)
-        (pairMembershipFormula 0 1 order.succ.succ.succ))))))
-
-theorem truth_relativeMaximalAntichainFormula {n} (Q order D A : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (relativeMaximalAntichainFormula Q order D A) env ↔
-      RelativeMaximalAntichainCode (env Q) (env order) (env D) (env A) := by
-  simp only [relativeMaximalAntichainFormula, Truth, truth_orderAntichainFormula,
-    truth_exMem, truth_pairMembershipFormula]
-  rfl
-
-
-
-
-
-def exGraphFields {n} (f : Fin n) (body : BoundedFormula (n + 2)) : BoundedFormula n :=
-  exMem f (exPairFields 0
-    (reindex (Fin.cases 0 (Fin.cases 1 (fun i => i.succ.succ.succ))) body))
-
-theorem truth_exGraphFields {n} (f : Fin n) (body : BoundedFormula (n + 2))
-    (env : Fin n → ZFSet.{u}) :
-    Truth (exGraphFields f body) env ↔
-      ∃ x y, ZFSet.pair x y ∈ env f ∧ Truth body (extend y (extend x env)) := by
-  simp only [exGraphFields, truth_exMem, truth_exPairFields, truth_reindex]
-  have rearrange (z x y : ZFSet.{u}) :
-      (fun i => extend y (extend x (extend z env))
-        (Fin.cases 0 (Fin.cases 1 (fun j => j.succ.succ.succ)) i)) =
-        extend y (extend x env) := by
-    funext i
-    refine Fin.cases ?_ (fun j => Fin.cases ?_ (fun k => ?_) j) i <;> rfl
-  simp only [rearrange]
-  change (∃ z ∈ env f, ∃ x y, z = ZFSet.pair x y ∧
-    Truth body (extend y (extend x env))) ↔ _
-  constructor
-  · rintro ⟨z, member, x, y, rfl, holds⟩
-    exact ⟨x, y, member, holds⟩
-  · rintro ⟨x, y, member, holds⟩
-    exact ⟨ZFSet.pair x y, member, x, y, rfl, holds⟩
-
-def exLinkedCoverageFields {n} (z : Fin n) (body : BoundedFormula (n + 3)) : BoundedFormula n :=
-  exPairFields z (exPairFields 0 (exPairFields 3
-    (exPairFields 0 (exPairFields 0 (exPairFields 0
-      (.conj (tupleShapeFormula 6 0)
-        (reindex (Fin.cases 9 (Fin.cases 1 (Fin.cases 7
-          (fun i => i.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ)))) body)))))))
-
-theorem truth_exLinkedCoverageFields {n} (z : Fin n) (body : BoundedFormula (n + 3))
-    (env : Fin n → ZFSet.{u}) :
-    Truth (exLinkedCoverageFields z body) env ↔
-      ∃ P G cutoff, LinkedCoverageFieldsCode (env z) P G cutoff ∧
-        Truth body (extend cutoff (extend G (extend P env))) := by
-  simp only [exLinkedCoverageFields, truth_exPairFields, Truth, truth_tupleShapeFormula,
-    truth_reindex]
-  have rearrange (s outer cutoff serial P tail r tail' μ tail'' G rest : ZFSet.{u}) :
-      (fun i => extend rest (extend G (extend tail'' (extend μ (extend tail' (extend r
-        (extend tail (extend P (extend serial (extend cutoff (extend outer (extend s env)))))))))))
-        (Fin.cases 9 (Fin.cases 1 (Fin.cases 7
-          (fun j => j.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ))) i)) =
-        extend cutoff (extend G (extend P env)) := by
-    funext i
-    refine Fin.cases ?_ (fun j => Fin.cases ?_ (fun k => Fin.cases ?_ (fun l => ?_) k) j) i <;> rfl
-  simp only [rearrange]
-  change (∃ s outer, env z = ZFSet.pair s outer ∧ ∃ cutoff serial,
-    outer = ZFSet.pair cutoff serial ∧ ∃ P tail, s = ZFSet.pair P tail ∧
-    ∃ r tail', tail = ZFSet.pair r tail' ∧ ∃ μ tail'', tail' = ZFSet.pair μ tail'' ∧
-    ∃ G rest, tail'' = ZFSet.pair G rest ∧
-      (∃ fields, rest = nonemptyTupleCode 6 fields) ∧
-      Truth body (extend cutoff (extend G (extend P env)))) ↔ _
-  constructor
-  · rintro ⟨s, outer, equal, cutoff, serial, rfl, P, tail, rfl, r, tail', rfl,
-      μ, tail'', rfl, G, rest, rfl, ⟨fields, rfl⟩, holds⟩
-    exact ⟨P, G, cutoff, ⟨r, μ, fields 0, fields 1, fields 2, fields 3, fields 4,
-      fields 5, fields 6, serial, equal⟩, holds⟩
-  · rintro ⟨P, G, cutoff, ⟨r, μ, m, inv, one, action, bottom, top, height, serial, equal⟩, holds⟩
-    let fields : Fin 7 → ZFSet.{u} := Fin.cases m (Fin.cases inv (Fin.cases one
-      (Fin.cases action (Fin.cases bottom (Fin.cases top (fun _ => height))))))
-    refine ⟨_, _, equal, cutoff, serial, rfl, P, _, rfl, r, _, rfl, μ, _, rfl,
-      G, nonemptyTupleCode 6 fields, rfl, ⟨fields, rfl⟩, holds⟩
-
-
-
-
-
-def exMainLimitStageFields {n} (T S : Fin n) (body : BoundedFormula (n + 4)) : BoundedFormula n :=
-  exGraphFields S (.conj (.mem 1 T.succ.succ)
-    (exLinkedCoverageFields 0 (reindex
-      (Fin.cases 0 (Fin.cases 1 (Fin.cases 2 (Fin.cases 4
-        (fun i => i.succ.succ.succ.succ.succ))))) body)))
-
-theorem truth_exMainLimitStageFields {n} (T S : Fin n) (body : BoundedFormula (n + 4))
-    (env : Fin n → ZFSet.{u}) :
-    Truth (exMainLimitStageFields T S body) env ↔
-      ∃ i z P G t, i ∈ env T ∧ ZFSet.pair i z ∈ env S ∧
-        LinkedCoverageFieldsCode z P G t ∧ Truth body (extend t (extend G (extend P (extend i env)))) := by
-  simp only [exMainLimitStageFields, truth_exGraphFields, Truth, truth_exLinkedCoverageFields,
-    truth_reindex]
-  have rearrange (i z P G t : ZFSet.{u}) :
-      (fun j => extend t (extend G (extend P (extend z (extend i env))))
-        (Fin.cases 0 (Fin.cases 1 (Fin.cases 2 (Fin.cases 4
-          (fun k => k.succ.succ.succ.succ.succ)))) j)) =
-        extend t (extend G (extend P (extend i env))) := by
-    funext j
-    refine Fin.cases ?_ (fun k => Fin.cases ?_ (fun l => Fin.cases ?_
-      (fun m => Fin.cases ?_ (fun a => ?_) m) l) k) j <;> rfl
-  simp only [rearrange]
-  change (∃ i z, ZFSet.pair i z ∈ env S ∧ i ∈ env T ∧ ∃ P G t,
-    LinkedCoverageFieldsCode z P G t ∧ Truth body (extend t (extend G (extend P (extend i env))))) ↔ _
-  constructor
-  · rintro ⟨i,z,entry,member,P,G,t,shape,holds⟩
-    exact ⟨i,z,P,G,t,member,entry,shape,holds⟩
-  · rintro ⟨i,z,P,G,t,member,entry,shape,holds⟩
-    exact ⟨i,z,entry,member,P,G,t,shape,holds⟩
-
-def exMainLimitConeFields {n} (T S row : Fin n) (body : BoundedFormula (n + 6)) : BoundedFormula n :=
-  exMainLimitStageFields T S (exGraphFields row.succ.succ.succ.succ
-    (.conj (orderedPairFormula 1 T.succ.succ.succ.succ.succ.succ 5)
-      (exPairFields 0 (reindex (Fin.cases 0 (Fin.cases 1 (Fin.cases 4 (Fin.cases 5
-        (Fin.cases 6 (Fin.cases 7 (fun i => i.succ.succ.succ.succ.succ.succ.succ.succ))))))) body))))
-
-theorem truth_exMainLimitConeFields {n} (T S row : Fin n) (body : BoundedFormula (n + 6))
-    (env : Fin n → ZFSet.{u}) :
-    Truth (exMainLimitConeFields T S row body) env ↔
-      ∃ i P G t points actors, MainLimitConeEntryCode (env T) (env S) (env row) i P G t points actors ∧
-        Truth body (extend actors (extend points (extend t (extend G (extend P (extend i env)))))) := by
-  simp only [exMainLimitConeFields, truth_exMainLimitStageFields, truth_exGraphFields, Truth,
-    truth_orderedPairFormula, truth_exPairFields, truth_reindex]
-  have rearrange (i P G t key value points actors : ZFSet.{u}) :
-      (fun j => extend actors (extend points (extend value (extend key (extend t
-        (extend G (extend P (extend i env)))))))
-        (Fin.cases 0 (Fin.cases 1 (Fin.cases 4 (Fin.cases 5 (Fin.cases 6
-          (Fin.cases 7 (fun k => k.succ.succ.succ.succ.succ.succ.succ.succ)))))) j)) =
-      extend actors (extend points (extend t (extend G (extend P (extend i env))))) := by
-    funext j
-    refine Fin.cases ?_ (fun a => Fin.cases ?_ (fun b => Fin.cases ?_ (fun c =>
-      Fin.cases ?_ (fun d => Fin.cases ?_ (fun e => Fin.cases ?_ (fun f => ?_) e) d) c) b) a) j <;> rfl
-  simp only [rearrange]
-  change (∃ i z P G t, i ∈ env T ∧ ZFSet.pair i z ∈ env S ∧ LinkedCoverageFieldsCode z P G t ∧
-    ∃ key value, ZFSet.pair key value ∈ env row ∧ key = ZFSet.pair (env T) i ∧
-    ∃ points actors, value = ZFSet.pair points actors ∧
-    Truth body (extend actors (extend points (extend t (extend G (extend P (extend i env))))))) ↔ _
-  constructor
-  · rintro ⟨i,z,P,G,t,member,entry,shape,key,value,rowEntry,rfl,points,actors,rfl,holds⟩
-    exact ⟨i,P,G,t,points,actors,⟨member,z,entry,shape,rowEntry⟩,holds⟩
-  · rintro ⟨i,P,G,t,points,actors,⟨member,z,entry,shape,rowEntry⟩,holds⟩
-    exact ⟨i,z,P,G,t,member,entry,shape,_,_,rowEntry,rfl,points,actors,rfl,holds⟩
-
-
-
-
-
-def certificateGraphEntryAt {n} (j F B f k : Fin n) : BoundedFormula n :=
-  exGraphFields k (.conj (.equal 1 j.succ.succ)
-    (exPairFields 0 (.conj (.equal 1 F.succ.succ.succ.succ)
-      (orderedPairFormula 0 B.succ.succ.succ.succ f.succ.succ.succ.succ))))
-
-theorem truth_certificateGraphEntryAt {n} (j F B f k : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (certificateGraphEntryAt j F B f k) env ↔
-      ZFSet.pair (env j) (ZFSet.pair (env F) (ZFSet.pair (env B) (env f))) ∈ env k := by
-  simp only [certificateGraphEntryAt, truth_exGraphFields, Truth,
-    truth_exPairFields, truth_orderedPairFormula]
-  change (∃ key certificate, ZFSet.pair key certificate ∈ env k ∧ key = env j ∧
-    ∃ profile tail, certificate = ZFSet.pair profile tail ∧ profile = env F ∧
-      tail = ZFSet.pair (env B) (env f)) ↔ _
-  constructor
-  · rintro ⟨key, certificate, entry, rfl, profile, tail, rfl, rfl, rfl⟩
-    exact entry
-  · intro entry
-    exact ⟨env j, _, entry, rfl, env F, _, rfl, rfl, rfl⟩
-
-def enumerationGraphEntryAt {n} (j e names g : Fin n) : BoundedFormula n :=
-  exGraphFields g (.conj (.equal 1 j.succ.succ)
-    (orderedPairFormula 0 e.succ.succ names.succ.succ))
-
-theorem truth_enumerationGraphEntryAt {n} (j e names g : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (enumerationGraphEntryAt j e names g) env ↔
-      ZFSet.pair (env j) (ZFSet.pair (env e) (env names)) ∈ env g := by
-  simp only [enumerationGraphEntryAt, truth_exGraphFields, Truth, truth_orderedPairFormula]
-  change (∃ key pair, ZFSet.pair key pair ∈ env g ∧ key = env j ∧
-    pair = ZFSet.pair (env e) (env names)) ↔ _
-  constructor
-  · rintro ⟨key, pair, entry, rfl, rfl⟩
-    exact entry
-  · intro entry
-    exact ⟨env j, _, entry, rfl, rfl⟩
-
-
-
-
-
-def relativeAntichainFamilyFormula {n} (j A Q order domains : Fin n) : BoundedFormula n :=
-  exGraphFields domains (.conj (.equal 1 j.succ.succ)
-    (relativeMaximalAntichainFormula Q.succ.succ order.succ.succ 0 A.succ.succ))
-
-theorem truth_relativeAntichainFamilyFormula {n} (j A Q order domains : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (relativeAntichainFamilyFormula j A Q order domains) env ↔
-      ∃ D, ZFSet.pair (env j) D ∈ env domains ∧
-        RelativeMaximalAntichainCode (env Q) (env order) D (env A) := by
-  simp only [relativeAntichainFamilyFormula, truth_exGraphFields, Truth,
-    truth_relativeMaximalAntichainFormula]
-  change (∃ key D, ZFSet.pair key D ∈ env domains ∧ key = env j ∧
-    RelativeMaximalAntichainCode (env Q) (env order) D (env A)) ↔ _
-  constructor
-  · rintro ⟨key, D, entry, rfl, code⟩
-    exact ⟨D, entry, code⟩
-  · rintro ⟨D, entry, code⟩
-    exact ⟨env j, D, entry, rfl, code⟩
-
-
-
-
-
-def assignmentQueryWithinFormula {n} (X T q : Fin n) : BoundedFormula n :=
-  exPairFields q (stageOneAssignmentsSubsetFormula 0 X.succ.succ T.succ.succ)
-
-theorem truth_assignmentQueryWithinFormula {n} (X T q : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (assignmentQueryWithinFormula X T q) env ↔
-      AssignmentQueryWithin (env X) (env T) (env q) := by
-  simp only [assignmentQueryWithinFormula, truth_exPairFields,
-    truth_stageOneAssignmentsSubsetFormula]
-  rfl
-
-def representativeIndexAdditionsMemberFormula {n} (i I T Q c X : Fin n) : BoundedFormula n :=
-  .conj (.mem i I) (exMem Q
-    (.conj (assignmentQueryWithinFormula X.succ T.succ 0)
-      (exGraphFields c.succ (.conj (.equal 1 2)
-        (exPairFields 0
-          (exMem T.succ.succ.succ.succ.succ
-            (exMem T.succ.succ.succ.succ.succ.succ
-              (exMem 2 (stageOneAssignmentFormula 0
-                i.succ.succ.succ.succ.succ.succ.succ.succ 2 1)))))))))
-
-theorem truth_representativeIndexAdditionsMemberFormula {n} (i I T Q c X : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (representativeIndexAdditionsMemberFormula i I T Q c X) env ↔
-      env i ∈ representativeIndexAdditions (env I) (env T) (env Q) (env c) (env X) := by
-  simp only [representativeIndexAdditionsMemberFormula, Truth, truth_exMem,
-    truth_assignmentQueryWithinFormula, truth_exGraphFields, truth_exPairFields,
-    truth_stageOneAssignmentFormula]
-  rw [mem_representativeIndexAdditions]
-  change (env i ∈ env I ∧ ∃ q ∈ env Q, AssignmentQueryWithin (env X) (env T) q ∧
-    ∃ key value, ZFSet.pair key value ∈ env c ∧ key = q ∧
-      ∃ row A, value = ZFSet.pair row A ∧ ∃ v ∈ env T, ∃ w ∈ env T,
-        ∃ z ∈ A, z = stageOneAssignment (env i) v w) ↔ _
-  apply and_congr Iff.rfl
-  constructor
-  · rintro ⟨q, hq, localQuery, key, value, entry, rfl, row, A, rfl, v, hv, w, hw, z, hz, rfl⟩
-    exact ⟨key, hq, localQuery, row, A, entry, v, hv, w, hw, hz⟩
-  · rintro ⟨q, hq, localQuery, row, A, entry, v, hv, w, hw, hz⟩
-    exact ⟨q, hq, localQuery, q, ZFSet.pair row A, entry, rfl, row, A, rfl,
-      v, hv, w, hw, stageOneAssignment (env i) v w, hz, rfl⟩
-
-
-
-
-
-def supportedCertificateFormula {n}
-    (nodes N order R niceEval visibilityEval value F B f : Fin n) : BoundedFormula n :=
-  .conj (.allMem F (.mem 0 nodes.succ))
-    (.conj (.allMem B (.mem 0 F.succ))
-      (.conj (.allMem F (exMem B.succ (pairMembershipFormula 0 1 order.succ.succ)))
-        (.conj (functionFormula B N f)
-          (.conj
-            (.neg (exGraphFields visibilityEval
-              (.conj (.mem 1 nodes.succ.succ)
-                (.neg (.conj (imp (.mem value.succ.succ 0) (.mem 1 F.succ.succ))
-                  (imp (.mem 1 F.succ.succ) (.mem value.succ.succ 0)))))))
-            (.allMem B (.allMem N.succ
-              (imp (pairMembershipFormula 1 0 f.succ.succ)
-                (.conj (pairMembershipFormula 1 0 R.succ.succ)
-                  (pairMembershipFormula 0 value.succ.succ niceEval.succ.succ)))))))))
-
-theorem truth_supportedCertificateFormula {n}
-    (nodes N order R niceEval visibilityEval value F B f : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (supportedCertificateFormula nodes N order R niceEval visibilityEval value F B f) env ↔
-      SupportedEqualityCertificate (env nodes) (env N) (env order) (env R)
-        (env niceEval) (env visibilityEval) (env value) (env F) (env B) (env f) := by
-  classical
-  simp only [supportedCertificateFormula, Truth, truth_exMem, truth_pairMembershipFormula,
-    truth_functionFormula, truth_exGraphFields, truth_imp, not_exists, not_and, not_not,
-    ← iff_def]
-  rfl
-
-def supportedCertificateEntryFormula {n}
-    (entry J PF PB WF nodes N order R inputEval niceEval visibilityEval : Fin n) :
-    BoundedFormula n :=
-  exPairFields entry (exPairFields 0 (exPairFields 0
-    (.conj (.mem 5 J.succ.succ.succ.succ.succ.succ)
-      (.conj (.mem 3 PF.succ.succ.succ.succ.succ.succ)
-        (.conj (.mem 1 PB.succ.succ.succ.succ.succ.succ)
-          (.conj (.mem 0 WF.succ.succ.succ.succ.succ.succ)
-            (exGraphFields inputEval.succ.succ.succ.succ.succ.succ
-              (.conj (.equal 1 7)
-                (supportedCertificateFormula
-                  nodes.succ.succ.succ.succ.succ.succ.succ.succ
-                  N.succ.succ.succ.succ.succ.succ.succ.succ
-                  order.succ.succ.succ.succ.succ.succ.succ.succ
-                  R.succ.succ.succ.succ.succ.succ.succ.succ
-                  niceEval.succ.succ.succ.succ.succ.succ.succ.succ
-                  visibilityEval.succ.succ.succ.succ.succ.succ.succ.succ
-                  0 5 3 2)))))))))
-
-theorem truth_supportedCertificateEntryFormula {n}
-    (entry J PF PB WF nodes N order R inputEval niceEval visibilityEval : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (supportedCertificateEntryFormula entry J PF PB WF nodes N order R
-      inputEval niceEval visibilityEval) env ↔
-      ∃ j ∈ env J, ∃ F ∈ env PF, ∃ B ∈ env PB, ∃ f ∈ env WF,
-        env entry = ZFSet.pair j (ZFSet.pair F (ZFSet.pair B f)) ∧
-        ∃ value, ZFSet.pair j value ∈ env inputEval ∧
-          SupportedEqualityCertificate (env nodes) (env N) (env order) (env R)
-            (env niceEval) (env visibilityEval) value F B f := by
-  simp only [supportedCertificateEntryFormula, truth_exPairFields, Truth,
-    truth_exGraphFields, truth_supportedCertificateFormula]
-  change (∃ j tail, env entry = ZFSet.pair j tail ∧
-    ∃ F rest, tail = ZFSet.pair F rest ∧
-    ∃ B f, rest = ZFSet.pair B f ∧
-      j ∈ env J ∧ F ∈ env PF ∧ B ∈ env PB ∧ f ∈ env WF ∧
-      ∃ j' value, ZFSet.pair j' value ∈ env inputEval ∧ j' = j ∧
-        SupportedEqualityCertificate (env nodes) (env N) (env order) (env R)
-          (env niceEval) (env visibilityEval) value F B f) ↔ _
-  constructor
-  · rintro ⟨j, tail, equal, F, rest, rfl, B, f, rfl, hj, hF, hB, hf,
-      j', value, evaluated, rfl, certificate⟩
-    exact ⟨j', hj, F, hF, B, hB, f, hf, equal, value, evaluated, certificate⟩
-  · rintro ⟨j, hj, F, hF, B, hB, f, hf, equal, value, evaluated, certificate⟩
-    exact ⟨j, _, equal, F, _, rfl, B, f, rfl, hj, hF, hB, hf,
-      j, value, evaluated, rfl, certificate⟩
-
-
-
-
-
-def exMainLimitImageFields {n} (actor : Bool) (T S row : Fin n)
-    (body : BoundedFormula (n + 1)) : BoundedFormula n :=
-  exMainLimitConeFields T S row (exGraphFields (if actor then 0 else 1)
-    (.conj (.mem 1 (if actor then 5 else 6))
-      (reindex (Fin.cases 0 (fun i => i.succ.succ.succ.succ.succ.succ.succ.succ)) body)))
-
-theorem truth_exMainLimitImageFields {n} (actor : Bool) (T S row : Fin n)
-    (body : BoundedFormula (n + 1)) (env : Fin n → ZFSet.{u}) :
-    Truth (exMainLimitImageFields actor T S row body) env ↔
-      ∃ x, (if actor then MainLimitOldActorImageCode (env T) (env S) (env row) x
-        else MainLimitOldPointImageCode (env T) (env S) (env row) x) ∧ Truth body (extend x env) := by
-  simp only [exMainLimitImageFields, truth_exMainLimitConeFields, truth_exGraphFields, Truth, truth_reindex]
-  have rearrange (i P G t points actors y x : ZFSet.{u}) :
-      (fun j => extend x (extend y (extend actors (extend points (extend t
-        (extend G (extend P (extend i env)))))))
-        (Fin.cases 0 (fun k => k.succ.succ.succ.succ.succ.succ.succ.succ) j)) = extend x env := by
-    funext j
-    refine Fin.cases ?_ (fun k => ?_) j <;> rfl
-  simp only [rearrange]
-  cases actor <;> simp only [Bool.false_eq_true, ite_false, ite_true]
-  · change (∃ i P G t points actors, MainLimitConeEntryCode (env T) (env S) (env row) i P G t points actors ∧
-      ∃ y x, ZFSet.pair y x ∈ points ∧ y ∈ P ∧ Truth body (extend x env)) ↔ _
-    constructor
-    · rintro ⟨i,P,G,t,points,actors,entry,y,x,image,member,holds⟩
-      exact ⟨x,⟨i,P,G,t,points,actors,y,entry,member,image⟩,holds⟩
-    · rintro ⟨x,⟨i,P,G,t,points,actors,y,entry,member,image⟩,holds⟩
-      exact ⟨i,P,G,t,points,actors,entry,y,x,image,member,holds⟩
-  · change (∃ i P G t points actors, MainLimitConeEntryCode (env T) (env S) (env row) i P G t points actors ∧
-      ∃ y x, ZFSet.pair y x ∈ actors ∧ y ∈ G ∧ Truth body (extend x env)) ↔ _
-    constructor
-    · rintro ⟨i,P,G,t,points,actors,entry,y,x,image,member,holds⟩
-      exact ⟨x,⟨i,P,G,t,points,actors,y,entry,member,image⟩,holds⟩
-    · rintro ⟨x,⟨i,P,G,t,points,actors,y,entry,member,image⟩,holds⟩
-      exact ⟨i,P,G,t,points,actors,entry,y,x,image,member,holds⟩
-
-def mainLimitImageFormula {n} (actor : Bool) (T S row x : Fin n) : BoundedFormula n :=
-  exMainLimitImageFields actor T S row (.equal 0 x.succ)
-
-theorem truth_mainLimitImageFormula {n} (actor : Bool) (T S row x : Fin n)
-    (env : Fin n → ZFSet.{u}) : Truth (mainLimitImageFormula actor T S row x) env ↔
-      (if actor then MainLimitOldActorImageCode (env T) (env S) (env row) (env x)
-        else MainLimitOldPointImageCode (env T) (env S) (env row) (env x)) := by
-  rw [mainLimitImageFormula, truth_exMainLimitImageFields]
-  change (∃ y, _ ∧ y = env x) ↔ _
-  constructor
-  · rintro ⟨y, member, rfl⟩
-    exact member
-  · exact fun member => ⟨env x, member, rfl⟩
-
-def mainLimitOldCutoffFormula {n} (T S t : Fin n) : BoundedFormula n :=
-  exMainLimitStageFields T S (disj (.equal t.succ.succ.succ.succ 0)
-    (.mem t.succ.succ.succ.succ 0))
-
-theorem truth_mainLimitOldCutoffFormula {n} (T S t : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (mainLimitOldCutoffFormula T S t) env ↔ MainLimitOldCutoffCode (env T) (env S) (env t) := by
-  simp only [mainLimitOldCutoffFormula, truth_exMainLimitStageFields, truth_disj, Truth]
-  change (∃ i z P G cutoff, i ∈ env T ∧ ZFSet.pair i z ∈ env S ∧
-    LinkedCoverageFieldsCode z P G cutoff ∧ (env t = cutoff ∨ env t ∈ cutoff)) ↔ _
-  constructor
-  · rintro ⟨i,z,P,G,cutoff,member,entry,shape,bound⟩
-    exact ⟨i,member,z,entry,P,G,cutoff,shape,bound⟩
-  · rintro ⟨i,member,z,entry,P,G,cutoff,shape,bound⟩
-    exact ⟨i,z,P,G,cutoff,member,entry,shape,bound⟩
-
-
-
-
-
-def mainLimitPointCoverageFormula {n} (T S row Q top : Fin n) : BoundedFormula n :=
-  .conj (.allMem Q (imp (.neg (.equal 0 top.succ))
-    (mainLimitImageFormula false T.succ S.succ row.succ 0)))
-    (.neg (exMainLimitImageFields false T S row
-      (.neg (.conj (.mem 0 Q.succ) (.neg (.equal 0 top.succ))))))
-
-theorem truth_mainLimitPointCoverageFormula {n} (T S row Q top : Fin n)
-    (env : Fin n → ZFSet.{u}) : Truth (mainLimitPointCoverageFormula T S row Q top) env ↔
-      ∀ x, (x ∈ env Q ∧ x ≠ env top) ↔ MainLimitOldPointImageCode (env T) (env S) (env row) x := by
-  classical
-  simp only [mainLimitPointCoverageFormula, Truth, truth_imp, truth_mainLimitImageFormula,
-    truth_exMainLimitImageFields, Bool.false_eq_true, ite_false, not_exists, not_and, not_not, Classical.not_imp]
-  change ((∀ x ∈ env Q, x ≠ env top → MainLimitOldPointImageCode (env T) (env S) (env row) x) ∧
-    ∀ x, MainLimitOldPointImageCode (env T) (env S) (env row) x → x ∈ env Q ∧ x ≠ env top) ↔ _
-  constructor
-  · rintro ⟨forward, reverse⟩ x
-    exact ⟨fun h => forward x h.1 h.2, reverse x⟩
-  · intro laws
-    exact ⟨fun x member different => (laws x).1 ⟨member,different⟩, fun x => (laws x).2⟩
-
-def mainLimitActorCoverageFormula {n} (T S row H : Fin n) : BoundedFormula n :=
-  .conj (.allMem H (mainLimitImageFormula true T.succ S.succ row.succ 0))
-    (.neg (exMainLimitImageFields true T S row (.neg (.mem 0 H.succ))))
-
-theorem truth_mainLimitActorCoverageFormula {n} (T S row H : Fin n)
-    (env : Fin n → ZFSet.{u}) : Truth (mainLimitActorCoverageFormula T S row H) env ↔
-      ∀ g, g ∈ env H ↔ MainLimitOldActorImageCode (env T) (env S) (env row) g := by
-  classical
-  simp only [mainLimitActorCoverageFormula, Truth, truth_mainLimitImageFormula,
-    truth_exMainLimitImageFields, ite_true, not_exists, not_and, not_not]
-  change ((∀ g ∈ env H, MainLimitOldActorImageCode (env T) (env S) (env row) g) ∧
-    ∀ g, MainLimitOldActorImageCode (env T) (env S) (env row) g → g ∈ env H) ↔ _
-  exact ⟨fun h g => ⟨h.1 g,h.2 g⟩, fun h => ⟨fun g => (h g).1,fun g => (h g).2⟩⟩
-
-def mainLimitStrictTopFormula {n} (T S row R top : Fin n) : BoundedFormula n :=
-  .neg (exMainLimitConeFields T S row (exGraphFields 1 (.neg
-    (.conj (pairMembershipFormula 0 top.succ.succ.succ.succ.succ.succ.succ.succ
-      R.succ.succ.succ.succ.succ.succ.succ.succ)
-      (.neg (pairMembershipFormula top.succ.succ.succ.succ.succ.succ.succ.succ 0
-        R.succ.succ.succ.succ.succ.succ.succ.succ))))))
-
-theorem truth_mainLimitStrictTopFormula {n} (T S row R top : Fin n)
-    (env : Fin n → ZFSet.{u}) : Truth (mainLimitStrictTopFormula T S row R top) env ↔
-      ∀ i P G t points actors, MainLimitConeEntryCode (env T) (env S) (env row) i P G t points actors →
-        ∀ x y, ZFSet.pair x y ∈ points → ZFSet.pair y (env top) ∈ env R ∧
-          ZFSet.pair (env top) y ∉ env R := by
-  classical
-  simp only [mainLimitStrictTopFormula, Truth, truth_exMainLimitConeFields,
-    truth_exGraphFields, truth_pairMembershipFormula, not_exists, not_and, not_not, Classical.not_imp]
-  rfl
-
-def mainLimitCutoffFormula {n} (T S cutoff : Fin n) : BoundedFormula n :=
-  .conj (.allMem cutoff (mainLimitOldCutoffFormula T.succ S.succ 0))
-    (.neg (exMainLimitStageFields T S (.neg
-      (.conj (.mem 0 cutoff.succ.succ.succ.succ)
-        (.allMem 0 (.mem 0 cutoff.succ.succ.succ.succ.succ))))))
-
-theorem truth_mainLimitCutoffFormula {n} (T S cutoff : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (mainLimitCutoffFormula T S cutoff) env ↔
-      ∀ t, t ∈ env cutoff ↔ MainLimitOldCutoffCode (env T) (env S) t := by
-  classical
-  simp only [mainLimitCutoffFormula, Truth, truth_mainLimitOldCutoffFormula,
-    truth_exMainLimitStageFields, not_exists, not_and, not_not, Classical.not_imp]
-  change ((∀ t ∈ env cutoff, MainLimitOldCutoffCode (env T) (env S) t) ∧
-    ∀ i z P G t, i ∈ env T → ZFSet.pair i z ∈ env S → LinkedCoverageFieldsCode z P G t →
-      t ∈ env cutoff ∧ ∀ s ∈ t, s ∈ env cutoff) ↔ _
-  constructor
-  · rintro ⟨forward,bound⟩ t
-    refine ⟨forward t, ?_⟩
-    rintro ⟨i,member,z,entry,P,G,s,shape,equal | lower⟩
-    · exact equal.symm ▸ (bound i z P G s member entry shape).1
-    · exact (bound i z P G s member entry shape).2 t lower
-  · intro laws
-    refine ⟨fun t => (laws t).1, ?_⟩
-    intro i z P G t member entry shape
-    exact ⟨(laws t).2 ⟨i,member,z,entry,P,G,t,shape,Or.inl rfl⟩,
-      fun s lower => (laws s).2 ⟨i,member,z,entry,P,G,t,shape,Or.inr lower⟩⟩
-
-def mainLimitTopBirthFormula {n} (top cutoff birth : Fin n) : BoundedFormula n :=
-  .conj (pairMembershipFormula top cutoff birth)
-    (.neg (exGraphFields birth (.conj (.equal 0 cutoff.succ.succ)
-      (.neg (.equal 1 top.succ.succ)))))
-
-theorem truth_mainLimitTopBirthFormula {n} (top cutoff birth : Fin n)
-    (env : Fin n → ZFSet.{u}) : Truth (mainLimitTopBirthFormula top cutoff birth) env ↔
-      ∀ x, ZFSet.pair x (env cutoff) ∈ env birth ↔ x = env top := by
-  classical
-  simp only [mainLimitTopBirthFormula, Truth, truth_pairMembershipFormula,
-    truth_exGraphFields, not_exists, not_and, not_not]
-  change (ZFSet.pair (env top) (env cutoff) ∈ env birth ∧
-    ∀ x t, ZFSet.pair x t ∈ env birth → t = env cutoff → x = env top) ↔ _
-  constructor
-  · rintro ⟨entry,unique⟩ x
-    exact ⟨fun image => unique x (env cutoff) image rfl, fun equal => equal.symm ▸ entry⟩
-  · intro laws
-    exact ⟨(laws (env top)).2 rfl, fun x t image equal => (laws x).1 (equal ▸ image)⟩
-
-def mainLimitCoverageFormula {n} (T S row Q H R top cutoff birth : Fin n) : BoundedFormula n :=
-  .conj (mainLimitPointCoverageFormula T S row Q top)
-    (.conj (mainLimitActorCoverageFormula T S row H)
-      (.conj (mainLimitStrictTopFormula T S row R top)
-        (.conj (mainLimitCutoffFormula T S cutoff) (mainLimitTopBirthFormula top cutoff birth))))
-
-theorem truth_mainLimitCoverageFormula {n} (T S row Q H R top cutoff birth : Fin n)
-    (env : Fin n → ZFSet.{u}) : Truth (mainLimitCoverageFormula T S row Q H R top cutoff birth) env ↔
-      MainLimitCoverageGraphCode (env T) (env S) (env row) (env Q) (env H) (env R)
-        (env top) (env cutoff) (env birth) := by
-  simp only [mainLimitCoverageFormula, Truth, truth_mainLimitPointCoverageFormula,
-    truth_mainLimitActorCoverageFormula, truth_mainLimitStrictTopFormula,
-    truth_mainLimitCutoffFormula, truth_mainLimitTopBirthFormula]
-  exact ⟨fun h => ⟨h.1,h.2.1,h.2.2.1,h.2.2.2.1,h.2.2.2.2⟩,
-    fun h => ⟨h.points,h.actors,h.strict_top,h.cutoff_mem,h.top_birth⟩⟩
-
-theorem realize_mainLimitCoverageFormula (M : TransitiveGround.{u}) {n}
-    (T S row Q H R top cutoff birth : Fin n) (env : Fin n → ZFSet.{u})
-    (members : ∀ i, env i ∈ M.sets) :
-    Realize M.sets (mainLimitCoverageFormula T S row Q H R top cutoff birth).toFormula env ↔
-      MainLimitCoverageGraphCode (env T) (env S) (env row) (env Q) (env H) (env R)
-        (env top) (env cutoff) (env birth) :=
-  (realize_toFormula M _ env members).trans (truth_mainLimitCoverageFormula T S row Q H R top cutoff birth env)
-
-end PartitionPilot.Forcing.BoundedFormula
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Definability.ForcingHistoryOutputFormulas
+import OAI.SetTheory.PartitionPrinciple.Forcing.GreedyAntichainTraces
+import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundMainPrefixLimitCoverageGraph
+
+namespace OAI
+
+
+namespace PartitionPilot.Forcing.BoundedFormula
+open SetFormula
+universe u
+
+def orderAntichainFormula {n} (Q order A : Fin n) : BoundedFormula n :=
+  .conj (.allMem A (.mem 0 Q.succ))
+    (.allMem A (.allMem A.succ (.allMem Q.succ.succ
+      (imp (.conj (pairMembershipFormula 0 2 order.succ.succ.succ)
+        (pairMembershipFormula 0 1 order.succ.succ.succ)) (.equal 2 1)))))
+
+theorem truth_orderAntichainFormula {n} (Q order A : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (orderAntichainFormula Q order A) env ↔ OrderAntichainCode (env Q) (env order) (env A) := by
+  simp only [orderAntichainFormula, Truth, truth_imp, truth_pairMembershipFormula]
+  constructor
+  · rintro ⟨subset, law⟩
+    exact ⟨subset, fun p hp q hq r hr first second => law p hp q hq r hr ⟨first, second⟩⟩
+  · rintro ⟨subset, law⟩
+    exact ⟨subset, fun p hp q hq r hr both => law p hp q hq r hr both.1 both.2⟩
+
+def relativeMaximalAntichainFormula {n} (Q order D A : Fin n) : BoundedFormula n :=
+  .conj (.allMem A (.mem 0 D.succ)) (.conj (orderAntichainFormula Q order A)
+    (.allMem D (exMem A.succ (exMem Q.succ.succ
+      (.conj (pairMembershipFormula 0 2 order.succ.succ.succ)
+        (pairMembershipFormula 0 1 order.succ.succ.succ))))))
+
+theorem truth_relativeMaximalAntichainFormula {n} (Q order D A : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (relativeMaximalAntichainFormula Q order D A) env ↔
+      RelativeMaximalAntichainCode (env Q) (env order) (env D) (env A) := by
+  simp only [relativeMaximalAntichainFormula, Truth, truth_orderAntichainFormula,
+    truth_exMem, truth_pairMembershipFormula]
+  rfl
+
+
+
+
+
+def exGraphFields {n} (f : Fin n) (body : BoundedFormula (n + 2)) : BoundedFormula n :=
+  exMem f (exPairFields 0
+    (reindex (Fin.cases 0 (Fin.cases 1 (fun i => i.succ.succ.succ))) body))
+
+theorem truth_exGraphFields {n} (f : Fin n) (body : BoundedFormula (n + 2))
+    (env : Fin n → ZFSet.{u}) :
+    Truth (exGraphFields f body) env ↔
+      ∃ x y, ZFSet.pair x y ∈ env f ∧ Truth body (extend y (extend x env)) := by
+  simp only [exGraphFields, truth_exMem, truth_exPairFields, truth_reindex]
+  have rearrange (z x y : ZFSet.{u}) :
+      (fun i => extend y (extend x (extend z env))
+        (Fin.cases 0 (Fin.cases 1 (fun j => j.succ.succ.succ)) i)) =
+        extend y (extend x env) := by
+    funext i
+    refine Fin.cases ?_ (fun j => Fin.cases ?_ (fun k => ?_) j) i <;> rfl
+  simp only [rearrange]
+  change (∃ z ∈ env f, ∃ x y, z = ZFSet.pair x y ∧
+    Truth body (extend y (extend x env))) ↔ _
+  constructor
+  · rintro ⟨z, member, x, y, rfl, holds⟩
+    exact ⟨x, y, member, holds⟩
+  · rintro ⟨x, y, member, holds⟩
+    exact ⟨ZFSet.pair x y, member, x, y, rfl, holds⟩
+
+def exLinkedCoverageFields {n} (z : Fin n) (body : BoundedFormula (n + 3)) : BoundedFormula n :=
+  exPairFields z (exPairFields 0 (exPairFields 3
+    (exPairFields 0 (exPairFields 0 (exPairFields 0
+      (.conj (tupleShapeFormula 6 0)
+        (reindex (Fin.cases 9 (Fin.cases 1 (Fin.cases 7
+          (fun i => i.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ)))) body)))))))
+
+theorem truth_exLinkedCoverageFields {n} (z : Fin n) (body : BoundedFormula (n + 3))
+    (env : Fin n → ZFSet.{u}) :
+    Truth (exLinkedCoverageFields z body) env ↔
+      ∃ P G cutoff, LinkedCoverageFieldsCode (env z) P G cutoff ∧
+        Truth body (extend cutoff (extend G (extend P env))) := by
+  simp only [exLinkedCoverageFields, truth_exPairFields, Truth, truth_tupleShapeFormula,
+    truth_reindex]
+  have rearrange (s outer cutoff serial P tail r tail' μ tail'' G rest : ZFSet.{u}) :
+      (fun i => extend rest (extend G (extend tail'' (extend μ (extend tail' (extend r
+        (extend tail (extend P (extend serial (extend cutoff (extend outer (extend s env)))))))))))
+        (Fin.cases 9 (Fin.cases 1 (Fin.cases 7
+          (fun j => j.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ))) i)) =
+        extend cutoff (extend G (extend P env)) := by
+    funext i
+    refine Fin.cases ?_ (fun j => Fin.cases ?_ (fun k => Fin.cases ?_ (fun l => ?_) k) j) i <;> rfl
+  simp only [rearrange]
+  change (∃ s outer, env z = ZFSet.pair s outer ∧ ∃ cutoff serial,
+    outer = ZFSet.pair cutoff serial ∧ ∃ P tail, s = ZFSet.pair P tail ∧
+    ∃ r tail', tail = ZFSet.pair r tail' ∧ ∃ μ tail'', tail' = ZFSet.pair μ tail'' ∧
+    ∃ G rest, tail'' = ZFSet.pair G rest ∧
+      (∃ fields, rest = nonemptyTupleCode 6 fields) ∧
+      Truth body (extend cutoff (extend G (extend P env)))) ↔ _
+  constructor
+  · rintro ⟨s, outer, equal, cutoff, serial, rfl, P, tail, rfl, r, tail', rfl,
+      μ, tail'', rfl, G, rest, rfl, ⟨fields, rfl⟩, holds⟩
+    exact ⟨P, G, cutoff, ⟨r, μ, fields 0, fields 1, fields 2, fields 3, fields 4,
+      fields 5, fields 6, serial, equal⟩, holds⟩
+  · rintro ⟨P, G, cutoff, ⟨r, μ, m, inv, one, action, bottom, top, height, serial, equal⟩, holds⟩
+    let fields : Fin 7 → ZFSet.{u} := Fin.cases m (Fin.cases inv (Fin.cases one
+      (Fin.cases action (Fin.cases bottom (Fin.cases top (fun _ => height))))))
+    refine ⟨_, _, equal, cutoff, serial, rfl, P, _, rfl, r, _, rfl, μ, _, rfl,
+      G, nonemptyTupleCode 6 fields, rfl, ⟨fields, rfl⟩, holds⟩
+
+
+
+
+
+def exMainLimitStageFields {n} (T S : Fin n) (body : BoundedFormula (n + 4)) : BoundedFormula n :=
+  exGraphFields S (.conj (.mem 1 T.succ.succ)
+    (exLinkedCoverageFields 0 (reindex
+      (Fin.cases 0 (Fin.cases 1 (Fin.cases 2 (Fin.cases 4
+        (fun i => i.succ.succ.succ.succ.succ))))) body)))
+
+theorem truth_exMainLimitStageFields {n} (T S : Fin n) (body : BoundedFormula (n + 4))
+    (env : Fin n → ZFSet.{u}) :
+    Truth (exMainLimitStageFields T S body) env ↔
+      ∃ i z P G t, i ∈ env T ∧ ZFSet.pair i z ∈ env S ∧
+        LinkedCoverageFieldsCode z P G t ∧ Truth body (extend t (extend G (extend P (extend i env)))) := by
+  simp only [exMainLimitStageFields, truth_exGraphFields, Truth, truth_exLinkedCoverageFields,
+    truth_reindex]
+  have rearrange (i z P G t : ZFSet.{u}) :
+      (fun j => extend t (extend G (extend P (extend z (extend i env))))
+        (Fin.cases 0 (Fin.cases 1 (Fin.cases 2 (Fin.cases 4
+          (fun k => k.succ.succ.succ.succ.succ)))) j)) =
+        extend t (extend G (extend P (extend i env))) := by
+    funext j
+    refine Fin.cases ?_ (fun k => Fin.cases ?_ (fun l => Fin.cases ?_
+      (fun m => Fin.cases ?_ (fun a => ?_) m) l) k) j <;> rfl
+  simp only [rearrange]
+  change (∃ i z, ZFSet.pair i z ∈ env S ∧ i ∈ env T ∧ ∃ P G t,
+    LinkedCoverageFieldsCode z P G t ∧ Truth body (extend t (extend G (extend P (extend i env))))) ↔ _
+  constructor
+  · rintro ⟨i,z,entry,member,P,G,t,shape,holds⟩
+    exact ⟨i,z,P,G,t,member,entry,shape,holds⟩
+  · rintro ⟨i,z,P,G,t,member,entry,shape,holds⟩
+    exact ⟨i,z,entry,member,P,G,t,shape,holds⟩
+
+def exMainLimitConeFields {n} (T S row : Fin n) (body : BoundedFormula (n + 6)) : BoundedFormula n :=
+  exMainLimitStageFields T S (exGraphFields row.succ.succ.succ.succ
+    (.conj (orderedPairFormula 1 T.succ.succ.succ.succ.succ.succ 5)
+      (exPairFields 0 (reindex (Fin.cases 0 (Fin.cases 1 (Fin.cases 4 (Fin.cases 5
+        (Fin.cases 6 (Fin.cases 7 (fun i => i.succ.succ.succ.succ.succ.succ.succ.succ))))))) body))))
+
+theorem truth_exMainLimitConeFields {n} (T S row : Fin n) (body : BoundedFormula (n + 6))
+    (env : Fin n → ZFSet.{u}) :
+    Truth (exMainLimitConeFields T S row body) env ↔
+      ∃ i P G t points actors, MainLimitConeEntryCode (env T) (env S) (env row) i P G t points actors ∧
+        Truth body (extend actors (extend points (extend t (extend G (extend P (extend i env)))))) := by
+  simp only [exMainLimitConeFields, truth_exMainLimitStageFields, truth_exGraphFields, Truth,
+    truth_orderedPairFormula, truth_exPairFields, truth_reindex]
+  have rearrange (i P G t key value points actors : ZFSet.{u}) :
+      (fun j => extend actors (extend points (extend value (extend key (extend t
+        (extend G (extend P (extend i env)))))))
+        (Fin.cases 0 (Fin.cases 1 (Fin.cases 4 (Fin.cases 5 (Fin.cases 6
+          (Fin.cases 7 (fun k => k.succ.succ.succ.succ.succ.succ.succ.succ)))))) j)) =
+      extend actors (extend points (extend t (extend G (extend P (extend i env))))) := by
+    funext j
+    refine Fin.cases ?_ (fun a => Fin.cases ?_ (fun b => Fin.cases ?_ (fun c =>
+      Fin.cases ?_ (fun d => Fin.cases ?_ (fun e => Fin.cases ?_ (fun f => ?_) e) d) c) b) a) j <;> rfl
+  simp only [rearrange]
+  change (∃ i z P G t, i ∈ env T ∧ ZFSet.pair i z ∈ env S ∧ LinkedCoverageFieldsCode z P G t ∧
+    ∃ key value, ZFSet.pair key value ∈ env row ∧ key = ZFSet.pair (env T) i ∧
+    ∃ points actors, value = ZFSet.pair points actors ∧
+    Truth body (extend actors (extend points (extend t (extend G (extend P (extend i env))))))) ↔ _
+  constructor
+  · rintro ⟨i,z,P,G,t,member,entry,shape,key,value,rowEntry,rfl,points,actors,rfl,holds⟩
+    exact ⟨i,P,G,t,points,actors,⟨member,z,entry,shape,rowEntry⟩,holds⟩
+  · rintro ⟨i,P,G,t,points,actors,⟨member,z,entry,shape,rowEntry⟩,holds⟩
+    exact ⟨i,z,P,G,t,member,entry,shape,_,_,rowEntry,rfl,points,actors,rfl,holds⟩
+
+
+
+
+
+def certificateGraphEntryAt {n} (j F B f k : Fin n) : BoundedFormula n :=
+  exGraphFields k (.conj (.equal 1 j.succ.succ)
+    (exPairFields 0 (.conj (.equal 1 F.succ.succ.succ.succ)
+      (orderedPairFormula 0 B.succ.succ.succ.succ f.succ.succ.succ.succ))))
+
+theorem truth_certificateGraphEntryAt {n} (j F B f k : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (certificateGraphEntryAt j F B f k) env ↔
+      ZFSet.pair (env j) (ZFSet.pair (env F) (ZFSet.pair (env B) (env f))) ∈ env k := by
+  simp only [certificateGraphEntryAt, truth_exGraphFields, Truth,
+    truth_exPairFields, truth_orderedPairFormula]
+  change (∃ key certificate, ZFSet.pair key certificate ∈ env k ∧ key = env j ∧
+    ∃ profile tail, certificate = ZFSet.pair profile tail ∧ profile = env F ∧
+      tail = ZFSet.pair (env B) (env f)) ↔ _
+  constructor
+  · rintro ⟨key, certificate, entry, rfl, profile, tail, rfl, rfl, rfl⟩
+    exact entry
+  · intro entry
+    exact ⟨env j, _, entry, rfl, env F, _, rfl, rfl, rfl⟩
+
+def enumerationGraphEntryAt {n} (j e names g : Fin n) : BoundedFormula n :=
+  exGraphFields g (.conj (.equal 1 j.succ.succ)
+    (orderedPairFormula 0 e.succ.succ names.succ.succ))
+
+theorem truth_enumerationGraphEntryAt {n} (j e names g : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (enumerationGraphEntryAt j e names g) env ↔
+      ZFSet.pair (env j) (ZFSet.pair (env e) (env names)) ∈ env g := by
+  simp only [enumerationGraphEntryAt, truth_exGraphFields, Truth, truth_orderedPairFormula]
+  change (∃ key pair, ZFSet.pair key pair ∈ env g ∧ key = env j ∧
+    pair = ZFSet.pair (env e) (env names)) ↔ _
+  constructor
+  · rintro ⟨key, pair, entry, rfl, rfl⟩
+    exact entry
+  · intro entry
+    exact ⟨env j, _, entry, rfl, rfl⟩
+
+
+
+
+
+def relativeAntichainFamilyFormula {n} (j A Q order domains : Fin n) : BoundedFormula n :=
+  exGraphFields domains (.conj (.equal 1 j.succ.succ)
+    (relativeMaximalAntichainFormula Q.succ.succ order.succ.succ 0 A.succ.succ))
+
+theorem truth_relativeAntichainFamilyFormula {n} (j A Q order domains : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (relativeAntichainFamilyFormula j A Q order domains) env ↔
+      ∃ D, ZFSet.pair (env j) D ∈ env domains ∧
+        RelativeMaximalAntichainCode (env Q) (env order) D (env A) := by
+  simp only [relativeAntichainFamilyFormula, truth_exGraphFields, Truth,
+    truth_relativeMaximalAntichainFormula]
+  change (∃ key D, ZFSet.pair key D ∈ env domains ∧ key = env j ∧
+    RelativeMaximalAntichainCode (env Q) (env order) D (env A)) ↔ _
+  constructor
+  · rintro ⟨key, D, entry, rfl, code⟩
+    exact ⟨D, entry, code⟩
+  · rintro ⟨D, entry, code⟩
+    exact ⟨env j, D, entry, rfl, code⟩
+
+
+
+
+
+def assignmentQueryWithinFormula {n} (X T q : Fin n) : BoundedFormula n :=
+  exPairFields q (stageOneAssignmentsSubsetFormula 0 X.succ.succ T.succ.succ)
+
+theorem truth_assignmentQueryWithinFormula {n} (X T q : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (assignmentQueryWithinFormula X T q) env ↔
+      AssignmentQueryWithin (env X) (env T) (env q) := by
+  simp only [assignmentQueryWithinFormula, truth_exPairFields,
+    truth_stageOneAssignmentsSubsetFormula]
+  rfl
+
+def representativeIndexAdditionsMemberFormula {n} (i I T Q c X : Fin n) : BoundedFormula n :=
+  .conj (.mem i I) (exMem Q
+    (.conj (assignmentQueryWithinFormula X.succ T.succ 0)
+      (exGraphFields c.succ (.conj (.equal 1 2)
+        (exPairFields 0
+          (exMem T.succ.succ.succ.succ.succ
+            (exMem T.succ.succ.succ.succ.succ.succ
+              (exMem 2 (stageOneAssignmentFormula 0
+                i.succ.succ.succ.succ.succ.succ.succ.succ 2 1)))))))))
+
+theorem truth_representativeIndexAdditionsMemberFormula {n} (i I T Q c X : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (representativeIndexAdditionsMemberFormula i I T Q c X) env ↔
+      env i ∈ representativeIndexAdditions (env I) (env T) (env Q) (env c) (env X) := by
+  simp only [representativeIndexAdditionsMemberFormula, Truth, truth_exMem,
+    truth_assignmentQueryWithinFormula, truth_exGraphFields, truth_exPairFields,
+    truth_stageOneAssignmentFormula]
+  rw [mem_representativeIndexAdditions]
+  change (env i ∈ env I ∧ ∃ q ∈ env Q, AssignmentQueryWithin (env X) (env T) q ∧
+    ∃ key value, ZFSet.pair key value ∈ env c ∧ key = q ∧
+      ∃ row A, value = ZFSet.pair row A ∧ ∃ v ∈ env T, ∃ w ∈ env T,
+        ∃ z ∈ A, z = stageOneAssignment (env i) v w) ↔ _
+  apply and_congr Iff.rfl
+  constructor
+  · rintro ⟨q, hq, localQuery, key, value, entry, rfl, row, A, rfl, v, hv, w, hw, z, hz, rfl⟩
+    exact ⟨key, hq, localQuery, row, A, entry, v, hv, w, hw, hz⟩
+  · rintro ⟨q, hq, localQuery, row, A, entry, v, hv, w, hw, hz⟩
+    exact ⟨q, hq, localQuery, q, ZFSet.pair row A, entry, rfl, row, A, rfl,
+      v, hv, w, hw, stageOneAssignment (env i) v w, hz, rfl⟩
+
+
+
+
+
+def supportedCertificateFormula {n}
+    (nodes N order R niceEval visibilityEval value F B f : Fin n) : BoundedFormula n :=
+  .conj (.allMem F (.mem 0 nodes.succ))
+    (.conj (.allMem B (.mem 0 F.succ))
+      (.conj (.allMem F (exMem B.succ (pairMembershipFormula 0 1 order.succ.succ)))
+        (.conj (functionFormula B N f)
+          (.conj
+            (.neg (exGraphFields visibilityEval
+              (.conj (.mem 1 nodes.succ.succ)
+                (.neg (.conj (imp (.mem value.succ.succ 0) (.mem 1 F.succ.succ))
+                  (imp (.mem 1 F.succ.succ) (.mem value.succ.succ 0)))))))
+            (.allMem B (.allMem N.succ
+              (imp (pairMembershipFormula 1 0 f.succ.succ)
+                (.conj (pairMembershipFormula 1 0 R.succ.succ)
+                  (pairMembershipFormula 0 value.succ.succ niceEval.succ.succ)))))))))
+
+theorem truth_supportedCertificateFormula {n}
+    (nodes N order R niceEval visibilityEval value F B f : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (supportedCertificateFormula nodes N order R niceEval visibilityEval value F B f) env ↔
+      SupportedEqualityCertificate (env nodes) (env N) (env order) (env R)
+        (env niceEval) (env visibilityEval) (env value) (env F) (env B) (env f) := by
+  classical
+  simp only [supportedCertificateFormula, Truth, truth_exMem, truth_pairMembershipFormula,
+    truth_functionFormula, truth_exGraphFields, truth_imp, not_exists, not_and, not_not,
+    ← iff_def]
+  rfl
+
+def supportedCertificateEntryFormula {n}
+    (entry J PF PB WF nodes N order R inputEval niceEval visibilityEval : Fin n) :
+    BoundedFormula n :=
+  exPairFields entry (exPairFields 0 (exPairFields 0
+    (.conj (.mem 5 J.succ.succ.succ.succ.succ.succ)
+      (.conj (.mem 3 PF.succ.succ.succ.succ.succ.succ)
+        (.conj (.mem 1 PB.succ.succ.succ.succ.succ.succ)
+          (.conj (.mem 0 WF.succ.succ.succ.succ.succ.succ)
+            (exGraphFields inputEval.succ.succ.succ.succ.succ.succ
+              (.conj (.equal 1 7)
+                (supportedCertificateFormula
+                  nodes.succ.succ.succ.succ.succ.succ.succ.succ
+                  N.succ.succ.succ.succ.succ.succ.succ.succ
+                  order.succ.succ.succ.succ.succ.succ.succ.succ
+                  R.succ.succ.succ.succ.succ.succ.succ.succ
+                  niceEval.succ.succ.succ.succ.succ.succ.succ.succ
+                  visibilityEval.succ.succ.succ.succ.succ.succ.succ.succ
+                  0 5 3 2)))))))))
+
+theorem truth_supportedCertificateEntryFormula {n}
+    (entry J PF PB WF nodes N order R inputEval niceEval visibilityEval : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (supportedCertificateEntryFormula entry J PF PB WF nodes N order R
+      inputEval niceEval visibilityEval) env ↔
+      ∃ j ∈ env J, ∃ F ∈ env PF, ∃ B ∈ env PB, ∃ f ∈ env WF,
+        env entry = ZFSet.pair j (ZFSet.pair F (ZFSet.pair B f)) ∧
+        ∃ value, ZFSet.pair j value ∈ env inputEval ∧
+          SupportedEqualityCertificate (env nodes) (env N) (env order) (env R)
+            (env niceEval) (env visibilityEval) value F B f := by
+  simp only [supportedCertificateEntryFormula, truth_exPairFields, Truth,
+    truth_exGraphFields, truth_supportedCertificateFormula]
+  change (∃ j tail, env entry = ZFSet.pair j tail ∧
+    ∃ F rest, tail = ZFSet.pair F rest ∧
+    ∃ B f, rest = ZFSet.pair B f ∧
+      j ∈ env J ∧ F ∈ env PF ∧ B ∈ env PB ∧ f ∈ env WF ∧
+      ∃ j' value, ZFSet.pair j' value ∈ env inputEval ∧ j' = j ∧
+        SupportedEqualityCertificate (env nodes) (env N) (env order) (env R)
+          (env niceEval) (env visibilityEval) value F B f) ↔ _
+  constructor
+  · rintro ⟨j, tail, equal, F, rest, rfl, B, f, rfl, hj, hF, hB, hf,
+      j', value, evaluated, rfl, certificate⟩
+    exact ⟨j', hj, F, hF, B, hB, f, hf, equal, value, evaluated, certificate⟩
+  · rintro ⟨j, hj, F, hF, B, hB, f, hf, equal, value, evaluated, certificate⟩
+    exact ⟨j, _, equal, F, _, rfl, B, f, rfl, hj, hF, hB, hf,
+      j, value, evaluated, rfl, certificate⟩
+
+
+
+
+
+def exMainLimitImageFields {n} (actor : Bool) (T S row : Fin n)
+    (body : BoundedFormula (n + 1)) : BoundedFormula n :=
+  exMainLimitConeFields T S row (exGraphFields (if actor then 0 else 1)
+    (.conj (.mem 1 (if actor then 5 else 6))
+      (reindex (Fin.cases 0 (fun i => i.succ.succ.succ.succ.succ.succ.succ.succ)) body)))
+
+theorem truth_exMainLimitImageFields {n} (actor : Bool) (T S row : Fin n)
+    (body : BoundedFormula (n + 1)) (env : Fin n → ZFSet.{u}) :
+    Truth (exMainLimitImageFields actor T S row body) env ↔
+      ∃ x, (if actor then MainLimitOldActorImageCode (env T) (env S) (env row) x
+        else MainLimitOldPointImageCode (env T) (env S) (env row) x) ∧ Truth body (extend x env) := by
+  simp only [exMainLimitImageFields, truth_exMainLimitConeFields, truth_exGraphFields, Truth, truth_reindex]
+  have rearrange (i P G t points actors y x : ZFSet.{u}) :
+      (fun j => extend x (extend y (extend actors (extend points (extend t
+        (extend G (extend P (extend i env)))))))
+        (Fin.cases 0 (fun k => k.succ.succ.succ.succ.succ.succ.succ.succ) j)) = extend x env := by
+    funext j
+    refine Fin.cases ?_ (fun k => ?_) j <;> rfl
+  simp only [rearrange]
+  cases actor <;> simp only [Bool.false_eq_true, ite_false, ite_true]
+  · change (∃ i P G t points actors, MainLimitConeEntryCode (env T) (env S) (env row) i P G t points actors ∧
+      ∃ y x, ZFSet.pair y x ∈ points ∧ y ∈ P ��� Truth body (extend x env)) ↔ _
+    constructor
+    · rintro ⟨i,P,G,t,points,actors,entry,y,x,image,member,holds⟩
+      exact ⟨x,⟨i,P,G,t,points,actors,y,entry,member,image⟩,holds⟩
+    · rintro ⟨x,⟨i,P,G,t,points,actors,y,entry,member,image⟩,holds⟩
+      exact ⟨i,P,G,t,points,actors,entry,y,x,image,member,holds⟩
+  · change (∃ i P G t points actors, MainLimitConeEntryCode (env T) (env S) (env row) i P G t points actors ∧
+      ∃ y x, ZFSet.pair y x ∈ actors ∧ y ∈ G ∧ Truth body (extend x env)) ↔ _
+    constructor
+    · rintro ⟨i,P,G,t,points,actors,entry,y,x,image,member,holds⟩
+      exact ⟨x,⟨i,P,G,t,points,actors,y,entry,member,image⟩,holds⟩
+    · rintro ⟨x,⟨i,P,G,t,points,actors,y,entry,member,image⟩,holds⟩
+      exact ⟨i,P,G,t,points,actors,entry,y,x,image,member,holds⟩
+
+def mainLimitImageFormula {n} (actor : Bool) (T S row x : Fin n) : BoundedFormula n :=
+  exMainLimitImageFields actor T S row (.equal 0 x.succ)
+
+theorem truth_mainLimitImageFormula {n} (actor : Bool) (T S row x : Fin n)
+    (env : Fin n → ZFSet.{u}) : Truth (mainLimitImageFormula actor T S row x) env ↔
+      (if actor then MainLimitOldActorImageCode (env T) (env S) (env row) (env x)
+        else MainLimitOldPointImageCode (env T) (env S) (env row) (env x)) := by
+  rw [mainLimitImageFormula, truth_exMainLimitImageFields]
+  change (∃ y, _ ∧ y = env x) ↔ _
+  constructor
+  · rintro ⟨y, member, rfl⟩
+    exact member
+  · exact fun member => ⟨env x, member, rfl⟩
+
+def mainLimitOldCutoffFormula {n} (T S t : Fin n) : BoundedFormula n :=
+  exMainLimitStageFields T S (disj (.equal t.succ.succ.succ.succ 0)
+    (.mem t.succ.succ.succ.succ 0))
+
+theorem truth_mainLimitOldCutoffFormula {n} (T S t : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (mainLimitOldCutoffFormula T S t) env ↔ MainLimitOldCutoffCode (env T) (env S) (env t) := by
+  simp only [mainLimitOldCutoffFormula, truth_exMainLimitStageFields, truth_disj, Truth]
+  change (∃ i z P G cutoff, i ∈ env T ∧ ZFSet.pair i z ∈ env S ∧
+    LinkedCoverageFieldsCode z P G cutoff ∧ (env t = cutoff ∨ env t ∈ cutoff)) ↔ _
+  constructor
+  · rintro ⟨i,z,P,G,cutoff,member,entry,shape,bound⟩
+    exact ⟨i,member,z,entry,P,G,cutoff,shape,bound⟩
+  · rintro ⟨i,member,z,entry,P,G,cutoff,shape,bound⟩
+    exact ⟨i,z,P,G,cutoff,member,entry,shape,bound⟩
+
+
+
+
+
+def mainLimitPointCoverageFormula {n} (T S row Q top : Fin n) : BoundedFormula n :=
+  .conj (.allMem Q (imp (.neg (.equal 0 top.succ))
+    (mainLimitImageFormula false T.succ S.succ row.succ 0)))
+    (.neg (exMainLimitImageFields false T S row
+      (.neg (.conj (.mem 0 Q.succ) (.neg (.equal 0 top.succ))))))
+
+theorem truth_mainLimitPointCoverageFormula {n} (T S row Q top : Fin n)
+    (env : Fin n → ZFSet.{u}) : Truth (mainLimitPointCoverageFormula T S row Q top) env ↔
+      ∀ x, (x ∈ env Q ∧ x ≠ env top) ↔ MainLimitOldPointImageCode (env T) (env S) (env row) x := by
+  classical
+  simp only [mainLimitPointCoverageFormula, Truth, truth_imp, truth_mainLimitImageFormula,
+    truth_exMainLimitImageFields, Bool.false_eq_true, ite_false, not_exists, not_and, not_not, Classical.not_imp]
+  change ((∀ x ∈ env Q, x ≠ env top → MainLimitOldPointImageCode (env T) (env S) (env row) x) ∧
+    ∀ x, MainLimitOldPointImageCode (env T) (env S) (env row) x → x ∈ env Q ∧ x ≠ env top) ↔ _
+  constructor
+  · rintro ⟨forward, reverse⟩ x
+    exact ⟨fun h => forward x h.1 h.2, reverse x⟩
+  · intro laws
+    exact ⟨fun x member different => (laws x).1 ⟨member,different⟩, fun x => (laws x).2⟩
+
+def mainLimitActorCoverageFormula {n} (T S row H : Fin n) : BoundedFormula n :=
+  .conj (.allMem H (mainLimitImageFormula true T.succ S.succ row.succ 0))
+    (.neg (exMainLimitImageFields true T S row (.neg (.mem 0 H.succ))))
+
+theorem truth_mainLimitActorCoverageFormula {n} (T S row H : Fin n)
+    (env : Fin n → ZFSet.{u}) : Truth (mainLimitActorCoverageFormula T S row H) env ↔
+      ∀ g, g ∈ env H ↔ MainLimitOldActorImageCode (env T) (env S) (env row) g := by
+  classical
+  simp only [mainLimitActorCoverageFormula, Truth, truth_mainLimitImageFormula,
+    truth_exMainLimitImageFields, ite_true, not_exists, not_and, not_not]
+  change ((∀ g ∈ env H, MainLimitOldActorImageCode (env T) (env S) (env row) g) ∧
+    ∀ g, MainLimitOldActorImageCode (env T) (env S) (env row) g → g ∈ env H) ↔ _
+  exact ⟨fun h g => ⟨h.1 g,h.2 g⟩, fun h => ⟨fun g => (h g).1,fun g => (h g).2⟩⟩
+
+def mainLimitStrictTopFormula {n} (T S row R top : Fin n) : BoundedFormula n :=
+  .neg (exMainLimitConeFields T S row (exGraphFields 1 (.neg
+    (.conj (pairMembershipFormula 0 top.succ.succ.succ.succ.succ.succ.succ.succ
+      R.succ.succ.succ.succ.succ.succ.succ.succ)
+      (.neg (pairMembershipFormula top.succ.succ.succ.succ.succ.succ.succ.succ 0
+        R.succ.succ.succ.succ.succ.succ.succ.succ))))))
+
+theorem truth_mainLimitStrictTopFormula {n} (T S row R top : Fin n)
+    (env : Fin n → ZFSet.{u}) : Truth (mainLimitStrictTopFormula T S row R top) env ↔
+      ∀ i P G t points actors, MainLimitConeEntryCode (env T) (env S) (env row) i P G t points actors →
+        ∀ x y, ZFSet.pair x y ∈ points → ZFSet.pair y (env top) ∈ env R ∧
+          ZFSet.pair (env top) y ∉ env R := by
+  classical
+  simp only [mainLimitStrictTopFormula, Truth, truth_exMainLimitConeFields,
+    truth_exGraphFields, truth_pairMembershipFormula, not_exists, not_and, not_not, Classical.not_imp]
+  rfl
+
+def mainLimitCutoffFormula {n} (T S cutoff : Fin n) : BoundedFormula n :=
+  .conj (.allMem cutoff (mainLimitOldCutoffFormula T.succ S.succ 0))
+    (.neg (exMainLimitStageFields T S (.neg
+      (.conj (.mem 0 cutoff.succ.succ.succ.succ)
+        (.allMem 0 (.mem 0 cutoff.succ.succ.succ.succ.succ))))))
+
+theorem truth_mainLimitCutoffFormula {n} (T S cutoff : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (mainLimitCutoffFormula T S cutoff) env ↔
+      ∀ t, t ∈ env cutoff ↔ MainLimitOldCutoffCode (env T) (env S) t := by
+  classical
+  simp only [mainLimitCutoffFormula, Truth, truth_mainLimitOldCutoffFormula,
+    truth_exMainLimitStageFields, not_exists, not_and, not_not, Classical.not_imp]
+  change ((∀ t ∈ env cutoff, MainLimitOldCutoffCode (env T) (env S) t) ∧
+    ∀ i z P G t, i ∈ env T → ZFSet.pair i z ∈ env S → LinkedCoverageFieldsCode z P G t →
+      t ∈ env cutoff ∧ ∀ s ∈ t, s ∈ env cutoff) ↔ _
+  constructor
+  · rintro ⟨forward,bound⟩ t
+    refine ⟨forward t, ?_⟩
+    rintro ⟨i,member,z,entry,P,G,s,shape,equal | lower⟩
+    · exact equal.symm ▸ (bound i z P G s member entry shape).1
+    · exact (bound i z P G s member entry shape).2 t lower
+  · intro laws
+    refine ⟨fun t => (laws t).1, ?_⟩
+    intro i z P G t member entry shape
+    exact ⟨(laws t).2 ⟨i,member,z,entry,P,G,t,shape,Or.inl rfl⟩,
+      fun s lower => (laws s).2 ⟨i,member,z,entry,P,G,t,shape,Or.inr lower⟩⟩
+
+def mainLimitTopBirthFormula {n} (top cutoff birth : Fin n) : BoundedFormula n :=
+  .conj (pairMembershipFormula top cutoff birth)
+    (.neg (exGraphFields birth (.conj (.equal 0 cutoff.succ.succ)
+      (.neg (.equal 1 top.succ.succ)))))
+
+theorem truth_mainLimitTopBirthFormula {n} (top cutoff birth : Fin n)
+    (env : Fin n → ZFSet.{u}) : Truth (mainLimitTopBirthFormula top cutoff birth) env ↔
+      ∀ x, ZFSet.pair x (env cutoff) ∈ env birth ↔ x = env top := by
+  classical
+  simp only [mainLimitTopBirthFormula, Truth, truth_pairMembershipFormula,
+    truth_exGraphFields, not_exists, not_and, not_not]
+  change (ZFSet.pair (env top) (env cutoff) ∈ env birth ∧
+    ∀ x t, ZFSet.pair x t ∈ env birth → t = env cutoff → x = env top) ↔ _
+  constructor
+  · rintro ⟨entry,unique⟩ x
+    exact ⟨fun image => unique x (env cutoff) image rfl, fun equal => equal.symm ▸ entry⟩
+  · intro laws
+    exact ⟨(laws (env top)).2 rfl, fun x t image equal => (laws x).1 (equal ▸ image)⟩
+
+def mainLimitCoverageFormula {n} (T S row Q H R top cutoff birth : Fin n) : BoundedFormula n :=
+  .conj (mainLimitPointCoverageFormula T S row Q top)
+    (.conj (mainLimitActorCoverageFormula T S row H)
+      (.conj (mainLimitStrictTopFormula T S row R top)
+        (.conj (mainLimitCutoffFormula T S cutoff) (mainLimitTopBirthFormula top cutoff birth))))
+
+theorem truth_mainLimitCoverageFormula {n} (T S row Q H R top cutoff birth : Fin n)
+    (env : Fin n → ZFSet.{u}) : Truth (mainLimitCoverageFormula T S row Q H R top cutoff birth) env ↔
+      MainLimitCoverageGraphCode (env T) (env S) (env row) (env Q) (env H) (env R)
+        (env top) (env cutoff) (env birth) := by
+  simp only [mainLimitCoverageFormula, Truth, truth_mainLimitPointCoverageFormula,
+    truth_mainLimitActorCoverageFormula, truth_mainLimitStrictTopFormula,
+    truth_mainLimitCutoffFormula, truth_mainLimitTopBirthFormula]
+  exact ⟨fun h => ⟨h.1,h.2.1,h.2.2.1,h.2.2.2.1,h.2.2.2.2⟩,
+    fun h => ⟨h.points,h.actors,h.strict_top,h.cutoff_mem,h.top_birth⟩⟩
+
+theorem realize_mainLimitCoverageFormula (M : TransitiveGround.{u}) {n}
+    (T S row Q H R top cutoff birth : Fin n) (env : Fin n → ZFSet.{u})
+    (members : ∀ i, env i ∈ M.sets) :
+    Realize M.sets (mainLimitCoverageFormula T S row Q H R top cutoff birth).toFormula env ↔
+      MainLimitCoverageGraphCode (env T) (env S) (env row) (env Q) (env H) (env R)
+        (env top) (env cutoff) (env birth) :=
+  (realize_toFormula M _ env members).trans (truth_mainLimitCoverageFormula T S row Q H R top cutoff birth env)
+
+end PartitionPilot.Forcing.BoundedFormula
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/MainPrefixTraceStepFormulas.lean

@@ -1,164 +1,164 @@
-import OAI.SetTheory.PartitionPrinciple.Definability.PreservedMainPrefixHistoryFormulas
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing
-open SetFormula
-universe u
-
-namespace SetFormula
-def mainPrefixAtIndexFormula {n} (T q : Fin n) : SetFormula n :=
-  exBlock 2 (BoundedFormula.mainPrefixTupleFormula (suffixIndex n 2 q)
-    (suffixIndex n 2 T) (prefixIndex n 2 0) (prefixIndex n 2 1)).toFormula
-
-def mainPrefixAtSuccessorFormula {n} (α q : Fin n) : SetFormula n :=
-  ex (.conj (BoundedFormula.successorFormula 0 α.succ).toFormula
-    (mainPrefixAtIndexFormula 0 q.succ))
-
-def mainPrefixHistoryExtendsFormula {n} (p q : Fin n) : SetFormula n :=
-  .all (.all (imp (BoundedFormula.pairMembershipFormula 1 0 p.succ.succ).toFormula
-    (mainPrefixExtensionFormula 0 q.succ.succ)))
-
-end SetFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-
-theorem realize_mainPrefixAtIndexFormula {n} (T q : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets) :
-    Realize M.sets (mainPrefixAtIndexFormula T q) env ↔ MainPrefixAtIndex (env T) (env q) := by
-  rw [mainPrefixAtIndexFormula, realize_exBlock]
-  have actual (f : Fin 2 → ZFSet.{u}) (ground : ∀ j, f j ∈ M.sets) :=
-    BoundedFormula.realize_mainPrefixTupleFormula M (suffixIndex n 2 q)
-      (suffixIndex n 2 T) (prefixIndex n 2 0) (prefixIndex n 2 1)
-      (extendMany 2 f env) (extendMany_members 2 f env ground members)
-  simp only [extendMany_prefix, extendMany_suffix] at actual
-  constructor
-  · rintro ⟨f, ground, recognized⟩
-    exact ⟨f 0, f 1, (actual f ground).1 recognized⟩
-  · rintro ⟨S, E, encoded⟩
-    have fields := M.mainPrefixCode_fields_mem (encoded ▸ members q)
-    let f : Fin 2 → ZFSet.{u} := Fin.cases S (fun _ => E)
-    have ground : ∀ j, f j ∈ M.sets := Fin.cases fields.2.1 (fun _ => fields.2.2)
-    exact ⟨f, ground, (actual f ground).2 encoded⟩
-
-theorem realize_mainPrefixAtSuccessorFormula {n} (α q : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets) :
-    Realize M.sets (mainPrefixAtSuccessorFormula α q) env ↔
-      MainPrefixAtIndex (insert (env α) (env α)) (env q) := by
-  rw [mainPrefixAtSuccessorFormula, realize_ex]
-  have actual T (ground : T ∈ M.sets) :
-      Realize M.sets (.conj (BoundedFormula.successorFormula 0 α.succ).toFormula
-        (mainPrefixAtIndexFormula 0 q.succ)) (extend T env) ↔
-      T = insert (env α) (env α) ∧ MainPrefixAtIndex T (env q) := by
-    change (_ ∧ _) ↔ _
-    rw [BoundedFormula.realize_toFormula M _ _ (Fin.cases ground members),
-      BoundedFormula.truth_successorFormula,
-      M.realize_mainPrefixAtIndexFormula _ _ _ (Fin.cases ground members)]
-    rfl
-  constructor
-  · rintro ⟨T, ground, recognized⟩
-    obtain ⟨rfl, code⟩ := (actual T ground).1 recognized
-    exact code
-  · intro code
-    obtain ⟨S, E, equal⟩ := code
-    have ground := (M.mainPrefixCode_fields_mem (equal ▸ members q)).1
-    exact ⟨_, ground, (actual _ ground).2 ⟨rfl, S, E, equal⟩⟩
-
-theorem realize_mainPrefixHistoryExtendsFormula {n} (p q : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets) :
-    Realize M.sets (mainPrefixHistoryExtendsFormula p q) env ↔
-      MainPrefixHistoryExtends (env p) (env q) := by
-  change (∀ i ∈ M.sets, ∀ old ∈ M.sets, Realize M.sets
-    (imp (BoundedFormula.pairMembershipFormula 1 0 p.succ.succ).toFormula
-      (mainPrefixExtensionFormula 0 q.succ.succ)) (extend old (extend i env))) ↔ _
-  have actual i old (hi : i ∈ M.sets) (ho : old ∈ M.sets) :
-      Realize M.sets
-        (imp (BoundedFormula.pairMembershipFormula 1 0 p.succ.succ).toFormula
-          (mainPrefixExtensionFormula 0 q.succ.succ)) (extend old (extend i env)) ↔
-      (ZFSet.pair i old ∈ env p → MainPrefixExtends old (env q)) := by
-    rw [realize_imp, BoundedFormula.realize_toFormula M _ _ (Fin.cases ho (Fin.cases hi members)),
-      BoundedFormula.truth_pairMembershipFormula,
-      M.realize_mainPrefixExtensionFormula _ _ _ (Fin.cases ho (Fin.cases hi members))]
-    rfl
-  constructor
-  · intro recognized i old entry
-    have pairGround := M.transitive (members p) entry
-    exact (actual i old (M.pair_left pairGround) (M.pair_right pairGround)).1
-      (recognized i (M.pair_left pairGround) old (M.pair_right pairGround)) entry
-  · intro history i hi old ho
-    exact (actual i old hi ho).2 (history i old)
-
-end TransitiveGround
-end PartitionPilot.Forcing
-
-
-
-namespace PartitionPilot.Forcing
-open SetFormula
-universe u
-
-namespace SetFormula
-def mainPrefixTraceBranchFormula {n} (seed g α p y : Fin n) : SetFormula n :=
-  disj (.conj (BoundedFormula.emptyFormula α).toFormula (.equal y seed))
-    (.conj (.neg (BoundedFormula.emptyFormula α).toFormula)
-      (ex (.conj (mainPrefixHistoryUnionFormula p.succ 0)
-        (BoundedFormula.pairMembershipFormula 0 y.succ g.succ).toFormula)))
-
-def mainPrefixTraceStepFormula {n} (B seed g α p y : Fin n) : SetFormula n :=
-  .conj (.mem y B) (.conj (mainPrefixAtSuccessorFormula α y)
-    (.conj (mainPrefixHistoryExtendsFormula p y) (mainPrefixTraceBranchFormula seed g α p y)))
-
-end SetFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-
-theorem realize_mainPrefixTraceBranchFormula {n} (seed g α p y : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets) :
-    Realize M.sets (mainPrefixTraceBranchFormula seed g α p y) env ↔
-      ((env α = ∅ ∧ env y = env seed) ∨ (env α ≠ ∅ ∧
-        ∃ input, MainPrefixHistoryUnionCode (env p) input ∧ ZFSet.pair input (env y) ∈ env g)) := by
-  have empty := (BoundedFormula.realize_toFormula M (BoundedFormula.emptyFormula α) env members).trans
-    (BoundedFormula.truth_emptyFormula α env)
-  rw [mainPrefixTraceBranchFormula, realize_disj]
-  change ((_ ∧ _) ∨ ((¬ _) ∧ _)) ↔ _
-  rw [empty]
-  apply or_congr Iff.rfl
-  apply and_congr Iff.rfl
-  rw [realize_ex]
-  have actual input (ground : input ∈ M.sets) :
-      Realize M.sets (.conj (mainPrefixHistoryUnionFormula p.succ 0)
-        (BoundedFormula.pairMembershipFormula 0 y.succ g.succ).toFormula) (extend input env) ↔
-      MainPrefixHistoryUnionCode (env p) input ∧ ZFSet.pair input (env y) ∈ env g := by
-    change (_ ∧ _) ↔ _
-    rw [M.realize_mainPrefixHistoryUnionFormula _ _ _ (Fin.cases ground members),
-      BoundedFormula.realize_toFormula M _ _ (Fin.cases ground members),
-      BoundedFormula.truth_pairMembershipFormula]
-    rfl
-  constructor
-  · rintro ⟨input, ground, recognized⟩
-    exact ⟨input, (actual input ground).1 recognized⟩
-  · rintro ⟨input, union, entry⟩
-    have ground := M.pair_left (M.transitive (members g) entry)
-    exact ⟨input, ground, (actual input ground).2 ⟨union, entry⟩⟩
-
-theorem realize_mainPrefixTraceStepFormula {n} (B seed g α p y : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets) :
-    Realize M.sets (mainPrefixTraceStepFormula B seed g α p y) env ↔
-      MainPrefixTraceStepCode (env B) (env seed) (env g) (env α) (env p) (env y) := by
-  unfold mainPrefixTraceStepFormula MainPrefixTraceStepCode
-  change (_ ∧ _ ∧ _ ∧ _) ↔ _
-  rw [M.realize_mainPrefixAtSuccessorFormula _ _ _ members,
-    M.realize_mainPrefixHistoryExtendsFormula _ _ _ members,
-    M.realize_mainPrefixTraceBranchFormula _ _ _ _ _ _ members]
-  rfl
-
-end TransitiveGround
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Definability.PreservedMainPrefixHistoryFormulas
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing
+open SetFormula
+universe u
+
+namespace SetFormula
+def mainPrefixAtIndexFormula {n} (T q : Fin n) : SetFormula n :=
+  exBlock 2 (BoundedFormula.mainPrefixTupleFormula (suffixIndex n 2 q)
+    (suffixIndex n 2 T) (prefixIndex n 2 0) (prefixIndex n 2 1)).toFormula
+
+def mainPrefixAtSuccessorFormula {n} (α q : Fin n) : SetFormula n :=
+  ex (.conj (BoundedFormula.successorFormula 0 α.succ).toFormula
+    (mainPrefixAtIndexFormula 0 q.succ))
+
+def mainPrefixHistoryExtendsFormula {n} (p q : Fin n) : SetFormula n :=
+  .all (.all (imp (BoundedFormula.pairMembershipFormula 1 0 p.succ.succ).toFormula
+    (mainPrefixExtensionFormula 0 q.succ.succ)))
+
+end SetFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+
+theorem realize_mainPrefixAtIndexFormula {n} (T q : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets) :
+    Realize M.sets (mainPrefixAtIndexFormula T q) env ↔ MainPrefixAtIndex (env T) (env q) := by
+  rw [mainPrefixAtIndexFormula, realize_exBlock]
+  have actual (f : Fin 2 → ZFSet.{u}) (ground : ∀ j, f j ∈ M.sets) :=
+    BoundedFormula.realize_mainPrefixTupleFormula M (suffixIndex n 2 q)
+      (suffixIndex n 2 T) (prefixIndex n 2 0) (prefixIndex n 2 1)
+      (extendMany 2 f env) (extendMany_members 2 f env ground members)
+  simp only [extendMany_prefix, extendMany_suffix] at actual
+  constructor
+  · rintro ⟨f, ground, recognized⟩
+    exact ⟨f 0, f 1, (actual f ground).1 recognized⟩
+  · rintro ⟨S, E, encoded⟩
+    have fields := M.mainPrefixCode_fields_mem (encoded ▸ members q)
+    let f : Fin 2 → ZFSet.{u} := Fin.cases S (fun _ => E)
+    have ground : ∀ j, f j ∈ M.sets := Fin.cases fields.2.1 (fun _ => fields.2.2)
+    exact ⟨f, ground, (actual f ground).2 encoded⟩
+
+theorem realize_mainPrefixAtSuccessorFormula {n} (α q : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets) :
+    Realize M.sets (mainPrefixAtSuccessorFormula α q) env ↔
+      MainPrefixAtIndex (insert (env α) (env α)) (env q) := by
+  rw [mainPrefixAtSuccessorFormula, realize_ex]
+  have actual T (ground : T ∈ M.sets) :
+      Realize M.sets (.conj (BoundedFormula.successorFormula 0 α.succ).toFormula
+        (mainPrefixAtIndexFormula 0 q.succ)) (extend T env) ↔
+      T = insert (env α) (env α) ∧ MainPrefixAtIndex T (env q) := by
+    change (_ ∧ _) ↔ _
+    rw [BoundedFormula.realize_toFormula M _ _ (Fin.cases ground members),
+      BoundedFormula.truth_successorFormula,
+      M.realize_mainPrefixAtIndexFormula _ _ _ (Fin.cases ground members)]
+    rfl
+  constructor
+  · rintro ⟨T, ground, recognized⟩
+    obtain ⟨rfl, code⟩ := (actual T ground).1 recognized
+    exact code
+  · intro code
+    obtain ⟨S, E, equal⟩ := code
+    have ground := (M.mainPrefixCode_fields_mem (equal ▸ members q)).1
+    exact ⟨_, ground, (actual _ ground).2 ⟨rfl, S, E, equal⟩⟩
+
+theorem realize_mainPrefixHistoryExtendsFormula {n} (p q : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets) :
+    Realize M.sets (mainPrefixHistoryExtendsFormula p q) env ↔
+      MainPrefixHistoryExtends (env p) (env q) := by
+  change (∀ i ∈ M.sets, ∀ old ∈ M.sets, Realize M.sets
+    (imp (BoundedFormula.pairMembershipFormula 1 0 p.succ.succ).toFormula
+      (mainPrefixExtensionFormula 0 q.succ.succ)) (extend old (extend i env))) ↔ _
+  have actual i old (hi : i ∈ M.sets) (ho : old ∈ M.sets) :
+      Realize M.sets
+        (imp (BoundedFormula.pairMembershipFormula 1 0 p.succ.succ).toFormula
+          (mainPrefixExtensionFormula 0 q.succ.succ)) (extend old (extend i env)) ↔
+      (ZFSet.pair i old ∈ env p → MainPrefixExtends old (env q)) := by
+    rw [realize_imp, BoundedFormula.realize_toFormula M _ _ (Fin.cases ho (Fin.cases hi members)),
+      BoundedFormula.truth_pairMembershipFormula,
+      M.realize_mainPrefixExtensionFormula _ _ _ (Fin.cases ho (Fin.cases hi members))]
+    rfl
+  constructor
+  · intro recognized i old entry
+    have pairGround := M.transitive (members p) entry
+    exact (actual i old (M.pair_left pairGround) (M.pair_right pairGround)).1
+      (recognized i (M.pair_left pairGround) old (M.pair_right pairGround)) entry
+  · intro history i hi old ho
+    exact (actual i old hi ho).2 (history i old)
+
+end TransitiveGround
+end PartitionPilot.Forcing
+
+
+
+namespace PartitionPilot.Forcing
+open SetFormula
+universe u
+
+namespace SetFormula
+def mainPrefixTraceBranchFormula {n} (seed g α p y : Fin n) : SetFormula n :=
+  disj (.conj (BoundedFormula.emptyFormula α).toFormula (.equal y seed))
+    (.conj (.neg (BoundedFormula.emptyFormula α).toFormula)
+      (ex (.conj (mainPrefixHistoryUnionFormula p.succ 0)
+        (BoundedFormula.pairMembershipFormula 0 y.succ g.succ).toFormula)))
+
+def mainPrefixTraceStepFormula {n} (B seed g α p y : Fin n) : SetFormula n :=
+  .conj (.mem y B) (.conj (mainPrefixAtSuccessorFormula α y)
+    (.conj (mainPrefixHistoryExtendsFormula p y) (mainPrefixTraceBranchFormula seed g α p y)))
+
+end SetFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+
+theorem realize_mainPrefixTraceBranchFormula {n} (seed g α p y : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets) :
+    Realize M.sets (mainPrefixTraceBranchFormula seed g α p y) env ↔
+      ((env α = ∅ ∧ env y = env seed) ∨ (env α ≠ ∅ ∧
+        ∃ input, MainPrefixHistoryUnionCode (env p) input ∧ ZFSet.pair input (env y) ∈ env g)) := by
+  have empty := (BoundedFormula.realize_toFormula M (BoundedFormula.emptyFormula α) env members).trans
+    (BoundedFormula.truth_emptyFormula α env)
+  rw [mainPrefixTraceBranchFormula, realize_disj]
+  change ((_ ∧ _) ∨ ((¬ _) ∧ _)) ↔ _
+  rw [empty]
+  apply or_congr Iff.rfl
+  apply and_congr Iff.rfl
+  rw [realize_ex]
+  have actual input (ground : input ∈ M.sets) :
+      Realize M.sets (.conj (mainPrefixHistoryUnionFormula p.succ 0)
+        (BoundedFormula.pairMembershipFormula 0 y.succ g.succ).toFormula) (extend input env) ↔
+      MainPrefixHistoryUnionCode (env p) input ∧ ZFSet.pair input (env y) ∈ env g := by
+    change (_ ∧ _) ↔ _
+    rw [M.realize_mainPrefixHistoryUnionFormula _ _ _ (Fin.cases ground members),
+      BoundedFormula.realize_toFormula M _ _ (Fin.cases ground members),
+      BoundedFormula.truth_pairMembershipFormula]
+    rfl
+  constructor
+  · rintro ⟨input, ground, recognized⟩
+    exact ⟨input, (actual input ground).1 recognized⟩
+  · rintro ⟨input, union, entry⟩
+    have ground := M.pair_left (M.transitive (members g) entry)
+    exact ⟨input, ground, (actual input ground).2 ⟨union, entry⟩⟩
+
+theorem realize_mainPrefixTraceStepFormula {n} (B seed g α p y : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets) :
+    Realize M.sets (mainPrefixTraceStepFormula B seed g α p y) env ↔
+      MainPrefixTraceStepCode (env B) (env seed) (env g) (env α) (env p) (env y) := by
+  unfold mainPrefixTraceStepFormula MainPrefixTraceStepCode
+  change (_ ∧ _ ∧ _ ∧ _) ↔ _
+  rw [M.realize_mainPrefixAtSuccessorFormula _ _ _ members,
+    M.realize_mainPrefixHistoryExtendsFormula _ _ _ members,
+    M.realize_mainPrefixTraceBranchFormula _ _ _ _ _ _ members]
+  rfl
+
+end TransitiveGround
+end PartitionPilot.Forcing
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/MainPrefixValidityFormulas.lean

@@ -1,241 +1,241 @@
-import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundLinkedMainStageLevels
-
-namespace OAI
-
-namespace PartitionPilot.Forcing
-open SetFormula
-universe u
-namespace BoundedFormula
-
-def pairedTransitionEntryFormula {n} (i j p a E : Fin n) : BoundedFormula n :=
-  exMem E (exMem 0 (exMem 0 (.conj
-    (orderedPairFormula 0 p.succ.succ.succ a.succ.succ.succ)
-    (orderedTripleFormula 2 j.succ.succ.succ i.succ.succ.succ 0))))
-
-theorem truth_pairedTransitionEntryFormula {n} (i j p a E : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (pairedTransitionEntryFormula i j p a E) env ↔
-      ZFSet.pair (ZFSet.pair (env j) (env i)) (ZFSet.pair (env p) (env a)) ∈ env E := by
-  simp only [pairedTransitionEntryFormula, truth_exMem, Truth,
-    truth_orderedPairFormula, truth_orderedTripleFormula]
-  change (∃ w ∈ env E, ∃ b ∈ w, ∃ c ∈ b, c = ZFSet.pair (env p) (env a) ∧
-    w = ZFSet.pair (ZFSet.pair (env j) (env i)) c) ↔ _
-  constructor
-  · rintro ⟨w, hw, b, _, c, _, rfl, rfl⟩
-    exact hw
-  · intro entry
-    refine ⟨_, entry, {ZFSet.pair (env j) (env i), ZFSet.pair (env p) (env a)},
-      ZFSet.mem_pair.2 (Or.inr rfl), _, ZFSet.mem_pair.2 (Or.inr rfl), rfl, rfl⟩
-
-end BoundedFormula
-
-namespace SetFormula
-
-def mainPrefixIdentityFormula {n} (E : Fin n) : SetFormula n :=
-  let v := prefixIndex n 3
-  allBlock 3 (BoundedFormula.imp
-    (BoundedFormula.pairedTransitionEntryFormula (v 0) (v 0) (v 1) (v 2) (suffixIndex n 3 E))
-    (.conj (BoundedFormula.graphDiagonalFormula (v 1))
-      (BoundedFormula.graphDiagonalFormula (v 2)))).toFormula
-
-def mainPrefixCompositionFormula {n} (E : Fin n) : SetFormula n :=
-  let v := prefixIndex n 9
-  let old := suffixIndex n 9 E
-  allBlock 9 (BoundedFormula.imp
-    (BoundedFormula.pairedTransitionEntryFormula (v 0) (v 1) (v 3) (v 4) old)
-    (BoundedFormula.imp
-      (BoundedFormula.pairedTransitionEntryFormula (v 1) (v 2) (v 5) (v 6) old)
-      (BoundedFormula.imp
-        (BoundedFormula.pairedTransitionEntryFormula (v 0) (v 2) (v 7) (v 8) old)
-        (.conj (BoundedFormula.graphCompositionFormula (v 3) (v 5) (v 7))
-          (BoundedFormula.graphCompositionFormula (v 4) (v 6) (v 8)))))).toFormula
-
-end SetFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-
-theorem realize_mainPrefixIdentityFormula {n} (E : Fin n) (env : Fin n → ZFSet.{u})
-    (members : ∀ j, env j ∈ M.sets) :
-    Realize M.sets (mainPrefixIdentityFormula E) env ↔
-      ∀ i p a, ZFSet.pair (ZFSet.pair i i) (ZFSet.pair p a) ∈ env E →
-        GraphDiagonalCode p ∧ GraphDiagonalCode a := by
-  rw [mainPrefixIdentityFormula, realize_allBlock]
-  have actual (fields : Fin 3 → ZFSet.{u}) (ground : ∀ j, fields j ∈ M.sets) :=
-    BoundedFormula.realize_toFormula M
-      (BoundedFormula.imp
-        (BoundedFormula.pairedTransitionEntryFormula (prefixIndex n 3 0) (prefixIndex n 3 0)
-          (prefixIndex n 3 1) (prefixIndex n 3 2) (suffixIndex n 3 E))
-        (.conj (BoundedFormula.graphDiagonalFormula (prefixIndex n 3 1))
-          (BoundedFormula.graphDiagonalFormula (prefixIndex n 3 2))))
-      (extendMany 3 fields env) (extendMany_members 3 fields env ground members)
-  simp only [BoundedFormula.truth_imp, BoundedFormula.Truth,
-    BoundedFormula.truth_pairedTransitionEntryFormula, BoundedFormula.truth_graphDiagonalFormula,
-    extendMany_prefix, extendMany_suffix] at actual
-  constructor
-  · intro recognized i p a entry
-    have hg := M.transitive (members E) entry
-    let fields : Fin 3 → ZFSet.{u} := Fin.cases i (Fin.cases p (fun _ => a))
-    have ground : ∀ j, fields j ∈ M.sets := Fin.cases (M.pair_left (M.pair_left hg))
-      (Fin.cases (M.pair_left (M.pair_right hg)) (fun _ => M.pair_right (M.pair_right hg)))
-    exact (actual fields ground).1 (recognized fields ground) entry
-  · intro law fields ground
-    exact (actual fields ground).2 (law (fields 0) (fields 1) (fields 2))
-
-theorem realize_mainPrefixCompositionFormula {n} (E : Fin n) (env : Fin n → ZFSet.{u})
-    (members : ∀ j, env j ∈ M.sets) :
-    Realize M.sets (mainPrefixCompositionFormula E) env ↔
-      ∀ i j k p₁ a₁ p₂ a₂ p₃ a₃,
-        ZFSet.pair (ZFSet.pair j i) (ZFSet.pair p₁ a₁) ∈ env E →
-        ZFSet.pair (ZFSet.pair k j) (ZFSet.pair p₂ a₂) ∈ env E →
-        ZFSet.pair (ZFSet.pair k i) (ZFSet.pair p₃ a₃) ∈ env E →
-        GraphCompositionCode p₁ p₂ p₃ ∧ GraphCompositionCode a₁ a₂ a₃ := by
-  rw [mainPrefixCompositionFormula, realize_allBlock]
-  have actual (fields : Fin 9 → ZFSet.{u}) (ground : ∀ j, fields j ∈ M.sets) :=
-    BoundedFormula.realize_toFormula M
-      (BoundedFormula.imp
-        (BoundedFormula.pairedTransitionEntryFormula (prefixIndex n 9 0) (prefixIndex n 9 1)
-          (prefixIndex n 9 3) (prefixIndex n 9 4) (suffixIndex n 9 E))
-        (BoundedFormula.imp
-          (BoundedFormula.pairedTransitionEntryFormula (prefixIndex n 9 1) (prefixIndex n 9 2)
-            (prefixIndex n 9 5) (prefixIndex n 9 6) (suffixIndex n 9 E))
-          (BoundedFormula.imp
-            (BoundedFormula.pairedTransitionEntryFormula (prefixIndex n 9 0) (prefixIndex n 9 2)
-              (prefixIndex n 9 7) (prefixIndex n 9 8) (suffixIndex n 9 E))
-            (.conj (BoundedFormula.graphCompositionFormula (prefixIndex n 9 3) (prefixIndex n 9 5) (prefixIndex n 9 7))
-              (BoundedFormula.graphCompositionFormula (prefixIndex n 9 4) (prefixIndex n 9 6) (prefixIndex n 9 8))))))
-      (extendMany 9 fields env) (extendMany_members 9 fields env ground members)
-  simp only [BoundedFormula.truth_imp, BoundedFormula.Truth,
-    BoundedFormula.truth_pairedTransitionEntryFormula, BoundedFormula.truth_graphCompositionFormula,
-    extendMany_prefix, extendMany_suffix] at actual
-  constructor
-  · intro recognized i j k p₁ a₁ p₂ a₂ p₃ a₃ first second third
-    have h₁ := M.transitive (members E) first
-    have h₂ := M.transitive (members E) second
-    have h₃ := M.transitive (members E) third
-    let fields : Fin 9 → ZFSet.{u} := Fin.cases i (Fin.cases j (Fin.cases k (Fin.cases p₁
-      (Fin.cases a₁ (Fin.cases p₂ (Fin.cases a₂ (Fin.cases p₃ (fun _ => a₃))))))))
-    have ground : ∀ a, fields a ∈ M.sets := Fin.cases (M.pair_right (M.pair_left h₁))
-      (Fin.cases (M.pair_left (M.pair_left h₁)) (Fin.cases (M.pair_left (M.pair_left h₂))
-      (Fin.cases (M.pair_left (M.pair_right h₁)) (Fin.cases (M.pair_right (M.pair_right h₁))
-      (Fin.cases (M.pair_left (M.pair_right h₂)) (Fin.cases (M.pair_right (M.pair_right h₂))
-      (Fin.cases (M.pair_left (M.pair_right h₃)) (fun _ => M.pair_right (M.pair_right h₃)))))))))
-    exact (actual fields ground).1 (recognized fields ground) first second third
-  · intro law fields ground
-    exact (actual fields ground).2 (law (fields 0) (fields 1) (fields 2) (fields 3)
-      (fields 4) (fields 5) (fields 6) (fields 7) (fields 8))
-
-end TransitiveGround
-
-namespace SetFormula
-
-def mainPrefixStagesFormula {n} (K Labels C D rD N S : Fin n) : SetFormula n :=
-  let old := suffixIndex n 2
-  let v := prefixIndex n 2
-  allBlock 2 (imp (BoundedFormula.pairMembershipFormula (v 0) (v 1) (old S)).toFormula
-    (linkedMainStageFormula (old K) (old Labels) (old C) (old D) (old rD) (old N) (v 1)))
-
-def mainPrefixTransitionsFormula {n} (K Labels C D rD N S E : Fin n) : SetFormula n :=
-  let old := suffixIndex n 5
-  let v := prefixIndex n 5
-  allBlock 5 (imp (BoundedFormula.conj
-    (BoundedFormula.pairMembershipFormula (v 0) (v 2) (old S))
-    (.conj (BoundedFormula.pairMembershipFormula (v 1) (v 3) (old S))
-      (BoundedFormula.tripleMembershipFormula (v 1) (v 0) (v 4) (old E)))).toFormula
-    (linkedMainTransitionFormula (old K) (old Labels) (old C) (old D) (old rD) (old N)
-      (v 2) (v 3) (v 4)))
-
-end SetFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-variable (unions : Realize M.sets SetFormula.union Fin.elim0)
-variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-variable (collection : CollectionSchema M.sets)
-include pairing unions powers separation collection
-
-theorem realize_mainPrefixStagesFormula {n} (K Labels C D rD N S : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
-    (omega : env N = ZFSet.omega) (ordinal : ordinalSetProperty (env K)) :
-    Realize M.sets (mainPrefixStagesFormula K Labels C D rD N S) env ↔
-      ∀ i a, ZFSet.pair i a ∈ env S →
-        ∃ linked : GroundLinkedMainStage M (env K) (env Labels) (env C) (env D) (env rD),
-          linked.code = a := by
-  rw [mainPrefixStagesFormula, realize_allBlock]
-  have actual (fields : Fin 2 → ZFSet.{u}) (ground : ∀ j, fields j ∈ M.sets) :
-      Realize M.sets
-        (imp (BoundedFormula.pairMembershipFormula (prefixIndex n 2 0) (prefixIndex n 2 1)
-          (suffixIndex n 2 S)).toFormula
-          (linkedMainStageFormula (suffixIndex n 2 K) (suffixIndex n 2 Labels)
-            (suffixIndex n 2 C) (suffixIndex n 2 D) (suffixIndex n 2 rD)
-            (suffixIndex n 2 N) (prefixIndex n 2 1))) (extendMany 2 fields env) ↔
-        ZFSet.pair (fields 0) (fields 1) ∈ env S →
-          ∃ linked : GroundLinkedMainStage M (env K) (env Labels) (env C) (env D) (env rD),
-            linked.code = fields 1 := by
-    rw [realize_imp, BoundedFormula.realize_toFormula M _ _
-      (extendMany_members 2 fields env ground members), BoundedFormula.truth_pairMembershipFormula,
-      M.realize_linkedMainStageFormula pairing unions powers separation collection _ _ _ _ _ _ _ _
-        (extendMany_members 2 fields env ground members)
-        (by simpa only [extendMany_suffix] using omega)
-        (by simpa only [extendMany_suffix] using ordinal)]
-    simp only [extendMany_prefix, extendMany_suffix]
-    rfl
-  constructor
-  · intro recognized i a entry
-    have hg := M.transitive (members S) entry
-    let fields : Fin 2 → ZFSet.{u} := Fin.cases i (fun _ => a)
-    have ground : ∀ j, fields j ∈ M.sets := Fin.cases (M.pair_left hg) (fun _ => M.pair_right hg)
-    exact (actual fields ground).1 (recognized fields ground) entry
-  · intro law fields ground
-    exact (actual fields ground).2 (law (fields 0) (fields 1))
-
-theorem realize_mainPrefixTransitionsFormula {n} (K Labels C D rD N S E : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
-    (omega : env N = ZFSet.omega) (ordinal : ordinalSetProperty (env K)) :
-    Realize M.sets (mainPrefixTransitionsFormula K Labels C D rD N S E) env ↔
-      ∀ i j a b z, ZFSet.pair i a ∈ env S → ZFSet.pair j b ∈ env S →
-        ZFSet.pair (ZFSet.pair j i) z ∈ env E →
-        LinkedMainTransitionCode M (env K) (env Labels) (env C) (env D) (env rD) a b z := by
-  rw [mainPrefixTransitionsFormula, realize_allBlock]
-  have actual (fields : Fin 5 → ZFSet.{u}) (ground : ∀ j, fields j ∈ M.sets) :
-      Realize M.sets
-        (imp (BoundedFormula.conj
-          (BoundedFormula.pairMembershipFormula (prefixIndex n 5 0) (prefixIndex n 5 2) (suffixIndex n 5 S))
-          (.conj (BoundedFormula.pairMembershipFormula (prefixIndex n 5 1) (prefixIndex n 5 3) (suffixIndex n 5 S))
-            (BoundedFormula.tripleMembershipFormula (prefixIndex n 5 1) (prefixIndex n 5 0) (prefixIndex n 5 4)
-              (suffixIndex n 5 E)))).toFormula
-          (linkedMainTransitionFormula (suffixIndex n 5 K) (suffixIndex n 5 Labels) (suffixIndex n 5 C)
-            (suffixIndex n 5 D) (suffixIndex n 5 rD) (suffixIndex n 5 N)
-            (prefixIndex n 5 2) (prefixIndex n 5 3) (prefixIndex n 5 4))) (extendMany 5 fields env) ↔
-        (ZFSet.pair (fields 0) (fields 2) ∈ env S ∧ ZFSet.pair (fields 1) (fields 3) ∈ env S ∧
-          ZFSet.pair (ZFSet.pair (fields 1) (fields 0)) (fields 4) ∈ env E) →
-        LinkedMainTransitionCode M (env K) (env Labels) (env C) (env D) (env rD)
-          (fields 2) (fields 3) (fields 4) := by
-    rw [realize_imp, BoundedFormula.realize_toFormula M _ _
-      (extendMany_members 5 fields env ground members)]
-    simp only [BoundedFormula.Truth, BoundedFormula.truth_pairMembershipFormula,
-      BoundedFormula.truth_tripleMembershipFormula]
-    rw [M.realize_linkedMainTransitionFormula pairing unions powers separation collection _ _ _ _ _ _ _ _ _ _
-      (extendMany_members 5 fields env ground members)
-      (by simpa only [extendMany_suffix] using omega)
-      (by simpa only [extendMany_suffix] using ordinal)]
-    simp only [extendMany_prefix, extendMany_suffix]
-  constructor
-  · intro recognized i j a b z first second third
-    have h₁ := M.transitive (members S) first
-    have h₂ := M.transitive (members S) second
-    have h₃ := M.transitive (members E) third
-    let fields : Fin 5 → ZFSet.{u} := Fin.cases i (Fin.cases j (Fin.cases a (Fin.cases b (fun _ => z))))
-    have ground : ∀ k, fields k ∈ M.sets := Fin.cases (M.pair_left h₁)
-      (Fin.cases (M.pair_left h₂) (Fin.cases (M.pair_right h₁)
-        (Fin.cases (M.pair_right h₂) (fun _ => M.pair_right h₃))))
-    exact (actual fields ground).1 (recognized fields ground) ⟨first, second, third⟩
-  · intro law fields ground
-    exact (actual fields ground).2 (fun entries =>
-      law (fields 0) (fields 1) (fields 2) (fields 3) (fields 4) entries.1 entries.2.1 entries.2.2)
-
-end TransitiveGround
-end PartitionPilot.Forcing
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundLinkedMainStageLevels
+
+namespace OAI
+
+namespace PartitionPilot.Forcing
+open SetFormula
+universe u
+namespace BoundedFormula
+
+def pairedTransitionEntryFormula {n} (i j p a E : Fin n) : BoundedFormula n :=
+  exMem E (exMem 0 (exMem 0 (.conj
+    (orderedPairFormula 0 p.succ.succ.succ a.succ.succ.succ)
+    (orderedTripleFormula 2 j.succ.succ.succ i.succ.succ.succ 0))))
+
+theorem truth_pairedTransitionEntryFormula {n} (i j p a E : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (pairedTransitionEntryFormula i j p a E) env ↔
+      ZFSet.pair (ZFSet.pair (env j) (env i)) (ZFSet.pair (env p) (env a)) ∈ env E := by
+  simp only [pairedTransitionEntryFormula, truth_exMem, Truth,
+    truth_orderedPairFormula, truth_orderedTripleFormula]
+  change (∃ w ∈ env E, ∃ b ∈ w, ∃ c ∈ b, c = ZFSet.pair (env p) (env a) ∧
+    w = ZFSet.pair (ZFSet.pair (env j) (env i)) c) ↔ _
+  constructor
+  · rintro ⟨w, hw, b, _, c, _, rfl, rfl⟩
+    exact hw
+  · intro entry
+    refine ⟨_, entry, {ZFSet.pair (env j) (env i), ZFSet.pair (env p) (env a)},
+      ZFSet.mem_pair.2 (Or.inr rfl), _, ZFSet.mem_pair.2 (Or.inr rfl), rfl, rfl⟩
+
+end BoundedFormula
+
+namespace SetFormula
+
+def mainPrefixIdentityFormula {n} (E : Fin n) : SetFormula n :=
+  let v := prefixIndex n 3
+  allBlock 3 (BoundedFormula.imp
+    (BoundedFormula.pairedTransitionEntryFormula (v 0) (v 0) (v 1) (v 2) (suffixIndex n 3 E))
+    (.conj (BoundedFormula.graphDiagonalFormula (v 1))
+      (BoundedFormula.graphDiagonalFormula (v 2)))).toFormula
+
+def mainPrefixCompositionFormula {n} (E : Fin n) : SetFormula n :=
+  let v := prefixIndex n 9
+  let old := suffixIndex n 9 E
+  allBlock 9 (BoundedFormula.imp
+    (BoundedFormula.pairedTransitionEntryFormula (v 0) (v 1) (v 3) (v 4) old)
+    (BoundedFormula.imp
+      (BoundedFormula.pairedTransitionEntryFormula (v 1) (v 2) (v 5) (v 6) old)
+      (BoundedFormula.imp
+        (BoundedFormula.pairedTransitionEntryFormula (v 0) (v 2) (v 7) (v 8) old)
+        (.conj (BoundedFormula.graphCompositionFormula (v 3) (v 5) (v 7))
+          (BoundedFormula.graphCompositionFormula (v 4) (v 6) (v 8)))))).toFormula
+
+end SetFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+
+theorem realize_mainPrefixIdentityFormula {n} (E : Fin n) (env : Fin n → ZFSet.{u})
+    (members : ∀ j, env j ∈ M.sets) :
+    Realize M.sets (mainPrefixIdentityFormula E) env ↔
+      ∀ i p a, ZFSet.pair (ZFSet.pair i i) (ZFSet.pair p a) ∈ env E →
+        GraphDiagonalCode p ∧ GraphDiagonalCode a := by
+  rw [mainPrefixIdentityFormula, realize_allBlock]
+  have actual (fields : Fin 3 → ZFSet.{u}) (ground : ∀ j, fields j ∈ M.sets) :=
+    BoundedFormula.realize_toFormula M
+      (BoundedFormula.imp
+        (BoundedFormula.pairedTransitionEntryFormula (prefixIndex n 3 0) (prefixIndex n 3 0)
+          (prefixIndex n 3 1) (prefixIndex n 3 2) (suffixIndex n 3 E))
+        (.conj (BoundedFormula.graphDiagonalFormula (prefixIndex n 3 1))
+          (BoundedFormula.graphDiagonalFormula (prefixIndex n 3 2))))
+      (extendMany 3 fields env) (extendMany_members 3 fields env ground members)
+  simp only [BoundedFormula.truth_imp, BoundedFormula.Truth,
+    BoundedFormula.truth_pairedTransitionEntryFormula, BoundedFormula.truth_graphDiagonalFormula,
+    extendMany_prefix, extendMany_suffix] at actual
+  constructor
+  · intro recognized i p a entry
+    have hg := M.transitive (members E) entry
+    let fields : Fin 3 → ZFSet.{u} := Fin.cases i (Fin.cases p (fun _ => a))
+    have ground : ∀ j, fields j ∈ M.sets := Fin.cases (M.pair_left (M.pair_left hg))
+      (Fin.cases (M.pair_left (M.pair_right hg)) (fun _ => M.pair_right (M.pair_right hg)))
+    exact (actual fields ground).1 (recognized fields ground) entry
+  · intro law fields ground
+    exact (actual fields ground).2 (law (fields 0) (fields 1) (fields 2))
+
+theorem realize_mainPrefixCompositionFormula {n} (E : Fin n) (env : Fin n → ZFSet.{u})
+    (members : ∀ j, env j ∈ M.sets) :
+    Realize M.sets (mainPrefixCompositionFormula E) env ↔
+      ∀ i j k p₁ a₁ p₂ a₂ p₃ a₃,
+        ZFSet.pair (ZFSet.pair j i) (ZFSet.pair p₁ a₁) ∈ env E →
+        ZFSet.pair (ZFSet.pair k j) (ZFSet.pair p₂ a₂) ∈ env E →
+        ZFSet.pair (ZFSet.pair k i) (ZFSet.pair p₃ a₃) ∈ env E →
+        GraphCompositionCode p₁ p₂ p₃ ∧ GraphCompositionCode a₁ a₂ a₃ := by
+  rw [mainPrefixCompositionFormula, realize_allBlock]
+  have actual (fields : Fin 9 → ZFSet.{u}) (ground : ∀ j, fields j ∈ M.sets) :=
+    BoundedFormula.realize_toFormula M
+      (BoundedFormula.imp
+        (BoundedFormula.pairedTransitionEntryFormula (prefixIndex n 9 0) (prefixIndex n 9 1)
+          (prefixIndex n 9 3) (prefixIndex n 9 4) (suffixIndex n 9 E))
+        (BoundedFormula.imp
+          (BoundedFormula.pairedTransitionEntryFormula (prefixIndex n 9 1) (prefixIndex n 9 2)
+            (prefixIndex n 9 5) (prefixIndex n 9 6) (suffixIndex n 9 E))
+          (BoundedFormula.imp
+            (BoundedFormula.pairedTransitionEntryFormula (prefixIndex n 9 0) (prefixIndex n 9 2)
+              (prefixIndex n 9 7) (prefixIndex n 9 8) (suffixIndex n 9 E))
+            (.conj (BoundedFormula.graphCompositionFormula (prefixIndex n 9 3) (prefixIndex n 9 5) (prefixIndex n 9 7))
+              (BoundedFormula.graphCompositionFormula (prefixIndex n 9 4) (prefixIndex n 9 6) (prefixIndex n 9 8))))))
+      (extendMany 9 fields env) (extendMany_members 9 fields env ground members)
+  simp only [BoundedFormula.truth_imp, BoundedFormula.Truth,
+    BoundedFormula.truth_pairedTransitionEntryFormula, BoundedFormula.truth_graphCompositionFormula,
+    extendMany_prefix, extendMany_suffix] at actual
+  constructor
+  · intro recognized i j k p₁ a₁ p₂ a₂ p₃ a₃ first second third
+    have h₁ := M.transitive (members E) first
+    have h₂ := M.transitive (members E) second
+    have h₃ := M.transitive (members E) third
+    let fields : Fin 9 → ZFSet.{u} := Fin.cases i (Fin.cases j (Fin.cases k (Fin.cases p₁
+      (Fin.cases a₁ (Fin.cases p₂ (Fin.cases a₂ (Fin.cases p₃ (fun _ => a₃))))))))
+    have ground : ∀ a, fields a ∈ M.sets := Fin.cases (M.pair_right (M.pair_left h₁))
+      (Fin.cases (M.pair_left (M.pair_left h₁)) (Fin.cases (M.pair_left (M.pair_left h₂))
+      (Fin.cases (M.pair_left (M.pair_right h₁)) (Fin.cases (M.pair_right (M.pair_right h₁))
+      (Fin.cases (M.pair_left (M.pair_right h₂)) (Fin.cases (M.pair_right (M.pair_right h₂))
+      (Fin.cases (M.pair_left (M.pair_right h₃)) (fun _ => M.pair_right (M.pair_right h₃)))))))))
+    exact (actual fields ground).1 (recognized fields ground) first second third
+  · intro law fields ground
+    exact (actual fields ground).2 (law (fields 0) (fields 1) (fields 2) (fields 3)
+      (fields 4) (fields 5) (fields 6) (fields 7) (fields 8))
+
+end TransitiveGround
+
+namespace SetFormula
+
+def mainPrefixStagesFormula {n} (K Labels C D rD N S : Fin n) : SetFormula n :=
+  let old := suffixIndex n 2
+  let v := prefixIndex n 2
+  allBlock 2 (imp (BoundedFormula.pairMembershipFormula (v 0) (v 1) (old S)).toFormula
+    (linkedMainStageFormula (old K) (old Labels) (old C) (old D) (old rD) (old N) (v 1)))
+
+def mainPrefixTransitionsFormula {n} (K Labels C D rD N S E : Fin n) : SetFormula n :=
+  let old := suffixIndex n 5
+  let v := prefixIndex n 5
+  allBlock 5 (imp (BoundedFormula.conj
+    (BoundedFormula.pairMembershipFormula (v 0) (v 2) (old S))
+    (.conj (BoundedFormula.pairMembershipFormula (v 1) (v 3) (old S))
+      (BoundedFormula.tripleMembershipFormula (v 1) (v 0) (v 4) (old E)))).toFormula
+    (linkedMainTransitionFormula (old K) (old Labels) (old C) (old D) (old rD) (old N)
+      (v 2) (v 3) (v 4)))
+
+end SetFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+variable (unions : Realize M.sets SetFormula.union Fin.elim0)
+variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+variable (collection : CollectionSchema M.sets)
+include pairing unions powers separation collection
+
+theorem realize_mainPrefixStagesFormula {n} (K Labels C D rD N S : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
+    (omega : env N = ZFSet.omega) (ordinal : ordinalSetProperty (env K)) :
+    Realize M.sets (mainPrefixStagesFormula K Labels C D rD N S) env ↔
+      ∀ i a, ZFSet.pair i a ∈ env S →
+        ∃ linked : GroundLinkedMainStage M (env K) (env Labels) (env C) (env D) (env rD),
+          linked.code = a := by
+  rw [mainPrefixStagesFormula, realize_allBlock]
+  have actual (fields : Fin 2 → ZFSet.{u}) (ground : ∀ j, fields j ∈ M.sets) :
+      Realize M.sets
+        (imp (BoundedFormula.pairMembershipFormula (prefixIndex n 2 0) (prefixIndex n 2 1)
+          (suffixIndex n 2 S)).toFormula
+          (linkedMainStageFormula (suffixIndex n 2 K) (suffixIndex n 2 Labels)
+            (suffixIndex n 2 C) (suffixIndex n 2 D) (suffixIndex n 2 rD)
+            (suffixIndex n 2 N) (prefixIndex n 2 1))) (extendMany 2 fields env) ↔
+        ZFSet.pair (fields 0) (fields 1) ∈ env S →
+          ∃ linked : GroundLinkedMainStage M (env K) (env Labels) (env C) (env D) (env rD),
+            linked.code = fields 1 := by
+    rw [realize_imp, BoundedFormula.realize_toFormula M _ _
+      (extendMany_members 2 fields env ground members), BoundedFormula.truth_pairMembershipFormula,
+      M.realize_linkedMainStageFormula pairing unions powers separation collection _ _ _ _ _ _ _ _
+        (extendMany_members 2 fields env ground members)
+        (by simpa only [extendMany_suffix] using omega)
+        (by simpa only [extendMany_suffix] using ordinal)]
+    simp only [extendMany_prefix, extendMany_suffix]
+    rfl
+  constructor
+  · intro recognized i a entry
+    have hg := M.transitive (members S) entry
+    let fields : Fin 2 → ZFSet.{u} := Fin.cases i (fun _ => a)
+    have ground : ∀ j, fields j ∈ M.sets := Fin.cases (M.pair_left hg) (fun _ => M.pair_right hg)
+    exact (actual fields ground).1 (recognized fields ground) entry
+  · intro law fields ground
+    exact (actual fields ground).2 (law (fields 0) (fields 1))
+
+theorem realize_mainPrefixTransitionsFormula {n} (K Labels C D rD N S E : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
+    (omega : env N = ZFSet.omega) (ordinal : ordinalSetProperty (env K)) :
+    Realize M.sets (mainPrefixTransitionsFormula K Labels C D rD N S E) env ↔
+      ∀ i j a b z, ZFSet.pair i a ∈ env S → ZFSet.pair j b ∈ env S →
+        ZFSet.pair (ZFSet.pair j i) z ∈ env E →
+        LinkedMainTransitionCode M (env K) (env Labels) (env C) (env D) (env rD) a b z := by
+  rw [mainPrefixTransitionsFormula, realize_allBlock]
+  have actual (fields : Fin 5 → ZFSet.{u}) (ground : ∀ j, fields j ∈ M.sets) :
+      Realize M.sets
+        (imp (BoundedFormula.conj
+          (BoundedFormula.pairMembershipFormula (prefixIndex n 5 0) (prefixIndex n 5 2) (suffixIndex n 5 S))
+          (.conj (BoundedFormula.pairMembershipFormula (prefixIndex n 5 1) (prefixIndex n 5 3) (suffixIndex n 5 S))
+            (BoundedFormula.tripleMembershipFormula (prefixIndex n 5 1) (prefixIndex n 5 0) (prefixIndex n 5 4)
+              (suffixIndex n 5 E)))).toFormula
+          (linkedMainTransitionFormula (suffixIndex n 5 K) (suffixIndex n 5 Labels) (suffixIndex n 5 C)
+            (suffixIndex n 5 D) (suffixIndex n 5 rD) (suffixIndex n 5 N)
+            (prefixIndex n 5 2) (prefixIndex n 5 3) (prefixIndex n 5 4))) (extendMany 5 fields env) ↔
+        (ZFSet.pair (fields 0) (fields 2) ∈ env S ∧ ZFSet.pair (fields 1) (fields 3) ∈ env S ∧
+          ZFSet.pair (ZFSet.pair (fields 1) (fields 0)) (fields 4) ∈ env E) →
+        LinkedMainTransitionCode M (env K) (env Labels) (env C) (env D) (env rD)
+          (fields 2) (fields 3) (fields 4) := by
+    rw [realize_imp, BoundedFormula.realize_toFormula M _ _
+      (extendMany_members 5 fields env ground members)]
+    simp only [BoundedFormula.Truth, BoundedFormula.truth_pairMembershipFormula,
+      BoundedFormula.truth_tripleMembershipFormula]
+    rw [M.realize_linkedMainTransitionFormula pairing unions powers separation collection _ _ _ _ _ _ _ _ _ _
+      (extendMany_members 5 fields env ground members)
+      (by simpa only [extendMany_suffix] using omega)
+      (by simpa only [extendMany_suffix] using ordinal)]
+    simp only [extendMany_prefix, extendMany_suffix]
+  constructor
+  · intro recognized i j a b z first second third
+    have h₁ := M.transitive (members S) first
+    have h₂ := M.transitive (members S) second
+    have h₃ := M.transitive (members E) third
+    let fields : Fin 5 → ZFSet.{u} := Fin.cases i (Fin.cases j (Fin.cases a (Fin.cases b (fun _ => z))))
+    have ground : ∀ k, fields k ∈ M.sets := Fin.cases (M.pair_left h₁)
+      (Fin.cases (M.pair_left h₂) (Fin.cases (M.pair_right h₁)
+        (Fin.cases (M.pair_right h₂) (fun _ => M.pair_right h₃))))
+    exact (actual fields ground).1 (recognized fields ground) ⟨first, second, third⟩
+  · intro law fields ground
+    exact (actual fields ground).2 (fun entries =>
+      law (fields 0) (fields 1) (fields 2) (fields 3) (fields 4) entries.1 entries.2.1 entries.2.2)
+
+end TransitiveGround
+end PartitionPilot.Forcing
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/MainTransitionValidityCodes.lean

@@ -1,131 +1,131 @@
-import OAI.SetTheory.PartitionPrinciple.Geometry.GroundMainTransitionLaws
-import OAI.SetTheory.PartitionPrinciple.Geometry.RectangleFulfillmentAtBound
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing
-open SetFormula
-universe u
-
-structure MainTransitionLaws
-    (P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors : ZFSet.{u}) : Prop where
-  point_embedding : MeetEmbeddingCode P Q rP rQ μP μQ points
-  order_iff : ∀ x y x' y', ZFSet.pair x x' ∈ points → ZFSet.pair y y' ∈ points →
-    (ZFSet.pair x' y' ∈ rQ ↔ ZFSet.pair x y ∈ rP)
-  group_embedding : GroupEmbeddingCode G H mG mH oneG oneH actors
-  equivariant : ∀ g g' x y x' y', ZFSet.pair g g' ∈ actors →
-    ZFSet.pair x x' ∈ points → ZFSet.pair y y' ∈ points →
-    ZFSet.pair (ZFSet.pair g x) y ∈ AP → ZFSet.pair (ZFSet.pair g' x') y' ∈ AQ
-  bottom : ZFSet.pair bP bQ ∈ points
-  height : ∀ x y z, ZFSet.pair x y ∈ points →
-    (ZFSet.pair y z ∈ heightQ ↔ ZFSet.pair x z ∈ heightP)
-  agreement : ∀ g h g' h' v v', ZFSet.pair g g' ∈ actors → ZFSet.pair h h' ∈ actors →
-    ZFSet.pair v v' ∈ points → ActionAgreementBelow P rP AP g h v →
-      ActionAgreementBelow Q rQ AQ g' h' v'
-
-namespace BoundedFormula
-
-def transitionOrderFormula {n} (P Q rP rQ points : Fin n) : BoundedFormula n :=
-  let lift (i : Fin n) := i.succ.succ.succ.succ
-  .allMem P (.allMem P.succ (.allMem Q.succ.succ (.allMem Q.succ.succ.succ
-    (imp (.conj (pairMembershipFormula 3 1 (lift points)) (pairMembershipFormula 2 0 (lift points)))
-      (.conj (imp (pairMembershipFormula 1 0 (lift rQ)) (pairMembershipFormula 3 2 (lift rP)))
-        (imp (pairMembershipFormula 3 2 (lift rP)) (pairMembershipFormula 1 0 (lift rQ))))))))
-
-def transitionEquivarianceFormula {n} (P Q G H AP AQ points actors : Fin n) : BoundedFormula n :=
-  let lift (i : Fin n) := i.succ.succ.succ.succ.succ.succ
-  .allMem G (.allMem H.succ (.allMem P.succ.succ (.allMem P.succ.succ.succ
-    (.allMem Q.succ.succ.succ.succ (.allMem Q.succ.succ.succ.succ.succ
-      (imp (.conj (pairMembershipFormula 5 4 (lift actors))
-        (.conj (pairMembershipFormula 3 1 (lift points))
-          (.conj (pairMembershipFormula 2 0 (lift points))
-            (tripleMembershipFormula 5 3 2 (lift AP)))))
-        (tripleMembershipFormula 4 1 0 (lift AQ))))))))
-
-def transitionHeightFormula {n} (P Q heightP heightQ points : Fin n) : BoundedFormula n :=
-  .allMem P (.allMem Q.succ (imp (pairMembershipFormula 1 0 points.succ.succ)
-    (graphFiberEqualityFormula 0 1 heightQ.succ.succ heightP.succ.succ)))
-
-def transitionAgreementFormula {n} (P Q rP rQ G H AP AQ points actors : Fin n) : BoundedFormula n :=
-  let lift (i : Fin n) := i.succ.succ.succ.succ.succ.succ
-  .allMem G (.allMem G.succ (.allMem H.succ.succ (.allMem H.succ.succ.succ
-    (.allMem P.succ.succ.succ.succ (.allMem Q.succ.succ.succ.succ.succ
-      (imp (.conj (pairMembershipFormula 5 3 (lift actors))
-        (.conj (pairMembershipFormula 4 2 (lift actors))
-          (.conj (pairMembershipFormula 1 0 (lift points))
-            (actionAgreementBelowFormula (lift P) (lift rP) (lift AP) 5 4 1))))
-        (actionAgreementBelowFormula (lift Q) (lift rQ) (lift AQ) 3 2 0)))))))
-
-def mainTransitionLawsFormula {n}
-    (P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors : Fin n) :
-    BoundedFormula n :=
-  .conj (meetEmbeddingFormula P Q rP rQ μP μQ points)
-    (.conj (transitionOrderFormula P Q rP rQ points)
-      (.conj (groupEmbeddingFormula G H mG mH oneG oneH actors)
-        (.conj (transitionEquivarianceFormula P Q G H AP AQ points actors)
-          (.conj (pairMembershipFormula bP bQ points)
-            (.conj (transitionHeightFormula P Q heightP heightQ points)
-              (transitionAgreementFormula P Q rP rQ G H AP AQ points actors))))))
-
-theorem truth_mainTransitionLawsFormula {n}
-    (P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (mainTransitionLawsFormula P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ
-      heightP heightQ points actors) env ↔
-    MainTransitionLaws (env P) (env Q) (env rP) (env rQ) (env μP) (env μQ) (env G) (env H)
-      (env mG) (env mH) (env oneG) (env oneH) (env AP) (env AQ) (env bP) (env bQ)
-      (env heightP) (env heightQ) (env points) (env actors) := by
-  simp only [mainTransitionLawsFormula, transitionOrderFormula, transitionEquivarianceFormula,
-    transitionHeightFormula, transitionAgreementFormula, Truth, truth_meetEmbeddingFormula,
-    truth_groupEmbeddingFormula, truth_imp, truth_pairMembershipFormula,
-    truth_tripleMembershipFormula, truth_graphFiberEqualityFormula, truth_actionAgreementBelowFormula]
-  constructor
-  · rintro ⟨point, order, group, equivariant, bottom, height, agreement⟩
-    have pb {x y : ZFSet.{u}} (entry : ZFSet.pair x y ∈ env points) : x ∈ env P ∧ y ∈ env Q :=
-      ZFSet.pair_mem_prod.1 (point.injection.function.1 entry)
-    have ab {x y : ZFSet.{u}} (entry : ZFSet.pair x y ∈ env actors) : x ∈ env G ∧ y ∈ env H :=
-      ZFSet.pair_mem_prod.1 (group.injection.function.1 entry)
-    refine ⟨point, ?_, group, ?_, bottom, ?_, ?_⟩
-    · intro x y x' y' xx yy
-      have h := order x (pb xx).1 y (pb yy).1 x' (pb xx).2 y' (pb yy).2 ⟨xx, yy⟩
-      exact ⟨h.1, h.2⟩
-    · intro g g' x y x' y' gg xx yy act
-      exact equivariant g (ab gg).1 g' (ab gg).2 x (pb xx).1 y (pb yy).1
-        x' (pb xx).2 y' (pb yy).2 ⟨gg, xx, yy, act⟩
-    · intro x y z entry
-      exact height x (pb entry).1 y (pb entry).2 entry z
-    · intro g h g' h' v v' gg hh vv agree
-      exact agreement g (ab gg).1 h (ab hh).1 g' (ab gg).2 h' (ab hh).2
-        v (pb vv).1 v' (pb vv).2 ⟨gg, hh, vv, agree⟩
-  · intro code
-    refine ⟨code.point_embedding, ?_, code.group_embedding, ?_, code.bottom, ?_, ?_⟩
-    · intro x _ y _ x' _ y' _ h
-      exact ⟨(code.order_iff x y x' y' h.1 h.2).1, (code.order_iff x y x' y' h.1 h.2).2⟩
-    · intro g _ g' _ x _ y _ x' _ y' _ h
-      exact code.equivariant g g' x y x' y' h.1 h.2.1 h.2.2.1 h.2.2.2
-    · intro x _ y _ entry z
-      exact code.height x y z entry
-    · intro g _ h _ g' _ h' _ v _ v' _ entries
-      exact code.agreement g h g' h' v v' entries.1 entries.2.1 entries.2.2.1 entries.2.2.2
-
-theorem realize_mainTransitionLawsFormula (M : TransitiveGround.{u}) {n}
-    (P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets) :
-    Realize M.sets (mainTransitionLawsFormula P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ
-      heightP heightQ points actors).toFormula env ↔
-    MainTransitionLaws (env P) (env Q) (env rP) (env rQ) (env μP) (env μQ) (env G) (env H)
-      (env mG) (env mH) (env oneG) (env oneH) (env AP) (env AQ) (env bP) (env bQ)
-      (env heightP) (env heightQ) (env points) (env actors) :=
-  (realize_toFormula M _ env members).trans
-    (truth_mainTransitionLawsFormula P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ
-      heightP heightQ points actors env)
-
-end BoundedFormula
-
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Geometry.GroundMainTransitionLaws
+import OAI.SetTheory.PartitionPrinciple.Geometry.RectangleFulfillmentAtBound
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing
+open SetFormula
+universe u
+
+structure MainTransitionLaws
+    (P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors : ZFSet.{u}) : Prop where
+  point_embedding : MeetEmbeddingCode P Q rP rQ μP μQ points
+  order_iff : ∀ x y x' y', ZFSet.pair x x' ∈ points → ZFSet.pair y y' ∈ points →
+    (ZFSet.pair x' y' ∈ rQ ↔ ZFSet.pair x y ∈ rP)
+  group_embedding : GroupEmbeddingCode G H mG mH oneG oneH actors
+  equivariant : ∀ g g' x y x' y', ZFSet.pair g g' ∈ actors →
+    ZFSet.pair x x' ∈ points → ZFSet.pair y y' ∈ points →
+    ZFSet.pair (ZFSet.pair g x) y ∈ AP → ZFSet.pair (ZFSet.pair g' x') y' ∈ AQ
+  bottom : ZFSet.pair bP bQ ∈ points
+  height : ∀ x y z, ZFSet.pair x y ∈ points →
+    (ZFSet.pair y z ∈ heightQ ↔ ZFSet.pair x z ∈ heightP)
+  agreement : ∀ g h g' h' v v', ZFSet.pair g g' ∈ actors → ZFSet.pair h h' ∈ actors →
+    ZFSet.pair v v' ∈ points → ActionAgreementBelow P rP AP g h v →
+      ActionAgreementBelow Q rQ AQ g' h' v'
+
+namespace BoundedFormula
+
+def transitionOrderFormula {n} (P Q rP rQ points : Fin n) : BoundedFormula n :=
+  let lift (i : Fin n) := i.succ.succ.succ.succ
+  .allMem P (.allMem P.succ (.allMem Q.succ.succ (.allMem Q.succ.succ.succ
+    (imp (.conj (pairMembershipFormula 3 1 (lift points)) (pairMembershipFormula 2 0 (lift points)))
+      (.conj (imp (pairMembershipFormula 1 0 (lift rQ)) (pairMembershipFormula 3 2 (lift rP)))
+        (imp (pairMembershipFormula 3 2 (lift rP)) (pairMembershipFormula 1 0 (lift rQ))))))))
+
+def transitionEquivarianceFormula {n} (P Q G H AP AQ points actors : Fin n) : BoundedFormula n :=
+  let lift (i : Fin n) := i.succ.succ.succ.succ.succ.succ
+  .allMem G (.allMem H.succ (.allMem P.succ.succ (.allMem P.succ.succ.succ
+    (.allMem Q.succ.succ.succ.succ (.allMem Q.succ.succ.succ.succ.succ
+      (imp (.conj (pairMembershipFormula 5 4 (lift actors))
+        (.conj (pairMembershipFormula 3 1 (lift points))
+          (.conj (pairMembershipFormula 2 0 (lift points))
+            (tripleMembershipFormula 5 3 2 (lift AP)))))
+        (tripleMembershipFormula 4 1 0 (lift AQ))))))))
+
+def transitionHeightFormula {n} (P Q heightP heightQ points : Fin n) : BoundedFormula n :=
+  .allMem P (.allMem Q.succ (imp (pairMembershipFormula 1 0 points.succ.succ)
+    (graphFiberEqualityFormula 0 1 heightQ.succ.succ heightP.succ.succ)))
+
+def transitionAgreementFormula {n} (P Q rP rQ G H AP AQ points actors : Fin n) : BoundedFormula n :=
+  let lift (i : Fin n) := i.succ.succ.succ.succ.succ.succ
+  .allMem G (.allMem G.succ (.allMem H.succ.succ (.allMem H.succ.succ.succ
+    (.allMem P.succ.succ.succ.succ (.allMem Q.succ.succ.succ.succ.succ
+      (imp (.conj (pairMembershipFormula 5 3 (lift actors))
+        (.conj (pairMembershipFormula 4 2 (lift actors))
+          (.conj (pairMembershipFormula 1 0 (lift points))
+            (actionAgreementBelowFormula (lift P) (lift rP) (lift AP) 5 4 1))))
+        (actionAgreementBelowFormula (lift Q) (lift rQ) (lift AQ) 3 2 0)))))))
+
+def mainTransitionLawsFormula {n}
+    (P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors : Fin n) :
+    BoundedFormula n :=
+  .conj (meetEmbeddingFormula P Q rP rQ μP μQ points)
+    (.conj (transitionOrderFormula P Q rP rQ points)
+      (.conj (groupEmbeddingFormula G H mG mH oneG oneH actors)
+        (.conj (transitionEquivarianceFormula P Q G H AP AQ points actors)
+          (.conj (pairMembershipFormula bP bQ points)
+            (.conj (transitionHeightFormula P Q heightP heightQ points)
+              (transitionAgreementFormula P Q rP rQ G H AP AQ points actors))))))
+
+theorem truth_mainTransitionLawsFormula {n}
+    (P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (mainTransitionLawsFormula P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ
+      heightP heightQ points actors) env ↔
+    MainTransitionLaws (env P) (env Q) (env rP) (env rQ) (env μP) (env μQ) (env G) (env H)
+      (env mG) (env mH) (env oneG) (env oneH) (env AP) (env AQ) (env bP) (env bQ)
+      (env heightP) (env heightQ) (env points) (env actors) := by
+  simp only [mainTransitionLawsFormula, transitionOrderFormula, transitionEquivarianceFormula,
+    transitionHeightFormula, transitionAgreementFormula, Truth, truth_meetEmbeddingFormula,
+    truth_groupEmbeddingFormula, truth_imp, truth_pairMembershipFormula,
+    truth_tripleMembershipFormula, truth_graphFiberEqualityFormula, truth_actionAgreementBelowFormula]
+  constructor
+  · rintro ⟨point, order, group, equivariant, bottom, height, agreement⟩
+    have pb {x y : ZFSet.{u}} (entry : ZFSet.pair x y ∈ env points) : x ∈ env P ∧ y ∈ env Q :=
+      ZFSet.pair_mem_prod.1 (point.injection.function.1 entry)
+    have ab {x y : ZFSet.{u}} (entry : ZFSet.pair x y ∈ env actors) : x ∈ env G ∧ y ∈ env H :=
+      ZFSet.pair_mem_prod.1 (group.injection.function.1 entry)
+    refine ⟨point, ?_, group, ?_, bottom, ?_, ?_⟩
+    · intro x y x' y' xx yy
+      have h := order x (pb xx).1 y (pb yy).1 x' (pb xx).2 y' (pb yy).2 ⟨xx, yy⟩
+      exact ⟨h.1, h.2⟩
+    · intro g g' x y x' y' gg xx yy act
+      exact equivariant g (ab gg).1 g' (ab gg).2 x (pb xx).1 y (pb yy).1
+        x' (pb xx).2 y' (pb yy).2 ⟨gg, xx, yy, act⟩
+    · intro x y z entry
+      exact height x (pb entry).1 y (pb entry).2 entry z
+    · intro g h g' h' v v' gg hh vv agree
+      exact agreement g (ab gg).1 h (ab hh).1 g' (ab gg).2 h' (ab hh).2
+        v (pb vv).1 v' (pb vv).2 ⟨gg, hh, vv, agree⟩
+  · intro code
+    refine ⟨code.point_embedding, ?_, code.group_embedding, ?_, code.bottom, ?_, ?_⟩
+    · intro x _ y _ x' _ y' _ h
+      exact ⟨(code.order_iff x y x' y' h.1 h.2).1, (code.order_iff x y x' y' h.1 h.2).2⟩
+    · intro g _ g' _ x _ y _ x' _ y' _ h
+      exact code.equivariant g g' x y x' y' h.1 h.2.1 h.2.2.1 h.2.2.2
+    · intro x _ y _ entry z
+      exact code.height x y z entry
+    · intro g _ h _ g' _ h' _ v _ v' _ entries
+      exact code.agreement g h g' h' v v' entries.1 entries.2.1 entries.2.2.1 entries.2.2.2
+
+theorem realize_mainTransitionLawsFormula (M : TransitiveGround.{u}) {n}
+    (P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ heightP heightQ points actors : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets) :
+    Realize M.sets (mainTransitionLawsFormula P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ
+      heightP heightQ points actors).toFormula env ↔
+    MainTransitionLaws (env P) (env Q) (env rP) (env rQ) (env μP) (env μQ) (env G) (env H)
+      (env mG) (env mH) (env oneG) (env oneH) (env AP) (env AQ) (env bP) (env bQ)
+      (env heightP) (env heightQ) (env points) (env actors) :=
+  (realize_toFormula M _ env members).trans
+    (truth_mainTransitionLawsFormula P Q rP rQ μP μQ G H mG mH oneG oneH AP AQ bP bQ
+      heightP heightQ points actors env)
+
+end BoundedFormula
+
+end PartitionPilot.Forcing
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/MapFamilyApplicationGraphs.lean

@@ -1,373 +1,373 @@
-import OAI.SetTheory.PartitionPrinciple.Definability.GroundFlatCopyGraphs
-
-namespace OAI
-
-
-namespace PartitionPilot.Forcing
-
-section
-
-universe u
-
-noncomputable def indexedRelationSection (B C R i : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => ∃ q ∈ B, ∃ y ∈ C,
-    z = ZFSet.pair q y ∧ ZFSet.pair (ZFSet.pair i q) y ∈ R) (ZFSet.prod B C)
-
-theorem indexedRelationSection_subset (B C R i : ZFSet.{u}) :
-    indexedRelationSection B C R i ⊆ ZFSet.prod B C :=
-  fun _ hz => (ZFSet.mem_sep.1 hz).1
-
-theorem mem_indexedRelationSection (B C R i z : ZFSet.{u}) :
-    z ∈ indexedRelationSection B C R i ↔ ∃ q ∈ B, ∃ y ∈ C,
-      z = ZFSet.pair q y ∧ ZFSet.pair (ZFSet.pair i q) y ∈ R := by
-  constructor
-  · intro hz
-    exact (ZFSet.mem_sep.1 hz).2
-  · rintro ⟨q, hq, y, hy, rfl, entry⟩
-    exact ZFSet.mem_sep.2 ⟨ZFSet.pair_mem_prod.2 ⟨hq, hy⟩, q, hq, y, hy, rfl, entry⟩
-
-theorem pair_mem_indexedRelationSection (B C R i q y : ZFSet.{u}) :
-    ZFSet.pair q y ∈ indexedRelationSection B C R i ↔
-      q ∈ B ∧ y ∈ C ∧ ZFSet.pair (ZFSet.pair i q) y ∈ R := by
-  rw [mem_indexedRelationSection]
-  constructor
-  · rintro ⟨q', hq, y', hy, equal, entry⟩
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
-    exact ⟨hq, hy, entry⟩
-  · rintro ⟨hq, hy, entry⟩
-    exact ⟨q, hq, y, hy, rfl, entry⟩
-
-
-
-
-
-
-namespace BoundedFormula
-
-open SetFormula
-
-def indexedRelationSectionEntryFormula {n} (z i b c r : Fin n) : BoundedFormula n :=
-  exMem b (exMem c.succ (.conj (orderedPairFormula z.succ.succ 1 0)
-    (tripleMembershipFormula i.succ.succ 1 0 r.succ.succ)))
-
-theorem truth_indexedRelationSectionEntryFormula {n} (z i b c r : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (indexedRelationSectionEntryFormula z i b c r) env ↔
-      env z ∈ indexedRelationSection (env b) (env c) (env r) (env i) := by
-  simp only [indexedRelationSectionEntryFormula, truth_exMem, Truth,
-    truth_orderedPairFormula, truth_tripleMembershipFormula, mem_indexedRelationSection]
-  rfl
-
-def indexedRelationSectionFormula {n} (f i b c r : Fin n) : BoundedFormula n :=
-  .conj (.allMem f (indexedRelationSectionEntryFormula 0 i.succ b.succ c.succ r.succ))
-    (.allMem b (.allMem c.succ
-      (imp (tripleMembershipFormula i.succ.succ 1 0 r.succ.succ)
-        (pairMembershipFormula 1 0 f.succ.succ))))
-
-theorem truth_indexedRelationSectionFormula {n} (f i b c r : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (indexedRelationSectionFormula f i b c r) env ↔
-      env f = indexedRelationSection (env b) (env c) (env r) (env i) := by
-  simp only [indexedRelationSectionFormula, Truth, truth_indexedRelationSectionEntryFormula,
-    truth_imp, truth_tripleMembershipFormula, truth_pairMembershipFormula]
-  constructor
-  · rintro ⟨subset, complete⟩
-    apply ZFSet.ext
-    intro z
-    refine ⟨subset z, ?_⟩
-    intro hz
-    obtain ⟨q, hq, y, hy, rfl, entry⟩ := (mem_indexedRelationSection _ _ _ _ z).1 hz
-    exact complete q hq y hy entry
-  · intro equal
-    refine ⟨fun _ hz => equal ▸ hz, ?_⟩
-    intro q hq y hy entry
-    change ZFSet.pair q y ∈ env f
-    rw [equal]
-    exact (pair_mem_indexedRelationSection _ _ _ _ q y).2 ⟨hq, hy, entry⟩
-
-def indexedRelationFamilyEntryFormula {n} (z domain bound b c r : Fin n) : BoundedFormula n :=
-  exMem domain (exMem bound.succ (.conj (orderedPairFormula z.succ.succ 1 0)
-    (indexedRelationSectionFormula 0 1 b.succ.succ c.succ.succ r.succ.succ)))
-
-theorem truth_indexedRelationFamilyEntryFormula {n} (z domain bound b c r : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (indexedRelationFamilyEntryFormula z domain bound b c r) env ↔
-      ∃ i ∈ env domain, ∃ f ∈ env bound, env z = ZFSet.pair i f ∧
-        f = indexedRelationSection (env b) (env c) (env r) i := by
-  simp only [indexedRelationFamilyEntryFormula, truth_exMem, Truth,
-    truth_orderedPairFormula, truth_indexedRelationSectionFormula]
-  rfl
-
-end BoundedFormula
-
-namespace TransitiveGround
-
-open SetFormula
-variable (M : TransitiveGround.{u})
-
-theorem indexedRelationSection_mem
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    {B C R i : ZFSet.{u}} (hB : B ∈ M.sets) (hC : C ∈ M.sets)
-    (hR : R ∈ M.sets) (hi : i ∈ M.sets) : indexedRelationSection B C R i ∈ M.sets := by
-  let params := extend i (extend B (extend C (extend R Fin.elim0)))
-  have selected := M.bounded_separation_mem separation
-    (BoundedFormula.indexedRelationSectionEntryFormula 0 1 2 3 4) params
-    (Fin.cases hi (Fin.cases hB (Fin.cases hC (Fin.cases hR (fun j => Fin.elim0 j)))))
-    (M.prod_mem pairing unions powers separation hB hC)
-  have equal : ZFSet.sep (fun z => BoundedFormula.Truth
-      (BoundedFormula.indexedRelationSectionEntryFormula 0 1 2 3 4) (extend z params))
-      (ZFSet.prod B C) = indexedRelationSection B C R i := by
-    apply ZFSet.ext
-    intro z
-    rw [ZFSet.mem_sep, BoundedFormula.truth_indexedRelationSectionEntryFormula]
-    exact ⟨And.right, fun hz => ⟨indexedRelationSection_subset B C R i hz, hz⟩⟩
-  exact equal ▸ selected
-
-noncomputable def indexedRelationSections (I B C R : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => ∃ i ∈ I, ∃ f ∈ M.groundRelations B C,
-    z = ZFSet.pair i f ∧ f = indexedRelationSection B C R i)
-    (ZFSet.prod I (M.groundRelations B C))
-
-theorem pair_mem_indexedRelationSections (I B C R i f : ZFSet.{u}) :
-    ZFSet.pair i f ∈ M.indexedRelationSections I B C R ↔
-      i ∈ I ∧ f ∈ M.groundRelations B C ∧ f = indexedRelationSection B C R i := by
-  rw [indexedRelationSections, ZFSet.mem_sep, ZFSet.pair_mem_prod]
-  constructor
-  · rintro ⟨⟨hi, hf⟩, j, _, g, _, equal, sectionEq⟩
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
-    exact ⟨hi, hf, sectionEq⟩
-  · rintro ⟨hi, hf, sectionEq⟩
-    exact ⟨⟨hi, hf⟩, i, hi, f, hf, rfl, sectionEq⟩
-
-theorem indexedRelationSections_mem
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    {I B C R : ZFSet.{u}} (hI : I ∈ M.sets) (hB : B ∈ M.sets)
-    (hC : C ∈ M.sets) (hR : R ∈ M.sets) : M.indexedRelationSections I B C R ∈ M.sets := by
-  have bound := M.groundRelations_mem pairing unions powers separation hB hC
-  let params := extend I (extend (M.groundRelations B C) (extend B (extend C (extend R Fin.elim0))))
-  have selected := M.bounded_separation_mem separation
-    (BoundedFormula.indexedRelationFamilyEntryFormula 0 1 2 3 4 5) params
-    (Fin.cases hI (Fin.cases bound (Fin.cases hB (Fin.cases hC
-      (Fin.cases hR (fun j => Fin.elim0 j))))))
-    (M.prod_mem pairing unions powers separation hI bound)
-  have equal : ZFSet.sep (fun z => BoundedFormula.Truth
-      (BoundedFormula.indexedRelationFamilyEntryFormula 0 1 2 3 4 5) (extend z params))
-      (ZFSet.prod I (M.groundRelations B C)) = M.indexedRelationSections I B C R := by
-    apply ZFSet.ext
-    intro z
-    rw [ZFSet.mem_sep, indexedRelationSections, ZFSet.mem_sep]
-    exact and_congr Iff.rfl (BoundedFormula.truth_indexedRelationFamilyEntryFormula 0 1 2 3 4 5 _)
-  exact equal ▸ selected
-
-theorem indexedRelationSections_function
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    {I B C R : ZFSet.{u}} (hI : I ∈ M.sets) (hB : B ∈ M.sets)
-    (hC : C ∈ M.sets) (hR : R ∈ M.sets) :
-    ZFSet.IsFunc I (M.groundRelations B C) (M.indexedRelationSections I B C R) := by
-  refine ⟨fun _ hz => (ZFSet.mem_sep.1 hz).1, ?_⟩
-  intro i hi
-  have sectionBound := (M.mem_groundRelations B C (indexedRelationSection B C R i)).2
-    ⟨M.indexedRelationSection_mem pairing unions powers separation hB hC hR (M.transitive hI hi),
-      indexedRelationSection_subset B C R i⟩
-  exact ⟨indexedRelationSection B C R i,
-    (M.pair_mem_indexedRelationSections I B C R i _).2 ⟨hi, sectionBound, rfl⟩,
-    fun f hf => ((M.pair_mem_indexedRelationSections I B C R i f).1 hf).2.2⟩
-
-theorem indexedRelationSections_spec
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    {I B C R : ZFSet.{u}} (hI : I ∈ M.sets) (hB : B ∈ M.sets)
-    (hC : C ∈ M.sets) (hR : R ∈ M.sets) :
-    M.indexedRelationSections I B C R ∈ M.sets ∧
-      ZFSet.IsFunc I (M.groundRelations B C) (M.indexedRelationSections I B C R) ∧
-      ∀ i f, ZFSet.pair i f ∈ M.indexedRelationSections I B C R ↔
-        i ∈ I ∧ f = indexedRelationSection B C R i := by
-  have func := M.indexedRelationSections_function pairing unions powers separation hI hB hC hR
-  refine ⟨M.indexedRelationSections_mem pairing unions powers separation hI hB hC hR, func, ?_⟩
-  intro i f
-  constructor
-  · intro entry
-    have parts := (M.pair_mem_indexedRelationSections I B C R i f).1 entry
-    exact ⟨parts.1, parts.2.2⟩
-  · rintro ⟨hi, rfl⟩
-    obtain ⟨g, entry, _⟩ := func.2 i hi
-    have equal := ((M.pair_mem_indexedRelationSections I B C R i g).1 entry).2.2
-    exact equal ▸ entry
-
-end TransitiveGround
-
-end
-
-
-
-open SetFormula
-universe u
-
-noncomputable def indexedCarrierLabels (T U A : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => ∃ i ∈ T, ∃ X ∈ ZFSet.sUnion (ZFSet.sUnion A), ∃ x ∈ X,
-    z = ZFSet.pair i x ∧ ZFSet.pair i X ∈ A) (ZFSet.prod T U)
-
-theorem indexedCarrierLabels_subset (T U A : ZFSet.{u}) :
-    indexedCarrierLabels T U A ⊆ ZFSet.prod T U :=
-  fun _ hz => (ZFSet.mem_sep.1 hz).1
-
-theorem mem_indexedCarrierLabels (T U A z : ZFSet.{u}) :
-    z ∈ indexedCarrierLabels T U A ↔
-      ∃ i ∈ T, ∃ X ∈ ZFSet.sUnion (ZFSet.sUnion A), ∃ x ∈ X,
-        x ∈ U ∧ z = ZFSet.pair i x ∧ ZFSet.pair i X ∈ A := by
-  constructor
-  · intro hz
-    obtain ⟨bound, i, hi, X, hX, x, hx, rfl, entry⟩ := ZFSet.mem_sep.1 hz
-    exact ⟨i, hi, X, hX, x, hx, (ZFSet.pair_mem_prod.1 bound).2, rfl, entry⟩
-  · rintro ⟨i, hi, X, hX, x, hx, hu, rfl, entry⟩
-    exact ZFSet.mem_sep.2 ⟨ZFSet.pair_mem_prod.2 ⟨hi, hu⟩, i, hi, X, hX, x, hx, rfl, entry⟩
-
-theorem pair_mem_indexedCarrierLabels (T U A i x : ZFSet.{u}) :
-    ZFSet.pair i x ∈ indexedCarrierLabels T U A ↔
-      i ∈ T ∧ x ∈ U ∧ ∃ X, ZFSet.pair i X ∈ A ∧ x ∈ X := by
-  rw [mem_indexedCarrierLabels]
-  constructor
-  · rintro ⟨j, hj, X, _, y, hy, hu, equal, entry⟩
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
-    exact ⟨hj, hu, X, entry, hy⟩
-  · rintro ⟨hi, hu, X, entry, hx⟩
-    exact ⟨i, hi, X, pair_second_mem_doubleUnion entry, x, hx, hu, rfl, entry⟩
-
-theorem pair_mem_indexedCarrierLabels_of_entry {T U A i X x : ZFSet.{u}}
-    (family : FunctionGraphOn T A) (entry : ZFSet.pair i X ∈ A) (bound : X ⊆ U) :
-    ZFSet.pair i x ∈ indexedCarrierLabels T U A ↔ x ∈ X := by
-  rw [pair_mem_indexedCarrierLabels]
-  constructor
-  · rintro ⟨_, _, Y, other, hx⟩
-    exact (family.unique other entry) ▸ hx
-  · intro hx
-    exact ⟨family.pair_source entry, bound hx, X, entry, hx⟩
-
-namespace BoundedFormula
-
-def indexedCarrierLabelFormula {n} (z T U A V : Fin n) : BoundedFormula n :=
-  exMem T (exMem V.succ (exMem 0
-    (.conj (.mem 0 U.succ.succ.succ)
-      (.conj (orderedPairFormula z.succ.succ.succ 2 0)
-        (pairMembershipFormula 2 1 A.succ.succ.succ)))))
-
-theorem truth_indexedCarrierLabelFormula {n} (z T U A V : Fin n)
-    (env : Fin n → ZFSet.{u}) (bound : env V = ZFSet.sUnion (ZFSet.sUnion (env A))) :
-    Truth (indexedCarrierLabelFormula z T U A V) env ↔
-      env z ∈ indexedCarrierLabels (env T) (env U) (env A) := by
-  simp only [indexedCarrierLabelFormula, truth_exMem, Truth,
-    truth_orderedPairFormula, truth_pairMembershipFormula]
-  change (∃ i ∈ env T, ∃ X ∈ env V, ∃ x ∈ X,
-    x ∈ env U ∧ env z = ZFSet.pair i x ∧ ZFSet.pair i X ∈ env A) ↔ _
-  rw [bound, mem_indexedCarrierLabels]
-
-end BoundedFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-
-theorem indexedCarrierLabels_mem
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    {T U A : ZFSet.{u}} (hT : T ∈ M.sets) (hU : U ∈ M.sets) (hA : A ∈ M.sets) :
-    indexedCarrierLabels T U A ∈ M.sets := by
-  have hV := M.union_mem unions (M.union_mem unions hA)
-  let params := extend T (extend U (extend A (extend (ZFSet.sUnion (ZFSet.sUnion A)) Fin.elim0)))
-  have selected := M.bounded_separation_mem separation
-    (BoundedFormula.indexedCarrierLabelFormula 0 1 2 3 4) params
-    (Fin.cases hT (Fin.cases hU (Fin.cases hA (Fin.cases hV (fun j => Fin.elim0 j)))))
-    (M.prod_mem pairing unions powers separation hT hU)
-  have equal : ZFSet.sep (fun z => BoundedFormula.Truth
-      (BoundedFormula.indexedCarrierLabelFormula 0 1 2 3 4) (extend z params))
-      (ZFSet.prod T U) = indexedCarrierLabels T U A := by
-    apply ZFSet.ext
-    intro z
-    rw [ZFSet.mem_sep, BoundedFormula.truth_indexedCarrierLabelFormula 0 1 2 3 4 _ rfl]
-    exact ⟨And.right, fun hz => ⟨indexedCarrierLabels_subset T U A hz, hz⟩⟩
-  exact equal ▸ selected
-
-end TransitiveGround
-
-
-
-
-
-noncomputable def mapFamilyApplicationGraph (I P Q family : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => ∃ i ∈ I, ∃ x ∈ P, ∃ y ∈ Q, ∃ f ∈ ZFSet.sUnion (ZFSet.sUnion family),
-    z = ZFSet.pair (ZFSet.pair i x) y ∧ ZFSet.pair i f ∈ family ∧ ZFSet.pair x y ∈ f)
-    (ZFSet.prod (ZFSet.prod I P) Q)
-
-theorem pair_mem_mapFamilyApplicationGraph (I P Q family i x y : ZFSet.{u}) :
-    ZFSet.pair (ZFSet.pair i x) y ∈ mapFamilyApplicationGraph I P Q family ↔
-      i ∈ I ∧ x ∈ P ∧ y ∈ Q ∧ ∃ f, ZFSet.pair i f ∈ family ∧ ZFSet.pair x y ∈ f := by
-  rw [mapFamilyApplicationGraph, ZFSet.mem_sep]
-  constructor
-  · rintro ⟨_, j, hj, a, ha, b, hb, f, _, equal, indexed, entry⟩
-    obtain ⟨inner, rfl⟩ := ZFSet.pair_inj.1 equal
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 inner
-    exact ⟨hj, ha, hb, f, indexed, entry⟩
-  · rintro ⟨hi, hx, hy, f, indexed, entry⟩
-    exact ⟨ZFSet.pair_mem_prod.2 ⟨ZFSet.pair_mem_prod.2 ⟨hi, hx⟩, hy⟩,
-      i, hi, x, hx, y, hy, f, pair_second_mem_doubleUnion indexed, rfl, indexed, entry⟩
-
-namespace BoundedFormula
-
-def mapFamilyApplicationEntryFormula {n} (z I P Q B family : Fin n) : BoundedFormula n :=
-  exMem I (exMem P.succ (exMem Q.succ.succ (exMem B.succ.succ.succ
-    (.conj (orderedTripleFormula z.succ.succ.succ.succ 3 2 1)
-      (.conj (pairMembershipFormula 3 0 family.succ.succ.succ.succ)
-        (pairMembershipFormula 2 1 0))))))
-
-theorem truth_mapFamilyApplicationEntryFormula {n} (z I P Q B family : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (mapFamilyApplicationEntryFormula z I P Q B family) env ↔
-      ∃ i ∈ env I, ∃ x ∈ env P, ∃ y ∈ env Q, ∃ f ∈ env B,
-        env z = ZFSet.pair (ZFSet.pair i x) y ∧
-          ZFSet.pair i f ∈ env family ∧ ZFSet.pair x y ∈ f := by
-  simp only [mapFamilyApplicationEntryFormula, truth_exMem, Truth,
-    truth_orderedTripleFormula, truth_pairMembershipFormula]
-  rfl
-
-end BoundedFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-
-theorem mapFamilyApplicationGraph_mem
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    {I P Q family : ZFSet.{u}} (hI : I ∈ M.sets) (hP : P ∈ M.sets)
-    (hQ : Q ∈ M.sets) (hFamily : family ∈ M.sets) :
-    mapFamilyApplicationGraph I P Q family ∈ M.sets := by
-  have hB := M.union_mem unions (M.union_mem unions hFamily)
-  let params := extend I (extend P (extend Q (extend (ZFSet.sUnion (ZFSet.sUnion family)) (extend family Fin.elim0))))
-  have selected := M.bounded_separation_mem separation
-    (BoundedFormula.mapFamilyApplicationEntryFormula 0 1 2 3 4 5) params
-    (Fin.cases hI (Fin.cases hP (Fin.cases hQ (Fin.cases hB (Fin.cases hFamily
-      (fun i => Fin.elim0 i))))))
-    (M.prod_mem pairing unions powers separation (M.prod_mem pairing unions powers separation hI hP) hQ)
-  have equal : ZFSet.sep (fun z => BoundedFormula.Truth
-      (BoundedFormula.mapFamilyApplicationEntryFormula 0 1 2 3 4 5) (extend z params))
-      (ZFSet.prod (ZFSet.prod I P) Q) = mapFamilyApplicationGraph I P Q family := by
-    apply ZFSet.ext
-    intro z
-    rw [ZFSet.mem_sep, mapFamilyApplicationGraph, ZFSet.mem_sep,
-      BoundedFormula.truth_mapFamilyApplicationEntryFormula]
-    rfl
-  exact equal ▸ selected
-
-end TransitiveGround
-
-
-end PartitionPilot.Forcing
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Definability.GroundFlatCopyGraphs
+
+namespace OAI
+
+
+namespace PartitionPilot.Forcing
+
+section
+
+universe u
+
+noncomputable def indexedRelationSection (B C R i : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => ∃ q ∈ B, ∃ y ∈ C,
+    z = ZFSet.pair q y ∧ ZFSet.pair (ZFSet.pair i q) y ∈ R) (ZFSet.prod B C)
+
+theorem indexedRelationSection_subset (B C R i : ZFSet.{u}) :
+    indexedRelationSection B C R i ⊆ ZFSet.prod B C :=
+  fun _ hz => (ZFSet.mem_sep.1 hz).1
+
+theorem mem_indexedRelationSection (B C R i z : ZFSet.{u}) :
+    z ∈ indexedRelationSection B C R i ↔ ∃ q ∈ B, ∃ y ∈ C,
+      z = ZFSet.pair q y ∧ ZFSet.pair (ZFSet.pair i q) y ∈ R := by
+  constructor
+  · intro hz
+    exact (ZFSet.mem_sep.1 hz).2
+  · rintro ⟨q, hq, y, hy, rfl, entry⟩
+    exact ZFSet.mem_sep.2 ⟨ZFSet.pair_mem_prod.2 ⟨hq, hy⟩, q, hq, y, hy, rfl, entry⟩
+
+theorem pair_mem_indexedRelationSection (B C R i q y : ZFSet.{u}) :
+    ZFSet.pair q y ∈ indexedRelationSection B C R i ↔
+      q ∈ B ∧ y ∈ C ∧ ZFSet.pair (ZFSet.pair i q) y ∈ R := by
+  rw [mem_indexedRelationSection]
+  constructor
+  · rintro ⟨q', hq, y', hy, equal, entry⟩
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
+    exact ⟨hq, hy, entry⟩
+  · rintro ⟨hq, hy, entry⟩
+    exact ⟨q, hq, y, hy, rfl, entry⟩
+
+
+
+
+
+
+namespace BoundedFormula
+
+open SetFormula
+
+def indexedRelationSectionEntryFormula {n} (z i b c r : Fin n) : BoundedFormula n :=
+  exMem b (exMem c.succ (.conj (orderedPairFormula z.succ.succ 1 0)
+    (tripleMembershipFormula i.succ.succ 1 0 r.succ.succ)))
+
+theorem truth_indexedRelationSectionEntryFormula {n} (z i b c r : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (indexedRelationSectionEntryFormula z i b c r) env ↔
+      env z ∈ indexedRelationSection (env b) (env c) (env r) (env i) := by
+  simp only [indexedRelationSectionEntryFormula, truth_exMem, Truth,
+    truth_orderedPairFormula, truth_tripleMembershipFormula, mem_indexedRelationSection]
+  rfl
+
+def indexedRelationSectionFormula {n} (f i b c r : Fin n) : BoundedFormula n :=
+  .conj (.allMem f (indexedRelationSectionEntryFormula 0 i.succ b.succ c.succ r.succ))
+    (.allMem b (.allMem c.succ
+      (imp (tripleMembershipFormula i.succ.succ 1 0 r.succ.succ)
+        (pairMembershipFormula 1 0 f.succ.succ))))
+
+theorem truth_indexedRelationSectionFormula {n} (f i b c r : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (indexedRelationSectionFormula f i b c r) env ↔
+      env f = indexedRelationSection (env b) (env c) (env r) (env i) := by
+  simp only [indexedRelationSectionFormula, Truth, truth_indexedRelationSectionEntryFormula,
+    truth_imp, truth_tripleMembershipFormula, truth_pairMembershipFormula]
+  constructor
+  · rintro ⟨subset, complete⟩
+    apply ZFSet.ext
+    intro z
+    refine ⟨subset z, ?_⟩
+    intro hz
+    obtain ⟨q, hq, y, hy, rfl, entry⟩ := (mem_indexedRelationSection _ _ _ _ z).1 hz
+    exact complete q hq y hy entry
+  · intro equal
+    refine ⟨fun _ hz => equal ▸ hz, ?_⟩
+    intro q hq y hy entry
+    change ZFSet.pair q y ∈ env f
+    rw [equal]
+    exact (pair_mem_indexedRelationSection _ _ _ _ q y).2 ⟨hq, hy, entry⟩
+
+def indexedRelationFamilyEntryFormula {n} (z domain bound b c r : Fin n) : BoundedFormula n :=
+  exMem domain (exMem bound.succ (.conj (orderedPairFormula z.succ.succ 1 0)
+    (indexedRelationSectionFormula 0 1 b.succ.succ c.succ.succ r.succ.succ)))
+
+theorem truth_indexedRelationFamilyEntryFormula {n} (z domain bound b c r : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (indexedRelationFamilyEntryFormula z domain bound b c r) env ↔
+      ∃ i ∈ env domain, ∃ f ∈ env bound, env z = ZFSet.pair i f ∧
+        f = indexedRelationSection (env b) (env c) (env r) i := by
+  simp only [indexedRelationFamilyEntryFormula, truth_exMem, Truth,
+    truth_orderedPairFormula, truth_indexedRelationSectionFormula]
+  rfl
+
+end BoundedFormula
+
+namespace TransitiveGround
+
+open SetFormula
+variable (M : TransitiveGround.{u})
+
+theorem indexedRelationSection_mem
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    {B C R i : ZFSet.{u}} (hB : B ∈ M.sets) (hC : C ∈ M.sets)
+    (hR : R ∈ M.sets) (hi : i ∈ M.sets) : indexedRelationSection B C R i ∈ M.sets := by
+  let params := extend i (extend B (extend C (extend R Fin.elim0)))
+  have selected := M.bounded_separation_mem separation
+    (BoundedFormula.indexedRelationSectionEntryFormula 0 1 2 3 4) params
+    (Fin.cases hi (Fin.cases hB (Fin.cases hC (Fin.cases hR (fun j => Fin.elim0 j)))))
+    (M.prod_mem pairing unions powers separation hB hC)
+  have equal : ZFSet.sep (fun z => BoundedFormula.Truth
+      (BoundedFormula.indexedRelationSectionEntryFormula 0 1 2 3 4) (extend z params))
+      (ZFSet.prod B C) = indexedRelationSection B C R i := by
+    apply ZFSet.ext
+    intro z
+    rw [ZFSet.mem_sep, BoundedFormula.truth_indexedRelationSectionEntryFormula]
+    exact ⟨And.right, fun hz => ⟨indexedRelationSection_subset B C R i hz, hz⟩⟩
+  exact equal ▸ selected
+
+noncomputable def indexedRelationSections (I B C R : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => ∃ i ∈ I, ∃ f ∈ M.groundRelations B C,
+    z = ZFSet.pair i f ∧ f = indexedRelationSection B C R i)
+    (ZFSet.prod I (M.groundRelations B C))
+
+theorem pair_mem_indexedRelationSections (I B C R i f : ZFSet.{u}) :
+    ZFSet.pair i f ∈ M.indexedRelationSections I B C R ↔
+      i ∈ I ∧ f ∈ M.groundRelations B C ∧ f = indexedRelationSection B C R i := by
+  rw [indexedRelationSections, ZFSet.mem_sep, ZFSet.pair_mem_prod]
+  constructor
+  · rintro ⟨⟨hi, hf⟩, j, _, g, _, equal, sectionEq⟩
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
+    exact ⟨hi, hf, sectionEq⟩
+  · rintro ⟨hi, hf, sectionEq⟩
+    exact ⟨⟨hi, hf⟩, i, hi, f, hf, rfl, sectionEq⟩
+
+theorem indexedRelationSections_mem
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    {I B C R : ZFSet.{u}} (hI : I ∈ M.sets) (hB : B ∈ M.sets)
+    (hC : C ∈ M.sets) (hR : R ∈ M.sets) : M.indexedRelationSections I B C R ∈ M.sets := by
+  have bound := M.groundRelations_mem pairing unions powers separation hB hC
+  let params := extend I (extend (M.groundRelations B C) (extend B (extend C (extend R Fin.elim0))))
+  have selected := M.bounded_separation_mem separation
+    (BoundedFormula.indexedRelationFamilyEntryFormula 0 1 2 3 4 5) params
+    (Fin.cases hI (Fin.cases bound (Fin.cases hB (Fin.cases hC
+      (Fin.cases hR (fun j => Fin.elim0 j))))))
+    (M.prod_mem pairing unions powers separation hI bound)
+  have equal : ZFSet.sep (fun z => BoundedFormula.Truth
+      (BoundedFormula.indexedRelationFamilyEntryFormula 0 1 2 3 4 5) (extend z params))
+      (ZFSet.prod I (M.groundRelations B C)) = M.indexedRelationSections I B C R := by
+    apply ZFSet.ext
+    intro z
+    rw [ZFSet.mem_sep, indexedRelationSections, ZFSet.mem_sep]
+    exact and_congr Iff.rfl (BoundedFormula.truth_indexedRelationFamilyEntryFormula 0 1 2 3 4 5 _)
+  exact equal ▸ selected
+
+theorem indexedRelationSections_function
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    {I B C R : ZFSet.{u}} (hI : I ∈ M.sets) (hB : B ∈ M.sets)
+    (hC : C ∈ M.sets) (hR : R ∈ M.sets) :
+    ZFSet.IsFunc I (M.groundRelations B C) (M.indexedRelationSections I B C R) := by
+  refine ⟨fun _ hz => (ZFSet.mem_sep.1 hz).1, ?_⟩
+  intro i hi
+  have sectionBound := (M.mem_groundRelations B C (indexedRelationSection B C R i)).2
+    ⟨M.indexedRelationSection_mem pairing unions powers separation hB hC hR (M.transitive hI hi),
+      indexedRelationSection_subset B C R i⟩
+  exact ⟨indexedRelationSection B C R i,
+    (M.pair_mem_indexedRelationSections I B C R i _).2 ⟨hi, sectionBound, rfl⟩,
+    fun f hf => ((M.pair_mem_indexedRelationSections I B C R i f).1 hf).2.2⟩
+
+theorem indexedRelationSections_spec
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    {I B C R : ZFSet.{u}} (hI : I ∈ M.sets) (hB : B ∈ M.sets)
+    (hC : C ∈ M.sets) (hR : R ∈ M.sets) :
+    M.indexedRelationSections I B C R ∈ M.sets ∧
+      ZFSet.IsFunc I (M.groundRelations B C) (M.indexedRelationSections I B C R) ∧
+      ∀ i f, ZFSet.pair i f ∈ M.indexedRelationSections I B C R ↔
+        i ∈ I ∧ f = indexedRelationSection B C R i := by
+  have func := M.indexedRelationSections_function pairing unions powers separation hI hB hC hR
+  refine ⟨M.indexedRelationSections_mem pairing unions powers separation hI hB hC hR, func, ?_⟩
+  intro i f
+  constructor
+  · intro entry
+    have parts := (M.pair_mem_indexedRelationSections I B C R i f).1 entry
+    exact ⟨parts.1, parts.2.2⟩
+  · rintro ⟨hi, rfl⟩
+    obtain ⟨g, entry, _⟩ := func.2 i hi
+    have equal := ((M.pair_mem_indexedRelationSections I B C R i g).1 entry).2.2
+    exact equal ▸ entry
+
+end TransitiveGround
+
+end
+
+
+
+open SetFormula
+universe u
+
+noncomputable def indexedCarrierLabels (T U A : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => ∃ i ∈ T, ∃ X ∈ ZFSet.sUnion (ZFSet.sUnion A), ∃ x ∈ X,
+    z = ZFSet.pair i x ∧ ZFSet.pair i X ∈ A) (ZFSet.prod T U)
+
+theorem indexedCarrierLabels_subset (T U A : ZFSet.{u}) :
+    indexedCarrierLabels T U A ⊆ ZFSet.prod T U :=
+  fun _ hz => (ZFSet.mem_sep.1 hz).1
+
+theorem mem_indexedCarrierLabels (T U A z : ZFSet.{u}) :
+    z ∈ indexedCarrierLabels T U A ↔
+      ∃ i ∈ T, ∃ X ∈ ZFSet.sUnion (ZFSet.sUnion A), ∃ x ∈ X,
+        x ∈ U ∧ z = ZFSet.pair i x ∧ ZFSet.pair i X ∈ A := by
+  constructor
+  · intro hz
+    obtain ⟨bound, i, hi, X, hX, x, hx, rfl, entry⟩ := ZFSet.mem_sep.1 hz
+    exact ⟨i, hi, X, hX, x, hx, (ZFSet.pair_mem_prod.1 bound).2, rfl, entry⟩
+  · rintro ⟨i, hi, X, hX, x, hx, hu, rfl, entry⟩
+    exact ZFSet.mem_sep.2 ⟨ZFSet.pair_mem_prod.2 ⟨hi, hu⟩, i, hi, X, hX, x, hx, rfl, entry⟩
+
+theorem pair_mem_indexedCarrierLabels (T U A i x : ZFSet.{u}) :
+    ZFSet.pair i x ∈ indexedCarrierLabels T U A ↔
+      i ∈ T ∧ x ∈ U ∧ ∃ X, ZFSet.pair i X ∈ A ∧ x ∈ X := by
+  rw [mem_indexedCarrierLabels]
+  constructor
+  · rintro ⟨j, hj, X, _, y, hy, hu, equal, entry⟩
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
+    exact ⟨hj, hu, X, entry, hy⟩
+  · rintro ⟨hi, hu, X, entry, hx⟩
+    exact ⟨i, hi, X, pair_second_mem_doubleUnion entry, x, hx, hu, rfl, entry⟩
+
+theorem pair_mem_indexedCarrierLabels_of_entry {T U A i X x : ZFSet.{u}}
+    (family : FunctionGraphOn T A) (entry : ZFSet.pair i X ∈ A) (bound : X ⊆ U) :
+    ZFSet.pair i x ∈ indexedCarrierLabels T U A ↔ x ∈ X := by
+  rw [pair_mem_indexedCarrierLabels]
+  constructor
+  · rintro ⟨_, _, Y, other, hx⟩
+    exact (family.unique other entry) ▸ hx
+  · intro hx
+    exact ⟨family.pair_source entry, bound hx, X, entry, hx⟩
+
+namespace BoundedFormula
+
+def indexedCarrierLabelFormula {n} (z T U A V : Fin n) : BoundedFormula n :=
+  exMem T (exMem V.succ (exMem 0
+    (.conj (.mem 0 U.succ.succ.succ)
+      (.conj (orderedPairFormula z.succ.succ.succ 2 0)
+        (pairMembershipFormula 2 1 A.succ.succ.succ)))))
+
+theorem truth_indexedCarrierLabelFormula {n} (z T U A V : Fin n)
+    (env : Fin n → ZFSet.{u}) (bound : env V = ZFSet.sUnion (ZFSet.sUnion (env A))) :
+    Truth (indexedCarrierLabelFormula z T U A V) env ↔
+      env z ∈ indexedCarrierLabels (env T) (env U) (env A) := by
+  simp only [indexedCarrierLabelFormula, truth_exMem, Truth,
+    truth_orderedPairFormula, truth_pairMembershipFormula]
+  change (∃ i ∈ env T, ∃ X ∈ env V, ∃ x ∈ X,
+    x ∈ env U ∧ env z = ZFSet.pair i x ∧ ZFSet.pair i X ∈ env A) ↔ _
+  rw [bound, mem_indexedCarrierLabels]
+
+end BoundedFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+
+theorem indexedCarrierLabels_mem
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    {T U A : ZFSet.{u}} (hT : T ∈ M.sets) (hU : U ∈ M.sets) (hA : A ∈ M.sets) :
+    indexedCarrierLabels T U A ∈ M.sets := by
+  have hV := M.union_mem unions (M.union_mem unions hA)
+  let params := extend T (extend U (extend A (extend (ZFSet.sUnion (ZFSet.sUnion A)) Fin.elim0)))
+  have selected := M.bounded_separation_mem separation
+    (BoundedFormula.indexedCarrierLabelFormula 0 1 2 3 4) params
+    (Fin.cases hT (Fin.cases hU (Fin.cases hA (Fin.cases hV (fun j => Fin.elim0 j)))))
+    (M.prod_mem pairing unions powers separation hT hU)
+  have equal : ZFSet.sep (fun z => BoundedFormula.Truth
+      (BoundedFormula.indexedCarrierLabelFormula 0 1 2 3 4) (extend z params))
+      (ZFSet.prod T U) = indexedCarrierLabels T U A := by
+    apply ZFSet.ext
+    intro z
+    rw [ZFSet.mem_sep, BoundedFormula.truth_indexedCarrierLabelFormula 0 1 2 3 4 _ rfl]
+    exact ⟨And.right, fun hz => ⟨indexedCarrierLabels_subset T U A hz, hz⟩⟩
+  exact equal ▸ selected
+
+end TransitiveGround
+
+
+
+
+
+noncomputable def mapFamilyApplicationGraph (I P Q family : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => ∃ i ∈ I, ∃ x ∈ P, ∃ y ∈ Q, ∃ f ∈ ZFSet.sUnion (ZFSet.sUnion family),
+    z = ZFSet.pair (ZFSet.pair i x) y ∧ ZFSet.pair i f ∈ family ∧ ZFSet.pair x y ∈ f)
+    (ZFSet.prod (ZFSet.prod I P) Q)
+
+theorem pair_mem_mapFamilyApplicationGraph (I P Q family i x y : ZFSet.{u}) :
+    ZFSet.pair (ZFSet.pair i x) y ∈ mapFamilyApplicationGraph I P Q family ↔
+      i ∈ I ∧ x ∈ P ∧ y ∈ Q ∧ ∃ f, ZFSet.pair i f ∈ family ∧ ZFSet.pair x y ∈ f := by
+  rw [mapFamilyApplicationGraph, ZFSet.mem_sep]
+  constructor
+  · rintro ⟨_, j, hj, a, ha, b, hb, f, _, equal, indexed, entry⟩
+    obtain ⟨inner, rfl⟩ := ZFSet.pair_inj.1 equal
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 inner
+    exact ⟨hj, ha, hb, f, indexed, entry⟩
+  · rintro ⟨hi, hx, hy, f, indexed, entry⟩
+    exact ⟨ZFSet.pair_mem_prod.2 ⟨ZFSet.pair_mem_prod.2 ⟨hi, hx⟩, hy⟩,
+      i, hi, x, hx, y, hy, f, pair_second_mem_doubleUnion indexed, rfl, indexed, entry⟩
+
+namespace BoundedFormula
+
+def mapFamilyApplicationEntryFormula {n} (z I P Q B family : Fin n) : BoundedFormula n :=
+  exMem I (exMem P.succ (exMem Q.succ.succ (exMem B.succ.succ.succ
+    (.conj (orderedTripleFormula z.succ.succ.succ.succ 3 2 1)
+      (.conj (pairMembershipFormula 3 0 family.succ.succ.succ.succ)
+        (pairMembershipFormula 2 1 0))))))
+
+theorem truth_mapFamilyApplicationEntryFormula {n} (z I P Q B family : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (mapFamilyApplicationEntryFormula z I P Q B family) env ↔
+      ∃ i ∈ env I, ∃ x ∈ env P, ∃ y ∈ env Q, ∃ f ∈ env B,
+        env z = ZFSet.pair (ZFSet.pair i x) y ∧
+          ZFSet.pair i f ∈ env family ∧ ZFSet.pair x y ∈ f := by
+  simp only [mapFamilyApplicationEntryFormula, truth_exMem, Truth,
+    truth_orderedTripleFormula, truth_pairMembershipFormula]
+  rfl
+
+end BoundedFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+
+theorem mapFamilyApplicationGraph_mem
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    {I P Q family : ZFSet.{u}} (hI : I ∈ M.sets) (hP : P ∈ M.sets)
+    (hQ : Q ∈ M.sets) (hFamily : family ∈ M.sets) :
+    mapFamilyApplicationGraph I P Q family ∈ M.sets := by
+  have hB := M.union_mem unions (M.union_mem unions hFamily)
+  let params := extend I (extend P (extend Q (extend (ZFSet.sUnion (ZFSet.sUnion family)) (extend family Fin.elim0))))
+  have selected := M.bounded_separation_mem separation
+    (BoundedFormula.mapFamilyApplicationEntryFormula 0 1 2 3 4 5) params
+    (Fin.cases hI (Fin.cases hP (Fin.cases hQ (Fin.cases hB (Fin.cases hFamily
+      (fun i => Fin.elim0 i))))))
+    (M.prod_mem pairing unions powers separation (M.prod_mem pairing unions powers separation hI hP) hQ)
+  have equal : ZFSet.sep (fun z => BoundedFormula.Truth
+      (BoundedFormula.mapFamilyApplicationEntryFormula 0 1 2 3 4 5) (extend z params))
+      (ZFSet.prod (ZFSet.prod I P) Q) = mapFamilyApplicationGraph I P Q family := by
+    apply ZFSet.ext
+    intro z
+    rw [ZFSet.mem_sep, mapFamilyApplicationGraph, ZFSet.mem_sep,
+      BoundedFormula.truth_mapFamilyApplicationEntryFormula]
+    rfl
+  exact equal ▸ selected
+
+end TransitiveGround
+
+
+end PartitionPilot.Forcing
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/NameSupportFormulas.lean

@@ -1,74 +1,74 @@
-import OAI.SetTheory.PartitionPrinciple.Forcing.GroundProductActions
-
-namespace OAI
-
-
-namespace PartitionPilot.Forcing
-
-open SetRealization Compression.RecursiveMaps
-universe u
-variable {I G : Type u} [Group G]
-
-noncomputable def supportBasisCode (b : Presentation I) (t : Presentation G)
-    (K : I → Subgroup G) : ZFSet.{u} := (b.product t).subset (fun z => z.2 ∈ K z.1)
-
-theorem pair_mem_supportBasisCode (b : Presentation I) (t : Presentation G)
-    (K : I → Subgroup G) (i : I) (g : G) :
-    ZFSet.pair (b.encode i) (t.encode g) ∈ supportBasisCode b t K ↔ g ∈ K i :=
-  (b.product t).encode_mem_subset (fun z => z.2 ∈ K z.1) (i, g)
-
-theorem finalSupportFamily_basis (Label : Type 1) (H : Subgroup (MainStage.OrdinalRun.FinalActor Label)) :
-    (MainStage.OrdinalRun.supportFamily Label).mem H ↔
-      ∃ C, (MainStage.OrdinalRun.finalAction Label).fixSubgroup C ≤ H := Iff.rfl
-
-end PartitionPilot.Forcing
-
-
-
-namespace PartitionPilot.Forcing.SetFormula
-
-def nameSupportFormula : SetFormula 6 :=
-  allConditions 3 (imp (pairMembershipFormula 2 0 5)
-    (atomicApplication nameActionFormula (extend 3 (extend 6 Fin.elim0)) 0 1 1))
-
-end PartitionPilot.Forcing.SetFormula
-
-namespace PartitionPilot.Forcing.TransitiveGround
-open SetRealization SetFormula
-universe u
-variable (M : TransitiveGround.{u}) {I G P : Type u} [Group G] [PartialOrder P]
-variable (a : PosetAction G P) (s : Presentation P) (t : Presentation G) (b : Presentation I)
-
-theorem realize_nameSupportFormula (K : I → Subgroup G)
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0)
-    (separation : SeparationSchema M.sets) (collection : CollectionSchema M.sets)
-    (carrier : s.carrier ∈ M.sets) (group : t.carrier ∈ M.sets)
-    (supports : supportBasisCode b t K ∈ M.sets)
-    (maps : a.conditionMapFamily s t ∈ M.sets)
-    (i : I) (hi : b.encode i ∈ M.sets) (τ : Name s) (hτ : τ.val ∈ M.sets) :
-    Realize M.sets nameSupportFormula
-      (extend τ.val (extend (b.encode i) (extend s.carrier (extend t.carrier
-        (extend (supportBasisCode b t K) (extend (a.conditionMapFamily s t) Fin.elim0)))))) ↔
-      K i ≤ a.stabilizer s τ := by
-  let env := extend τ.val (extend (b.encode i) (extend s.carrier (extend t.carrier
-    (extend (supportBasisCode b t K) (extend (a.conditionMapFamily s t) Fin.elim0)))))
-  rw [nameSupportFormula, M.realize_allConditions t 3 _ env group rfl]
-  change (∀ g, Realize M.sets _ _) ↔ ∀ g, g ∈ K i → a.act s g τ = τ
-  apply forall_congr'
-  intro g
-  let e := extend (t.encode g) env
-  rw [realize_imp, M.realize_pairMembershipFormula pairing 2 0 5 e hi
-    (M.transitive group (t.encode_mem g)) supports]
-  change (ZFSet.pair (b.encode i) (t.encode g) ∈ supportBasisCode b t K → Realize M.sets _ e) ↔ _
-  rw [pair_mem_supportBasisCode]
-  apply forall_congr'
-  intro _
-  rw [realize_atomicApplication, map_extend, map_extend, map_empty]
-  exact M.realize_nameActionFormula a s t pairing unions powers separation collection
-    carrier group maps g τ τ hτ hτ
-
-end PartitionPilot.Forcing.TransitiveGround
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Forcing.GroundProductActions
+
+namespace OAI
+
+
+namespace PartitionPilot.Forcing
+
+open SetRealization Compression.RecursiveMaps
+universe u
+variable {I G : Type u} [Group G]
+
+noncomputable def supportBasisCode (b : Presentation I) (t : Presentation G)
+    (K : I → Subgroup G) : ZFSet.{u} := (b.product t).subset (fun z => z.2 ∈ K z.1)
+
+theorem pair_mem_supportBasisCode (b : Presentation I) (t : Presentation G)
+    (K : I → Subgroup G) (i : I) (g : G) :
+    ZFSet.pair (b.encode i) (t.encode g) ∈ supportBasisCode b t K ↔ g ∈ K i :=
+  (b.product t).encode_mem_subset (fun z => z.2 ∈ K z.1) (i, g)
+
+theorem finalSupportFamily_basis (Label : Type 1) (H : Subgroup (MainStage.OrdinalRun.FinalActor Label)) :
+    (MainStage.OrdinalRun.supportFamily Label).mem H ↔
+      ∃ C, (MainStage.OrdinalRun.finalAction Label).fixSubgroup C ≤ H := Iff.rfl
+
+end PartitionPilot.Forcing
+
+
+
+namespace PartitionPilot.Forcing.SetFormula
+
+def nameSupportFormula : SetFormula 6 :=
+  allConditions 3 (imp (pairMembershipFormula 2 0 5)
+    (atomicApplication nameActionFormula (extend 3 (extend 6 Fin.elim0)) 0 1 1))
+
+end PartitionPilot.Forcing.SetFormula
+
+namespace PartitionPilot.Forcing.TransitiveGround
+open SetRealization SetFormula
+universe u
+variable (M : TransitiveGround.{u}) {I G P : Type u} [Group G] [PartialOrder P]
+variable (a : PosetAction G P) (s : Presentation P) (t : Presentation G) (b : Presentation I)
+
+theorem realize_nameSupportFormula (K : I → Subgroup G)
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0)
+    (separation : SeparationSchema M.sets) (collection : CollectionSchema M.sets)
+    (carrier : s.carrier ∈ M.sets) (group : t.carrier ∈ M.sets)
+    (supports : supportBasisCode b t K ∈ M.sets)
+    (maps : a.conditionMapFamily s t ∈ M.sets)
+    (i : I) (hi : b.encode i ∈ M.sets) (τ : Name s) (hτ : τ.val ∈ M.sets) :
+    Realize M.sets nameSupportFormula
+      (extend τ.val (extend (b.encode i) (extend s.carrier (extend t.carrier
+        (extend (supportBasisCode b t K) (extend (a.conditionMapFamily s t) Fin.elim0)))))) ↔
+      K i ≤ a.stabilizer s τ := by
+  let env := extend τ.val (extend (b.encode i) (extend s.carrier (extend t.carrier
+    (extend (supportBasisCode b t K) (extend (a.conditionMapFamily s t) Fin.elim0)))))
+  rw [nameSupportFormula, M.realize_allConditions t 3 _ env group rfl]
+  change (∀ g, Realize M.sets _ _) ↔ ∀ g, g ∈ K i → a.act s g τ = τ
+  apply forall_congr'
+  intro g
+  let e := extend (t.encode g) env
+  rw [realize_imp, M.realize_pairMembershipFormula pairing 2 0 5 e hi
+    (M.transitive group (t.encode_mem g)) supports]
+  change (ZFSet.pair (b.encode i) (t.encode g) ∈ supportBasisCode b t K → Realize M.sets _ e) ↔ _
+  rw [pair_mem_supportBasisCode]
+  apply forall_congr'
+  intro _
+  rw [realize_atomicApplication, map_extend, map_extend, map_empty]
+  exact M.realize_nameActionFormula a s t pairing unions powers separation collection
+    carrier group maps g τ τ hτ hτ
+
+end PartitionPilot.Forcing.TransitiveGround
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/NatUnionCodes.lean

@@ -1,373 +1,373 @@
-import OAI.SetTheory.PartitionPrinciple.Transfinite.SetRankBounds
-
-namespace OAI
-
-
-namespace PartitionPilot.SetRealization.Presentation
-
-universe u
-variable {A B : Type u} (s : Presentation A) (t : Presentation B) (f : A → B)
-
-noncomputable def graph : ZFSet.{u} :=
-  (s.product t).subset (fun a => f a.1 = a.2)
-
-theorem pair_mem_graph (a : A) (b : B) :
-    ZFSet.pair (s.encode a) (t.encode b) ∈ s.graph t f ↔ f a = b :=
-  (s.product t).encode_mem_subset (fun a => f a.1 = a.2) (a, b)
-
-theorem mem_graph (x : ZFSet.{u}) :
-    x ∈ s.graph t f ↔ ∃ a, ZFSet.pair (s.encode a) (t.encode (f a)) = x := by
-  rw [graph, mem_subset]
-  constructor
-  · rintro ⟨⟨a, b⟩, h, eq⟩
-    change f a = b at h
-    subst b
-    exact ⟨a, eq⟩
-  · rintro ⟨a, eq⟩
-    exact ⟨(a, f a), rfl, eq⟩
-
-theorem graph_isFunc : ZFSet.IsFunc s.carrier t.carrier (s.graph t f) := by
-  refine ⟨(s.product t).subset_carrier _, ?_⟩
-  intro x hx
-  rcases (s.mem_carrier x).1 hx with ⟨a, rfl⟩
-  refine ⟨t.encode (f a), (s.pair_mem_graph t f a (f a)).2 rfl, ?_⟩
-  intro y hy
-  rcases (s.mem_graph t f _).1 hy with ⟨b, eq⟩
-  have parts := ZFSet.pair_inj.1 eq
-  have ba := s.injective parts.1
-  simpa only [ba] using parts.2.symm
-
-theorem graph_mem_funs : s.graph t f ∈ ZFSet.funs s.carrier t.carrier :=
-  ZFSet.mem_funs.2 (s.graph_isFunc t f)
-
-theorem graph_rank_lt {o : Ordinal.{u}} (limit : Order.IsSuccLimit o)
-    (hs : ZFSet.rank s.carrier < o) (ht : ZFSet.rank t.carrier < o) :
-    ZFSet.rank (s.graph t f) < o :=
-  (s.product t).subset_rank_lt (s.product_rank_lt limit t hs ht) _
-
-end PartitionPilot.SetRealization.Presentation
-
-
-
-namespace PartitionPilot.Forcing
-
-open scoped ZFSet
-
-universe u
-
-def FunctionGraphOn (A f : ZFSet.{u}) : Prop :=
-  ∃ B, ZFSet.IsFunc A B f
-
-def graphRestriction (A f : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => z ∈ ZFSet.prod A (⋃₀ ⋃₀ f)) f
-
-theorem pair_first_mem_doubleUnion {x y f : ZFSet.{u}}
-    (entry : ZFSet.pair x y ∈ f) : x ∈ ⋃₀ ⋃₀ f := by
-  exact ZFSet.mem_sUnion.2 ⟨{x}, ZFSet.mem_sUnion.2
-    ⟨ZFSet.pair x y, entry, ZFSet.mem_pair.2 (Or.inl rfl)⟩,
-    ZFSet.mem_singleton.2 rfl⟩
-
-theorem pair_second_mem_doubleUnion {x y f : ZFSet.{u}}
-    (entry : ZFSet.pair x y ∈ f) : y ∈ ⋃₀ ⋃₀ f := by
-  exact ZFSet.mem_sUnion.2 ⟨{x, y}, ZFSet.mem_sUnion.2
-    ⟨ZFSet.pair x y, entry, ZFSet.mem_pair.2 (Or.inr rfl)⟩,
-    ZFSet.mem_pair.2 (Or.inr rfl)⟩
-
-theorem pair_mem_graphRestriction {A f x y : ZFSet.{u}} :
-    ZFSet.pair x y ∈ graphRestriction A f ↔ ZFSet.pair x y ∈ f ∧ x ∈ A := by
-  constructor
-  · intro h
-    exact ⟨(ZFSet.mem_sep.1 h).1, (ZFSet.pair_mem_prod.1 (ZFSet.mem_sep.1 h).2).1⟩
-  · rintro ⟨entry, hx⟩
-    exact ZFSet.mem_sep.2 ⟨entry, ZFSet.pair_mem_prod.2
-      ⟨hx, pair_second_mem_doubleUnion entry⟩⟩
-
-theorem mem_graphRestriction {A f z : ZFSet.{u}} :
-    z ∈ graphRestriction A f ↔ ∃ x ∈ A, ∃ y, z = ZFSet.pair x y ∧ ZFSet.pair x y ∈ f := by
-  constructor
-  · intro h
-    obtain ⟨x, hx, y, _, rfl⟩ := ZFSet.mem_prod.1 (ZFSet.mem_sep.1 h).2
-    exact ⟨x, hx, y, rfl, (ZFSet.mem_sep.1 h).1⟩
-  · rintro ⟨x, hx, y, rfl, entry⟩
-    exact pair_mem_graphRestriction.2 ⟨entry, hx⟩
-
-theorem graphRestriction_subset (A f : ZFSet.{u}) : graphRestriction A f ⊆ f :=
-  fun _ h => (ZFSet.mem_sep.1 h).1
-
-theorem graphRestriction_restrict {A B f : ZFSet.{u}} (subset : B ⊆ A) :
-    graphRestriction B (graphRestriction A f) = graphRestriction B f := by
-  apply ZFSet.ext
-  intro z
-  constructor
-  · intro hz
-    obtain ⟨x, hx, y, rfl, entry⟩ := mem_graphRestriction.1 hz
-    exact pair_mem_graphRestriction.2 ⟨(pair_mem_graphRestriction.1 entry).1, hx⟩
-  · intro hz
-    obtain ⟨x, hx, y, rfl, entry⟩ := mem_graphRestriction.1 hz
-    exact pair_mem_graphRestriction.2
-      ⟨pair_mem_graphRestriction.2 ⟨entry, subset hx⟩, hx⟩
-
-theorem graphRestriction_eq_sep {A B C f : ZFSet.{u}} (h : ZFSet.IsFunc A B f) :
-    graphRestriction C f = ZFSet.sep (fun z => z ∈ ZFSet.prod C B) f := by
-  apply ZFSet.ext
-  intro z
-  constructor
-  · intro hz
-    obtain ⟨x, hx, y, rfl, entry⟩ := mem_graphRestriction.1 hz
-    exact ZFSet.mem_sep.2 ⟨entry, ZFSet.pair_mem_prod.2
-      ⟨hx, (ZFSet.pair_mem_prod.1 (h.1 entry)).2⟩⟩
-  · intro hz
-    obtain ⟨x, hx, y, _, rfl⟩ := ZFSet.mem_prod.1 (ZFSet.mem_sep.1 hz).2
-    exact pair_mem_graphRestriction.2 ⟨(ZFSet.mem_sep.1 hz).1, hx⟩
-
-theorem graphRestriction_insert_of_not_mem {A f x y : ZFSet.{u}} (fresh : x ∉ A) :
-    graphRestriction A (insert (ZFSet.pair x y) f) = graphRestriction A f := by
-  apply ZFSet.ext
-  intro z
-  constructor
-  · intro hz
-    obtain ⟨a, ha, b, rfl, entry⟩ := mem_graphRestriction.1 hz
-    rcases ZFSet.mem_insert_iff.1 entry with eq | entry
-    · exact False.elim (fresh ((ZFSet.pair_inj.1 eq).1 ▸ ha))
-    · exact pair_mem_graphRestriction.2 ⟨entry, ha⟩
-  · intro hz
-    obtain ⟨a, ha, b, rfl, entry⟩ := mem_graphRestriction.1 hz
-    exact pair_mem_graphRestriction.2 ⟨ZFSet.mem_insert_iff.2 (Or.inr entry), ha⟩
-
-namespace FunctionGraphOn
-
-theorem to_isFunc {A f : ZFSet.{u}} (h : FunctionGraphOn A f) :
-    ZFSet.IsFunc A (⋃₀ ⋃₀ f) f := by
-  obtain ⟨B, shape, total⟩ := h
-  refine ⟨?_, total⟩
-  intro z hz
-  obtain ⟨x, hx, y, _, rfl⟩ := ZFSet.mem_prod.1 (shape hz)
-  exact ZFSet.pair_mem_prod.2 ⟨hx, pair_second_mem_doubleUnion hz⟩
-
-theorem shape {A f : ZFSet.{u}} (h : FunctionGraphOn A f) :
-    ∀ z ∈ f, ∃ x ∈ A, ∃ y, z = ZFSet.pair x y := by
-  intro z hz
-  obtain ⟨x, hx, y, _, eq⟩ := ZFSet.mem_prod.1 (h.to_isFunc.1 hz)
-  exact ⟨x, hx, y, eq⟩
-
-theorem total {A f x : ZFSet.{u}} (h : FunctionGraphOn A f) (hx : x ∈ A) :
-    ∃ y, ZFSet.pair x y ∈ f := by
-  obtain ⟨y, entry, _⟩ := h.to_isFunc.2 x hx
-  exact ⟨y, entry⟩
-
-theorem pair_source {A f x y : ZFSet.{u}} (h : FunctionGraphOn A f)
-    (entry : ZFSet.pair x y ∈ f) : x ∈ A :=
-  (ZFSet.pair_mem_prod.1 (h.to_isFunc.1 entry)).1
-
-theorem unique {A f x y z : ZFSet.{u}} (h : FunctionGraphOn A f)
-    (hy : ZFSet.pair x y ∈ f) (hz : ZFSet.pair x z ∈ f) : y = z := by
-  obtain ⟨w, _, unique⟩ := h.to_isFunc.2 x (h.pair_source hy)
-  exact (unique y hy).trans (unique z hz).symm
-
-theorem restrict {A B f : ZFSet.{u}} (h : FunctionGraphOn A f) (subset : B ⊆ A) :
-    FunctionGraphOn B (graphRestriction B f) := by
-  refine ⟨⋃₀ ⋃₀ f, ?_, ?_⟩
-  · intro z hz
-    exact (ZFSet.mem_sep.1 hz).2
-  · intro x hx
-    obtain ⟨y, entry⟩ := h.total (subset hx)
-    refine ⟨y, pair_mem_graphRestriction.2 ⟨entry, hx⟩, ?_⟩
-    intro z hz
-    exact h.unique (pair_mem_graphRestriction.1 hz).1 entry
-
-theorem restriction_eq {A f : ZFSet.{u}} (h : FunctionGraphOn A f) :
-    graphRestriction A f = f := by
-  apply ZFSet.ext
-  intro z
-  constructor
-  · exact fun hz => graphRestriction_subset A f hz
-  · intro hz
-    exact ZFSet.mem_sep.2 ⟨hz, h.to_isFunc.1 hz⟩
-
-theorem eq_of_agree {A f g : ZFSet.{u}} (hf : FunctionGraphOn A f)
-    (hg : FunctionGraphOn A g)
-    (agree : ∀ x y z, ZFSet.pair x y ∈ f → ZFSet.pair x z ∈ g → y = z) : f = g := by
-  apply ZFSet.ext
-  intro z
-  constructor
-  · intro hz
-    obtain ⟨x, hx, y, _, rfl⟩ := ZFSet.mem_prod.1 (hf.to_isFunc.1 hz)
-    obtain ⟨w, hw⟩ := hg.total hx
-    exact (agree x y w hz hw).symm ▸ hw
-  · intro hz
-    obtain ⟨x, hx, y, _, rfl⟩ := ZFSet.mem_prod.1 (hg.to_isFunc.1 hz)
-    obtain ⟨w, hw⟩ := hf.total hx
-    exact agree x w y hw hz ▸ hw
-
-theorem empty : FunctionGraphOn (∅ : ZFSet.{u}) ∅ :=
-  ⟨∅, ZFSet.empty_subset _, fun x hx => False.elim (ZFSet.notMem_empty x hx)⟩
-
-theorem insert {A f x : ZFSet.{u}} (h : FunctionGraphOn A f) (fresh : x ∉ A)
-    (y : ZFSet.{u}) : FunctionGraphOn (Insert.insert x A) (Insert.insert (ZFSet.pair x y) f) := by
-  classical
-  refine ⟨Insert.insert y (⋃₀ ⋃₀ f), ?_, ?_⟩
-  · intro z hz
-    rcases ZFSet.mem_insert_iff.1 hz with rfl | hz
-    · exact ZFSet.pair_mem_prod.2
-        ⟨ZFSet.mem_insert_iff.2 (Or.inl rfl), ZFSet.mem_insert_iff.2 (Or.inl rfl)⟩
-    · obtain ⟨a, ha, b, hb, rfl⟩ := ZFSet.mem_prod.1 (h.to_isFunc.1 hz)
-      exact ZFSet.pair_mem_prod.2
-        ⟨ZFSet.mem_insert_iff.2 (Or.inr ha), ZFSet.mem_insert_iff.2 (Or.inr hb)⟩
-  · intro a ha
-    rcases ZFSet.mem_insert_iff.1 ha with rfl | ha
-    · refine ⟨y, ZFSet.mem_insert_iff.2 (Or.inl rfl), ?_⟩
-      intro b hb
-      rcases ZFSet.mem_insert_iff.1 hb with eq | hb
-      · exact (ZFSet.pair_inj.1 eq).2
-      · exact False.elim (fresh (h.pair_source hb))
-    · obtain ⟨b, entry⟩ := h.total ha
-      refine ⟨b, ZFSet.mem_insert_iff.2 (Or.inr entry), ?_⟩
-      intro c hc
-      rcases ZFSet.mem_insert_iff.1 hc with eq | hc
-      · exact False.elim (fresh ((ZFSet.pair_inj.1 eq).1 ▸ ha))
-      · exact h.unique hc entry
-
-theorem successor {A f : ZFSet.{u}} (h : FunctionGraphOn A f) (y : ZFSet.{u}) :
-    FunctionGraphOn (Insert.insert A A) (Insert.insert (ZFSet.pair A y) f) :=
-  h.insert (ZFSet.mem_irrefl A) y
-
-end FunctionGraphOn
-
-theorem functionGraphOn_sUnion {A W : ZFSet.{u}}
-    (shape : ∀ f ∈ W, ∃ B, B ⊆ A ∧ FunctionGraphOn B f)
-    (cover : ∀ x ∈ A, ∃ f ∈ W, ∃ y, ZFSet.pair x y ∈ f)
-    (agree : ∀ f ∈ W, ∀ g ∈ W, ∀ x y z,
-      ZFSet.pair x y ∈ f → ZFSet.pair x z ∈ g → y = z) :
-    FunctionGraphOn A (⋃₀ W) := by
-  refine ⟨⋃₀ ⋃₀ (⋃₀ W), ?_, ?_⟩
-  · intro z hz
-    obtain ⟨f, hf, entry⟩ := ZFSet.mem_sUnion.1 hz
-    obtain ⟨B, subset, func⟩ := shape f hf
-    obtain ⟨x, hx, y, _, rfl⟩ := ZFSet.mem_prod.1 (func.to_isFunc.1 entry)
-    exact ZFSet.pair_mem_prod.2 ⟨subset hx, pair_second_mem_doubleUnion hz⟩
-  · intro x hx
-    obtain ⟨f, hf, y, entry⟩ := cover x hx
-    refine ⟨y, ZFSet.mem_sUnion.2 ⟨f, hf, entry⟩, ?_⟩
-    intro z hz
-    obtain ⟨g, hg, rel⟩ := ZFSet.mem_sUnion.1 hz
-    exact agree g hg f hf x z y rel entry
-
-end PartitionPilot.Forcing
-
-
-
-namespace PartitionPilot.SetRealization.Presentation
-universe u
-variable {A B : Type u} (s : Presentation A) (e : B ≃ A)
-
-def reindex : Presentation B where
-  carrier := s.carrier
-  encode b := s.encode (e b)
-  injective := s.injective.comp e.injective
-  mem_carrier x := by
-    rw [s.mem_carrier]
-    exact ⟨fun ⟨a, eq⟩ => ⟨e.symm a, by simpa only [e.apply_symm_apply] using eq⟩,
-      fun ⟨b, eq⟩ => ⟨e b, eq⟩⟩
-
-theorem reindex_carrier : (s.reindex e).carrier = s.carrier := rfl
-
-theorem reindex_encode (b : B) : (s.reindex e).encode b = s.encode (e b) := rfl
-
-theorem graph_reindex {C : Type u} (t : Presentation C) (f : C → B) :
-    t.graph (s.reindex e) f = t.graph s (fun x => e (f x)) := by
-  apply ZFSet.ext
-  intro z
-  rw [mem_graph, mem_graph]
-  rfl
-
-end PartitionPilot.SetRealization.Presentation
-
-
-
-namespace PartitionPilot.Forcing
-universe u
-
-def NatUnionCode (stages : Nat → ZFSet.{u}) (union : ZFSet.{u}) : Prop :=
-  ∀ x, x ∈ union ↔ ∃ n, x ∈ stages n
-
-namespace NatUnionCode
-
-theorem subset {stages : Nat → ZFSet.{u}} {union : ZFSet.{u}}
-    (code : NatUnionCode stages union) (n : Nat) : stages n ⊆ union :=
-  fun _ hx => (code _).2 ⟨n, hx⟩
-
-theorem constant (A : ZFSet.{u}) : NatUnionCode (fun _ => A) A := by
-  intro x
-  exact ⟨fun hx => ⟨0, hx⟩, fun ⟨_, hx⟩ => hx⟩
-
-theorem prod_left {stages : Nat → ZFSet.{u}} {union : ZFSet.{u}}
-    (code : NatUnionCode stages union) (A : ZFSet.{u}) :
-    NatUnionCode (fun n => ZFSet.prod A (stages n)) (ZFSet.prod A union) := by
-  intro z
-  constructor
-  · rintro hz
-    obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 hz
-    obtain ⟨n, hn⟩ := (code y).1 hy
-    exact ⟨n, ZFSet.pair_mem_prod.2 ⟨hx, hn⟩⟩
-  · rintro ⟨n, hn⟩
-    obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 hn
-    exact ZFSet.pair_mem_prod.2 ⟨hx, code.subset n hy⟩
-
-theorem prod {A B : Nat → ZFSet.{u}} {U V : ZFSet.{u}}
-    (left : NatUnionCode A U) (right : NatUnionCode B V)
-    (leftMono : ∀ n m, n ≤ m → A n ⊆ A m)
-    (rightMono : ∀ n m, n ≤ m → B n ⊆ B m) :
-    NatUnionCode (fun n => ZFSet.prod (A n) (B n)) (ZFSet.prod U V) := by
-  intro z
-  constructor
-  · intro hz
-    obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 hz
-    obtain ⟨n, hn⟩ := (left x).1 hx
-    obtain ⟨m, hm⟩ := (right y).1 hy
-    exact ⟨max n m, ZFSet.pair_mem_prod.2
-      ⟨leftMono n _ (le_max_left n m) hn, rightMono m _ (le_max_right n m) hm⟩⟩
-  · rintro ⟨n, hn⟩
-    obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 hn
-    exact ZFSet.pair_mem_prod.2 ⟨left.subset n hx, right.subset n hy⟩
-
-theorem isFunc {A B f : Nat → ZFSet.{u}} {U V F : ZFSet.{u}}
-    (domain : NatUnionCode A U) (range : NatUnionCode B V) (graph : NatUnionCode f F)
-    (functions : ∀ n, ZFSet.IsFunc (A n) (B n) (f n))
-    (graphMono : ∀ n m, n ≤ m → f n ⊆ f m) : ZFSet.IsFunc U V F := by
-  constructor
-  · intro z hz
-    obtain ⟨n, hn⟩ := (graph z).1 hz
-    obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 ((functions n).1 hn)
-    exact ZFSet.pair_mem_prod.2 ⟨domain.subset n hx, range.subset n hy⟩
-  · intro x hx
-    obtain ⟨n, hn⟩ := (domain x).1 hx
-    obtain ⟨y, entry, _⟩ := (functions n).2 x hn
-    refine ⟨y, graph.subset n entry, ?_⟩
-    intro z hz
-    obtain ⟨m, hm⟩ := (graph _).1 hz
-    have first := graphMono n (max n m) (le_max_left n m) entry
-    have second := graphMono m (max n m) (le_max_right n m) hm
-    have inDomain := (ZFSet.pair_mem_prod.1 ((functions (max n m)).1 first)).1
-    obtain ⟨_, _, unique⟩ := (functions (max n m)).2 x inDomain
-    exact (unique z second).trans (unique y first).symm
-
-theorem function_entry_iff {A B f : Nat → ZFSet.{u}} {U V F : ZFSet.{u}}
-    (graph : NatUnionCode f F) (function : ZFSet.IsFunc U V F)
-    (functions : ∀ n, ZFSet.IsFunc (A n) (B n) (f n))
-    (n : Nat) {x y : ZFSet.{u}} (hx : x ∈ A n) :
-    ZFSet.pair x y ∈ F ↔ ZFSet.pair x y ∈ f n := by
-  constructor
-  · intro entry
-    obtain ⟨z, old, _⟩ := (functions n).2 x hx
-    have oldUnion := graph.subset n old
-    have inDomain := (ZFSet.pair_mem_prod.1 (function.1 oldUnion)).1
-    obtain ⟨_, _, unique⟩ := function.2 x inDomain
-    have equal : y = z := (unique y entry).trans (unique z oldUnion).symm
-    exact equal.symm ▸ old
-  · exact fun entry => graph.subset n entry
-
-end NatUnionCode
-
-end PartitionPilot.Forcing
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Transfinite.SetRankBounds
+
+namespace OAI
+
+
+namespace PartitionPilot.SetRealization.Presentation
+
+universe u
+variable {A B : Type u} (s : Presentation A) (t : Presentation B) (f : A → B)
+
+noncomputable def graph : ZFSet.{u} :=
+  (s.product t).subset (fun a => f a.1 = a.2)
+
+theorem pair_mem_graph (a : A) (b : B) :
+    ZFSet.pair (s.encode a) (t.encode b) ∈ s.graph t f ↔ f a = b :=
+  (s.product t).encode_mem_subset (fun a => f a.1 = a.2) (a, b)
+
+theorem mem_graph (x : ZFSet.{u}) :
+    x ∈ s.graph t f ↔ ∃ a, ZFSet.pair (s.encode a) (t.encode (f a)) = x := by
+  rw [graph, mem_subset]
+  constructor
+  · rintro ⟨⟨a, b⟩, h, eq⟩
+    change f a = b at h
+    subst b
+    exact ⟨a, eq⟩
+  · rintro ⟨a, eq⟩
+    exact ⟨(a, f a), rfl, eq⟩
+
+theorem graph_isFunc : ZFSet.IsFunc s.carrier t.carrier (s.graph t f) := by
+  refine ⟨(s.product t).subset_carrier _, ?_⟩
+  intro x hx
+  rcases (s.mem_carrier x).1 hx with ⟨a, rfl⟩
+  refine ⟨t.encode (f a), (s.pair_mem_graph t f a (f a)).2 rfl, ?_⟩
+  intro y hy
+  rcases (s.mem_graph t f _).1 hy with ⟨b, eq⟩
+  have parts := ZFSet.pair_inj.1 eq
+  have ba := s.injective parts.1
+  simpa only [ba] using parts.2.symm
+
+theorem graph_mem_funs : s.graph t f ∈ ZFSet.funs s.carrier t.carrier :=
+  ZFSet.mem_funs.2 (s.graph_isFunc t f)
+
+theorem graph_rank_lt {o : Ordinal.{u}} (limit : Order.IsSuccLimit o)
+    (hs : ZFSet.rank s.carrier < o) (ht : ZFSet.rank t.carrier < o) :
+    ZFSet.rank (s.graph t f) < o :=
+  (s.product t).subset_rank_lt (s.product_rank_lt limit t hs ht) _
+
+end PartitionPilot.SetRealization.Presentation
+
+
+
+namespace PartitionPilot.Forcing
+
+open scoped ZFSet
+
+universe u
+
+def FunctionGraphOn (A f : ZFSet.{u}) : Prop :=
+  ∃ B, ZFSet.IsFunc A B f
+
+def graphRestriction (A f : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => z ∈ ZFSet.prod A (⋃₀ ⋃₀ f)) f
+
+theorem pair_first_mem_doubleUnion {x y f : ZFSet.{u}}
+    (entry : ZFSet.pair x y ∈ f) : x ∈ ⋃₀ ⋃₀ f := by
+  exact ZFSet.mem_sUnion.2 ⟨{x}, ZFSet.mem_sUnion.2
+    ⟨ZFSet.pair x y, entry, ZFSet.mem_pair.2 (Or.inl rfl)⟩,
+    ZFSet.mem_singleton.2 rfl⟩
+
+theorem pair_second_mem_doubleUnion {x y f : ZFSet.{u}}
+    (entry : ZFSet.pair x y ∈ f) : y ∈ ⋃₀ ⋃₀ f := by
+  exact ZFSet.mem_sUnion.2 ⟨{x, y}, ZFSet.mem_sUnion.2
+    ⟨ZFSet.pair x y, entry, ZFSet.mem_pair.2 (Or.inr rfl)⟩,
+    ZFSet.mem_pair.2 (Or.inr rfl)⟩
+
+theorem pair_mem_graphRestriction {A f x y : ZFSet.{u}} :
+    ZFSet.pair x y ∈ graphRestriction A f ↔ ZFSet.pair x y ∈ f ∧ x ∈ A := by
+  constructor
+  · intro h
+    exact ⟨(ZFSet.mem_sep.1 h).1, (ZFSet.pair_mem_prod.1 (ZFSet.mem_sep.1 h).2).1⟩
+  · rintro ⟨entry, hx⟩
+    exact ZFSet.mem_sep.2 ⟨entry, ZFSet.pair_mem_prod.2
+      ⟨hx, pair_second_mem_doubleUnion entry⟩⟩
+
+theorem mem_graphRestriction {A f z : ZFSet.{u}} :
+    z ∈ graphRestriction A f ↔ ∃ x ∈ A, ∃ y, z = ZFSet.pair x y ∧ ZFSet.pair x y ∈ f := by
+  constructor
+  · intro h
+    obtain ⟨x, hx, y, _, rfl⟩ := ZFSet.mem_prod.1 (ZFSet.mem_sep.1 h).2
+    exact ⟨x, hx, y, rfl, (ZFSet.mem_sep.1 h).1⟩
+  · rintro ⟨x, hx, y, rfl, entry⟩
+    exact pair_mem_graphRestriction.2 ⟨entry, hx⟩
+
+theorem graphRestriction_subset (A f : ZFSet.{u}) : graphRestriction A f ⊆ f :=
+  fun _ h => (ZFSet.mem_sep.1 h).1
+
+theorem graphRestriction_restrict {A B f : ZFSet.{u}} (subset : B ⊆ A) :
+    graphRestriction B (graphRestriction A f) = graphRestriction B f := by
+  apply ZFSet.ext
+  intro z
+  constructor
+  · intro hz
+    obtain ⟨x, hx, y, rfl, entry⟩ := mem_graphRestriction.1 hz
+    exact pair_mem_graphRestriction.2 ⟨(pair_mem_graphRestriction.1 entry).1, hx⟩
+  · intro hz
+    obtain ⟨x, hx, y, rfl, entry⟩ := mem_graphRestriction.1 hz
+    exact pair_mem_graphRestriction.2
+      ⟨pair_mem_graphRestriction.2 ⟨entry, subset hx⟩, hx⟩
+
+theorem graphRestriction_eq_sep {A B C f : ZFSet.{u}} (h : ZFSet.IsFunc A B f) :
+    graphRestriction C f = ZFSet.sep (fun z => z ∈ ZFSet.prod C B) f := by
+  apply ZFSet.ext
+  intro z
+  constructor
+  · intro hz
+    obtain ⟨x, hx, y, rfl, entry⟩ := mem_graphRestriction.1 hz
+    exact ZFSet.mem_sep.2 ⟨entry, ZFSet.pair_mem_prod.2
+      ⟨hx, (ZFSet.pair_mem_prod.1 (h.1 entry)).2⟩⟩
+  · intro hz
+    obtain ⟨x, hx, y, _, rfl⟩ := ZFSet.mem_prod.1 (ZFSet.mem_sep.1 hz).2
+    exact pair_mem_graphRestriction.2 ⟨(ZFSet.mem_sep.1 hz).1, hx⟩
+
+theorem graphRestriction_insert_of_not_mem {A f x y : ZFSet.{u}} (fresh : x ∉ A) :
+    graphRestriction A (insert (ZFSet.pair x y) f) = graphRestriction A f := by
+  apply ZFSet.ext
+  intro z
+  constructor
+  · intro hz
+    obtain ⟨a, ha, b, rfl, entry⟩ := mem_graphRestriction.1 hz
+    rcases ZFSet.mem_insert_iff.1 entry with eq | entry
+    · exact False.elim (fresh ((ZFSet.pair_inj.1 eq).1 ▸ ha))
+    · exact pair_mem_graphRestriction.2 ⟨entry, ha⟩
+  · intro hz
+    obtain ⟨a, ha, b, rfl, entry⟩ := mem_graphRestriction.1 hz
+    exact pair_mem_graphRestriction.2 ⟨ZFSet.mem_insert_iff.2 (Or.inr entry), ha⟩
+
+namespace FunctionGraphOn
+
+theorem to_isFunc {A f : ZFSet.{u}} (h : FunctionGraphOn A f) :
+    ZFSet.IsFunc A (⋃₀ ⋃₀ f) f := by
+  obtain ⟨B, shape, total⟩ := h
+  refine ⟨?_, total⟩
+  intro z hz
+  obtain ⟨x, hx, y, _, rfl⟩ := ZFSet.mem_prod.1 (shape hz)
+  exact ZFSet.pair_mem_prod.2 ⟨hx, pair_second_mem_doubleUnion hz⟩
+
+theorem shape {A f : ZFSet.{u}} (h : FunctionGraphOn A f) :
+    ∀ z ∈ f, ∃ x ∈ A, ∃ y, z = ZFSet.pair x y := by
+  intro z hz
+  obtain ⟨x, hx, y, _, eq⟩ := ZFSet.mem_prod.1 (h.to_isFunc.1 hz)
+  exact ⟨x, hx, y, eq⟩
+
+theorem total {A f x : ZFSet.{u}} (h : FunctionGraphOn A f) (hx : x ∈ A) :
+    ∃ y, ZFSet.pair x y ∈ f := by
+  obtain ⟨y, entry, _⟩ := h.to_isFunc.2 x hx
+  exact ⟨y, entry⟩
+
+theorem pair_source {A f x y : ZFSet.{u}} (h : FunctionGraphOn A f)
+    (entry : ZFSet.pair x y ∈ f) : x ∈ A :=
+  (ZFSet.pair_mem_prod.1 (h.to_isFunc.1 entry)).1
+
+theorem unique {A f x y z : ZFSet.{u}} (h : FunctionGraphOn A f)
+    (hy : ZFSet.pair x y ∈ f) (hz : ZFSet.pair x z ∈ f) : y = z := by
+  obtain ⟨w, _, unique⟩ := h.to_isFunc.2 x (h.pair_source hy)
+  exact (unique y hy).trans (unique z hz).symm
+
+theorem restrict {A B f : ZFSet.{u}} (h : FunctionGraphOn A f) (subset : B ⊆ A) :
+    FunctionGraphOn B (graphRestriction B f) := by
+  refine ⟨⋃₀ ⋃₀ f, ?_, ?_⟩
+  · intro z hz
+    exact (ZFSet.mem_sep.1 hz).2
+  · intro x hx
+    obtain ⟨y, entry⟩ := h.total (subset hx)
+    refine ⟨y, pair_mem_graphRestriction.2 ⟨entry, hx⟩, ?_⟩
+    intro z hz
+    exact h.unique (pair_mem_graphRestriction.1 hz).1 entry
+
+theorem restriction_eq {A f : ZFSet.{u}} (h : FunctionGraphOn A f) :
+    graphRestriction A f = f := by
+  apply ZFSet.ext
+  intro z
+  constructor
+  · exact fun hz => graphRestriction_subset A f hz
+  · intro hz
+    exact ZFSet.mem_sep.2 ⟨hz, h.to_isFunc.1 hz⟩
+
+theorem eq_of_agree {A f g : ZFSet.{u}} (hf : FunctionGraphOn A f)
+    (hg : FunctionGraphOn A g)
+    (agree : ∀ x y z, ZFSet.pair x y ∈ f → ZFSet.pair x z ∈ g → y = z) : f = g := by
+  apply ZFSet.ext
+  intro z
+  constructor
+  · intro hz
+    obtain ⟨x, hx, y, _, rfl⟩ := ZFSet.mem_prod.1 (hf.to_isFunc.1 hz)
+    obtain ⟨w, hw⟩ := hg.total hx
+    exact (agree x y w hz hw).symm ▸ hw
+  · intro hz
+    obtain ⟨x, hx, y, _, rfl⟩ := ZFSet.mem_prod.1 (hg.to_isFunc.1 hz)
+    obtain ⟨w, hw⟩ := hf.total hx
+    exact agree x w y hw hz ▸ hw
+
+theorem empty : FunctionGraphOn (∅ : ZFSet.{u}) ∅ :=
+  ⟨∅, ZFSet.empty_subset _, fun x hx => False.elim (ZFSet.notMem_empty x hx)⟩
+
+theorem insert {A f x : ZFSet.{u}} (h : FunctionGraphOn A f) (fresh : x ∉ A)
+    (y : ZFSet.{u}) : FunctionGraphOn (Insert.insert x A) (Insert.insert (ZFSet.pair x y) f) := by
+  classical
+  refine ⟨Insert.insert y (⋃₀ ⋃₀ f), ?_, ?_⟩
+  · intro z hz
+    rcases ZFSet.mem_insert_iff.1 hz with rfl | hz
+    · exact ZFSet.pair_mem_prod.2
+        ⟨ZFSet.mem_insert_iff.2 (Or.inl rfl), ZFSet.mem_insert_iff.2 (Or.inl rfl)⟩
+    · obtain ⟨a, ha, b, hb, rfl⟩ := ZFSet.mem_prod.1 (h.to_isFunc.1 hz)
+      exact ZFSet.pair_mem_prod.2
+        ⟨ZFSet.mem_insert_iff.2 (Or.inr ha), ZFSet.mem_insert_iff.2 (Or.inr hb)⟩
+  · intro a ha
+    rcases ZFSet.mem_insert_iff.1 ha with rfl | ha
+    · refine ⟨y, ZFSet.mem_insert_iff.2 (Or.inl rfl), ?_⟩
+      intro b hb
+      rcases ZFSet.mem_insert_iff.1 hb with eq | hb
+      · exact (ZFSet.pair_inj.1 eq).2
+      · exact False.elim (fresh (h.pair_source hb))
+    · obtain ⟨b, entry⟩ := h.total ha
+      refine ⟨b, ZFSet.mem_insert_iff.2 (Or.inr entry), ?_⟩
+      intro c hc
+      rcases ZFSet.mem_insert_iff.1 hc with eq | hc
+      · exact False.elim (fresh ((ZFSet.pair_inj.1 eq).1 ▸ ha))
+      · exact h.unique hc entry
+
+theorem successor {A f : ZFSet.{u}} (h : FunctionGraphOn A f) (y : ZFSet.{u}) :
+    FunctionGraphOn (Insert.insert A A) (Insert.insert (ZFSet.pair A y) f) :=
+  h.insert (ZFSet.mem_irrefl A) y
+
+end FunctionGraphOn
+
+theorem functionGraphOn_sUnion {A W : ZFSet.{u}}
+    (shape : ∀ f ∈ W, ∃ B, B ⊆ A ∧ FunctionGraphOn B f)
+    (cover : ∀ x ∈ A, ∃ f ∈ W, ∃ y, ZFSet.pair x y ∈ f)
+    (agree : ∀ f ∈ W, ∀ g ∈ W, ∀ x y z,
+      ZFSet.pair x y ∈ f → ZFSet.pair x z ∈ g → y = z) :
+    FunctionGraphOn A (⋃₀ W) := by
+  refine ⟨⋃₀ ⋃₀ (⋃₀ W), ?_, ?_⟩
+  · intro z hz
+    obtain ⟨f, hf, entry⟩ := ZFSet.mem_sUnion.1 hz
+    obtain ⟨B, subset, func⟩ := shape f hf
+    obtain ⟨x, hx, y, _, rfl⟩ := ZFSet.mem_prod.1 (func.to_isFunc.1 entry)
+    exact ZFSet.pair_mem_prod.2 ⟨subset hx, pair_second_mem_doubleUnion hz⟩
+  · intro x hx
+    obtain ⟨f, hf, y, entry⟩ := cover x hx
+    refine ⟨y, ZFSet.mem_sUnion.2 ⟨f, hf, entry⟩, ?_⟩
+    intro z hz
+    obtain ⟨g, hg, rel⟩ := ZFSet.mem_sUnion.1 hz
+    exact agree g hg f hf x z y rel entry
+
+end PartitionPilot.Forcing
+
+
+
+namespace PartitionPilot.SetRealization.Presentation
+universe u
+variable {A B : Type u} (s : Presentation A) (e : B ≃ A)
+
+def reindex : Presentation B where
+  carrier := s.carrier
+  encode b := s.encode (e b)
+  injective := s.injective.comp e.injective
+  mem_carrier x := by
+    rw [s.mem_carrier]
+    exact ⟨fun ⟨a, eq⟩ => ⟨e.symm a, by simpa only [e.apply_symm_apply] using eq⟩,
+      fun ⟨b, eq⟩ => ⟨e b, eq⟩⟩
+
+theorem reindex_carrier : (s.reindex e).carrier = s.carrier := rfl
+
+theorem reindex_encode (b : B) : (s.reindex e).encode b = s.encode (e b) := rfl
+
+theorem graph_reindex {C : Type u} (t : Presentation C) (f : C → B) :
+    t.graph (s.reindex e) f = t.graph s (fun x => e (f x)) := by
+  apply ZFSet.ext
+  intro z
+  rw [mem_graph, mem_graph]
+  rfl
+
+end PartitionPilot.SetRealization.Presentation
+
+
+
+namespace PartitionPilot.Forcing
+universe u
+
+def NatUnionCode (stages : Nat → ZFSet.{u}) (union : ZFSet.{u}) : Prop :=
+  ∀ x, x ∈ union ↔ ∃ n, x ∈ stages n
+
+namespace NatUnionCode
+
+theorem subset {stages : Nat → ZFSet.{u}} {union : ZFSet.{u}}
+    (code : NatUnionCode stages union) (n : Nat) : stages n ⊆ union :=
+  fun _ hx => (code _).2 ⟨n, hx⟩
+
+theorem constant (A : ZFSet.{u}) : NatUnionCode (fun _ => A) A := by
+  intro x
+  exact ⟨fun hx => ⟨0, hx⟩, fun ⟨_, hx⟩ => hx⟩
+
+theorem prod_left {stages : Nat → ZFSet.{u}} {union : ZFSet.{u}}
+    (code : NatUnionCode stages union) (A : ZFSet.{u}) :
+    NatUnionCode (fun n => ZFSet.prod A (stages n)) (ZFSet.prod A union) := by
+  intro z
+  constructor
+  · rintro hz
+    obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 hz
+    obtain ⟨n, hn⟩ := (code y).1 hy
+    exact ⟨n, ZFSet.pair_mem_prod.2 ⟨hx, hn⟩⟩
+  · rintro ⟨n, hn⟩
+    obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 hn
+    exact ZFSet.pair_mem_prod.2 ⟨hx, code.subset n hy⟩
+
+theorem prod {A B : Nat → ZFSet.{u}} {U V : ZFSet.{u}}
+    (left : NatUnionCode A U) (right : NatUnionCode B V)
+    (leftMono : ∀ n m, n ≤ m → A n ⊆ A m)
+    (rightMono : ∀ n m, n ≤ m → B n ⊆ B m) :
+    NatUnionCode (fun n => ZFSet.prod (A n) (B n)) (ZFSet.prod U V) := by
+  intro z
+  constructor
+  · intro hz
+    obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 hz
+    obtain ⟨n, hn⟩ := (left x).1 hx
+    obtain ⟨m, hm⟩ := (right y).1 hy
+    exact ⟨max n m, ZFSet.pair_mem_prod.2
+      ⟨leftMono n _ (le_max_left n m) hn, rightMono m _ (le_max_right n m) hm⟩⟩
+  · rintro ⟨n, hn⟩
+    obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 hn
+    exact ZFSet.pair_mem_prod.2 ⟨left.subset n hx, right.subset n hy⟩
+
+theorem isFunc {A B f : Nat → ZFSet.{u}} {U V F : ZFSet.{u}}
+    (domain : NatUnionCode A U) (range : NatUnionCode B V) (graph : NatUnionCode f F)
+    (functions : ∀ n, ZFSet.IsFunc (A n) (B n) (f n))
+    (graphMono : ∀ n m, n ≤ m → f n ⊆ f m) : ZFSet.IsFunc U V F := by
+  constructor
+  · intro z hz
+    obtain ⟨n, hn⟩ := (graph z).1 hz
+    obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 ((functions n).1 hn)
+    exact ZFSet.pair_mem_prod.2 ⟨domain.subset n hx, range.subset n hy⟩
+  · intro x hx
+    obtain ⟨n, hn⟩ := (domain x).1 hx
+    obtain ⟨y, entry, _⟩ := (functions n).2 x hn
+    refine ⟨y, graph.subset n entry, ?_⟩
+    intro z hz
+    obtain ⟨m, hm⟩ := (graph _).1 hz
+    have first := graphMono n (max n m) (le_max_left n m) entry
+    have second := graphMono m (max n m) (le_max_right n m) hm
+    have inDomain := (ZFSet.pair_mem_prod.1 ((functions (max n m)).1 first)).1
+    obtain ⟨_, _, unique⟩ := (functions (max n m)).2 x inDomain
+    exact (unique z second).trans (unique y first).symm
+
+theorem function_entry_iff {A B f : Nat → ZFSet.{u}} {U V F : ZFSet.{u}}
+    (graph : NatUnionCode f F) (function : ZFSet.IsFunc U V F)
+    (functions : ∀ n, ZFSet.IsFunc (A n) (B n) (f n))
+    (n : Nat) {x y : ZFSet.{u}} (hx : x ∈ A n) :
+    ZFSet.pair x y ∈ F ↔ ZFSet.pair x y ∈ f n := by
+  constructor
+  · intro entry
+    obtain ⟨z, old, _⟩ := (functions n).2 x hx
+    have oldUnion := graph.subset n old
+    have inDomain := (ZFSet.pair_mem_prod.1 (function.1 oldUnion)).1
+    obtain ⟨_, _, unique⟩ := function.2 x inDomain
+    have equal : y = z := (unique y entry).trans (unique z oldUnion).symm
+    exact equal.symm ▸ old
+  · exact fun entry => graph.subset n entry
+
+end NatUnionCode
+
+end PartitionPilot.Forcing
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/NaturalSetCodes.lean

@@ -1,149 +1,149 @@
-import OAI.SetTheory.PartitionPrinciple.Forcing.OrbitPairGraphNames
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.SetRealization
-
-universe u
-
-def SetMembers (Q : ZFSet.{u}) : Type u := Shrink Q
-
-namespace SetMembers
-
-noncomputable def raw {Q : ZFSet.{u}} (x : SetMembers Q) : ZFSet.{u} :=
-  ((equivShrink.{u} Q).symm x).val
-
-theorem raw_mem {Q : ZFSet.{u}} (x : SetMembers Q) : raw x ∈ Q :=
-  ((equivShrink.{u} Q).symm x).property
-
-theorem raw_injective (Q : ZFSet.{u}) : Function.Injective (@raw Q) := by
-  intro x y eq
-  apply (equivShrink.{u} Q).symm.injective
-  exact Subtype.ext eq
-
-noncomputable def ofMem {Q : ZFSet.{u}} (x : ZFSet.{u}) (hx : x ∈ Q) : SetMembers Q :=
-  equivShrink.{u} Q ⟨x, hx⟩
-
-theorem raw_ofMem {Q : ZFSet.{u}} (x : ZFSet.{u}) (hx : x ∈ Q) : raw (ofMem x hx) = x := by
-  exact congrArg Subtype.val ((equivShrink.{u} Q).symm_apply_apply ⟨x, hx⟩)
-
-theorem ofMem_raw {Q : ZFSet.{u}} (x : SetMembers Q) : ofMem (raw x) (raw_mem x) = x :=
-  (equivShrink.{u} Q).apply_symm_apply x
-
-noncomputable def presentation (Q : ZFSet.{u}) : Presentation (SetMembers Q) where
-  carrier := Q
-  encode := raw
-  injective := raw_injective Q
-  mem_carrier x := ⟨fun hx => ⟨ofMem x hx, raw_ofMem x hx⟩,
-    fun ⟨a, eq⟩ => eq ▸ raw_mem a⟩
-
-end SetMembers
-
-end PartitionPilot.SetRealization
-
-namespace PartitionPilot.Forcing.TransitiveGround
-
-open SetRealization
-universe u
-variable (M : TransitiveGround.{u})
-
-theorem setMember_ground {Q : ZFSet.{u}} (hQ : Q ∈ M.sets) (x : SetMembers Q) :
-    SetMembers.raw x ∈ M.sets := M.transitive hQ (SetMembers.raw_mem x)
-
-theorem setMembers_countable (small : M.sets.Countable) {Q : ZFSet.{u}} (hQ : Q ∈ M.sets) :
-    Countable (SetMembers Q) := M.conditions_countable (SetMembers.presentation Q) small hQ
-
-end PartitionPilot.Forcing.TransitiveGround
-
-
-
-namespace PartitionPilot.Forcing
-
-universe u
-
-def natSetCode (n : Nat) : ZFSet.{u} := ZFSet.mk (PSet.ofNat n)
-
-theorem natSetCode_zero : natSetCode 0 = (∅ : ZFSet.{u}) := rfl
-
-theorem natSetCode_succ (n : Nat) :
-    natSetCode (n + 1) = insert (natSetCode n) (natSetCode n) := rfl
-
-theorem mem_omega_iff_natSetCode (x : ZFSet.{u}) :
-    x ∈ ZFSet.omega ↔ ∃ n, x = natSetCode n := by
-  induction x using Quotient.inductionOn with
-  | h x =>
-    constructor
-    · rintro ⟨⟨n⟩, h⟩
-      exact ⟨n, ZFSet.sound h⟩
-    · rintro ⟨n, h⟩
-      exact ⟨⟨n⟩, ZFSet.exact h⟩
-
-theorem natSetCode_mem_omega (n : Nat) : natSetCode n ∈ ZFSet.omega.{u} :=
-  (mem_omega_iff_natSetCode _).2 ⟨n, rfl⟩
-
-def zeroOrSuccessor (x : ZFSet.{u}) : Prop :=
-  x = ∅ ∨ ∃ y ∈ x, x = insert y y
-
-def naturalSetProperty (x : ZFSet.{u}) : Prop :=
-  setTransitive x ∧ zeroOrSuccessor x ∧
-    ∀ y ∈ x, setTransitive y ∧ zeroOrSuccessor y
-
-theorem naturalSetProperty_empty : naturalSetProperty (∅ : ZFSet.{u}) := by
-  refine ⟨?_, Or.inl rfl, ?_⟩
-  · intro y hy
-    exact False.elim (ZFSet.notMem_empty y hy)
-  · intro y hy
-    exact False.elim (ZFSet.notMem_empty y hy)
-
-theorem naturalSetProperty_succ {x : ZFSet.{u}} (h : naturalSetProperty x) :
-    naturalSetProperty (insert x x) := by
-  refine ⟨?_, Or.inr ⟨x, ZFSet.mem_insert x x, rfl⟩, ?_⟩
-  · intro y hy z hz
-    rcases ZFSet.mem_insert_iff.1 hy with rfl | hy
-    · exact ZFSet.mem_insert_of_mem _ hz
-    · exact ZFSet.mem_insert_of_mem x (h.1 y hy z hz)
-  · intro y hy
-    rcases ZFSet.mem_insert_iff.1 hy with rfl | hy
-    · exact ⟨h.1, h.2.1⟩
-    · exact h.2.2 y hy
-
-theorem naturalSetProperty_member {x y : ZFSet.{u}}
-    (h : naturalSetProperty x) (hy : y ∈ x) : naturalSetProperty y := by
-  have facts := h.2.2 y hy
-  exact ⟨facts.1, facts.2, fun z hz => h.2.2 z (h.1 y hy z hz)⟩
-
-theorem naturalSetProperty_iff (x : ZFSet.{u}) :
-    naturalSetProperty x ↔ ∃ n, x = natSetCode n := by
-  constructor
-  · induction x using ZFSet.inductionOn with
-    | h x ih =>
-      intro hx
-      rcases hx.2.1 with empty | ⟨y, hy, succ⟩
-      · exact ⟨0, empty⟩
-      · obtain ⟨n, eq⟩ := ih y hy (naturalSetProperty_member hx hy)
-        exact ⟨n + 1, by rw [succ, eq]; rfl⟩
-  · rintro ⟨n, rfl⟩
-    induction n with
-    | zero => exact naturalSetProperty_empty
-    | succ n ih => exact naturalSetProperty_succ ih
-
-theorem naturalSetProperty_iff_mem_omega (x : ZFSet.{u}) :
-    naturalSetProperty x ↔ x ∈ ZFSet.omega :=
-  (naturalSetProperty_iff x).trans (mem_omega_iff_natSetCode x).symm
-
-instance omegaMembers_countable : Countable (SetRealization.SetMembers ZFSet.omega.{u}) := by
-  let f (n : Nat) := SetRealization.SetMembers.ofMem (natSetCode n) (natSetCode_mem_omega n)
-  have onto : Function.Surjective f := by
-    intro x
-    obtain ⟨n, eq⟩ := (mem_omega_iff_natSetCode _).1 (SetRealization.SetMembers.raw_mem x)
-    refine ⟨n, SetRealization.SetMembers.raw_injective _ ?_⟩
-    exact (SetRealization.SetMembers.raw_ofMem _ _).trans eq.symm
-  exact onto.countable
-
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Forcing.OrbitPairGraphNames
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.SetRealization
+
+universe u
+
+def SetMembers (Q : ZFSet.{u}) : Type u := Shrink Q
+
+namespace SetMembers
+
+noncomputable def raw {Q : ZFSet.{u}} (x : SetMembers Q) : ZFSet.{u} :=
+  ((equivShrink.{u} Q).symm x).val
+
+theorem raw_mem {Q : ZFSet.{u}} (x : SetMembers Q) : raw x ∈ Q :=
+  ((equivShrink.{u} Q).symm x).property
+
+theorem raw_injective (Q : ZFSet.{u}) : Function.Injective (@raw Q) := by
+  intro x y eq
+  apply (equivShrink.{u} Q).symm.injective
+  exact Subtype.ext eq
+
+noncomputable def ofMem {Q : ZFSet.{u}} (x : ZFSet.{u}) (hx : x ∈ Q) : SetMembers Q :=
+  equivShrink.{u} Q ⟨x, hx⟩
+
+theorem raw_ofMem {Q : ZFSet.{u}} (x : ZFSet.{u}) (hx : x ∈ Q) : raw (ofMem x hx) = x := by
+  exact congrArg Subtype.val ((equivShrink.{u} Q).symm_apply_apply ⟨x, hx⟩)
+
+theorem ofMem_raw {Q : ZFSet.{u}} (x : SetMembers Q) : ofMem (raw x) (raw_mem x) = x :=
+  (equivShrink.{u} Q).apply_symm_apply x
+
+noncomputable def presentation (Q : ZFSet.{u}) : Presentation (SetMembers Q) where
+  carrier := Q
+  encode := raw
+  injective := raw_injective Q
+  mem_carrier x := ⟨fun hx => ⟨ofMem x hx, raw_ofMem x hx⟩,
+    fun ⟨a, eq⟩ => eq ▸ raw_mem a⟩
+
+end SetMembers
+
+end PartitionPilot.SetRealization
+
+namespace PartitionPilot.Forcing.TransitiveGround
+
+open SetRealization
+universe u
+variable (M : TransitiveGround.{u})
+
+theorem setMember_ground {Q : ZFSet.{u}} (hQ : Q ∈ M.sets) (x : SetMembers Q) :
+    SetMembers.raw x ∈ M.sets := M.transitive hQ (SetMembers.raw_mem x)
+
+theorem setMembers_countable (small : M.sets.Countable) {Q : ZFSet.{u}} (hQ : Q ∈ M.sets) :
+    Countable (SetMembers Q) := M.conditions_countable (SetMembers.presentation Q) small hQ
+
+end PartitionPilot.Forcing.TransitiveGround
+
+
+
+namespace PartitionPilot.Forcing
+
+universe u
+
+def natSetCode (n : Nat) : ZFSet.{u} := ZFSet.mk (PSet.ofNat n)
+
+theorem natSetCode_zero : natSetCode 0 = (∅ : ZFSet.{u}) := rfl
+
+theorem natSetCode_succ (n : Nat) :
+    natSetCode (n + 1) = insert (natSetCode n) (natSetCode n) := rfl
+
+theorem mem_omega_iff_natSetCode (x : ZFSet.{u}) :
+    x ∈ ZFSet.omega ↔ ∃ n, x = natSetCode n := by
+  induction x using Quotient.inductionOn with
+  | h x =>
+    constructor
+    · rintro ⟨⟨n⟩, h⟩
+      exact ⟨n, ZFSet.sound h⟩
+    · rintro ⟨n, h⟩
+      exact ⟨⟨n⟩, ZFSet.exact h⟩
+
+theorem natSetCode_mem_omega (n : Nat) : natSetCode n ∈ ZFSet.omega.{u} :=
+  (mem_omega_iff_natSetCode _).2 ⟨n, rfl⟩
+
+def zeroOrSuccessor (x : ZFSet.{u}) : Prop :=
+  x = ∅ ∨ ∃ y ∈ x, x = insert y y
+
+def naturalSetProperty (x : ZFSet.{u}) : Prop :=
+  setTransitive x ∧ zeroOrSuccessor x ∧
+    ∀ y ∈ x, setTransitive y ∧ zeroOrSuccessor y
+
+theorem naturalSetProperty_empty : naturalSetProperty (∅ : ZFSet.{u}) := by
+  refine ⟨?_, Or.inl rfl, ?_⟩
+  · intro y hy
+    exact False.elim (ZFSet.notMem_empty y hy)
+  · intro y hy
+    exact False.elim (ZFSet.notMem_empty y hy)
+
+theorem naturalSetProperty_succ {x : ZFSet.{u}} (h : naturalSetProperty x) :
+    naturalSetProperty (insert x x) := by
+  refine ⟨?_, Or.inr ⟨x, ZFSet.mem_insert x x, rfl⟩, ?_⟩
+  · intro y hy z hz
+    rcases ZFSet.mem_insert_iff.1 hy with rfl | hy
+    · exact ZFSet.mem_insert_of_mem _ hz
+    · exact ZFSet.mem_insert_of_mem x (h.1 y hy z hz)
+  · intro y hy
+    rcases ZFSet.mem_insert_iff.1 hy with rfl | hy
+    · exact ⟨h.1, h.2.1⟩
+    · exact h.2.2 y hy
+
+theorem naturalSetProperty_member {x y : ZFSet.{u}}
+    (h : naturalSetProperty x) (hy : y ∈ x) : naturalSetProperty y := by
+  have facts := h.2.2 y hy
+  exact ⟨facts.1, facts.2, fun z hz => h.2.2 z (h.1 y hy z hz)⟩
+
+theorem naturalSetProperty_iff (x : ZFSet.{u}) :
+    naturalSetProperty x ↔ ∃ n, x = natSetCode n := by
+  constructor
+  · induction x using ZFSet.inductionOn with
+    | h x ih =>
+      intro hx
+      rcases hx.2.1 with empty | ⟨y, hy, succ⟩
+      · exact ⟨0, empty⟩
+      · obtain ⟨n, eq⟩ := ih y hy (naturalSetProperty_member hx hy)
+        exact ⟨n + 1, by rw [succ, eq]; rfl⟩
+  · rintro ⟨n, rfl⟩
+    induction n with
+    | zero => exact naturalSetProperty_empty
+    | succ n ih => exact naturalSetProperty_succ ih
+
+theorem naturalSetProperty_iff_mem_omega (x : ZFSet.{u}) :
+    naturalSetProperty x ↔ x ∈ ZFSet.omega :=
+  (naturalSetProperty_iff x).trans (mem_omega_iff_natSetCode x).symm
+
+instance omegaMembers_countable : Countable (SetRealization.SetMembers ZFSet.omega.{u}) := by
+  let f (n : Nat) := SetRealization.SetMembers.ofMem (natSetCode n) (natSetCode_mem_omega n)
+  have onto : Function.Surjective f := by
+    intro x
+    obtain ⟨n, eq⟩ := (mem_omega_iff_natSetCode _).1 (SetRealization.SetMembers.raw_mem x)
+    refine ⟨n, SetRealization.SetMembers.raw_injective _ ?_⟩
+    exact (SetRealization.SetMembers.raw_ofMem _ _).trans eq.symm
+  exact onto.countable
+
+end PartitionPilot.Forcing
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/NaturalStepFormulas.lean

@@ -1,259 +1,259 @@
-import OAI.SetTheory.PartitionPrinciple.Definability.TaggedSumPresentations
-
-namespace OAI
-
-
-namespace PartitionPilot.Forcing
-
-section
-
-universe u
-
-namespace SetFormula
-
-def functionGraphOnFormula {n} (a f : Fin n) : SetFormula n :=
-  ex (BoundedFormula.functionFormula a.succ 0 f.succ).toFormula
-
-end SetFormula
-
-namespace BoundedFormula
-
-def graphRestrictionFormula {n} (p a b f : Fin n) : BoundedFormula n :=
-  .conj (.allMem p (.conj (.mem 0 f.succ) (productElementFormula 0 a.succ b.succ)))
-    (.allMem f (imp (productElementFormula 0 a.succ b.succ) (.mem 0 p.succ)))
-
-theorem truth_graphRestrictionFormula {n} (p a b f : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (graphRestrictionFormula p a b f) env ↔
-      env p = ZFSet.sep (fun z => z ∈ ZFSet.prod (env a) (env b)) (env f) := by
-  simp only [graphRestrictionFormula, Truth, truth_imp, truth_productElementFormula]
-  change ((∀ z ∈ env p, z ∈ env f ∧ z ∈ ZFSet.prod (env a) (env b)) ∧
-    (∀ z ∈ env f, z ∈ ZFSet.prod (env a) (env b) → z ∈ env p)) ↔ _
-  constructor
-  · rintro ⟨forward, backward⟩
-    apply ZFSet.ext
-    intro z
-    rw [ZFSet.mem_sep]
-    exact ⟨forward z, fun hz => backward z hz.1 hz.2⟩
-  · intro eq
-    rw [eq]
-    exact ⟨fun z hz => ZFSet.mem_sep.1 hz, fun z hz bound => ZFSet.mem_sep.2 ⟨hz, bound⟩⟩
-
-end BoundedFormula
-
-namespace TransitiveGround
-
-open SetFormula
-variable (M : TransitiveGround.{u})
-
-theorem realize_functionGraphOnFormula
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    {n} (a f : Fin n) (env : Fin n → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets) :
-    Realize M.sets (functionGraphOnFormula a f) env ↔ FunctionGraphOn (env a) (env f) := by
-  rw [functionGraphOnFormula, realize_ex]
-  constructor
-  · rintro ⟨B, hB, code⟩
-    exact ⟨B, (BoundedFormula.truth_functionFormula a.succ 0 f.succ _).1
-      ((BoundedFormula.realize_toFormula M _ _ (Fin.cases hB members)).1 code)⟩
-  · intro code
-    have range := M.union_mem unions (M.union_mem unions (members f))
-    exact ⟨ZFSet.sUnion (ZFSet.sUnion (env f)), range,
-      (BoundedFormula.realize_toFormula M _ _ (Fin.cases range members)).2
-        ((BoundedFormula.truth_functionFormula a.succ 0 f.succ _).2 code.to_isFunc)⟩
-
-theorem realize_graphRestrictionFormula {n} (p a b f : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets) :
-    Realize M.sets (BoundedFormula.graphRestrictionFormula p a b f).toFormula env ↔
-      env p = ZFSet.sep (fun z => z ∈ ZFSet.prod (env a) (env b)) (env f) :=
-  (BoundedFormula.realize_toFormula M _ _ members).trans
-    (BoundedFormula.truth_graphRestrictionFormula p a b f env)
-
-end TransitiveGround
-
-end
-
-
-
-
-open SetFormula
-universe u
-
-def groundRecursionStep (M : TransitiveGround.{u}) {k : Nat}
-    (φ : SetFormula (k + 3)) (params : Fin k → ZFSet.{u}) (a p y : ZFSet.{u}) : Prop :=
-  p ∈ M.sets ∧ y ∈ M.sets ∧ Realize M.sets φ (extend a (extend p (extend y params)))
-
-namespace SetFormula
-
-def ordinalRecursionTraceFormula {k : Nat} (φ : SetFormula (k + 3)) : SetFormula (k + 2) :=
-  ex <| .conj (BoundedFormula.functionFormula 1 0 2).toFormula <|
-    .all <| imp (.mem 0 2) <| .all <| imp (.mem 0 2) <|
-      imp (BoundedFormula.pairMembershipFormula 1 0 4).toFormula <|
-        ex <| .conj (BoundedFormula.graphRestrictionFormula 0 2 3 5).toFormula <|
-          reindex (extend 2 (extend 0 (extend 1
-            (fun j => j.succ.succ.succ.succ.succ.succ)))) φ
-
-def ordinalSuccessorTraceFormula {k : Nat} (φ : SetFormula (k + 3)) : SetFormula (k + 2) :=
-  ex (.conj (BoundedFormula.successorFormula 0 1).toFormula
-    (reindex (extend 0 (extend 2 (fun j => j.succ.succ.succ))) (ordinalRecursionTraceFormula φ)))
-
-end SetFormula
-
-namespace TransitiveGround
-
-variable (M : TransitiveGround.{u})
-
-theorem realize_ordinalRecursionTraceFormula
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    {k : Nat} (φ : SetFormula (k + 3)) (params : Fin k → ZFSet.{u})
-    (members : ∀ i, params i ∈ M.sets) {A f : ZFSet.{u}}
-    (hA : A ∈ M.sets) (hf : f ∈ M.sets) :
-    Realize M.sets (ordinalRecursionTraceFormula φ) (extend A (extend f params)) ↔
-      OrdinalRecursionTrace (groundRecursionStep M φ params) A f := by
-  rw [ordinalRecursionTraceFormula, realize_ex]
-  constructor
-  · rintro ⟨B, hB, function, steps⟩
-    have mem3 : ∀ i, extend B (extend A (extend f params)) i ∈ M.sets :=
-      Fin.cases hB (Fin.cases hA (Fin.cases hf members))
-    have func : ZFSet.IsFunc A B f := (BoundedFormula.truth_functionFormula 1 0 2 _).1
-      ((BoundedFormula.realize_toFormula M _ _ mem3).1 function)
-    refine ⟨⟨B, func⟩, ?_⟩
-    intro a ha y ay
-    have haM := M.transitive hA ha
-    have hyB := (ZFSet.pair_mem_prod.1 (func.1 ay)).2
-    have hyM := M.transitive hB hyB
-    have first := (realize_imp M.sets _ _ _).1 (steps a haM) ha
-    have second := (realize_imp M.sets _ _ _).1 (first y hyM) hyB
-    have mem5 : ∀ i, extend y (extend a (extend B (extend A (extend f params)))) i ∈ M.sets :=
-      Fin.cases hyM (Fin.cases haM mem3)
-    have pairCode := (BoundedFormula.realize_toFormula M _ _ mem5).2
-      ((BoundedFormula.truth_pairMembershipFormula 1 0 4 _).2 ay)
-    obtain ⟨p, hp, restricted, step⟩ := (realize_ex M.sets _ _).1
-      ((realize_imp M.sets _ _ _).1 second pairCode)
-    have eq := (M.realize_graphRestrictionFormula 0 2 3 5 _ (Fin.cases hp mem5)).1 restricted
-    have same : p = graphRestriction a f := eq.trans (graphRestriction_eq_sep func).symm
-    rw [realize_reindex, map_extend, map_extend, map_extend] at step
-    change Realize M.sets φ (extend a (extend p (extend y params))) at step
-    rw [same] at hp step
-    exact ⟨hp, hyM, step⟩
-  · intro trace
-    let B := ZFSet.sUnion (ZFSet.sUnion f)
-    have hB : B ∈ M.sets := M.union_mem unions (M.union_mem unions hf)
-    have func : ZFSet.IsFunc A B f := trace.1.to_isFunc
-    have mem3 : ∀ i, extend B (extend A (extend f params)) i ∈ M.sets :=
-      Fin.cases hB (Fin.cases hA (Fin.cases hf members))
-    refine ⟨B, hB, (BoundedFormula.realize_toFormula M _ _ mem3).2
-      ((BoundedFormula.truth_functionFormula 1 0 2 _).2 func), ?_⟩
-    intro a haM
-    apply (realize_imp M.sets _ _ _).2
-    intro ha y hyM
-    apply (realize_imp M.sets _ _ _).2
-    intro _
-    apply (realize_imp M.sets _ _ _).2
-    intro pairCode
-    have mem5 : ∀ i, extend y (extend a (extend B (extend A (extend f params)))) i ∈ M.sets :=
-      Fin.cases hyM (Fin.cases haM mem3)
-    have ay := (BoundedFormula.truth_pairMembershipFormula 1 0 4 _).1
-      ((BoundedFormula.realize_toFormula M _ _ mem5).1 pairCode)
-    obtain ⟨hp, _, step⟩ := trace.2 a ha y ay
-    apply (realize_ex M.sets _ _).2
-    refine ⟨graphRestriction a f, hp,
-      (M.realize_graphRestrictionFormula 0 2 3 5 _ (Fin.cases hp mem5)).2
-        (graphRestriction_eq_sep func), ?_⟩
-    rw [realize_reindex, map_extend, map_extend, map_extend]
-    exact step
-
-theorem realize_ordinalSuccessorTraceFormula
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    {k : Nat} (φ : SetFormula (k + 3)) (params : Fin k → ZFSet.{u})
-    (members : ∀ i, params i ∈ M.sets) {a f : ZFSet.{u}}
-    (ha : a ∈ M.sets) (hf : f ∈ M.sets) :
-    Realize M.sets (ordinalSuccessorTraceFormula φ) (extend a (extend f params)) ↔
-      OrdinalRecursionTrace (groundRecursionStep M φ params) (insert a a) f := by
-  rw [ordinalSuccessorTraceFormula, realize_ex]
-  constructor
-  · rintro ⟨A, hA, successor, trace⟩
-    have eq := (BoundedFormula.truth_successorFormula 0 1 _).1
-      ((BoundedFormula.realize_toFormula M _ _
-        (Fin.cases hA (Fin.cases ha (Fin.cases hf members)))).1 successor)
-    rw [realize_reindex, map_extend, map_extend] at trace
-    change Realize M.sets (ordinalRecursionTraceFormula φ) (extend A (extend f params)) at trace
-    have code := (M.realize_ordinalRecursionTraceFormula unions φ params members hA hf).1 trace
-    exact eq ▸ code
-  · intro trace
-    have hA := M.insert_mem pairing unions ha ha
-    refine ⟨insert a a, hA, (BoundedFormula.realize_toFormula M _ _
-      (Fin.cases hA (Fin.cases ha (Fin.cases hf members)))).2
-        ((BoundedFormula.truth_successorFormula 0 1 _).2 rfl), ?_⟩
-    rw [realize_reindex, map_extend, map_extend]
-    exact (M.realize_ordinalRecursionTraceFormula unions φ params members hA hf).2 trace
-
-end TransitiveGround
-
-
-
-
-
-namespace SetFormula
-
-def naturalStepFormula {k : Nat} (successor : SetFormula (k + 2)) : SetFormula (k + 4) :=
-  disj (.conj (BoundedFormula.emptyFormula 0).toFormula (.equal 2 3))
-    (ex (ex (.conj (BoundedFormula.successorFormula 2 1).toFormula
-      (.conj (BoundedFormula.pairMembershipFormula 1 0 3).toFormula
-        (reindex (extend 0 (extend 4 (fun j => j.succ.succ.succ.succ.succ.succ))) successor)))))
-
-end SetFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-
-theorem realize_naturalStepFormula {k : Nat} (φ : SetFormula (k + 2))
-    (params : Fin k → ZFSet.{u}) (members : ∀ i, params i ∈ M.sets)
-    {a p y base : ZFSet.{u}} (ha : a ∈ M.sets) (hp : p ∈ M.sets)
-    (hy : y ∈ M.sets) (hb : base ∈ M.sets) :
-    Realize M.sets (naturalStepFormula φ) (extend a (extend p (extend y (extend base params)))) ↔
-      (a = ∅ ∧ y = base) ∨ ∃ m ∈ M.sets, ∃ x ∈ M.sets,
-        a = insert m m ∧ ZFSet.pair m x ∈ p ∧
-          Realize M.sets φ (extend x (extend y params)) := by
-  have mem4 : ∀ i, extend a (extend p (extend y (extend base params))) i ∈ M.sets :=
-    Fin.cases ha (Fin.cases hp (Fin.cases hy (Fin.cases hb members)))
-  rw [naturalStepFormula, realize_disj]
-  apply or_congr
-  · change (Realize M.sets (BoundedFormula.emptyFormula 0).toFormula _ ∧ y = base) ↔ _
-    exact and_congr ((BoundedFormula.realize_toFormula M _ _ mem4).trans
-      (BoundedFormula.truth_emptyFormula _ _)) Iff.rfl
-  · rw [realize_ex]
-    apply exists_congr
-    intro m
-    apply and_congr_right
-    intro hm
-    rw [realize_ex]
-    apply exists_congr
-    intro x
-    apply and_congr_right
-    intro hx
-    have mem6 : ∀ i, extend x (extend m (extend a (extend p (extend y (extend base params))))) i ∈ M.sets :=
-      Fin.cases hx (Fin.cases hm mem4)
-    change (Realize M.sets (BoundedFormula.successorFormula 2 1).toFormula _ ∧
-      Realize M.sets (BoundedFormula.pairMembershipFormula 1 0 3).toFormula _ ∧ _) ↔ _
-    rw [BoundedFormula.realize_toFormula M _ _ mem6, BoundedFormula.truth_successorFormula,
-      BoundedFormula.realize_toFormula M _ _ mem6, BoundedFormula.truth_pairMembershipFormula,
-      realize_reindex, map_extend, map_extend]
-    rfl
-
-end TransitiveGround
-
-theorem natSetCode_succ_eq_insert_iff (n : Nat) (x : ZFSet.{u}) :
-    natSetCode (n + 1) = insert x x ↔ x = natSetCode n := by
-  constructor
-  · intro equal
-    have member : x ∈ natSetCode (n + 1) := equal.symm ▸ ZFSet.mem_insert x x
-    obtain ⟨j, _, rfl⟩ := (mem_natSetCode x (n + 1)).1 member
-    have codes : natSetCode (n + 1) = natSetCode (j + 1) := equal
-    exact congrArg natSetCode (Nat.add_right_cancel (natSetCode_injective codes)).symm
-  · rintro rfl
-    rfl
-
-
-end PartitionPilot.Forcing
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Definability.TaggedSumPresentations
+
+namespace OAI
+
+
+namespace PartitionPilot.Forcing
+
+section
+
+universe u
+
+namespace SetFormula
+
+def functionGraphOnFormula {n} (a f : Fin n) : SetFormula n :=
+  ex (BoundedFormula.functionFormula a.succ 0 f.succ).toFormula
+
+end SetFormula
+
+namespace BoundedFormula
+
+def graphRestrictionFormula {n} (p a b f : Fin n) : BoundedFormula n :=
+  .conj (.allMem p (.conj (.mem 0 f.succ) (productElementFormula 0 a.succ b.succ)))
+    (.allMem f (imp (productElementFormula 0 a.succ b.succ) (.mem 0 p.succ)))
+
+theorem truth_graphRestrictionFormula {n} (p a b f : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (graphRestrictionFormula p a b f) env ↔
+      env p = ZFSet.sep (fun z => z ∈ ZFSet.prod (env a) (env b)) (env f) := by
+  simp only [graphRestrictionFormula, Truth, truth_imp, truth_productElementFormula]
+  change ((∀ z ∈ env p, z ∈ env f ∧ z ∈ ZFSet.prod (env a) (env b)) ∧
+    (∀ z ∈ env f, z ∈ ZFSet.prod (env a) (env b) → z ∈ env p)) ↔ _
+  constructor
+  · rintro ⟨forward, backward⟩
+    apply ZFSet.ext
+    intro z
+    rw [ZFSet.mem_sep]
+    exact ⟨forward z, fun hz => backward z hz.1 hz.2⟩
+  · intro eq
+    rw [eq]
+    exact ⟨fun z hz => ZFSet.mem_sep.1 hz, fun z hz bound => ZFSet.mem_sep.2 ⟨hz, bound⟩⟩
+
+end BoundedFormula
+
+namespace TransitiveGround
+
+open SetFormula
+variable (M : TransitiveGround.{u})
+
+theorem realize_functionGraphOnFormula
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    {n} (a f : Fin n) (env : Fin n → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets) :
+    Realize M.sets (functionGraphOnFormula a f) env ↔ FunctionGraphOn (env a) (env f) := by
+  rw [functionGraphOnFormula, realize_ex]
+  constructor
+  · rintro ⟨B, hB, code⟩
+    exact ⟨B, (BoundedFormula.truth_functionFormula a.succ 0 f.succ _).1
+      ((BoundedFormula.realize_toFormula M _ _ (Fin.cases hB members)).1 code)⟩
+  · intro code
+    have range := M.union_mem unions (M.union_mem unions (members f))
+    exact ⟨ZFSet.sUnion (ZFSet.sUnion (env f)), range,
+      (BoundedFormula.realize_toFormula M _ _ (Fin.cases range members)).2
+        ((BoundedFormula.truth_functionFormula a.succ 0 f.succ _).2 code.to_isFunc)⟩
+
+theorem realize_graphRestrictionFormula {n} (p a b f : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets) :
+    Realize M.sets (BoundedFormula.graphRestrictionFormula p a b f).toFormula env ↔
+      env p = ZFSet.sep (fun z => z ∈ ZFSet.prod (env a) (env b)) (env f) :=
+  (BoundedFormula.realize_toFormula M _ _ members).trans
+    (BoundedFormula.truth_graphRestrictionFormula p a b f env)
+
+end TransitiveGround
+
+end
+
+
+
+
+open SetFormula
+universe u
+
+def groundRecursionStep (M : TransitiveGround.{u}) {k : Nat}
+    (φ : SetFormula (k + 3)) (params : Fin k → ZFSet.{u}) (a p y : ZFSet.{u}) : Prop :=
+  p ∈ M.sets ∧ y ∈ M.sets ∧ Realize M.sets φ (extend a (extend p (extend y params)))
+
+namespace SetFormula
+
+def ordinalRecursionTraceFormula {k : Nat} (φ : SetFormula (k + 3)) : SetFormula (k + 2) :=
+  ex <| .conj (BoundedFormula.functionFormula 1 0 2).toFormula <|
+    .all <| imp (.mem 0 2) <| .all <| imp (.mem 0 2) <|
+      imp (BoundedFormula.pairMembershipFormula 1 0 4).toFormula <|
+        ex <| .conj (BoundedFormula.graphRestrictionFormula 0 2 3 5).toFormula <|
+          reindex (extend 2 (extend 0 (extend 1
+            (fun j => j.succ.succ.succ.succ.succ.succ)))) φ
+
+def ordinalSuccessorTraceFormula {k : Nat} (φ : SetFormula (k + 3)) : SetFormula (k + 2) :=
+  ex (.conj (BoundedFormula.successorFormula 0 1).toFormula
+    (reindex (extend 0 (extend 2 (fun j => j.succ.succ.succ))) (ordinalRecursionTraceFormula φ)))
+
+end SetFormula
+
+namespace TransitiveGround
+
+variable (M : TransitiveGround.{u})
+
+theorem realize_ordinalRecursionTraceFormula
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    {k : Nat} (φ : SetFormula (k + 3)) (params : Fin k → ZFSet.{u})
+    (members : ∀ i, params i ∈ M.sets) {A f : ZFSet.{u}}
+    (hA : A ∈ M.sets) (hf : f ∈ M.sets) :
+    Realize M.sets (ordinalRecursionTraceFormula φ) (extend A (extend f params)) ↔
+      OrdinalRecursionTrace (groundRecursionStep M φ params) A f := by
+  rw [ordinalRecursionTraceFormula, realize_ex]
+  constructor
+  · rintro ⟨B, hB, function, steps⟩
+    have mem3 : ∀ i, extend B (extend A (extend f params)) i ∈ M.sets :=
+      Fin.cases hB (Fin.cases hA (Fin.cases hf members))
+    have func : ZFSet.IsFunc A B f := (BoundedFormula.truth_functionFormula 1 0 2 _).1
+      ((BoundedFormula.realize_toFormula M _ _ mem3).1 function)
+    refine ⟨⟨B, func⟩, ?_⟩
+    intro a ha y ay
+    have haM := M.transitive hA ha
+    have hyB := (ZFSet.pair_mem_prod.1 (func.1 ay)).2
+    have hyM := M.transitive hB hyB
+    have first := (realize_imp M.sets _ _ _).1 (steps a haM) ha
+    have second := (realize_imp M.sets _ _ _).1 (first y hyM) hyB
+    have mem5 : ∀ i, extend y (extend a (extend B (extend A (extend f params)))) i ∈ M.sets :=
+      Fin.cases hyM (Fin.cases haM mem3)
+    have pairCode := (BoundedFormula.realize_toFormula M _ _ mem5).2
+      ((BoundedFormula.truth_pairMembershipFormula 1 0 4 _).2 ay)
+    obtain ⟨p, hp, restricted, step⟩ := (realize_ex M.sets _ _).1
+      ((realize_imp M.sets _ _ _).1 second pairCode)
+    have eq := (M.realize_graphRestrictionFormula 0 2 3 5 _ (Fin.cases hp mem5)).1 restricted
+    have same : p = graphRestriction a f := eq.trans (graphRestriction_eq_sep func).symm
+    rw [realize_reindex, map_extend, map_extend, map_extend] at step
+    change Realize M.sets φ (extend a (extend p (extend y params))) at step
+    rw [same] at hp step
+    exact ⟨hp, hyM, step⟩
+  · intro trace
+    let B := ZFSet.sUnion (ZFSet.sUnion f)
+    have hB : B ∈ M.sets := M.union_mem unions (M.union_mem unions hf)
+    have func : ZFSet.IsFunc A B f := trace.1.to_isFunc
+    have mem3 : ∀ i, extend B (extend A (extend f params)) i ∈ M.sets :=
+      Fin.cases hB (Fin.cases hA (Fin.cases hf members))
+    refine ⟨B, hB, (BoundedFormula.realize_toFormula M _ _ mem3).2
+      ((BoundedFormula.truth_functionFormula 1 0 2 _).2 func), ?_⟩
+    intro a haM
+    apply (realize_imp M.sets _ _ _).2
+    intro ha y hyM
+    apply (realize_imp M.sets _ _ _).2
+    intro _
+    apply (realize_imp M.sets _ _ _).2
+    intro pairCode
+    have mem5 : ∀ i, extend y (extend a (extend B (extend A (extend f params)))) i ∈ M.sets :=
+      Fin.cases hyM (Fin.cases haM mem3)
+    have ay := (BoundedFormula.truth_pairMembershipFormula 1 0 4 _).1
+      ((BoundedFormula.realize_toFormula M _ _ mem5).1 pairCode)
+    obtain ⟨hp, _, step⟩ := trace.2 a ha y ay
+    apply (realize_ex M.sets _ _).2
+    refine ⟨graphRestriction a f, hp,
+      (M.realize_graphRestrictionFormula 0 2 3 5 _ (Fin.cases hp mem5)).2
+        (graphRestriction_eq_sep func), ?_⟩
+    rw [realize_reindex, map_extend, map_extend, map_extend]
+    exact step
+
+theorem realize_ordinalSuccessorTraceFormula
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    {k : Nat} (φ : SetFormula (k + 3)) (params : Fin k → ZFSet.{u})
+    (members : ∀ i, params i ∈ M.sets) {a f : ZFSet.{u}}
+    (ha : a ∈ M.sets) (hf : f ∈ M.sets) :
+    Realize M.sets (ordinalSuccessorTraceFormula φ) (extend a (extend f params)) ↔
+      OrdinalRecursionTrace (groundRecursionStep M φ params) (insert a a) f := by
+  rw [ordinalSuccessorTraceFormula, realize_ex]
+  constructor
+  · rintro ⟨A, hA, successor, trace⟩
+    have eq := (BoundedFormula.truth_successorFormula 0 1 _).1
+      ((BoundedFormula.realize_toFormula M _ _
+        (Fin.cases hA (Fin.cases ha (Fin.cases hf members)))).1 successor)
+    rw [realize_reindex, map_extend, map_extend] at trace
+    change Realize M.sets (ordinalRecursionTraceFormula φ) (extend A (extend f params)) at trace
+    have code := (M.realize_ordinalRecursionTraceFormula unions φ params members hA hf).1 trace
+    exact eq ▸ code
+  · intro trace
+    have hA := M.insert_mem pairing unions ha ha
+    refine ⟨insert a a, hA, (BoundedFormula.realize_toFormula M _ _
+      (Fin.cases hA (Fin.cases ha (Fin.cases hf members)))).2
+        ((BoundedFormula.truth_successorFormula 0 1 _).2 rfl), ?_⟩
+    rw [realize_reindex, map_extend, map_extend]
+    exact (M.realize_ordinalRecursionTraceFormula unions φ params members hA hf).2 trace
+
+end TransitiveGround
+
+
+
+
+
+namespace SetFormula
+
+def naturalStepFormula {k : Nat} (successor : SetFormula (k + 2)) : SetFormula (k + 4) :=
+  disj (.conj (BoundedFormula.emptyFormula 0).toFormula (.equal 2 3))
+    (ex (ex (.conj (BoundedFormula.successorFormula 2 1).toFormula
+      (.conj (BoundedFormula.pairMembershipFormula 1 0 3).toFormula
+        (reindex (extend 0 (extend 4 (fun j => j.succ.succ.succ.succ.succ.succ))) successor)))))
+
+end SetFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+
+theorem realize_naturalStepFormula {k : Nat} (φ : SetFormula (k + 2))
+    (params : Fin k → ZFSet.{u}) (members : ∀ i, params i ∈ M.sets)
+    {a p y base : ZFSet.{u}} (ha : a ∈ M.sets) (hp : p ∈ M.sets)
+    (hy : y ∈ M.sets) (hb : base ∈ M.sets) :
+    Realize M.sets (naturalStepFormula φ) (extend a (extend p (extend y (extend base params)))) ↔
+      (a = ∅ ∧ y = base) ∨ ∃ m ∈ M.sets, ∃ x ∈ M.sets,
+        a = insert m m ∧ ZFSet.pair m x ∈ p ∧
+          Realize M.sets φ (extend x (extend y params)) := by
+  have mem4 : ∀ i, extend a (extend p (extend y (extend base params))) i ∈ M.sets :=
+    Fin.cases ha (Fin.cases hp (Fin.cases hy (Fin.cases hb members)))
+  rw [naturalStepFormula, realize_disj]
+  apply or_congr
+  · change (Realize M.sets (BoundedFormula.emptyFormula 0).toFormula _ ∧ y = base) ↔ _
+    exact and_congr ((BoundedFormula.realize_toFormula M _ _ mem4).trans
+      (BoundedFormula.truth_emptyFormula _ _)) Iff.rfl
+  · rw [realize_ex]
+    apply exists_congr
+    intro m
+    apply and_congr_right
+    intro hm
+    rw [realize_ex]
+    apply exists_congr
+    intro x
+    apply and_congr_right
+    intro hx
+    have mem6 : ∀ i, extend x (extend m (extend a (extend p (extend y (extend base params))))) i ∈ M.sets :=
+      Fin.cases hx (Fin.cases hm mem4)
+    change (Realize M.sets (BoundedFormula.successorFormula 2 1).toFormula _ ∧
+      Realize M.sets (BoundedFormula.pairMembershipFormula 1 0 3).toFormula _ ∧ _) ↔ _
+    rw [BoundedFormula.realize_toFormula M _ _ mem6, BoundedFormula.truth_successorFormula,
+      BoundedFormula.realize_toFormula M _ _ mem6, BoundedFormula.truth_pairMembershipFormula,
+      realize_reindex, map_extend, map_extend]
+    rfl
+
+end TransitiveGround
+
+theorem natSetCode_succ_eq_insert_iff (n : Nat) (x : ZFSet.{u}) :
+    natSetCode (n + 1) = insert x x ↔ x = natSetCode n := by
+  constructor
+  · intro equal
+    have member : x ∈ natSetCode (n + 1) := equal.symm ▸ ZFSet.mem_insert x x
+    obtain ⟨j, _, rfl⟩ := (mem_natSetCode x (n + 1)).1 member
+    have codes : natSetCode (n + 1) = natSetCode (j + 1) := equal
+    exact congrArg natSetCode (Nat.add_right_cancel (natSetCode_injective codes)).symm
+  · rintro rfl
+    rfl
+
+
+end PartitionPilot.Forcing
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/NonemptyTupleFields.lean

@@ -1,482 +1,482 @@
-import OAI.SetTheory.PartitionPrinciple.Models.GroundInjectionRestrictions
-
-namespace OAI
-
-
-namespace PartitionPilot.Forcing
-
-universe u
-
-noncomputable def nonemptyTupleCode : (k : Nat) → (Fin (k + 1) → ZFSet.{u}) → ZFSet.{u}
-  | 0, fields => fields 0
-  | k + 1, fields => ZFSet.pair (fields 0) (nonemptyTupleCode k (fun i => fields i.succ))
-
-theorem nonemptyTupleCode_injective (k : Nat) : Function.Injective (nonemptyTupleCode.{u} k) := by
-  induction k with
-  | zero =>
-    intro fields fields' equal
-    funext i
-    exact Fin.cases equal (fun j => Fin.elim0 j) i
-  | succ k ih =>
-    intro fields fields' equal
-    obtain ⟨head, tail⟩ := ZFSet.pair_inj.1 equal
-    have same := ih tail
-    funext i
-    exact Fin.cases head (fun j => congrFun same j) i
-
-namespace BoundedFormula
-
-open SetFormula
-
-def nonemptyTupleFormula : (k : Nat) → {n : Nat} →
-    Fin n → (Fin (k + 1) → Fin n) → BoundedFormula n
-  | 0, _, z, fields => .equal z (fields 0)
-  | k + 1, _, z, fields => exMem z (exMem 0
-      (.conj (orderedPairFormula z.succ.succ (fields 0).succ.succ 0)
-        (nonemptyTupleFormula k 0 (fun i => (fields i.succ).succ.succ))))
-
-theorem truth_nonemptyTupleFormula (k : Nat) {n : Nat} (z : Fin n)
-    (fields : Fin (k + 1) → Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (nonemptyTupleFormula k z fields) env ↔
-      env z = nonemptyTupleCode k (fun i => env (fields i)) := by
-  induction k generalizing n with
-  | zero => rfl
-  | succ k ih =>
-    simp only [nonemptyTupleFormula, truth_exMem, Truth, truth_orderedPairFormula, ih]
-    change (∃ a ∈ env z, ∃ b ∈ a, env z = ZFSet.pair (env (fields 0)) b ∧
-      b = nonemptyTupleCode k (fun i => env (fields i.succ))) ↔ _
-    constructor
-    · rintro ⟨_, _, b, _, outer, tail⟩
-      rw [outer, tail]
-      rfl
-    · intro equal
-      let tail := nonemptyTupleCode k (fun i => env (fields i.succ))
-      have outer : env z = ZFSet.pair (env (fields 0)) tail := equal
-      refine ⟨{env (fields 0), tail}, ?_, tail, ZFSet.mem_pair.2 (Or.inr rfl), outer, rfl⟩
-      rw [outer]
-      exact ZFSet.mem_pair.2 (Or.inr rfl)
-
-end BoundedFormula
-
-namespace TransitiveGround
-
-open SetFormula
-variable (M : TransitiveGround.{u})
-
-theorem nonemptyTupleCode_mem (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (k : Nat) (fields : Fin (k + 1) → ZFSet.{u}) (ground : ∀ i, fields i ∈ M.sets) :
-    nonemptyTupleCode k fields ∈ M.sets := by
-  induction k with
-  | zero => exact ground 0
-  | succ k ih => exact M.orderedPair_mem pairing (ground 0) (ih _ (fun i => ground i.succ))
-
-theorem nonemptyTupleCode_field_mem (k : Nat) (fields : Fin (k + 1) → ZFSet.{u})
-    (ground : nonemptyTupleCode k fields ∈ M.sets) : ∀ i, fields i ∈ M.sets := by
-  induction k with
-  | zero => exact Fin.cases ground (fun i => Fin.elim0 i)
-  | succ k ih =>
-    have pairGround : ZFSet.pair (fields 0) (nonemptyTupleCode k (fun i => fields i.succ)) ∈ M.sets := ground
-    have both : ({fields 0, nonemptyTupleCode k (fun i => fields i.succ)} : ZFSet.{u}) ∈ M.sets :=
-      M.transitive pairGround (ZFSet.mem_pair.2 (Or.inr rfl))
-    have head := M.transitive both (ZFSet.mem_pair.2 (Or.inl rfl))
-    have tail := M.transitive both (ZFSet.mem_pair.2 (Or.inr rfl))
-    exact Fin.cases head (ih _ tail)
-
-end TransitiveGround
-
-end PartitionPilot.Forcing
-
-
-
-namespace PartitionPilot.Forcing.BoundedFormula
-open SetFormula
-universe u
-
-def reindex : {n m : Nat} → (Fin n → Fin m) → BoundedFormula n → BoundedFormula m
-  | _, _, f, .equal i j => .equal (f i) (f j)
-  | _, _, f, .mem i j => .mem (f i) (f j)
-  | _, _, f, .neg φ => .neg (reindex f φ)
-  | _, _, f, .conj φ ψ => .conj (reindex f φ) (reindex f ψ)
-  | _, _, f, .allMem b φ => .allMem (f b) (reindex (liftIndex f) φ)
-
-theorem truth_reindex {n m} (f : Fin n → Fin m) (φ : BoundedFormula n)
-    (env : Fin m → ZFSet.{u}) :
-    Truth (reindex f φ) env ↔ Truth φ (fun i => env (f i)) := by
-  induction φ generalizing m with
-  | equal i j => rfl
-  | mem i j => rfl
-  | neg φ ih => exact not_congr (ih f env)
-  | conj φ ψ ihφ ihψ => exact and_congr (ihφ f env) (ihψ f env)
-  | allMem b φ ih =>
-    change (∀ x ∈ env (f b), Truth (reindex (liftIndex f) φ) (extend x env)) ↔ _
-    apply forall_congr'
-    intro x
-    apply forall_congr'
-    intro _
-    rw [ih, extend_liftIndex]
-
-def exPairFields {n} (z : Fin n) (body : BoundedFormula (n + 2)) : BoundedFormula n :=
-  exMem z (exMem 0 (exMem z.succ.succ (exMem 0
-    (.conj (orderedPairFormula z.succ.succ.succ.succ 2 0)
-      (reindex (Fin.cases 0 (Fin.cases 2 (fun i => i.succ.succ.succ.succ))) body)))))
-
-theorem truth_exPairFields {n} (z : Fin n) (body : BoundedFormula (n + 2))
-    (env : Fin n → ZFSet.{u}) :
-    Truth (exPairFields z body) env ↔
-      ∃ x y, env z = ZFSet.pair x y ∧ Truth body (extend y (extend x env)) := by
-  simp only [exPairFields, truth_exMem, Truth, truth_orderedPairFormula, truth_reindex]
-  have rearrange (a x b y : ZFSet.{u}) :
-      (fun i => extend y (extend b (extend x (extend a env)))
-        (Fin.cases 0 (Fin.cases 2 (fun j => j.succ.succ.succ.succ)) i)) =
-        extend y (extend x env) := by
-    funext i
-    refine Fin.cases ?_ (fun j => Fin.cases ?_ (fun k => ?_) j) i <;> rfl
-  simp only [rearrange]
-  change (∃ a ∈ env z, ∃ x ∈ a, ∃ b ∈ env z, ∃ y ∈ b,
-    env z = ZFSet.pair x y ∧ Truth body (extend y (extend x env))) ↔ _
-  constructor
-  · rintro ⟨a, _, x, _, b, _, y, _, equal, holds⟩
-    exact ⟨x, y, equal, holds⟩
-  · rintro ⟨x, y, equal, holds⟩
-    have both : ({x, y} : ZFSet.{u}) ∈ env z := by
-      rw [equal]
-      exact ZFSet.mem_pair.2 (Or.inr rfl)
-    exact ⟨{x,y}, both, x, ZFSet.mem_pair.2 (Or.inl rfl),
-      {x,y}, both, y, ZFSet.mem_pair.2 (Or.inr rfl), equal, holds⟩
-
-def tupleShapeFormula : (k : Nat) → {n : Nat} → Fin n → BoundedFormula n
-  | 0, _, z => .equal z z
-  | k + 1, _, z => exPairFields z (tupleShapeFormula k 0)
-
-theorem truth_tupleShapeFormula (k : Nat) {n} (z : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (tupleShapeFormula k z) env ↔ ∃ fields, env z = nonemptyTupleCode k fields := by
-  induction k generalizing n with
-  | zero =>
-    change env z = env z ↔ ∃ fields : Fin 1 → ZFSet.{u}, env z = fields 0
-    exact ⟨fun _ => ⟨fun _ => env z, rfl⟩, fun _ => rfl⟩
-  | succ k ih =>
-    rw [tupleShapeFormula, truth_exPairFields]
-    constructor
-    · rintro ⟨x, y, equal, shape⟩
-      obtain ⟨fields, tail⟩ := (ih 0 (extend y (extend x env))).1 shape
-      refine ⟨Fin.cases x fields, ?_⟩
-      change env z = ZFSet.pair x (nonemptyTupleCode k fields)
-      exact equal.trans (congrArg (ZFSet.pair x) tail)
-    · rintro ⟨fields, equal⟩
-      exact ⟨fields 0, nonemptyTupleCode k (fun i => fields i.succ), equal,
-        (ih 0 _).2 ⟨fun i => fields i.succ, rfl⟩⟩
-
-end PartitionPilot.Forcing.BoundedFormula
-
-
-
-namespace PartitionPilot.Forcing
-universe u
-
-noncomputable def refinementIndexCode (level C E U Rf Rc : ZFSet.{u}) : ZFSet.{u} :=
-  nonemptyTupleCode 5 ![level, C, E, U, Rf, Rc]
-
-theorem refinementIndexCode_eq_iff (level C E U Rf Rc level' C' E' U' Rf' Rc' : ZFSet.{u}) :
-    refinementIndexCode level C E U Rf Rc = refinementIndexCode level' C' E' U' Rf' Rc' ↔
-      level = level' ∧ C = C' ∧ E = E' ∧ U = U' ∧ Rf = Rf' ∧ Rc = Rc' := by
-  simp only [refinementIndexCode, nonemptyTupleCode, Matrix.cons_val_zero,
-    Matrix.cons_val_succ, ZFSet.pair_inj]
-
-noncomputable def refinementIndexBound (L P V W : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.prod L (ZFSet.prod P (ZFSet.prod P (ZFSet.prod V (ZFSet.prod W W))))
-
-theorem mem_refinementIndexBound (L P V W z : ZFSet.{u}) :
-    z ∈ refinementIndexBound L P V W ↔
-      ∃ level ∈ L, ∃ C ∈ P, ∃ E ∈ P, ∃ U ∈ V, ∃ Rf ∈ W, ∃ Rc ∈ W,
-        z = refinementIndexCode level C E U Rf Rc := by
-  simp only [refinementIndexBound, ZFSet.mem_prod]
-  constructor
-  · rintro ⟨level, hlevel, rest, ⟨C, hC, rest', ⟨E, hE, rest'', ⟨U, hU,
-      rest''', ⟨Rf, hRf, Rc, hRc, rfl⟩, rfl⟩, rfl⟩, rfl⟩, rfl⟩
-    exact ⟨level, hlevel, C, hC, E, hE, U, hU, Rf, hRf, Rc, hRc, rfl⟩
-  · rintro ⟨level, hlevel, C, hC, E, hE, U, hU, Rf, hRf, Rc, hRc, rfl⟩
-    exact ⟨level, hlevel, _, ⟨C, hC, _, ⟨E, hE, _, ⟨U, hU, _,
-      ⟨Rf, hRf, Rc, hRc, rfl⟩, rfl⟩, rfl⟩, rfl⟩, rfl⟩
-
-theorem refinementIndexCode_mem_bound (L P V W level C E U Rf Rc : ZFSet.{u}) :
-    refinementIndexCode level C E U Rf Rc ∈ refinementIndexBound L P V W ↔
-      level ∈ L ∧ C ∈ P ∧ E ∈ P ∧ U ∈ V ∧ Rf ∈ W ∧ Rc ∈ W := by
-  rw [mem_refinementIndexBound]
-  constructor
-  · rintro ⟨l, hl, c, hc, e, he, a, ha, r, hr, t, ht, equal⟩
-    obtain ⟨rfl, rfl, rfl, rfl, rfl, rfl⟩ := (refinementIndexCode_eq_iff _ _ _ _ _ _ _ _ _ _ _ _).1 equal
-    exact ⟨hl, hc, he, ha, hr, ht⟩
-  · rintro ⟨hl, hc, he, hu, hf, hr⟩
-    exact ⟨level, hl, C, hc, E, he, U, hu, Rf, hf, Rc, hr, rfl⟩
-
-namespace BoundedFormula
-
-def refinementIndexFormula {n : Nat} (z level C E U Rf Rc : Fin n) : BoundedFormula n :=
-  nonemptyTupleFormula 5 z ![level, C, E, U, Rf, Rc]
-
-theorem truth_refinementIndexFormula {n : Nat} (z level C E U Rf Rc : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (refinementIndexFormula z level C E U Rf Rc) env ↔
-      env z = refinementIndexCode (env level) (env C) (env E) (env U) (env Rf) (env Rc) := by
-  rw [refinementIndexFormula, truth_nonemptyTupleFormula]
-  rfl
-
-end BoundedFormula
-
-end PartitionPilot.Forcing
-
-
-
-namespace PartitionPilot.Forcing.TransitiveGround
-open SetFormula
-universe u
-variable (M : TransitiveGround.{u})
-
-theorem refinementIndexCode_mem (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    {level C E U Rf Rc : ZFSet.{u}} (hl : level ∈ M.sets) (hC : C ∈ M.sets)
-    (hE : E ∈ M.sets) (hU : U ∈ M.sets) (hf : Rf ∈ M.sets) (hc : Rc ∈ M.sets) :
-    refinementIndexCode level C E U Rf Rc ∈ M.sets :=
-  M.nonemptyTupleCode_mem pairing 5 _
-    (Fin.cases hl (Fin.cases hC (Fin.cases hE (Fin.cases hU
-      (Fin.cases hf (Fin.cases hc (fun j => Fin.elim0 j)))))))
-
-theorem refinementIndexCode_fields_mem {level C E U Rf Rc : ZFSet.{u}}
-    (ground : refinementIndexCode level C E U Rf Rc ∈ M.sets) :
-    level ∈ M.sets ∧ C ∈ M.sets ∧ E ∈ M.sets ∧ U ∈ M.sets ∧
-      Rf ∈ M.sets ∧ Rc ∈ M.sets := by
-  have fields := M.nonemptyTupleCode_field_mem 5 ![level, C, E, U, Rf, Rc] ground
-  exact ⟨fields 0, fields 1, fields 2, fields 3, fields 4, fields 5⟩
-
-theorem refinementIndexBound_mem (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    {L P V W : ZFSet.{u}} (hL : L ∈ M.sets) (hP : P ∈ M.sets)
-    (hV : V ∈ M.sets) (hW : W ∈ M.sets) : refinementIndexBound L P V W ∈ M.sets :=
-  M.prod_mem pairing unions powers separation hL
-    (M.prod_mem pairing unions powers separation hP
-      (M.prod_mem pairing unions powers separation hP
-        (M.prod_mem pairing unions powers separation hV
-          (M.prod_mem pairing unions powers separation hW hW))))
-
-end PartitionPilot.Forcing.TransitiveGround
-
-
-
-namespace PartitionPilot.Forcing
-open SetFormula
-universe u
-
-noncomputable def refinementIndexFieldGraph (I B : ZFSet.{u}) (j : Fin 6) : ZFSet.{u} :=
-  ZFSet.sep (fun z => ∃ fields : Fin 6 → ZFSet.{u},
-    nonemptyTupleCode 5 fields ∈ I ∧ z = ZFSet.pair (nonemptyTupleCode 5 fields) (fields j))
-      (ZFSet.prod I B)
-
-theorem pair_mem_refinementIndexFieldGraph (I B x y : ZFSet.{u}) (j : Fin 6) :
-    ZFSet.pair x y ∈ refinementIndexFieldGraph I B j ↔
-      x ∈ I ∧ y ∈ B ∧ ∃ fields : Fin 6 → ZFSet.{u}, x = nonemptyTupleCode 5 fields ∧ y = fields j := by
-  rw [refinementIndexFieldGraph, ZFSet.mem_sep, ZFSet.pair_mem_prod]
-  constructor
-  · rintro ⟨⟨hx, hy⟩, fields, _, eq⟩
-    exact ⟨hx, hy, fields, ZFSet.pair_inj.1 eq⟩
-  · rintro ⟨hx, hy, fields, rfl, rfl⟩
-    exact ⟨⟨hx, hy⟩, fields, hx, rfl⟩
-
-theorem refinementIndexFieldGraph_entry (I B : ZFSet.{u}) (fields : Fin 6 → ZFSet.{u})
-    (j : Fin 6) (y : ZFSet.{u}) :
-    ZFSet.pair (nonemptyTupleCode 5 fields) y ∈ refinementIndexFieldGraph I B j ↔
-      nonemptyTupleCode 5 fields ∈ I ∧ y ∈ B ∧ y = fields j := by
-  rw [pair_mem_refinementIndexFieldGraph]
-  constructor
-  · rintro ⟨hi, hy, fields', equal, value⟩
-    have same := nonemptyTupleCode_injective 5 equal
-    exact ⟨hi, hy, value.trans (congrFun same j).symm⟩
-  · rintro ⟨hi, hy, value⟩
-    exact ⟨hi, hy, fields, rfl, value⟩
-
-theorem refinementIndexFieldGraph_function (I B : ZFSet.{u}) (j : Fin 6)
-    (fields : ∀ x ∈ I, ∃ v : Fin 6 → ZFSet.{u}, x = nonemptyTupleCode 5 v ∧ v j ∈ B) :
-    ZFSet.IsFunc I B (refinementIndexFieldGraph I B j) := by
-  refine ⟨fun _ hz => (ZFSet.mem_sep.1 hz).1, ?_⟩
-  intro x hx
-  obtain ⟨v, rfl, hv⟩ := fields x hx
-  refine ⟨v j, (refinementIndexFieldGraph_entry I B v j _).2 ⟨hx, hv, rfl⟩, ?_⟩
-  intro y hy
-  exact ((refinementIndexFieldGraph_entry I B v j y).1 hy).2.2
-
-namespace SetFormula
-
-def refinementIndexFieldFormula {n} (z I : Fin n) (j : Fin 6) : SetFormula n :=
-  let old := suffixIndex n 7
-  let w := prefixIndex n 7
-  exBlock 7 (.conj (.mem (w 0) (old I))
-    (.conj (BoundedFormula.nonemptyTupleFormula 5 (w 0) (fun k => w k.succ)).toFormula
-      (BoundedFormula.orderedPairFormula (old z) (w 0) (w j.succ)).toFormula))
-
-end SetFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-
-theorem realize_refinementIndexFieldFormula {n} (z I : Fin n) (j : Fin 6)
-    (env : Fin n → ZFSet.{u}) (members : ∀ k, env k ∈ M.sets) :
-    Realize M.sets (refinementIndexFieldFormula z I j) env ↔
-      ∃ fields : Fin 6 → ZFSet.{u}, nonemptyTupleCode 5 fields ∈ env I ∧
-        env z = ZFSet.pair (nonemptyTupleCode 5 fields) (fields j) := by
-  rw [refinementIndexFieldFormula, realize_exBlock]
-  have actual (w : Fin 7 → ZFSet.{u}) (ground : ∀ k, w k ∈ M.sets) :
-      Realize M.sets (.conj (.mem (prefixIndex n 7 0) (suffixIndex n 7 I))
-        (.conj (BoundedFormula.nonemptyTupleFormula 5 (prefixIndex n 7 0)
-          (fun k => prefixIndex n 7 k.succ)).toFormula
-          (BoundedFormula.orderedPairFormula (suffixIndex n 7 z) (prefixIndex n 7 0)
-            (prefixIndex n 7 j.succ)).toFormula)) (extendMany 7 w env) ↔
-      w 0 ∈ env I ∧ w 0 = nonemptyTupleCode 5 (fun k => w k.succ) ∧
-        env z = ZFSet.pair (w 0) (w j.succ) := by
-    simp only [Realize, BoundedFormula.realize_toFormula M _ _
-      (extendMany_members 7 w env ground members), BoundedFormula.truth_nonemptyTupleFormula,
-      BoundedFormula.truth_orderedPairFormula, extendMany_prefix, extendMany_suffix]
-  constructor
-  · rintro ⟨w, ground, holds⟩
-    obtain ⟨hi, eq, pair⟩ := (actual w ground).1 holds
-    exact ⟨fun k => w k.succ, eq ▸ hi, eq ▸ pair⟩
-  · rintro ⟨fields, hi, pair⟩
-    have hcode := M.transitive (members I) hi
-    have hf := M.nonemptyTupleCode_field_mem 5 fields hcode
-    let w := extend (nonemptyTupleCode 5 fields) fields
-    have ground : ∀ k, w k ∈ M.sets := Fin.cases hcode hf
-    exact ⟨w, ground, (actual w ground).2 ⟨hi, rfl, pair⟩⟩
-
-theorem refinementIndexFieldGraph_mem
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    {I B : ZFSet.{u}} (hI : I ∈ M.sets) (hB : B ∈ M.sets) (j : Fin 6) :
-    refinementIndexFieldGraph I B j ∈ M.sets := by
-  have hp := M.prod_mem pairing unions powers separation hI hB
-  let params := extend I Fin.elim0
-  have ground := M.separation_mem separation (refinementIndexFieldFormula 0 1 j)
-    params (Fin.cases hI (fun k => Fin.elim0 k)) hp
-  have equal : ZFSet.sep (fun z => Realize M.sets (refinementIndexFieldFormula 0 1 j)
-      (extend z params)) (ZFSet.prod I B) = refinementIndexFieldGraph I B j := by
-    apply ZFSet.ext
-    intro z
-    rw [ZFSet.mem_sep, refinementIndexFieldGraph, ZFSet.mem_sep]
-    apply and_congr_right
-    intro hz
-    exact M.realize_refinementIndexFieldFormula 0 1 j _
-      (Fin.cases (M.transitive hp hz) (Fin.cases hI (fun k => Fin.elim0 k)))
-  exact equal ▸ ground
-
-end TransitiveGround
-
-end PartitionPilot.Forcing
-
-
-
-namespace PartitionPilot.Forcing.TransitiveGround
-
-open SetFormula
-open scoped ZFSet
-universe u
-variable (M : TransitiveGround.{u})
-
-theorem graphRestriction_mem
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (separation : SeparationSchema M.sets)
-    {A f : ZFSet.{u}} (hA : A ∈ M.sets) (hf : f ∈ M.sets) :
-    graphRestriction A f ∈ M.sets :=
-  M.injection_restriction_mem separation hA (M.union_mem unions (M.union_mem unions hf)) hf
-
-theorem functionGraphOn_ground_range
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    {A f : ZFSet.{u}} (hf : f ∈ M.sets) (h : FunctionGraphOn A f) :
-    ∃ B ∈ M.sets, ZFSet.IsFunc A B f :=
-  ⟨⋃₀ ⋃₀ f, M.union_mem unions (M.union_mem unions hf), h.to_isFunc⟩
-
-end PartitionPilot.Forcing.TransitiveGround
-
-
-
-namespace PartitionPilot.Forcing
-open SetFormula
-open scoped ZFSet
-universe u
-
-noncomputable def tupleFieldBound : Nat → ZFSet.{u} → ZFSet.{u}
-  | 0, B => B
-  | k + 1, B => (⋃₀ ⋃₀ B) ∪ tupleFieldBound k (⋃₀ ⋃₀ B)
-
-theorem nonemptyTupleCode_field_mem_bound (k : Nat) (fields : Fin (k + 1) → ZFSet.{u})
-    {B : ZFSet.{u}} (member : nonemptyTupleCode k fields ∈ B) :
-    ∀ j, fields j ∈ tupleFieldBound k B := by
-  induction k generalizing B with
-  | zero => exact Fin.cases member (fun j => Fin.elim0 j)
-  | succ k ih =>
-    have pair : ZFSet.pair (fields 0) (nonemptyTupleCode k (fun j => fields j.succ)) ∈ B := member
-    exact Fin.cases (ZFSet.mem_union.2 (Or.inl (pair_first_mem_doubleUnion pair)))
-      (fun j => ZFSet.mem_union.2 (Or.inr (ih _ (pair_second_mem_doubleUnion pair) j)))
-
-namespace BoundedFormula
-noncomputable def tupleFieldFormula : (k : Nat) → {n : Nat} → Fin n → Fin n → Fin (k + 1) → BoundedFormula n
-  | 0, _, z, y, _ => .equal y z
-  | k + 1, _, z, y, j => exPairFields z
-      (Fin.cases (.conj (.equal y.succ.succ 1) (tupleShapeFormula k 0))
-        (fun i => tupleFieldFormula k 0 y.succ.succ i) j)
-
-theorem truth_tupleFieldFormula (k : Nat) {n : Nat} (z y : Fin n) (j : Fin (k + 1))
-    (env : Fin n → ZFSet.{u}) :
-    Truth (tupleFieldFormula k z y j) env ↔
-      ∃ fields : Fin (k + 1) → ZFSet.{u}, env z = nonemptyTupleCode k fields ∧ env y = fields j := by
-  induction k generalizing n with
-  | zero =>
-    change env y = env z ↔ ∃ fields : Fin 1 → ZFSet.{u}, env z = fields 0 ∧ env y = fields j
-    constructor
-    · intro equal
-      exact ⟨fun _ => env z, rfl, equal⟩
-    · rintro ⟨fields, first, second⟩
-      have eq : j = 0 := Fin.cases rfl (fun i => Fin.elim0 i) j
-      exact (eq ▸ second).trans first.symm
-  | succ k ih =>
-    rw [tupleFieldFormula, truth_exPairFields]
-    refine Fin.cases ?_ (fun i => ?_) j
-    · simp only [Fin.cases_zero, Truth, truth_tupleShapeFormula]
-      constructor
-      · rintro ⟨head, tail, pair, value, fields, tuple⟩
-        let all : Fin (k + 2) → ZFSet.{u} := Fin.cases head fields
-        refine ⟨all, ?_, ?_⟩
-        · change env z = ZFSet.pair head (nonemptyTupleCode k fields)
-          exact pair.trans (congrArg (ZFSet.pair head) tuple)
-        · exact value
-      · rintro ⟨fields, pair, value⟩
-        exact ⟨fields 0, nonemptyTupleCode k (fun i => fields i.succ), pair,
-          value, fun i => fields i.succ, rfl⟩
-    · simp only [Fin.cases_succ, ih]
-      constructor
-      · rintro ⟨head, tail, pair, fields, tuple, value⟩
-        let all : Fin (k + 2) → ZFSet.{u} := Fin.cases head fields
-        refine ⟨all, ?_, ?_⟩
-        · change env z = ZFSet.pair head (nonemptyTupleCode k fields)
-          exact pair.trans (congrArg (ZFSet.pair head) tuple)
-        · exact value
-      · rintro ⟨fields, pair, value⟩
-        exact ⟨fields 0, nonemptyTupleCode k (fun i => fields i.succ), pair,
-          fun i => fields i.succ, rfl, value⟩
-
-end BoundedFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-theorem tupleFieldBound_mem
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (k : Nat) {B : ZFSet.{u}} (ground : B ∈ M.sets) : tupleFieldBound k B ∈ M.sets := by
-  induction k generalizing B with
-  | zero => exact ground
-  | succ k ih =>
-    have hB := M.union_mem unions (M.union_mem unions ground)
-    exact M.binary_union_mem pairing unions hB (ih hB)
-
-end TransitiveGround
-
-end PartitionPilot.Forcing
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Models.GroundInjectionRestrictions
+
+namespace OAI
+
+
+namespace PartitionPilot.Forcing
+
+universe u
+
+noncomputable def nonemptyTupleCode : (k : Nat) → (Fin (k + 1) → ZFSet.{u}) → ZFSet.{u}
+  | 0, fields => fields 0
+  | k + 1, fields => ZFSet.pair (fields 0) (nonemptyTupleCode k (fun i => fields i.succ))
+
+theorem nonemptyTupleCode_injective (k : Nat) : Function.Injective (nonemptyTupleCode.{u} k) := by
+  induction k with
+  | zero =>
+    intro fields fields' equal
+    funext i
+    exact Fin.cases equal (fun j => Fin.elim0 j) i
+  | succ k ih =>
+    intro fields fields' equal
+    obtain ⟨head, tail⟩ := ZFSet.pair_inj.1 equal
+    have same := ih tail
+    funext i
+    exact Fin.cases head (fun j => congrFun same j) i
+
+namespace BoundedFormula
+
+open SetFormula
+
+def nonemptyTupleFormula : (k : Nat) → {n : Nat} →
+    Fin n → (Fin (k + 1) → Fin n) → BoundedFormula n
+  | 0, _, z, fields => .equal z (fields 0)
+  | k + 1, _, z, fields => exMem z (exMem 0
+      (.conj (orderedPairFormula z.succ.succ (fields 0).succ.succ 0)
+        (nonemptyTupleFormula k 0 (fun i => (fields i.succ).succ.succ))))
+
+theorem truth_nonemptyTupleFormula (k : Nat) {n : Nat} (z : Fin n)
+    (fields : Fin (k + 1) → Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (nonemptyTupleFormula k z fields) env ↔
+      env z = nonemptyTupleCode k (fun i => env (fields i)) := by
+  induction k generalizing n with
+  | zero => rfl
+  | succ k ih =>
+    simp only [nonemptyTupleFormula, truth_exMem, Truth, truth_orderedPairFormula, ih]
+    change (∃ a ∈ env z, ∃ b ∈ a, env z = ZFSet.pair (env (fields 0)) b ∧
+      b = nonemptyTupleCode k (fun i => env (fields i.succ))) ↔ _
+    constructor
+    · rintro ⟨_, _, b, _, outer, tail⟩
+      rw [outer, tail]
+      rfl
+    · intro equal
+      let tail := nonemptyTupleCode k (fun i => env (fields i.succ))
+      have outer : env z = ZFSet.pair (env (fields 0)) tail := equal
+      refine ⟨{env (fields 0), tail}, ?_, tail, ZFSet.mem_pair.2 (Or.inr rfl), outer, rfl⟩
+      rw [outer]
+      exact ZFSet.mem_pair.2 (Or.inr rfl)
+
+end BoundedFormula
+
+namespace TransitiveGround
+
+open SetFormula
+variable (M : TransitiveGround.{u})
+
+theorem nonemptyTupleCode_mem (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (k : Nat) (fields : Fin (k + 1) → ZFSet.{u}) (ground : ∀ i, fields i ∈ M.sets) :
+    nonemptyTupleCode k fields ∈ M.sets := by
+  induction k with
+  | zero => exact ground 0
+  | succ k ih => exact M.orderedPair_mem pairing (ground 0) (ih _ (fun i => ground i.succ))
+
+theorem nonemptyTupleCode_field_mem (k : Nat) (fields : Fin (k + 1) → ZFSet.{u})
+    (ground : nonemptyTupleCode k fields ∈ M.sets) : ∀ i, fields i ∈ M.sets := by
+  induction k with
+  | zero => exact Fin.cases ground (fun i => Fin.elim0 i)
+  | succ k ih =>
+    have pairGround : ZFSet.pair (fields 0) (nonemptyTupleCode k (fun i => fields i.succ)) ∈ M.sets := ground
+    have both : ({fields 0, nonemptyTupleCode k (fun i => fields i.succ)} : ZFSet.{u}) ∈ M.sets :=
+      M.transitive pairGround (ZFSet.mem_pair.2 (Or.inr rfl))
+    have head := M.transitive both (ZFSet.mem_pair.2 (Or.inl rfl))
+    have tail := M.transitive both (ZFSet.mem_pair.2 (Or.inr rfl))
+    exact Fin.cases head (ih _ tail)
+
+end TransitiveGround
+
+end PartitionPilot.Forcing
+
+
+
+namespace PartitionPilot.Forcing.BoundedFormula
+open SetFormula
+universe u
+
+def reindex : {n m : Nat} → (Fin n → Fin m) → BoundedFormula n → BoundedFormula m
+  | _, _, f, .equal i j => .equal (f i) (f j)
+  | _, _, f, .mem i j => .mem (f i) (f j)
+  | _, _, f, .neg φ => .neg (reindex f φ)
+  | _, _, f, .conj φ ψ => .conj (reindex f φ) (reindex f ψ)
+  | _, _, f, .allMem b φ => .allMem (f b) (reindex (liftIndex f) φ)
+
+theorem truth_reindex {n m} (f : Fin n → Fin m) (φ : BoundedFormula n)
+    (env : Fin m → ZFSet.{u}) :
+    Truth (reindex f φ) env ↔ Truth φ (fun i => env (f i)) := by
+  induction φ generalizing m with
+  | equal i j => rfl
+  | mem i j => rfl
+  | neg φ ih => exact not_congr (ih f env)
+  | conj φ ψ ihφ ihψ => exact and_congr (ihφ f env) (ihψ f env)
+  | allMem b φ ih =>
+    change (∀ x ∈ env (f b), Truth (reindex (liftIndex f) φ) (extend x env)) ↔ _
+    apply forall_congr'
+    intro x
+    apply forall_congr'
+    intro _
+    rw [ih, extend_liftIndex]
+
+def exPairFields {n} (z : Fin n) (body : BoundedFormula (n + 2)) : BoundedFormula n :=
+  exMem z (exMem 0 (exMem z.succ.succ (exMem 0
+    (.conj (orderedPairFormula z.succ.succ.succ.succ 2 0)
+      (reindex (Fin.cases 0 (Fin.cases 2 (fun i => i.succ.succ.succ.succ))) body)))))
+
+theorem truth_exPairFields {n} (z : Fin n) (body : BoundedFormula (n + 2))
+    (env : Fin n → ZFSet.{u}) :
+    Truth (exPairFields z body) env ↔
+      ∃ x y, env z = ZFSet.pair x y ∧ Truth body (extend y (extend x env)) := by
+  simp only [exPairFields, truth_exMem, Truth, truth_orderedPairFormula, truth_reindex]
+  have rearrange (a x b y : ZFSet.{u}) :
+      (fun i => extend y (extend b (extend x (extend a env)))
+        (Fin.cases 0 (Fin.cases 2 (fun j => j.succ.succ.succ.succ)) i)) =
+        extend y (extend x env) := by
+    funext i
+    refine Fin.cases ?_ (fun j => Fin.cases ?_ (fun k => ?_) j) i <;> rfl
+  simp only [rearrange]
+  change (∃ a ∈ env z, ∃ x ∈ a, ∃ b ∈ env z, ∃ y ∈ b,
+    env z = ZFSet.pair x y ∧ Truth body (extend y (extend x env))) ↔ _
+  constructor
+  · rintro ⟨a, _, x, _, b, _, y, _, equal, holds⟩
+    exact ⟨x, y, equal, holds⟩
+  · rintro ⟨x, y, equal, holds⟩
+    have both : ({x, y} : ZFSet.{u}) ∈ env z := by
+      rw [equal]
+      exact ZFSet.mem_pair.2 (Or.inr rfl)
+    exact ⟨{x,y}, both, x, ZFSet.mem_pair.2 (Or.inl rfl),
+      {x,y}, both, y, ZFSet.mem_pair.2 (Or.inr rfl), equal, holds⟩
+
+def tupleShapeFormula : (k : Nat) → {n : Nat} → Fin n → BoundedFormula n
+  | 0, _, z => .equal z z
+  | k + 1, _, z => exPairFields z (tupleShapeFormula k 0)
+
+theorem truth_tupleShapeFormula (k : Nat) {n} (z : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (tupleShapeFormula k z) env ↔ ∃ fields, env z = nonemptyTupleCode k fields := by
+  induction k generalizing n with
+  | zero =>
+    change env z = env z ↔ ∃ fields : Fin 1 → ZFSet.{u}, env z = fields 0
+    exact ⟨fun _ => ⟨fun _ => env z, rfl⟩, fun _ => rfl⟩
+  | succ k ih =>
+    rw [tupleShapeFormula, truth_exPairFields]
+    constructor
+    · rintro ⟨x, y, equal, shape⟩
+      obtain ⟨fields, tail⟩ := (ih 0 (extend y (extend x env))).1 shape
+      refine ⟨Fin.cases x fields, ?_⟩
+      change env z = ZFSet.pair x (nonemptyTupleCode k fields)
+      exact equal.trans (congrArg (ZFSet.pair x) tail)
+    · rintro ⟨fields, equal⟩
+      exact ⟨fields 0, nonemptyTupleCode k (fun i => fields i.succ), equal,
+        (ih 0 _).2 ⟨fun i => fields i.succ, rfl⟩⟩
+
+end PartitionPilot.Forcing.BoundedFormula
+
+
+
+namespace PartitionPilot.Forcing
+universe u
+
+noncomputable def refinementIndexCode (level C E U Rf Rc : ZFSet.{u}) : ZFSet.{u} :=
+  nonemptyTupleCode 5 ![level, C, E, U, Rf, Rc]
+
+theorem refinementIndexCode_eq_iff (level C E U Rf Rc level' C' E' U' Rf' Rc' : ZFSet.{u}) :
+    refinementIndexCode level C E U Rf Rc = refinementIndexCode level' C' E' U' Rf' Rc' ↔
+      level = level' ∧ C = C' ∧ E = E' ∧ U = U' ∧ Rf = Rf' ∧ Rc = Rc' := by
+  simp only [refinementIndexCode, nonemptyTupleCode, Matrix.cons_val_zero,
+    Matrix.cons_val_succ, ZFSet.pair_inj]
+
+noncomputable def refinementIndexBound (L P V W : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.prod L (ZFSet.prod P (ZFSet.prod P (ZFSet.prod V (ZFSet.prod W W))))
+
+theorem mem_refinementIndexBound (L P V W z : ZFSet.{u}) :
+    z ∈ refinementIndexBound L P V W ↔
+      ∃ level ∈ L, ∃ C ∈ P, ∃ E ∈ P, ∃ U ∈ V, ∃ Rf ∈ W, ∃ Rc ∈ W,
+        z = refinementIndexCode level C E U Rf Rc := by
+  simp only [refinementIndexBound, ZFSet.mem_prod]
+  constructor
+  · rintro ⟨level, hlevel, rest, ⟨C, hC, rest', ⟨E, hE, rest'', ⟨U, hU,
+      rest''', ⟨Rf, hRf, Rc, hRc, rfl⟩, rfl⟩, rfl⟩, rfl⟩, rfl⟩
+    exact ⟨level, hlevel, C, hC, E, hE, U, hU, Rf, hRf, Rc, hRc, rfl⟩
+  · rintro ⟨level, hlevel, C, hC, E, hE, U, hU, Rf, hRf, Rc, hRc, rfl⟩
+    exact ⟨level, hlevel, _, ⟨C, hC, _, ⟨E, hE, _, ⟨U, hU, _,
+      ⟨Rf, hRf, Rc, hRc, rfl⟩, rfl⟩, rfl⟩, rfl⟩, rfl⟩
+
+theorem refinementIndexCode_mem_bound (L P V W level C E U Rf Rc : ZFSet.{u}) :
+    refinementIndexCode level C E U Rf Rc ∈ refinementIndexBound L P V W ↔
+      level ∈ L ∧ C ∈ P ∧ E ∈ P ∧ U ∈ V ∧ Rf ∈ W ∧ Rc ∈ W := by
+  rw [mem_refinementIndexBound]
+  constructor
+  · rintro ⟨l, hl, c, hc, e, he, a, ha, r, hr, t, ht, equal⟩
+    obtain ⟨rfl, rfl, rfl, rfl, rfl, rfl⟩ := (refinementIndexCode_eq_iff _ _ _ _ _ _ _ _ _ _ _ _).1 equal
+    exact ⟨hl, hc, he, ha, hr, ht⟩
+  · rintro ⟨hl, hc, he, hu, hf, hr⟩
+    exact ⟨level, hl, C, hc, E, he, U, hu, Rf, hf, Rc, hr, rfl⟩
+
+namespace BoundedFormula
+
+def refinementIndexFormula {n : Nat} (z level C E U Rf Rc : Fin n) : BoundedFormula n :=
+  nonemptyTupleFormula 5 z ![level, C, E, U, Rf, Rc]
+
+theorem truth_refinementIndexFormula {n : Nat} (z level C E U Rf Rc : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (refinementIndexFormula z level C E U Rf Rc) env ↔
+      env z = refinementIndexCode (env level) (env C) (env E) (env U) (env Rf) (env Rc) := by
+  rw [refinementIndexFormula, truth_nonemptyTupleFormula]
+  rfl
+
+end BoundedFormula
+
+end PartitionPilot.Forcing
+
+
+
+namespace PartitionPilot.Forcing.TransitiveGround
+open SetFormula
+universe u
+variable (M : TransitiveGround.{u})
+
+theorem refinementIndexCode_mem (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    {level C E U Rf Rc : ZFSet.{u}} (hl : level ∈ M.sets) (hC : C ∈ M.sets)
+    (hE : E ∈ M.sets) (hU : U ∈ M.sets) (hf : Rf ∈ M.sets) (hc : Rc ∈ M.sets) :
+    refinementIndexCode level C E U Rf Rc ∈ M.sets :=
+  M.nonemptyTupleCode_mem pairing 5 _
+    (Fin.cases hl (Fin.cases hC (Fin.cases hE (Fin.cases hU
+      (Fin.cases hf (Fin.cases hc (fun j => Fin.elim0 j)))))))
+
+theorem refinementIndexCode_fields_mem {level C E U Rf Rc : ZFSet.{u}}
+    (ground : refinementIndexCode level C E U Rf Rc ∈ M.sets) :
+    level ∈ M.sets ∧ C ∈ M.sets ∧ E ∈ M.sets ∧ U ∈ M.sets ∧
+      Rf ∈ M.sets ∧ Rc ∈ M.sets := by
+  have fields := M.nonemptyTupleCode_field_mem 5 ![level, C, E, U, Rf, Rc] ground
+  exact ⟨fields 0, fields 1, fields 2, fields 3, fields 4, fields 5⟩
+
+theorem refinementIndexBound_mem (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    {L P V W : ZFSet.{u}} (hL : L ∈ M.sets) (hP : P ∈ M.sets)
+    (hV : V ∈ M.sets) (hW : W ∈ M.sets) : refinementIndexBound L P V W ∈ M.sets :=
+  M.prod_mem pairing unions powers separation hL
+    (M.prod_mem pairing unions powers separation hP
+      (M.prod_mem pairing unions powers separation hP
+        (M.prod_mem pairing unions powers separation hV
+          (M.prod_mem pairing unions powers separation hW hW))))
+
+end PartitionPilot.Forcing.TransitiveGround
+
+
+
+namespace PartitionPilot.Forcing
+open SetFormula
+universe u
+
+noncomputable def refinementIndexFieldGraph (I B : ZFSet.{u}) (j : Fin 6) : ZFSet.{u} :=
+  ZFSet.sep (fun z => ∃ fields : Fin 6 → ZFSet.{u},
+    nonemptyTupleCode 5 fields ∈ I ∧ z = ZFSet.pair (nonemptyTupleCode 5 fields) (fields j))
+      (ZFSet.prod I B)
+
+theorem pair_mem_refinementIndexFieldGraph (I B x y : ZFSet.{u}) (j : Fin 6) :
+    ZFSet.pair x y ∈ refinementIndexFieldGraph I B j ↔
+      x ∈ I ∧ y ∈ B ∧ ∃ fields : Fin 6 → ZFSet.{u}, x = nonemptyTupleCode 5 fields ∧ y = fields j := by
+  rw [refinementIndexFieldGraph, ZFSet.mem_sep, ZFSet.pair_mem_prod]
+  constructor
+  · rintro ⟨⟨hx, hy⟩, fields, _, eq⟩
+    exact ⟨hx, hy, fields, ZFSet.pair_inj.1 eq⟩
+  · rintro ⟨hx, hy, fields, rfl, rfl⟩
+    exact ⟨⟨hx, hy⟩, fields, hx, rfl⟩
+
+theorem refinementIndexFieldGraph_entry (I B : ZFSet.{u}) (fields : Fin 6 → ZFSet.{u})
+    (j : Fin 6) (y : ZFSet.{u}) :
+    ZFSet.pair (nonemptyTupleCode 5 fields) y ∈ refinementIndexFieldGraph I B j ↔
+      nonemptyTupleCode 5 fields ∈ I ∧ y ∈ B ∧ y = fields j := by
+  rw [pair_mem_refinementIndexFieldGraph]
+  constructor
+  · rintro ⟨hi, hy, fields', equal, value⟩
+    have same := nonemptyTupleCode_injective 5 equal
+    exact ⟨hi, hy, value.trans (congrFun same j).symm⟩
+  · rintro ⟨hi, hy, value⟩
+    exact ⟨hi, hy, fields, rfl, value⟩
+
+theorem refinementIndexFieldGraph_function (I B : ZFSet.{u}) (j : Fin 6)
+    (fields : ∀ x ∈ I, ∃ v : Fin 6 → ZFSet.{u}, x = nonemptyTupleCode 5 v ∧ v j ∈ B) :
+    ZFSet.IsFunc I B (refinementIndexFieldGraph I B j) := by
+  refine ⟨fun _ hz => (ZFSet.mem_sep.1 hz).1, ?_⟩
+  intro x hx
+  obtain ⟨v, rfl, hv⟩ := fields x hx
+  refine ⟨v j, (refinementIndexFieldGraph_entry I B v j _).2 ⟨hx, hv, rfl⟩, ?_⟩
+  intro y hy
+  exact ((refinementIndexFieldGraph_entry I B v j y).1 hy).2.2
+
+namespace SetFormula
+
+def refinementIndexFieldFormula {n} (z I : Fin n) (j : Fin 6) : SetFormula n :=
+  let old := suffixIndex n 7
+  let w := prefixIndex n 7
+  exBlock 7 (.conj (.mem (w 0) (old I))
+    (.conj (BoundedFormula.nonemptyTupleFormula 5 (w 0) (fun k => w k.succ)).toFormula
+      (BoundedFormula.orderedPairFormula (old z) (w 0) (w j.succ)).toFormula))
+
+end SetFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+
+theorem realize_refinementIndexFieldFormula {n} (z I : Fin n) (j : Fin 6)
+    (env : Fin n → ZFSet.{u}) (members : ∀ k, env k ∈ M.sets) :
+    Realize M.sets (refinementIndexFieldFormula z I j) env ↔
+      ∃ fields : Fin 6 → ZFSet.{u}, nonemptyTupleCode 5 fields ∈ env I ∧
+        env z = ZFSet.pair (nonemptyTupleCode 5 fields) (fields j) := by
+  rw [refinementIndexFieldFormula, realize_exBlock]
+  have actual (w : Fin 7 → ZFSet.{u}) (ground : ∀ k, w k ∈ M.sets) :
+      Realize M.sets (.conj (.mem (prefixIndex n 7 0) (suffixIndex n 7 I))
+        (.conj (BoundedFormula.nonemptyTupleFormula 5 (prefixIndex n 7 0)
+          (fun k => prefixIndex n 7 k.succ)).toFormula
+          (BoundedFormula.orderedPairFormula (suffixIndex n 7 z) (prefixIndex n 7 0)
+            (prefixIndex n 7 j.succ)).toFormula)) (extendMany 7 w env) ↔
+      w 0 ∈ env I ∧ w 0 = nonemptyTupleCode 5 (fun k => w k.succ) ∧
+        env z = ZFSet.pair (w 0) (w j.succ) := by
+    simp only [Realize, BoundedFormula.realize_toFormula M _ _
+      (extendMany_members 7 w env ground members), BoundedFormula.truth_nonemptyTupleFormula,
+      BoundedFormula.truth_orderedPairFormula, extendMany_prefix, extendMany_suffix]
+  constructor
+  · rintro ⟨w, ground, holds⟩
+    obtain ⟨hi, eq, pair⟩ := (actual w ground).1 holds
+    exact ⟨fun k => w k.succ, eq ▸ hi, eq ▸ pair⟩
+  · rintro ⟨fields, hi, pair⟩
+    have hcode := M.transitive (members I) hi
+    have hf := M.nonemptyTupleCode_field_mem 5 fields hcode
+    let w := extend (nonemptyTupleCode 5 fields) fields
+    have ground : ∀ k, w k ∈ M.sets := Fin.cases hcode hf
+    exact ⟨w, ground, (actual w ground).2 ⟨hi, rfl, pair⟩⟩
+
+theorem refinementIndexFieldGraph_mem
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    {I B : ZFSet.{u}} (hI : I ∈ M.sets) (hB : B ∈ M.sets) (j : Fin 6) :
+    refinementIndexFieldGraph I B j ∈ M.sets := by
+  have hp := M.prod_mem pairing unions powers separation hI hB
+  let params := extend I Fin.elim0
+  have ground := M.separation_mem separation (refinementIndexFieldFormula 0 1 j)
+    params (Fin.cases hI (fun k => Fin.elim0 k)) hp
+  have equal : ZFSet.sep (fun z => Realize M.sets (refinementIndexFieldFormula 0 1 j)
+      (extend z params)) (ZFSet.prod I B) = refinementIndexFieldGraph I B j := by
+    apply ZFSet.ext
+    intro z
+    rw [ZFSet.mem_sep, refinementIndexFieldGraph, ZFSet.mem_sep]
+    apply and_congr_right
+    intro hz
+    exact M.realize_refinementIndexFieldFormula 0 1 j _
+      (Fin.cases (M.transitive hp hz) (Fin.cases hI (fun k => Fin.elim0 k)))
+  exact equal ▸ ground
+
+end TransitiveGround
+
+end PartitionPilot.Forcing
+
+
+
+namespace PartitionPilot.Forcing.TransitiveGround
+
+open SetFormula
+open scoped ZFSet
+universe u
+variable (M : TransitiveGround.{u})
+
+theorem graphRestriction_mem
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (separation : SeparationSchema M.sets)
+    {A f : ZFSet.{u}} (hA : A ∈ M.sets) (hf : f ∈ M.sets) :
+    graphRestriction A f ∈ M.sets :=
+  M.injection_restriction_mem separation hA (M.union_mem unions (M.union_mem unions hf)) hf
+
+theorem functionGraphOn_ground_range
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    {A f : ZFSet.{u}} (hf : f ∈ M.sets) (h : FunctionGraphOn A f) :
+    ∃ B ∈ M.sets, ZFSet.IsFunc A B f :=
+  ⟨⋃₀ ⋃₀ f, M.union_mem unions (M.union_mem unions hf), h.to_isFunc⟩
+
+end PartitionPilot.Forcing.TransitiveGround
+
+
+
+namespace PartitionPilot.Forcing
+open SetFormula
+open scoped ZFSet
+universe u
+
+noncomputable def tupleFieldBound : Nat → ZFSet.{u} → ZFSet.{u}
+  | 0, B => B
+  | k + 1, B => (⋃₀ ⋃₀ B) ∪ tupleFieldBound k (⋃₀ ⋃₀ B)
+
+theorem nonemptyTupleCode_field_mem_bound (k : Nat) (fields : Fin (k + 1) → ZFSet.{u})
+    {B : ZFSet.{u}} (member : nonemptyTupleCode k fields ∈ B) :
+    ∀ j, fields j ∈ tupleFieldBound k B := by
+  induction k generalizing B with
+  | zero => exact Fin.cases member (fun j => Fin.elim0 j)
+  | succ k ih =>
+    have pair : ZFSet.pair (fields 0) (nonemptyTupleCode k (fun j => fields j.succ)) ∈ B := member
+    exact Fin.cases (ZFSet.mem_union.2 (Or.inl (pair_first_mem_doubleUnion pair)))
+      (fun j => ZFSet.mem_union.2 (Or.inr (ih _ (pair_second_mem_doubleUnion pair) j)))
+
+namespace BoundedFormula
+noncomputable def tupleFieldFormula : (k : Nat) → {n : Nat} → Fin n → Fin n → Fin (k + 1) → BoundedFormula n
+  | 0, _, z, y, _ => .equal y z
+  | k + 1, _, z, y, j => exPairFields z
+      (Fin.cases (.conj (.equal y.succ.succ 1) (tupleShapeFormula k 0))
+        (fun i => tupleFieldFormula k 0 y.succ.succ i) j)
+
+theorem truth_tupleFieldFormula (k : Nat) {n : Nat} (z y : Fin n) (j : Fin (k + 1))
+    (env : Fin n → ZFSet.{u}) :
+    Truth (tupleFieldFormula k z y j) env ↔
+      ∃ fields : Fin (k + 1) → ZFSet.{u}, env z = nonemptyTupleCode k fields ∧ env y = fields j := by
+  induction k generalizing n with
+  | zero =>
+    change env y = env z ↔ ∃ fields : Fin 1 → ZFSet.{u}, env z = fields 0 ∧ env y = fields j
+    constructor
+    · intro equal
+      exact ⟨fun _ => env z, rfl, equal⟩
+    · rintro ⟨fields, first, second⟩
+      have eq : j = 0 := Fin.cases rfl (fun i => Fin.elim0 i) j
+      exact (eq ▸ second).trans first.symm
+  | succ k ih =>
+    rw [tupleFieldFormula, truth_exPairFields]
+    refine Fin.cases ?_ (fun i => ?_) j
+    · simp only [Fin.cases_zero, Truth, truth_tupleShapeFormula]
+      constructor
+      · rintro ⟨head, tail, pair, value, fields, tuple⟩
+        let all : Fin (k + 2) → ZFSet.{u} := Fin.cases head fields
+        refine ⟨all, ?_, ?_⟩
+        · change env z = ZFSet.pair head (nonemptyTupleCode k fields)
+          exact pair.trans (congrArg (ZFSet.pair head) tuple)
+        · exact value
+      · rintro ⟨fields, pair, value⟩
+        exact ⟨fields 0, nonemptyTupleCode k (fun i => fields i.succ), pair,
+          value, fun i => fields i.succ, rfl⟩
+    · simp only [Fin.cases_succ, ih]
+      constructor
+      · rintro ⟨head, tail, pair, fields, tuple, value⟩
+        let all : Fin (k + 2) → ZFSet.{u} := Fin.cases head fields
+        refine ⟨all, ?_, ?_⟩
+        · change env z = ZFSet.pair head (nonemptyTupleCode k fields)
+          exact pair.trans (congrArg (ZFSet.pair head) tuple)
+        · exact value
+      · rintro ⟨fields, pair, value⟩
+        exact ⟨fields 0, nonemptyTupleCode k (fun i => fields i.succ), pair,
+          fun i => fields i.succ, rfl, value⟩
+
+end BoundedFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+theorem tupleFieldBound_mem
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (k : Nat) {B : ZFSet.{u}} (ground : B ∈ M.sets) : tupleFieldBound k B ∈ M.sets := by
+  induction k generalizing B with
+  | zero => exact ground
+  | succ k ih =>
+    have hB := M.union_mem unions (M.union_mem unions ground)
+    exact M.binary_union_mem pairing unions hB (ih hB)
+
+end TransitiveGround
+
+end PartitionPilot.Forcing
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/OrbitImageFormulas.lean

@@ -1,93 +1,93 @@
-import OAI.SetTheory.PartitionPrinciple.Geometry.GroundDefinableSelections
-
-namespace OAI
-
-
-namespace PartitionPilot.Forcing.SetFormula
-
-def codedNameActionFormula : SetFormula 5 :=
-  .conj (domainApplication uniformNameFormula (extend 3 Fin.elim0) 1)
-    (.conj (domainApplication uniformNameFormula (extend 3 Fin.elim0) 2) nameActionFormula)
-
-def orbitImageFormula : SetFormula 6 :=
-  ex (exConditions 5 (.conj (.mem 1 4) (.conj (orderedPairFormula 2 0 1)
-    (atomicApplication codedNameActionFormula (extend 5 (extend 7 Fin.elim0)) 0 1 3))))
-
-end PartitionPilot.Forcing.SetFormula
-
-namespace PartitionPilot.Forcing.TransitiveGround
-
-open SetRealization SetFormula
-universe u
-variable (M : TransitiveGround.{u}) {G P : Type u} [Group G] [PartialOrder P]
-variable (a : PosetAction G P) (s : Presentation P) (t : Presentation G)
-
-theorem realize_codedNameActionFormula
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0)
-    (separation : SeparationSchema M.sets) (collection : CollectionSchema M.sets)
-    (carrier : s.carrier ∈ M.sets) (group : t.carrier ∈ M.sets)
-    (maps : a.conditionMapFamily s t ∈ M.sets)
-    (g : G) (x y : ZFSet.{u}) (hx : x ∈ M.sets) (hy : y ∈ M.sets) :
-    Realize M.sets codedNameActionFormula (extend (t.encode g) (extend x (extend y
-      (extend s.carrier (extend (a.conditionMapFamily s t) Fin.elim0))))) ↔
-      ∃ σ : (M.nameDomain s).names, σ.val.val = x ∧ y = (a.act s g σ.val).val := by
-  rw [codedNameActionFormula]
-  change (Realize M.sets _ _ ∧ Realize M.sets _ _ ∧ Realize M.sets _ _) ↔ _
-  simp only [realize_domainApplication, map_extend, map_empty]
-  constructor
-  · rintro ⟨nameX, nameY, action⟩
-    have nx := (M.realize_uniformNameFormula s pairing unions powers separation collection carrier x hx).1 nameX
-    have ny := (M.realize_uniformNameFormula s pairing unions powers separation collection carrier y hy).1 nameY
-    have eq := (M.realize_nameActionFormula a s t pairing unions powers separation collection carrier group maps
-      g ⟨x, nx⟩ ⟨y, ny⟩ hx hy).1 action
-    exact ⟨⟨⟨x, nx⟩, hx⟩, rfl, (congrArg Subtype.val eq).symm⟩
-  · rintro ⟨σ, rfl, rfl⟩
-    refine ⟨(M.realize_uniformNameFormula s pairing unions powers separation collection carrier _ hx).2 σ.val.property,
-      (M.realize_uniformNameFormula s pairing unions powers separation collection carrier _ hy).2
-        (a.act s g σ.val).property, ?_⟩
-    exact (M.realize_nameActionFormula a s t pairing unions powers separation collection carrier group maps
-      g σ.val (a.act s g σ.val) hx hy).2 rfl
-
-noncomputable def orbitParameters (W : ZFSet.{u}) : Fin 4 → ZFSet.{u} :=
-  extend W (extend s.carrier (extend t.carrier (extend (a.conditionMapFamily s t) Fin.elim0)))
-
-theorem realize_orbitImageFormula
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0)
-    (separation : SeparationSchema M.sets) (collection : CollectionSchema M.sets)
-    (carrier : s.carrier ∈ M.sets) (group : t.carrier ∈ M.sets)
-    (maps : a.conditionMapFamily s t ∈ M.sets)
-    (W z y : ZFSet.{u}) (hz : z ∈ M.sets) (hy : y ∈ M.sets) :
-    Realize M.sets orbitImageFormula (extend z (extend y (orbitParameters a s t W))) ↔
-      ∃ g, ∃ σ : (M.nameDomain s).names, σ.val.val ∈ W ∧
-        z = ZFSet.pair (t.encode g) σ.val.val ∧ y = (a.act s g σ.val).val := by
-  rw [orbitImageFormula, realize_ex]
-  constructor
-  · rintro ⟨x, hx, rest⟩
-    obtain ⟨g, member, shape, action⟩ := (M.realize_exConditions t 5 _
-      (extend x (extend z (extend y (orbitParameters a s t W)))) group rfl).1 rest
-    rw [realize_atomicApplication, map_extend, map_extend, map_empty] at action
-    obtain ⟨σ, eq, output⟩ := (M.realize_codedNameActionFormula a s t pairing unions powers separation collection
-      carrier group maps g x y hx hy).1 action
-    have raw := (M.realize_orderedPairFormula pairing 2 0 1
-      (extend (t.encode g) (extend x (extend z (extend y (orbitParameters a s t W))))) hz
-      (M.transitive group (t.encode_mem g)) hx).1 shape
-    exact ⟨g, σ, eq.symm ▸ member, raw.trans (congrArg (ZFSet.pair (t.encode g)) eq.symm), output⟩
-  · rintro ⟨g, σ, member, shape, output⟩
-    refine ⟨σ.val.val, σ.property, ?_⟩
-    apply (M.realize_exConditions t 5 _
-      (extend σ.val.val (extend z (extend y (orbitParameters a s t W)))) group rfl).2
-    refine ⟨g, member, ?_, ?_⟩
-    · exact (M.realize_orderedPairFormula pairing 2 0 1
-        (extend (t.encode g) (extend σ.val.val (extend z (extend y (orbitParameters a s t W))))) hz
-        (M.transitive group (t.encode_mem g)) σ.property).2 shape
-    · rw [realize_atomicApplication, map_extend, map_extend, map_empty]
-      exact (M.realize_codedNameActionFormula a s t pairing unions powers separation collection
-        carrier group maps g σ.val.val y σ.property hy).2 ⟨σ, rfl, output⟩
-
-end PartitionPilot.Forcing.TransitiveGround
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Geometry.GroundDefinableSelections
+
+namespace OAI
+
+
+namespace PartitionPilot.Forcing.SetFormula
+
+def codedNameActionFormula : SetFormula 5 :=
+  .conj (domainApplication uniformNameFormula (extend 3 Fin.elim0) 1)
+    (.conj (domainApplication uniformNameFormula (extend 3 Fin.elim0) 2) nameActionFormula)
+
+def orbitImageFormula : SetFormula 6 :=
+  ex (exConditions 5 (.conj (.mem 1 4) (.conj (orderedPairFormula 2 0 1)
+    (atomicApplication codedNameActionFormula (extend 5 (extend 7 Fin.elim0)) 0 1 3))))
+
+end PartitionPilot.Forcing.SetFormula
+
+namespace PartitionPilot.Forcing.TransitiveGround
+
+open SetRealization SetFormula
+universe u
+variable (M : TransitiveGround.{u}) {G P : Type u} [Group G] [PartialOrder P]
+variable (a : PosetAction G P) (s : Presentation P) (t : Presentation G)
+
+theorem realize_codedNameActionFormula
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0)
+    (separation : SeparationSchema M.sets) (collection : CollectionSchema M.sets)
+    (carrier : s.carrier ∈ M.sets) (group : t.carrier ∈ M.sets)
+    (maps : a.conditionMapFamily s t ∈ M.sets)
+    (g : G) (x y : ZFSet.{u}) (hx : x ∈ M.sets) (hy : y ∈ M.sets) :
+    Realize M.sets codedNameActionFormula (extend (t.encode g) (extend x (extend y
+      (extend s.carrier (extend (a.conditionMapFamily s t) Fin.elim0))))) ↔
+      ∃ σ : (M.nameDomain s).names, σ.val.val = x ∧ y = (a.act s g σ.val).val := by
+  rw [codedNameActionFormula]
+  change (Realize M.sets _ _ ∧ Realize M.sets _ _ ∧ Realize M.sets _ _) ↔ _
+  simp only [realize_domainApplication, map_extend, map_empty]
+  constructor
+  · rintro ⟨nameX, nameY, action⟩
+    have nx := (M.realize_uniformNameFormula s pairing unions powers separation collection carrier x hx).1 nameX
+    have ny := (M.realize_uniformNameFormula s pairing unions powers separation collection carrier y hy).1 nameY
+    have eq := (M.realize_nameActionFormula a s t pairing unions powers separation collection carrier group maps
+      g ⟨x, nx⟩ ⟨y, ny⟩ hx hy).1 action
+    exact ⟨⟨⟨x, nx⟩, hx⟩, rfl, (congrArg Subtype.val eq).symm⟩
+  · rintro ⟨σ, rfl, rfl⟩
+    refine ⟨(M.realize_uniformNameFormula s pairing unions powers separation collection carrier _ hx).2 σ.val.property,
+      (M.realize_uniformNameFormula s pairing unions powers separation collection carrier _ hy).2
+        (a.act s g σ.val).property, ?_⟩
+    exact (M.realize_nameActionFormula a s t pairing unions powers separation collection carrier group maps
+      g σ.val (a.act s g σ.val) hx hy).2 rfl
+
+noncomputable def orbitParameters (W : ZFSet.{u}) : Fin 4 → ZFSet.{u} :=
+  extend W (extend s.carrier (extend t.carrier (extend (a.conditionMapFamily s t) Fin.elim0)))
+
+theorem realize_orbitImageFormula
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0)
+    (separation : SeparationSchema M.sets) (collection : CollectionSchema M.sets)
+    (carrier : s.carrier ∈ M.sets) (group : t.carrier ∈ M.sets)
+    (maps : a.conditionMapFamily s t ∈ M.sets)
+    (W z y : ZFSet.{u}) (hz : z ∈ M.sets) (hy : y ∈ M.sets) :
+    Realize M.sets orbitImageFormula (extend z (extend y (orbitParameters a s t W))) ↔
+      ∃ g, ∃ σ : (M.nameDomain s).names, σ.val.val ∈ W ∧
+        z = ZFSet.pair (t.encode g) σ.val.val ∧ y = (a.act s g σ.val).val := by
+  rw [orbitImageFormula, realize_ex]
+  constructor
+  · rintro ⟨x, hx, rest⟩
+    obtain ⟨g, member, shape, action⟩ := (M.realize_exConditions t 5 _
+      (extend x (extend z (extend y (orbitParameters a s t W)))) group rfl).1 rest
+    rw [realize_atomicApplication, map_extend, map_extend, map_empty] at action
+    obtain ⟨σ, eq, output⟩ := (M.realize_codedNameActionFormula a s t pairing unions powers separation collection
+      carrier group maps g x y hx hy).1 action
+    have raw := (M.realize_orderedPairFormula pairing 2 0 1
+      (extend (t.encode g) (extend x (extend z (extend y (orbitParameters a s t W))))) hz
+      (M.transitive group (t.encode_mem g)) hx).1 shape
+    exact ⟨g, σ, eq.symm ▸ member, raw.trans (congrArg (ZFSet.pair (t.encode g)) eq.symm), output⟩
+  · rintro ⟨g, σ, member, shape, output⟩
+    refine ⟨σ.val.val, σ.property, ?_⟩
+    apply (M.realize_exConditions t 5 _
+      (extend σ.val.val (extend z (extend y (orbitParameters a s t W)))) group rfl).2
+    refine ⟨g, member, ?_, ?_⟩
+    · exact (M.realize_orderedPairFormula pairing 2 0 1
+        (extend (t.encode g) (extend σ.val.val (extend z (extend y (orbitParameters a s t W))))) hz
+        (M.transitive group (t.encode_mem g)) σ.property).2 shape
+    · rw [realize_atomicApplication, map_extend, map_extend, map_empty]
+      exact (M.realize_codedNameActionFormula a s t pairing unions powers separation collection
+        carrier group maps g σ.val.val y σ.property hy).2 ⟨σ, rfl, output⟩
+
+end PartitionPilot.Forcing.TransitiveGround
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/PairPushFilterFamilies.lean

@@ -1,148 +1,148 @@
-import OAI.SetTheory.PartitionPrinciple.Forcing.GroundFilterCopies
-
-namespace OAI
-
-namespace PartitionPilot.Forcing
-
-universe u
-
-noncomputable def pushFilterCode (L rL S F : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun y => ∃ f ∈ F, ∃ z ∈ L,
-    ZFSet.pair f z ∈ S ∧ ZFSet.pair z y ∈ rL) L
-
-theorem mem_pushFilterCode (L rL S F y : ZFSet.{u}) :
-    y ∈ pushFilterCode L rL S F ↔ y ∈ L ∧ ∃ f ∈ F, ∃ z ∈ L,
-      ZFSet.pair f z ∈ S ∧ ZFSet.pair z y ∈ rL := ZFSet.mem_sep
-
-theorem pushFilterCode_subset (L rL S F : ZFSet.{u}) : pushFilterCode L rL S F ⊆ L :=
-  fun _ hy => ((mem_pushFilterCode L rL S F _).1 hy).1
-
-theorem MeetEmbeddingCode.order_iff {P L rP rL μP μL S x y x' y' : ZFSet.{u}}
-    (embedding : MeetEmbeddingCode P L rP rL μP μL S)
-    (source : MeetOrderCode P rP μP) (target : MeetOrderCode L rL μL)
-    (first : ZFSet.pair x x' ∈ S) (second : ZFSet.pair y y' ∈ S) :
-    ZFSet.pair x' y' ∈ rL ↔ ZFSet.pair x y ∈ rP := by
-  refine ⟨?_, fun lower => embedding.monotone x y x' y' lower first second⟩
-  intro lower
-  have sx := ZFSet.pair_mem_prod.1 (embedding.injection.function.1 first)
-  have sy := ZFSet.pair_mem_prod.1 (embedding.injection.function.1 second)
-  obtain ⟨z, meetXY, _⟩ := source.operation.2 (ZFSet.pair x y)
-    (ZFSet.pair_mem_prod.2 ⟨sx.1, sy.1⟩)
-  have hz := (ZFSet.pair_mem_prod.1 (source.operation.1 meetXY)).2
-  obtain ⟨z', image, _⟩ := embedding.injection.function.2 z hz
-  have hz' := (ZFSet.pair_mem_prod.1 (embedding.injection.function.1 image)).2
-  have imageMeet := embedding.map_meet x y z x' y' z' meetXY first second image
-  have equalImage : z' = x' := target.order.antisymm z' hz' x' sx.2
-    (target.lower_left x' y' z' imageMeet)
-    (target.greatest x' y' z' x' sx.2 imageMeet (target.order.refl x' sx.2) lower)
-  have equal : z = x := embedding.injection.injective z x x' (equalImage ▸ image) first
-  exact equal ▸ source.lower_right x y z meetXY
-
-theorem meetFilter_pushFilter {P L rP rL μP μL S F : ZFSet.{u}}
-    (source : MeetOrderCode P rP μP) (target : MeetOrderCode L rL μL)
-    (embedding : MeetEmbeddingCode P L rP rL μP μL S)
-    (filter : MeetFilterCode P rP μP F) :
-    MeetFilterCode L rL μL (pushFilterCode L rL S F) where
-  subset := pushFilterCode_subset L rL S F
-  nonempty := by
-    obtain ⟨f, hf⟩ := filter.nonempty
-    obtain ⟨z, image, _⟩ := embedding.injection.function.2 f (filter.subset hf)
-    have hz := (ZFSet.pair_mem_prod.1 (embedding.injection.function.1 image)).2
-    exact ⟨z, (mem_pushFilterCode L rL S F z).2
-      ⟨hz, f, hf, z, hz, image, target.order.refl z hz⟩⟩
-  upward := by
-    intro x hx y hy lower
-    obtain ⟨hxL, f, hf, z, hz, image, below⟩ := (mem_pushFilterCode L rL S F x).1 hx
-    exact (mem_pushFilterCode L rL S F y).2
-      ⟨hy, f, hf, z, hz, image, target.order.trans z hz x hxL y hy below lower⟩
-  closed_meet := by
-    intro x hx y hy z meetXY
-    obtain ⟨hxL, f, hf, f', hf', first, belowX⟩ := (mem_pushFilterCode L rL S F x).1 hx
-    obtain ⟨hyL, g, hg, g', hg', second, belowY⟩ := (mem_pushFilterCode L rL S F y).1 hy
-    have hz := (ZFSet.pair_mem_prod.1 (target.operation.1 meetXY)).2
-    obtain ⟨h, meetFG, _⟩ := source.operation.2 (ZFSet.pair f g)
-      (ZFSet.pair_mem_prod.2 ⟨filter.subset hf, filter.subset hg⟩)
-    have hhF := filter.closed_meet f hf g hg h meetFG
-    obtain ⟨h', image, _⟩ := embedding.injection.function.2 h (filter.subset hhF)
-    have hh' := (ZFSet.pair_mem_prod.1 (embedding.injection.function.1 image)).2
-    have imageMeet := embedding.map_meet f g h f' g' h' meetFG first second image
-    have left := target.order.trans h' hh' f' hf' x hxL
-      (target.lower_left f' g' h' imageMeet) belowX
-    have right := target.order.trans h' hh' g' hg' y hyL
-      (target.lower_right f' g' h' imageMeet) belowY
-    exact (mem_pushFilterCode L rL S F z).2
-      ⟨hz, h, hhF, h', hh', image, target.greatest x y z h' hh' meetXY left right⟩
-
-theorem pushFilter_trace {P L rP rL μP μL S F x y : ZFSet.{u}}
-    (source : MeetOrderCode P rP μP) (target : MeetOrderCode L rL μL)
-    (embedding : MeetEmbeddingCode P L rP rL μP μL S)
-    (filter : MeetFilterCode P rP μP F) (entry : ZFSet.pair x y ∈ S) :
-    y ∈ pushFilterCode L rL S F ↔ x ∈ F := by
-  have shape := ZFSet.pair_mem_prod.1 (embedding.injection.function.1 entry)
-  constructor
-  · intro positive
-    obtain ⟨_, f, hf, z, _, image, below⟩ := (mem_pushFilterCode L rL S F y).1 positive
-    exact filter.upward f hf x shape.1 ((embedding.order_iff source target image entry).1 below)
-  · intro positive
-    exact (mem_pushFilterCode L rL S F y).2
-      ⟨shape.2, x, positive, y, shape.2, entry, target.order.refl y shape.2⟩
-
-theorem pushFilter_lower_bound {P L rP rL μP μL S F e e' y : ZFSet.{u}}
-    (target : MeetOrderCode L rL μL) (embedding : MeetEmbeddingCode P L rP rL ��P μL S)
-    (lower : ∀ f ∈ F, ZFSet.pair e f ∈ rP) (entry : ZFSet.pair e e' ∈ S)
-    (positive : y ∈ pushFilterCode L rL S F) : ZFSet.pair e' y ∈ rL := by
-  obtain ⟨hy, f, hf, z, hz, image, below⟩ := (mem_pushFilterCode L rL S F y).1 positive
-  have he' := (ZFSet.pair_mem_prod.1 (embedding.injection.function.1 entry)).2
-  exact target.order.trans e' he' z hz y hy
-    (embedding.monotone e f e' z (lower f hf) entry image) below
-
-noncomputable def pairPushFilterFamily (K I J L rL Ss Fs B : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => ∃ i ∈ I, ∃ j ∈ J, ∃ S ∈ Ss.sUnion.sUnion,
-    ∃ F ∈ Fs.sUnion.sUnion, ∃ V ∈ B,
-    z = ZFSet.pair (ZFSet.pair i j) V ∧ ZFSet.pair i S ∈ Ss ∧ ZFSet.pair j F ∈ Fs ∧
-      V = pushFilterCode L rL S F) (ZFSet.prod K B)
-
-theorem pair_mem_pairPushFilterFamily (K I J L rL Ss Fs B i j V : ZFSet.{u}) :
-    ZFSet.pair (ZFSet.pair i j) V ∈ pairPushFilterFamily K I J L rL Ss Fs B ↔
-      ZFSet.pair i j ∈ K ∧ V ∈ B ∧ i ∈ I ∧ j ∈ J ∧ ∃ S F,
-        ZFSet.pair i S ∈ Ss ∧ ZFSet.pair j F ∈ Fs ∧ V = pushFilterCode L rL S F := by
-  rw [pairPushFilterFamily, ZFSet.mem_sep, ZFSet.pair_mem_prod]
-  constructor
-  · rintro ⟨⟨hk, hV⟩, i', hi, j', hj, S, _, F, _, V', _, equal, eS, eF, value⟩
-    obtain ⟨pairEq, rfl⟩ := ZFSet.pair_inj.1 equal
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 pairEq
-    exact ⟨hk, hV, hi, hj, S, F, eS, eF, value⟩
-  · rintro ⟨hk, hV, hi, hj, S, F, eS, eF, value⟩
-    exact ⟨⟨hk, hV⟩, i, hi, j, hj, S, pair_second_mem_doubleUnion eS,
-      F, pair_second_mem_doubleUnion eF, V, hV, rfl, eS, eF, value⟩
-
-theorem pairPushFilterFamily_entry_iff {K I J L rL Ss Fs B i j S F V : ZFSet.{u}}
-    (maps : FunctionGraphOn I Ss) (filters : FunctionGraphOn J Fs)
-    (mapEntry : ZFSet.pair i S ∈ Ss) (filterEntry : ZFSet.pair j F ∈ Fs) :
-    ZFSet.pair (ZFSet.pair i j) V ∈ pairPushFilterFamily K I J L rL Ss Fs B ↔
-      ZFSet.pair i j ∈ K ∧ V ∈ B ∧ V = pushFilterCode L rL S F := by
-  rw [pair_mem_pairPushFilterFamily]
-  constructor
-  · rintro ⟨hk, hV, _, _, S', F', eS, eF, value⟩
-    exact ⟨hk, hV, maps.unique eS mapEntry ▸ filters.unique eF filterEntry ▸ value⟩
-  · rintro ⟨hk, hV, value⟩
-    exact ⟨hk, hV, maps.pair_source mapEntry, filters.pair_source filterEntry,
-      S, F, mapEntry, filterEntry, value⟩
-
-theorem pairPushFilterFamily_function {K I J L rL Ss Fs B : ZFSet.{u}}
-    (subset : K ⊆ ZFSet.prod I J) (maps : FunctionGraphOn I Ss) (filters : FunctionGraphOn J Fs)
-    (bounds : ∀ i ∈ I, ∀ j ∈ J, ∀ S F,
-      ZFSet.pair i S ∈ Ss → ZFSet.pair j F ∈ Fs → pushFilterCode L rL S F ∈ B) :
-    ZFSet.IsFunc K B (pairPushFilterFamily K I J L rL Ss Fs B) := by
-  refine ⟨fun _ hz => (ZFSet.mem_sep.1 hz).1, ?_⟩
-  intro k hk
-  obtain ⟨i, hi, j, hj, rfl⟩ := ZFSet.mem_prod.1 (subset hk)
-  obtain ⟨S, eS⟩ := maps.total hi
-  obtain ⟨F, eF⟩ := filters.total hj
-  exact ⟨pushFilterCode L rL S F,
-    (pairPushFilterFamily_entry_iff maps filters eS eF).2 ⟨hk, bounds i hi j hj S F eS eF, rfl⟩,
-    fun V hV => ((pairPushFilterFamily_entry_iff maps filters eS eF).1 hV).2.2⟩
-
-end PartitionPilot.Forcing
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Forcing.GroundFilterCopies
+
+namespace OAI
+
+namespace PartitionPilot.Forcing
+
+universe u
+
+noncomputable def pushFilterCode (L rL S F : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun y => ∃ f ∈ F, ∃ z ∈ L,
+    ZFSet.pair f z ∈ S ∧ ZFSet.pair z y ∈ rL) L
+
+theorem mem_pushFilterCode (L rL S F y : ZFSet.{u}) :
+    y ∈ pushFilterCode L rL S F ↔ y ∈ L ∧ ∃ f ∈ F, ∃ z ∈ L,
+      ZFSet.pair f z ∈ S ∧ ZFSet.pair z y ∈ rL := ZFSet.mem_sep
+
+theorem pushFilterCode_subset (L rL S F : ZFSet.{u}) : pushFilterCode L rL S F ⊆ L :=
+  fun _ hy => ((mem_pushFilterCode L rL S F _).1 hy).1
+
+theorem MeetEmbeddingCode.order_iff {P L rP rL μP μL S x y x' y' : ZFSet.{u}}
+    (embedding : MeetEmbeddingCode P L rP rL μP μL S)
+    (source : MeetOrderCode P rP μP) (target : MeetOrderCode L rL μL)
+    (first : ZFSet.pair x x' ∈ S) (second : ZFSet.pair y y' ∈ S) :
+    ZFSet.pair x' y' ∈ rL ↔ ZFSet.pair x y ∈ rP := by
+  refine ⟨?_, fun lower => embedding.monotone x y x' y' lower first second⟩
+  intro lower
+  have sx := ZFSet.pair_mem_prod.1 (embedding.injection.function.1 first)
+  have sy := ZFSet.pair_mem_prod.1 (embedding.injection.function.1 second)
+  obtain ⟨z, meetXY, _⟩ := source.operation.2 (ZFSet.pair x y)
+    (ZFSet.pair_mem_prod.2 ⟨sx.1, sy.1⟩)
+  have hz := (ZFSet.pair_mem_prod.1 (source.operation.1 meetXY)).2
+  obtain ⟨z', image, _⟩ := embedding.injection.function.2 z hz
+  have hz' := (ZFSet.pair_mem_prod.1 (embedding.injection.function.1 image)).2
+  have imageMeet := embedding.map_meet x y z x' y' z' meetXY first second image
+  have equalImage : z' = x' := target.order.antisymm z' hz' x' sx.2
+    (target.lower_left x' y' z' imageMeet)
+    (target.greatest x' y' z' x' sx.2 imageMeet (target.order.refl x' sx.2) lower)
+  have equal : z = x := embedding.injection.injective z x x' (equalImage ▸ image) first
+  exact equal ▸ source.lower_right x y z meetXY
+
+theorem meetFilter_pushFilter {P L rP rL μP μL S F : ZFSet.{u}}
+    (source : MeetOrderCode P rP μP) (target : MeetOrderCode L rL μL)
+    (embedding : MeetEmbeddingCode P L rP rL μP μL S)
+    (filter : MeetFilterCode P rP μP F) :
+    MeetFilterCode L rL μL (pushFilterCode L rL S F) where
+  subset := pushFilterCode_subset L rL S F
+  nonempty := by
+    obtain ⟨f, hf⟩ := filter.nonempty
+    obtain ⟨z, image, _⟩ := embedding.injection.function.2 f (filter.subset hf)
+    have hz := (ZFSet.pair_mem_prod.1 (embedding.injection.function.1 image)).2
+    exact ⟨z, (mem_pushFilterCode L rL S F z).2
+      ⟨hz, f, hf, z, hz, image, target.order.refl z hz⟩⟩
+  upward := by
+    intro x hx y hy lower
+    obtain ⟨hxL, f, hf, z, hz, image, below⟩ := (mem_pushFilterCode L rL S F x).1 hx
+    exact (mem_pushFilterCode L rL S F y).2
+      ⟨hy, f, hf, z, hz, image, target.order.trans z hz x hxL y hy below lower⟩
+  closed_meet := by
+    intro x hx y hy z meetXY
+    obtain ⟨hxL, f, hf, f', hf', first, belowX⟩ := (mem_pushFilterCode L rL S F x).1 hx
+    obtain ⟨hyL, g, hg, g', hg', second, belowY⟩ := (mem_pushFilterCode L rL S F y).1 hy
+    have hz := (ZFSet.pair_mem_prod.1 (target.operation.1 meetXY)).2
+    obtain ⟨h, meetFG, _⟩ := source.operation.2 (ZFSet.pair f g)
+      (ZFSet.pair_mem_prod.2 ⟨filter.subset hf, filter.subset hg⟩)
+    have hhF := filter.closed_meet f hf g hg h meetFG
+    obtain ⟨h', image, _⟩ := embedding.injection.function.2 h (filter.subset hhF)
+    have hh' := (ZFSet.pair_mem_prod.1 (embedding.injection.function.1 image)).2
+    have imageMeet := embedding.map_meet f g h f' g' h' meetFG first second image
+    have left := target.order.trans h' hh' f' hf' x hxL
+      (target.lower_left f' g' h' imageMeet) belowX
+    have right := target.order.trans h' hh' g' hg' y hyL
+      (target.lower_right f' g' h' imageMeet) belowY
+    exact (mem_pushFilterCode L rL S F z).2
+      ⟨hz, h, hhF, h', hh', image, target.greatest x y z h' hh' meetXY left right⟩
+
+theorem pushFilter_trace {P L rP rL μP μL S F x y : ZFSet.{u}}
+    (source : MeetOrderCode P rP μP) (target : MeetOrderCode L rL μL)
+    (embedding : MeetEmbeddingCode P L rP rL μP μL S)
+    (filter : MeetFilterCode P rP μP F) (entry : ZFSet.pair x y ∈ S) :
+    y ∈ pushFilterCode L rL S F ↔ x ∈ F := by
+  have shape := ZFSet.pair_mem_prod.1 (embedding.injection.function.1 entry)
+  constructor
+  · intro positive
+    obtain ⟨_, f, hf, z, _, image, below⟩ := (mem_pushFilterCode L rL S F y).1 positive
+    exact filter.upward f hf x shape.1 ((embedding.order_iff source target image entry).1 below)
+  · intro positive
+    exact (mem_pushFilterCode L rL S F y).2
+      ⟨shape.2, x, positive, y, shape.2, entry, target.order.refl y shape.2⟩
+
+theorem pushFilter_lower_bound {P L rP rL μP μL S F e e' y : ZFSet.{u}}
+    (target : MeetOrderCode L rL μL) (embedding : MeetEmbeddingCode P L rP rL μP μL S)
+    (lower : ∀ f ∈ F, ZFSet.pair e f ∈ rP) (entry : ZFSet.pair e e' ∈ S)
+    (positive : y ∈ pushFilterCode L rL S F) : ZFSet.pair e' y ∈ rL := by
+  obtain ⟨hy, f, hf, z, hz, image, below⟩ := (mem_pushFilterCode L rL S F y).1 positive
+  have he' := (ZFSet.pair_mem_prod.1 (embedding.injection.function.1 entry)).2
+  exact target.order.trans e' he' z hz y hy
+    (embedding.monotone e f e' z (lower f hf) entry image) below
+
+noncomputable def pairPushFilterFamily (K I J L rL Ss Fs B : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => ∃ i ∈ I, ∃ j ∈ J, ∃ S ∈ Ss.sUnion.sUnion,
+    ∃ F ∈ Fs.sUnion.sUnion, ∃ V ∈ B,
+    z = ZFSet.pair (ZFSet.pair i j) V ∧ ZFSet.pair i S ∈ Ss ∧ ZFSet.pair j F ∈ Fs ∧
+      V = pushFilterCode L rL S F) (ZFSet.prod K B)
+
+theorem pair_mem_pairPushFilterFamily (K I J L rL Ss Fs B i j V : ZFSet.{u}) :
+    ZFSet.pair (ZFSet.pair i j) V ∈ pairPushFilterFamily K I J L rL Ss Fs B ↔
+      ZFSet.pair i j ∈ K ∧ V ∈ B ∧ i ∈ I ∧ j ∈ J ∧ ∃ S F,
+        ZFSet.pair i S ∈ Ss ∧ ZFSet.pair j F ∈ Fs ∧ V = pushFilterCode L rL S F := by
+  rw [pairPushFilterFamily, ZFSet.mem_sep, ZFSet.pair_mem_prod]
+  constructor
+  · rintro ⟨⟨hk, hV⟩, i', hi, j', hj, S, _, F, _, V', _, equal, eS, eF, value⟩
+    obtain ⟨pairEq, rfl⟩ := ZFSet.pair_inj.1 equal
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 pairEq
+    exact ⟨hk, hV, hi, hj, S, F, eS, eF, value⟩
+  · rintro ⟨hk, hV, hi, hj, S, F, eS, eF, value⟩
+    exact ⟨⟨hk, hV⟩, i, hi, j, hj, S, pair_second_mem_doubleUnion eS,
+      F, pair_second_mem_doubleUnion eF, V, hV, rfl, eS, eF, value⟩
+
+theorem pairPushFilterFamily_entry_iff {K I J L rL Ss Fs B i j S F V : ZFSet.{u}}
+    (maps : FunctionGraphOn I Ss) (filters : FunctionGraphOn J Fs)
+    (mapEntry : ZFSet.pair i S ∈ Ss) (filterEntry : ZFSet.pair j F ∈ Fs) :
+    ZFSet.pair (ZFSet.pair i j) V ∈ pairPushFilterFamily K I J L rL Ss Fs B ↔
+      ZFSet.pair i j ∈ K ∧ V ∈ B ∧ V = pushFilterCode L rL S F := by
+  rw [pair_mem_pairPushFilterFamily]
+  constructor
+  · rintro ⟨hk, hV, _, _, S', F', eS, eF, value⟩
+    exact ⟨hk, hV, maps.unique eS mapEntry ▸ filters.unique eF filterEntry ▸ value⟩
+  · rintro ⟨hk, hV, value⟩
+    exact ⟨hk, hV, maps.pair_source mapEntry, filters.pair_source filterEntry,
+      S, F, mapEntry, filterEntry, value⟩
+
+theorem pairPushFilterFamily_function {K I J L rL Ss Fs B : ZFSet.{u}}
+    (subset : K ⊆ ZFSet.prod I J) (maps : FunctionGraphOn I Ss) (filters : FunctionGraphOn J Fs)
+    (bounds : ∀ i ∈ I, ∀ j ∈ J, ∀ S F,
+      ZFSet.pair i S ∈ Ss → ZFSet.pair j F ∈ Fs → pushFilterCode L rL S F ∈ B) :
+    ZFSet.IsFunc K B (pairPushFilterFamily K I J L rL Ss Fs B) := by
+  refine ⟨fun _ hz => (ZFSet.mem_sep.1 hz).1, ?_⟩
+  intro k hk
+  obtain ⟨i, hi, j, hj, rfl⟩ := ZFSet.mem_prod.1 (subset hk)
+  obtain ⟨S, eS⟩ := maps.total hi
+  obtain ⟨F, eF⟩ := filters.total hj
+  exact ⟨pushFilterCode L rL S F,
+    (pairPushFilterFamily_entry_iff maps filters eS eF).2 ⟨hk, bounds i hi j hj S F eS eF, rfl⟩,
+    fun V hV => ((pairPushFilterFamily_entry_iff maps filters eS eF).1 hV).2.2⟩
+
+end PartitionPilot.Forcing
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/ParentSupportCodes.lean

@@ -1,632 +1,632 @@
-import OAI.SetTheory.PartitionPrinciple.Definability.GroundPairCompositions
-
-namespace OAI
-
-
-namespace PartitionPilot.Forcing.BoundedFormula
-
-open SetFormula
-universe u
-
-def orderedRightTripleFormula {n} (w x c q : Fin n) : BoundedFormula n :=
-  exMem w (exMem 0 (.conj (orderedPairFormula 0 c.succ.succ q.succ.succ)
-    (orderedPairFormula w.succ.succ x.succ.succ 0)))
-
-def rightTripleMembershipFormula {n} (x c q f : Fin n) : BoundedFormula n :=
-  exMem f (orderedRightTripleFormula 0 x.succ c.succ q.succ)
-
-theorem truth_orderedRightTripleFormula {n} (w x c q : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (orderedRightTripleFormula w x c q) env ↔
-      env w = ZFSet.pair (env x) (ZFSet.pair (env c) (env q)) := by
-  simp only [orderedRightTripleFormula, truth_exMem, Truth, truth_orderedPairFormula]
-  change (∃ a ∈ env w, ∃ b ∈ a, b = ZFSet.pair (env c) (env q) ∧
-    env w = ZFSet.pair (env x) b) ↔ _
-  constructor
-  · rintro ⟨_, _, _, _, rfl, equal⟩
-    exact equal
-  · intro equal
-    refine ⟨{env x, ZFSet.pair (env c) (env q)}, ?_, ZFSet.pair (env c) (env q),
-      ZFSet.mem_pair.2 (Or.inr rfl), rfl, equal⟩
-    rw [equal]
-    exact ZFSet.mem_pair.2 (Or.inr rfl)
-
-theorem truth_rightTripleMembershipFormula {n} (x c q f : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (rightTripleMembershipFormula x c q f) env ↔
-      ZFSet.pair (env x) (ZFSet.pair (env c) (env q)) ∈ env f := by
-  simp only [rightTripleMembershipFormula, truth_exMem, truth_orderedRightTripleFormula]
-  change (∃ w ∈ env f, w = ZFSet.pair (env x) (ZFSet.pair (env c) (env q))) ↔ _
-  constructor
-  · rintro ⟨w, hw, heq⟩
-    exact heq ▸ hw
-  · intro hw
-    exact ⟨_, hw, rfl⟩
-
-def relationToProductFormula {n} (a c q f : Fin n) : BoundedFormula n :=
-  .allMem f (exMem a.succ (exMem c.succ.succ
-    (exMem q.succ.succ.succ (orderedRightTripleFormula 3 2 1 0))))
-
-def functionToProductFormula {n} (a c q f : Fin n) : BoundedFormula n :=
-  .conj (relationToProductFormula a c q f)
-    (.allMem a (exMem c.succ (exMem q.succ.succ
-      (.conj (rightTripleMembershipFormula 2 1 0 f.succ.succ.succ)
-        (.allMem c.succ.succ.succ (.allMem q.succ.succ.succ.succ
-          (imp (rightTripleMembershipFormula 4 1 0 f.succ.succ.succ.succ.succ)
-            (.conj (.equal 1 3) (.equal 0 2)))))))))
-
-theorem truth_relationToProductFormula {n} (a c q f : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (relationToProductFormula a c q f) env ↔
-      env f ⊆ ZFSet.prod (env a) (ZFSet.prod (env c) (env q)) := by
-  simp only [relationToProductFormula, Truth, truth_exMem, truth_orderedRightTripleFormula]
-  constructor
-  · intro h w hw
-    obtain ⟨x, hx, d, hd, v, hv, equal⟩ := h w hw
-    exact ZFSet.mem_prod.2 ⟨x, hx, ZFSet.pair d v, ZFSet.pair_mem_prod.2 ⟨hd, hv⟩, equal⟩
-  · intro h w hw
-    obtain ⟨x, hx, y, hy, equal⟩ := ZFSet.mem_prod.1 (h hw)
-    obtain ⟨d, hd, v, hv, rfl⟩ := ZFSet.mem_prod.1 hy
-    exact ⟨x, hx, d, hd, v, hv, equal⟩
-
-theorem truth_functionToProductFormula {n} (a c q f : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (functionToProductFormula a c q f) env ↔
-      ZFSet.IsFunc (env a) (ZFSet.prod (env c) (env q)) (env f) := by
-  simp only [functionToProductFormula, Truth, truth_relationToProductFormula, truth_exMem,
-    truth_rightTripleMembershipFormula, truth_imp]
-  constructor
-  · rintro ⟨shape, total⟩
-    refine ⟨shape, ?_⟩
-    intro x hx
-    obtain ⟨d, _, v, _, entry, unique⟩ := total x hx
-    refine ⟨ZFSet.pair d v, entry, ?_⟩
-    intro y hy
-    obtain ⟨b, hb, z, hz, rfl⟩ := ZFSet.mem_prod.1 (ZFSet.pair_mem_prod.1 (shape hy)).2
-    have both : b = d ∧ z = v := unique b hb z hz hy
-    obtain ⟨rfl, rfl⟩ := both
-    rfl
-  · rintro ⟨shape, total⟩
-    refine ⟨shape, ?_⟩
-    intro x hx
-    obtain ⟨y, entry, unique⟩ := total x hx
-    obtain ⟨d, hd, v, hv, rfl⟩ := ZFSet.mem_prod.1 (ZFSet.pair_mem_prod.1 (shape entry)).2
-    refine ⟨d, hd, v, hv, entry, ?_⟩
-    intro b _ z _ hz
-    exact ZFSet.pair_injective (unique _ hz)
-
-end PartitionPilot.Forcing.BoundedFormula
-
-
-
-namespace PartitionPilot.Forcing
-
-open scoped ZFSet
-
-universe u
-
-structure ChoiceFunctionCode (A f : ZFSet.{u}) : Prop where
-  function : ZFSet.IsFunc A (⋃₀ A) f
-  chosen : ∀ x y, ZFSet.pair x y ∈ f → y ∈ x
-
-namespace BoundedFormula
-
-open SetFormula
-
-theorem truth_nonemptyFormula {n} (x : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (nonemptyFormula x) env ↔ (env x).Nonempty := by
-  simp only [nonemptyFormula, truth_exMem, Truth]
-  exact ⟨fun ⟨y, hy, _⟩ => ⟨y, hy⟩, fun ⟨y, hy⟩ => ⟨y, hy, True.intro⟩⟩
-
-theorem truth_choiceFunctionFormula {n} (a f : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (choiceFunctionFormula a f) env ↔ ChoiceFunctionCode (env a) (env f) := by
-  simp only [choiceFunctionFormula, Truth, truth_exMem, truth_orderedPairFormula,
-    truth_pairMembershipFormula, truth_imp]
-  change ((∀ z ∈ env f, ∃ x ∈ env a, ∃ y ∈ x, z = ZFSet.pair x y) ∧
-    ∀ x ∈ env a, ∃ y ∈ x, ZFSet.pair x y ∈ env f ∧
-      ∀ z ∈ x, ZFSet.pair x z ∈ env f → z = y) ↔ _
-  constructor
-  · rintro ⟨shape, total⟩
-    have chosen : ∀ x y, ZFSet.pair x y ∈ env f → y ∈ x := by
-      intro x y rel
-      obtain ⟨x', _, y', hy', eq⟩ := shape _ rel
-      obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 eq
-      exact hy'
-    refine ⟨⟨?_, ?_⟩, chosen⟩
-    · intro z hz
-      obtain ⟨x, hx, y, hy, rfl⟩ := shape z hz
-      exact ZFSet.pair_mem_prod.2 ⟨hx, ZFSet.mem_sUnion.2 ⟨x, hx, hy⟩⟩
-    · intro x hx
-      obtain ⟨y, _, rel, unique⟩ := total x hx
-      exact ⟨y, rel, fun z hz => unique z (chosen x z hz) hz⟩
-  · intro h
-    refine ⟨?_, ?_⟩
-    · intro z hz
-      obtain ⟨x, hx, y, _, eq⟩ := ZFSet.mem_prod.1 (h.function.1 hz)
-      exact ⟨x, hx, y, h.chosen x y (eq ▸ hz), eq⟩
-    · intro x hx
-      obtain ⟨y, rel, unique⟩ := h.function.2 x hx
-      exact ⟨y, h.chosen x y rel, rel, fun z _ hz => unique z hz⟩
-
-end BoundedFormula
-
-
-namespace TransitiveGround
-
-open SetFormula
-variable (M : TransitiveGround.{u})
-
-theorem choice_witness (choice : Realize M.sets SetFormula.choice Fin.elim0)
-    {A : ZFSet.{u}} (hA : A ∈ M.sets) (nonempty : ∀ x ∈ A, x.Nonempty) :
-    ∃ f ∈ M.sets, ChoiceFunctionCode A f := by
-  have selected := (realize_imp M.sets _ _ _).1 (choice A hA)
-  have premise : Realize M.sets
-      (BoundedFormula.allMem 0 (BoundedFormula.nonemptyFormula 0)).toFormula (extend A Fin.elim0) := by
-    apply (BoundedFormula.realize_toFormula M _ _ (Fin.cases hA (fun i => Fin.elim0 i))).2
-    intro x hx
-    exact (BoundedFormula.truth_nonemptyFormula 0 _).2 (nonempty x hx)
-  obtain ⟨f, hf, rel⟩ := (realize_ex M.sets _ _).1 (selected premise)
-  exact ⟨f, hf, (BoundedFormula.truth_choiceFunctionFormula 1 0 _).1
-    ((BoundedFormula.realize_toFormula M _ _ (Fin.cases hf (Fin.cases hA (fun i => Fin.elim0 i)))).1 rel)⟩
-
-end TransitiveGround
-
-end PartitionPilot.Forcing
-
-
-
-namespace PartitionPilot.Forcing
-
-universe u
-
-noncomputable def relationFiber (B r x : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun y => ZFSet.pair x y ∈ r) B
-
-theorem mem_relationFiber (B r x y : ZFSet.{u}) :
-    y ∈ relationFiber B r x ↔ y ∈ B ∧ ZFSet.pair x y ∈ r := ZFSet.mem_sep
-
-noncomputable def choiceUniformGraph (A B r F c : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => ∃ x ∈ A, ∃ y ∈ B, z = ZFSet.pair x y ∧
-    relationFiber B r x ∈ F ∧ ZFSet.pair (relationFiber B r x) y ∈ c) (ZFSet.prod A B)
-
-theorem pair_mem_choiceUniformGraph (A B r F c x y : ZFSet.{u}) :
-    ZFSet.pair x y ∈ choiceUniformGraph A B r F c ↔
-      x ∈ A ∧ y ∈ B ∧ relationFiber B r x ∈ F ∧ ZFSet.pair (relationFiber B r x) y ∈ c := by
-  rw [choiceUniformGraph, ZFSet.mem_sep]
-  constructor
-  · rintro ⟨_, a, ha, b, hb, eq, hf, rel⟩
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 eq
-    exact ⟨ha, hb, hf, rel⟩
-  · rintro ⟨hx, hy, hf, rel⟩
-    exact ⟨ZFSet.pair_mem_prod.2 ⟨hx, hy⟩, x, hx, y, hy, rfl, hf, rel⟩
-
-theorem choiceUniformGraph_function {A B r F c : ZFSet.{u}} (choice : ChoiceFunctionCode F c)
-    (fibers : ∀ x ∈ A, relationFiber B r x ∈ F) :
-    ZFSet.IsFunc A B (choiceUniformGraph A B r F c) ∧ choiceUniformGraph A B r F c ⊆ r := by
-  refine ⟨⟨fun _ hz => (ZFSet.mem_sep.1 hz).1, ?_⟩, ?_⟩
-  · intro x hx
-    obtain ⟨y, rel, unique⟩ := choice.function.2 (relationFiber B r x) (fibers x hx)
-    have hy := (mem_relationFiber B r x y).1 (choice.chosen _ _ rel)
-    exact ⟨y, (pair_mem_choiceUniformGraph A B r F c x y).2 ⟨hx, hy.1, fibers x hx, rel⟩,
-      fun z hz => unique z ((pair_mem_choiceUniformGraph A B r F c x z).1 hz).2.2.2⟩
-  · intro z hz
-    obtain ⟨_, x, _, y, _, eq, _, rel⟩ := ZFSet.mem_sep.1 hz
-    exact eq.symm ▸ ((mem_relationFiber B r x y).1 (choice.chosen _ _ rel)).2
-
-namespace BoundedFormula
-
-open SetFormula
-
-def fiberFormula {n} (f x b r : Fin n) : BoundedFormula n :=
-  .conj (.allMem f (.mem 0 b.succ)) (.allMem b
-    (.conj (imp (.mem 0 f.succ) (pairMembershipFormula x.succ 0 r.succ))
-      (imp (pairMembershipFormula x.succ 0 r.succ) (.mem 0 f.succ))))
-
-theorem truth_fiberFormula {n} (f x b r : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (fiberFormula f x b r) env ↔ env f = relationFiber (env b) (env r) (env x) := by
-  simp only [fiberFormula, Truth, truth_imp, truth_pairMembershipFormula]
-  change ((∀ y ∈ env f, y ∈ env b) ∧ ∀ y ∈ env b,
-    (y ∈ env f → ZFSet.pair (env x) y ∈ env r) ∧ (ZFSet.pair (env x) y ∈ env r → y ∈ env f)) ↔ _
-  constructor
-  · rintro ⟨subset, spec⟩
-    apply ZFSet.ext
-    intro y
-    rw [mem_relationFiber]
-    exact ⟨fun hy => ⟨subset y hy, (spec y (subset y hy)).1 hy⟩,
-      fun ⟨hy, rel⟩ => (spec y hy).2 rel⟩
-  · intro eq
-    rw [eq]
-    exact ⟨fun _ hy => (ZFSet.mem_sep.1 hy).1,
-      fun y hy => ⟨fun rel => (ZFSet.mem_sep.1 rel).2, fun rel => ZFSet.mem_sep.2 ⟨hy, rel⟩⟩⟩
-
-def choiceUniformEntryFormula {n} (z a b r f c : Fin n) : BoundedFormula n :=
-  exMem a (exMem b.succ (exMem f.succ.succ
-    (.conj (orderedPairFormula z.succ.succ.succ 2 1)
-      (.conj (fiberFormula 0 2 b.succ.succ.succ r.succ.succ.succ)
-        (pairMembershipFormula 0 1 c.succ.succ.succ)))))
-
-theorem truth_choiceUniformEntryFormula {n} (z a b r f c : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (choiceUniformEntryFormula z a b r f c) env ↔
-      ∃ x ∈ env a, ∃ y ∈ env b, env z = ZFSet.pair x y ∧
-        relationFiber (env b) (env r) x ∈ env f ∧ ZFSet.pair (relationFiber (env b) (env r) x) y ∈ env c := by
-  simp only [choiceUniformEntryFormula, truth_exMem, Truth,
-    truth_orderedPairFormula, truth_fiberFormula, truth_pairMembershipFormula]
-  change (∃ x ∈ env a, ∃ y ∈ env b, ∃ F ∈ env f, env z = ZFSet.pair x y ∧
-    F = relationFiber (env b) (env r) x ∧ ZFSet.pair F y ∈ env c) ↔ _
-  constructor
-  · rintro ⟨x, hx, y, hy, F, hF, eq, rfl, rel⟩
-    exact ⟨x, hx, y, hy, eq, hF, rel⟩
-  · rintro ⟨x, hx, y, hy, eq, hF, rel⟩
-    exact ⟨x, hx, y, hy, relationFiber (env b) (env r) x, hF, eq, rfl, rel⟩
-
-end BoundedFormula
-
-namespace TransitiveGround
-
-open SetFormula
-variable (M : TransitiveGround.{u})
-
-theorem relationFiber_mem (separation : SeparationSchema M.sets) {B r x : ZFSet.{u}}
-    (hB : B ∈ M.sets) (hr : r ∈ M.sets) (hx : x ∈ M.sets) : relationFiber B r x ∈ M.sets := by
-  let params := extend x (extend r Fin.elim0)
-  have selected := M.bounded_separation_mem separation (BoundedFormula.pairMembershipFormula 1 0 2)
-    params (Fin.cases hx (Fin.cases hr (fun i => Fin.elim0 i))) hB
-  have eq : ZFSet.sep (fun y => BoundedFormula.Truth (BoundedFormula.pairMembershipFormula 1 0 2)
-      (extend y params)) B = relationFiber B r x := by
-    apply ZFSet.ext
-    intro y
-    rw [ZFSet.mem_sep, mem_relationFiber]
-    exact and_congr Iff.rfl (BoundedFormula.truth_pairMembershipFormula 1 0 2 _)
-  exact eq ▸ selected
-
-noncomputable def nonemptyGroundSubsets (B : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep ZFSet.Nonempty (M.groundPower B)
-
-theorem mem_nonemptyGroundSubsets (B F : ZFSet.{u}) :
-    F ∈ M.nonemptyGroundSubsets B ↔ F ∈ M.sets ∧ F ⊆ B ∧ F.Nonempty := by
-  rw [nonemptyGroundSubsets, ZFSet.mem_sep, M.mem_groundPower]
-  exact and_assoc
-
-theorem nonemptyGroundSubsets_mem (powers : Realize M.sets powerSet Fin.elim0)
-    (separation : SeparationSchema M.sets) {B : ZFSet.{u}} (hB : B ∈ M.sets) :
-    M.nonemptyGroundSubsets B ∈ M.sets := by
-  have selected := M.bounded_separation_mem separation (BoundedFormula.nonemptyFormula 0)
-    Fin.elim0 (fun i => Fin.elim0 i) (M.groundPower_mem powers hB)
-  have eq : ZFSet.sep (fun F => BoundedFormula.Truth (BoundedFormula.nonemptyFormula 0)
-      (extend F Fin.elim0)) (M.groundPower B) = M.nonemptyGroundSubsets B := by
-    apply ZFSet.ext
-    intro F
-    rw [ZFSet.mem_sep, nonemptyGroundSubsets, ZFSet.mem_sep]
-    exact and_congr Iff.rfl (BoundedFormula.truth_nonemptyFormula 0 _)
-  exact eq ▸ selected
-
-theorem choiceUniformGraph_mem
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    {A B r F c : ZFSet.{u}} (hA : A ∈ M.sets) (hB : B ∈ M.sets)
-    (hr : r ∈ M.sets) (hF : F ∈ M.sets) (hc : c ∈ M.sets) : choiceUniformGraph A B r F c ∈ M.sets := by
-  let params := extend A (extend B (extend r (extend F (extend c Fin.elim0))))
-  have selected := M.bounded_separation_mem separation (BoundedFormula.choiceUniformEntryFormula 0 1 2 3 4 5)
-    params (Fin.cases hA (Fin.cases hB (Fin.cases hr (Fin.cases hF (Fin.cases hc (fun i => Fin.elim0 i))))))
-    (M.prod_mem pairing unions powers separation hA hB)
-  have eq : ZFSet.sep (fun z => BoundedFormula.Truth (BoundedFormula.choiceUniformEntryFormula 0 1 2 3 4 5)
-      (extend z params)) (ZFSet.prod A B) = choiceUniformGraph A B r F c := by
-    apply ZFSet.ext
-    intro z
-    rw [ZFSet.mem_sep, choiceUniformGraph, ZFSet.mem_sep]
-    exact and_congr Iff.rfl (BoundedFormula.truth_choiceUniformEntryFormula 0 1 2 3 4 5 _)
-  exact eq ▸ selected
-
-theorem uniformize_relation
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    (choice : Realize M.sets SetFormula.choice Fin.elim0)
-    {A B r : ZFSet.{u}} (hA : A ∈ M.sets) (hB : B ∈ M.sets) (hr : r ∈ M.sets)
-    (total : ∀ x ∈ A, ∃ y ∈ B, ZFSet.pair x y ∈ r) :
-    ∃ f ∈ M.sets, ZFSet.IsFunc A B f ∧ f ⊆ r := by
-  have family := M.nonemptyGroundSubsets_mem powers separation hB
-  obtain ⟨c, hc, code⟩ := M.choice_witness choice family
-    (fun F hF => ((M.mem_nonemptyGroundSubsets B F).1 hF).2.2)
-  have fibers (x : ZFSet.{u}) (hx : x ∈ A) : relationFiber B r x ∈ M.nonemptyGroundSubsets B := by
-    obtain ⟨y, hy, rel⟩ := total x hx
-    exact (M.mem_nonemptyGroundSubsets B _).2
-      ⟨M.relationFiber_mem separation hB hr (M.transitive hA hx), fun _ hz => (ZFSet.mem_sep.1 hz).1,
-        y, (mem_relationFiber B r x y).2 ⟨hy, rel⟩⟩
-  exact ⟨choiceUniformGraph A B r (M.nonemptyGroundSubsets B) c,
-    M.choiceUniformGraph_mem pairing unions powers separation hA hB hr family hc,
-    choiceUniformGraph_function code fibers⟩
-
-end TransitiveGround
-
-end PartitionPilot.Forcing
-
-
-
-namespace PartitionPilot.Forcing
-open SetFormula
-universe u
-
-namespace BoundedFormula
-def relationFiberFamilyEntryFormula {n} (z I W B R : Fin n) : BoundedFormula n :=
-  exMem I (exMem W.succ (.conj (orderedPairFormula z.succ.succ 1 0)
-    (fiberFormula 0 1 B.succ.succ R.succ.succ)))
-
-theorem truth_relationFiberFamilyEntryFormula {n} (z I W B R : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (relationFiberFamilyEntryFormula z I W B R) env ↔
-      ∃ i ∈ env I, ∃ f ∈ env W, env z = ZFSet.pair i f ∧
-        f = relationFiber (env B) (env R) i := by
-  simp only [relationFiberFamilyEntryFormula, truth_exMem, Truth,
-    truth_orderedPairFormula, truth_fiberFormula]
-  rfl
-end BoundedFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-
-noncomputable def relationFiberFamily (I B R : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => ∃ i ∈ I, ∃ f ∈ M.groundPower B,
-    z = ZFSet.pair i f ∧ f = relationFiber B R i) (ZFSet.prod I (M.groundPower B))
-
-theorem pair_mem_relationFiberFamily (I B R i f : ZFSet.{u}) :
-    ZFSet.pair i f ∈ M.relationFiberFamily I B R ↔
-      i ∈ I ∧ f ∈ M.groundPower B ∧ f = relationFiber B R i := by
-  rw [relationFiberFamily, ZFSet.mem_sep, ZFSet.pair_mem_prod]
-  constructor
-  · rintro ⟨_, j, hj, g, hg, equal, value⟩
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
-    exact ⟨hj, hg, value⟩
-  · rintro ⟨hi, hf, equal⟩
-    exact ⟨⟨hi, hf⟩, i, hi, f, hf, rfl, equal⟩
-
-variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-variable (unions : Realize M.sets SetFormula.union Fin.elim0)
-variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-variable {I B R : ZFSet.{u}} (hI : I ∈ M.sets) (hB : B ∈ M.sets) (hR : R ∈ M.sets)
-
-include pairing unions powers separation hI hB hR in
-theorem relationFiberFamily_mem : M.relationFiberFamily I B R ∈ M.sets := by
-  have hW := M.groundPower_mem powers hB
-  let params := extend I (extend (M.groundPower B) (extend B (extend R Fin.elim0)))
-  have selected := M.bounded_separation_mem separation
-    (BoundedFormula.relationFiberFamilyEntryFormula 0 1 2 3 4) params
-    (Fin.cases hI (Fin.cases hW (Fin.cases hB (Fin.cases hR (fun j => Fin.elim0 j)))))
-    (M.prod_mem pairing unions powers separation hI hW)
-  have equal : ZFSet.sep (fun z => BoundedFormula.Truth
-      (BoundedFormula.relationFiberFamilyEntryFormula 0 1 2 3 4) (extend z params))
-      (ZFSet.prod I (M.groundPower B)) = M.relationFiberFamily I B R := by
-    apply ZFSet.ext
-    intro z
-    rw [ZFSet.mem_sep, relationFiberFamily, ZFSet.mem_sep]
-    exact and_congr Iff.rfl (BoundedFormula.truth_relationFiberFamilyEntryFormula 0 1 2 3 4 _)
-  exact equal ▸ selected
-
-include separation hI hB hR in
-theorem relationFiberFamily_function :
-    ZFSet.IsFunc I (M.groundPower B) (M.relationFiberFamily I B R) := by
-  refine ⟨fun _ hz => (ZFSet.mem_sep.1 hz).1, ?_⟩
-  intro i hi
-  have bound := (M.mem_groundPower B (relationFiber B R i)).2
-    ⟨M.relationFiber_mem separation hB hR (M.transitive hI hi),
-      fun _ hz => (mem_relationFiber _ _ _ _).1 hz |>.1⟩
-  exact ⟨relationFiber B R i,
-    (M.pair_mem_relationFiberFamily I B R i _).2 ⟨hi, bound, rfl⟩,
-    fun f entry => ((M.pair_mem_relationFiberFamily I B R i f).1 entry).2.2⟩
-
-include separation hI hB hR in
-theorem relationFiberFamily_entries (i f : ZFSet.{u}) :
-    ZFSet.pair i f ∈ M.relationFiberFamily I B R ↔ i ∈ I ∧ f = relationFiber B R i := by
-  constructor
-  · intro entry
-    have parts := (M.pair_mem_relationFiberFamily I B R i f).1 entry
-    exact ⟨parts.1, parts.2.2⟩
-  · rintro ⟨hi, rfl⟩
-    obtain ⟨f, entry, _⟩ := (M.relationFiberFamily_function separation hI hB hR).2 i hi
-    have equal := ((M.pair_mem_relationFiberFamily I B R i f).1 entry).2.2
-    exact equal ▸ entry
-
-end TransitiveGround
-
-
-
-
-
-def ExternalCosetSupport (E U C classifier copies zero v y : ZFSet.{u}) : Prop :=
-  ∃ c ∈ C, ∃ w ∈ E, ∃ x ∈ U, v = ZFSet.pair zero c ∧
-    ZFSet.pair w c ∈ classifier ∧ ZFSet.pair (ZFSet.pair w x) y ∈ copies
-
-def ExternalTileSupport (E Q Requests localPoints action first v y : ZFSet.{u}) : Prop :=
-  ∃ w ∈ E, ∃ r ∈ Requests, ∃ x ∈ Q, v = ZFSet.pair first (ZFSet.pair w r) ∧
-    ZFSet.pair r x ∈ localPoints ∧ ZFSet.pair (ZFSet.pair w x) y ∈ action
-
-def externalStarSupportGraph (V Q E U C Requests classifier copies localPoints action zero first : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => ∃ v ∈ V, ∃ y ∈ Q, z = ZFSet.pair v y ∧
-    (ExternalCosetSupport E U C classifier copies zero v y ∨
-      ExternalTileSupport E Q Requests localPoints action first v y)) (ZFSet.prod V Q)
-
-theorem pair_mem_externalStarSupportGraph (V Q E U C Requests classifier copies localPoints action zero first v y : ZFSet.{u}) :
-    ZFSet.pair v y ∈ externalStarSupportGraph V Q E U C Requests classifier copies localPoints action zero first ↔
-      v ∈ V ∧ y ∈ Q ∧ (ExternalCosetSupport E U C classifier copies zero v y ∨
-        ExternalTileSupport E Q Requests localPoints action first v y) := by
-  rw [externalStarSupportGraph, ZFSet.mem_sep]
-  constructor
-  · rintro ⟨_, v', hv, y', hy, equal, body⟩
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
-    exact ⟨hv, hy, body⟩
-  · rintro ⟨hv, hy, body⟩
-    exact ⟨ZFSet.pair_mem_prod.2 ⟨hv, hy⟩, v, hv, y, hy, rfl, body⟩
-
-namespace BoundedFormula
-
-def externalCosetSupportFormula {n} (E U C classifier copies zero v y : Fin n) : BoundedFormula n :=
-  exMem C (exMem E.succ (exMem U.succ.succ
-    (.conj (orderedPairFormula v.succ.succ.succ zero.succ.succ.succ 2)
-      (.conj (pairMembershipFormula 1 2 classifier.succ.succ.succ)
-        (tripleMembershipFormula 1 0 y.succ.succ.succ copies.succ.succ.succ)))))
-
-theorem truth_externalCosetSupportFormula {n} (E U C classifier copies zero v y : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (externalCosetSupportFormula E U C classifier copies zero v y) env ↔
-      ExternalCosetSupport (env E) (env U) (env C) (env classifier) (env copies) (env zero) (env v) (env y) := by
-  simp only [externalCosetSupportFormula, truth_exMem, Truth, truth_orderedPairFormula,
-    truth_pairMembershipFormula, truth_tripleMembershipFormula, ExternalCosetSupport]
-  rfl
-
-def externalTileSupportFormula {n} (E Q Requests localPoints action first v y : Fin n) : BoundedFormula n :=
-  exMem E (exMem Requests.succ (exMem Q.succ.succ
-    (.conj (orderedRightTripleFormula v.succ.succ.succ first.succ.succ.succ 2 1)
-      (.conj (pairMembershipFormula 1 0 localPoints.succ.succ.succ)
-        (tripleMembershipFormula 2 0 y.succ.succ.succ action.succ.succ.succ)))))
-
-theorem truth_externalTileSupportFormula {n} (E Q Requests localPoints action first v y : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (externalTileSupportFormula E Q Requests localPoints action first v y) env ↔
-      ExternalTileSupport (env E) (env Q) (env Requests) (env localPoints) (env action) (env first) (env v) (env y) := by
-  simp only [externalTileSupportFormula, truth_exMem, Truth, truth_orderedRightTripleFormula,
-    truth_pairMembershipFormula, truth_tripleMembershipFormula, ExternalTileSupport]
-  rfl
-
-def externalStarSupportEntryFormula {n} (z V Q E U C Requests classifier copies localPoints action zero first : Fin n) : BoundedFormula n :=
-  exMem V (exMem Q.succ (.conj (orderedPairFormula z.succ.succ 1 0)
-    (.disj (externalCosetSupportFormula E.succ.succ U.succ.succ C.succ.succ
-      classifier.succ.succ copies.succ.succ zero.succ.succ 1 0)
-      (externalTileSupportFormula E.succ.succ Q.succ.succ Requests.succ.succ
-        localPoints.succ.succ action.succ.succ first.succ.succ 1 0))))
-
-theorem truth_externalStarSupportEntryFormula {n} (z V Q E U C Requests classifier copies localPoints action zero first : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (externalStarSupportEntryFormula z V Q E U C Requests classifier copies localPoints action zero first) env ↔
-      env z ∈ externalStarSupportGraph (env V) (env Q) (env E) (env U) (env C) (env Requests)
-        (env classifier) (env copies) (env localPoints) (env action) (env zero) (env first) := by
-  simp only [externalStarSupportEntryFormula, truth_exMem, Truth, truth_disj, truth_orderedPairFormula,
-    truth_externalCosetSupportFormula, truth_externalTileSupportFormula, externalStarSupportGraph, ZFSet.mem_sep]
-  refine ⟨fun body => ⟨?_, body⟩, And.right⟩
-  obtain ⟨v, hv, y, hy, equal, _⟩ := body
-  change env z = ZFSet.pair v y at equal
-  rw [equal]
-  exact ZFSet.pair_mem_prod.2 ⟨hv, hy⟩
-end BoundedFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-theorem externalStarSupportGraph_mem
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    {V Q E U C Requests classifier copies localPoints action zero first : ZFSet.{u}}
-    (hV : V ∈ M.sets) (hQ : Q ∈ M.sets) (hE : E ∈ M.sets) (hU : U ∈ M.sets)
-    (hC : C ∈ M.sets) (hRequests : Requests ∈ M.sets) (hClassifier : classifier ∈ M.sets)
-    (hCopies : copies ∈ M.sets) (hLocal : localPoints ∈ M.sets) (hAction : action ∈ M.sets)
-    (hZero : zero ∈ M.sets) (hFirst : first ∈ M.sets) :
-    externalStarSupportGraph V Q E U C Requests classifier copies localPoints action zero first ∈ M.sets := by
-  let params := extend V (extend Q (extend E (extend U (extend C (extend Requests (extend classifier (extend copies (extend localPoints (extend action (extend zero (extend first (Fin.elim0))))))))))))
-  have members : ∀ i, params i ∈ M.sets := Fin.cases hV (Fin.cases hQ (Fin.cases hE (Fin.cases hU (Fin.cases hC (Fin.cases hRequests (Fin.cases hClassifier (Fin.cases hCopies (Fin.cases hLocal (Fin.cases hAction (Fin.cases hZero (Fin.cases hFirst ((fun i => Fin.elim0 i)))))))))))))
-  have selected := M.bounded_separation_mem separation
-    (BoundedFormula.externalStarSupportEntryFormula 0 1 2 3 4 5 6 7 8 9 10 11 12) params members
-    (M.prod_mem pairing unions powers separation hV hQ)
-  have equal : ZFSet.sep (fun z => BoundedFormula.Truth
-      (BoundedFormula.externalStarSupportEntryFormula 0 1 2 3 4 5 6 7 8 9 10 11 12) (extend z params))
-      (ZFSet.prod V Q) = externalStarSupportGraph V Q E U C Requests classifier copies localPoints action zero first := by
-    apply ZFSet.ext
-    intro z
-    rw [ZFSet.mem_sep, BoundedFormula.truth_externalStarSupportEntryFormula]
-    change (z ∈ ZFSet.prod V Q ∧ z ∈ externalStarSupportGraph V Q E U C Requests classifier copies localPoints action zero first) ↔ _
-    exact ⟨And.right, fun hz => ⟨(ZFSet.mem_sep.1 hz).1, hz⟩⟩
-  exact equal ▸ selected
-
-end TransitiveGround
-
-
-
-
-
-def parentSupportGraph (V Q supports parents : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => ∃ v ∈ V, ∃ y ∈ Q, z = ZFSet.pair v y ∧ ZFSet.pair v y ∈ supports ∧
-    ∃ p ∈ V, ZFSet.pair v p ∈ parents ∧ ZFSet.pair p y ∈ supports) (ZFSet.prod V Q)
-
-def freshSupportGraph (V Q supports parents : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => z ∉ parentSupportGraph V Q supports parents) supports
-
-theorem pair_mem_parentSupportGraph (V Q supports parents v y : ZFSet.{u}) :
-    ZFSet.pair v y ∈ parentSupportGraph V Q supports parents ↔ v ∈ V ∧ y ∈ Q ∧
-      ZFSet.pair v y ∈ supports ∧ ∃ p ∈ V, ZFSet.pair v p ∈ parents ∧ ZFSet.pair p y ∈ supports := by
-  rw [parentSupportGraph, ZFSet.mem_sep]
-  constructor
-  · rintro ⟨_, v', hv, y', hy, equal, body⟩
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
-    exact ⟨hv, hy, body⟩
-  · rintro ⟨hv, hy, body⟩
-    exact ⟨ZFSet.pair_mem_prod.2 ⟨hv, hy⟩, v, hv, y, hy, rfl, body⟩
-
-theorem pair_mem_parentSupportGraph_of_parent {V Q supports parents v p y : ZFSet.{u}}
-    (function : ZFSet.IsFunc V V parents) (parent : ZFSet.pair v p ∈ parents) :
-    ZFSet.pair v y ∈ parentSupportGraph V Q supports parents ↔
-      y ∈ Q ∧ ZFSet.pair v y ∈ supports ∧ ZFSet.pair p y ∈ supports := by
-  have shape := ZFSet.pair_mem_prod.1 (function.1 parent)
-  rw [pair_mem_parentSupportGraph]
-  constructor
-  · rintro ⟨_, hy, supported, p', _, atParent, supportedParent⟩
-    have equal := (show FunctionGraphOn V parents from ⟨V, function⟩).unique atParent parent
-    exact ⟨hy, supported, equal ▸ supportedParent⟩
-  · rintro ⟨hy, supported, supportedParent⟩
-    exact ⟨shape.1, hy, supported, p, shape.2, parent, supportedParent⟩
-
-theorem pair_mem_freshSupportGraph (V Q supports parents v y : ZFSet.{u}) :
-    ZFSet.pair v y ∈ freshSupportGraph V Q supports parents ↔
-      ZFSet.pair v y ∈ supports ∧ ZFSet.pair v y ∉ parentSupportGraph V Q supports parents := by
-  exact ZFSet.mem_sep
-
-namespace BoundedFormula
-def parentSupportEntryFormula {n} (z V Q supports parents : Fin n) : BoundedFormula n :=
-  exMem V (exMem Q.succ (.conj (orderedPairFormula z.succ.succ 1 0)
-    (.conj (pairMembershipFormula 1 0 supports.succ.succ)
-      (exMem V.succ.succ (.conj (pairMembershipFormula 2 0 parents.succ.succ.succ)
-        (pairMembershipFormula 0 1 supports.succ.succ.succ))))))
-
-theorem truth_parentSupportEntryFormula {n} (z V Q supports parents : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (parentSupportEntryFormula z V Q supports parents) env ↔
-      env z ∈ parentSupportGraph (env V) (env Q) (env supports) (env parents) := by
-  simp only [parentSupportEntryFormula, truth_exMem, Truth, truth_orderedPairFormula,
-    truth_pairMembershipFormula, parentSupportGraph, ZFSet.mem_sep]
-  refine ⟨fun h => ⟨?_, h⟩, And.right⟩
-  obtain ⟨v, hv, y, hy, equal, _⟩ := h
-  change env z = ZFSet.pair v y at equal
-  rw [equal]
-  exact ZFSet.pair_mem_prod.2 ⟨hv, hy⟩
-end BoundedFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-variable (unions : Realize M.sets SetFormula.union Fin.elim0)
-variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-variable {V Q supports parents : ZFSet.{u}} (hV : V ∈ M.sets) (hQ : Q ∈ M.sets)
-variable (hSupports : supports ∈ M.sets) (hParents : parents ∈ M.sets)
-include pairing unions powers separation hV hQ hSupports hParents
-
-theorem parentSupportGraph_mem : parentSupportGraph V Q supports parents ∈ M.sets := by
-  let params := extend V (extend Q (extend supports (extend parents Fin.elim0)))
-  have selected := M.bounded_separation_mem separation
-    (BoundedFormula.parentSupportEntryFormula 0 1 2 3 4) params
-    (Fin.cases hV (Fin.cases hQ (Fin.cases hSupports (Fin.cases hParents (fun i => Fin.elim0 i)))))
-    (M.prod_mem pairing unions powers separation hV hQ)
-  have equal : ZFSet.sep (fun z => BoundedFormula.Truth
-      (BoundedFormula.parentSupportEntryFormula 0 1 2 3 4) (extend z params)) (ZFSet.prod V Q) =
-      parentSupportGraph V Q supports parents := by
-    apply ZFSet.ext
-    intro z
-    rw [ZFSet.mem_sep, BoundedFormula.truth_parentSupportEntryFormula]
-    exact ⟨And.right, fun hz => ⟨(ZFSet.mem_sep.1 hz).1, hz⟩⟩
-  exact equal ▸ selected
-
-theorem freshSupportGraph_mem : freshSupportGraph V Q supports parents ∈ M.sets := by
-  have parentGround := M.parentSupportGraph_mem pairing unions powers separation hV hQ hSupports hParents
-  exact M.bounded_separation_mem separation (BoundedFormula.neg (.mem 0 1))
-    (extend (parentSupportGraph V Q supports parents) Fin.elim0)
-    (Fin.cases parentGround (fun i => Fin.elim0 i)) hSupports
-
-end TransitiveGround
-
-end PartitionPilot.Forcing
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Definability.GroundPairCompositions
+
+namespace OAI
+
+
+namespace PartitionPilot.Forcing.BoundedFormula
+
+open SetFormula
+universe u
+
+def orderedRightTripleFormula {n} (w x c q : Fin n) : BoundedFormula n :=
+  exMem w (exMem 0 (.conj (orderedPairFormula 0 c.succ.succ q.succ.succ)
+    (orderedPairFormula w.succ.succ x.succ.succ 0)))
+
+def rightTripleMembershipFormula {n} (x c q f : Fin n) : BoundedFormula n :=
+  exMem f (orderedRightTripleFormula 0 x.succ c.succ q.succ)
+
+theorem truth_orderedRightTripleFormula {n} (w x c q : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (orderedRightTripleFormula w x c q) env ↔
+      env w = ZFSet.pair (env x) (ZFSet.pair (env c) (env q)) := by
+  simp only [orderedRightTripleFormula, truth_exMem, Truth, truth_orderedPairFormula]
+  change (∃ a ∈ env w, ∃ b ∈ a, b = ZFSet.pair (env c) (env q) ∧
+    env w = ZFSet.pair (env x) b) ↔ _
+  constructor
+  · rintro ⟨_, _, _, _, rfl, equal⟩
+    exact equal
+  · intro equal
+    refine ⟨{env x, ZFSet.pair (env c) (env q)}, ?_, ZFSet.pair (env c) (env q),
+      ZFSet.mem_pair.2 (Or.inr rfl), rfl, equal⟩
+    rw [equal]
+    exact ZFSet.mem_pair.2 (Or.inr rfl)
+
+theorem truth_rightTripleMembershipFormula {n} (x c q f : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (rightTripleMembershipFormula x c q f) env ↔
+      ZFSet.pair (env x) (ZFSet.pair (env c) (env q)) ∈ env f := by
+  simp only [rightTripleMembershipFormula, truth_exMem, truth_orderedRightTripleFormula]
+  change (∃ w ∈ env f, w = ZFSet.pair (env x) (ZFSet.pair (env c) (env q))) ↔ _
+  constructor
+  · rintro ⟨w, hw, heq⟩
+    exact heq ▸ hw
+  · intro hw
+    exact ⟨_, hw, rfl⟩
+
+def relationToProductFormula {n} (a c q f : Fin n) : BoundedFormula n :=
+  .allMem f (exMem a.succ (exMem c.succ.succ
+    (exMem q.succ.succ.succ (orderedRightTripleFormula 3 2 1 0))))
+
+def functionToProductFormula {n} (a c q f : Fin n) : BoundedFormula n :=
+  .conj (relationToProductFormula a c q f)
+    (.allMem a (exMem c.succ (exMem q.succ.succ
+      (.conj (rightTripleMembershipFormula 2 1 0 f.succ.succ.succ)
+        (.allMem c.succ.succ.succ (.allMem q.succ.succ.succ.succ
+          (imp (rightTripleMembershipFormula 4 1 0 f.succ.succ.succ.succ.succ)
+            (.conj (.equal 1 3) (.equal 0 2)))))))))
+
+theorem truth_relationToProductFormula {n} (a c q f : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (relationToProductFormula a c q f) env ↔
+      env f ⊆ ZFSet.prod (env a) (ZFSet.prod (env c) (env q)) := by
+  simp only [relationToProductFormula, Truth, truth_exMem, truth_orderedRightTripleFormula]
+  constructor
+  · intro h w hw
+    obtain ⟨x, hx, d, hd, v, hv, equal⟩ := h w hw
+    exact ZFSet.mem_prod.2 ⟨x, hx, ZFSet.pair d v, ZFSet.pair_mem_prod.2 ⟨hd, hv⟩, equal⟩
+  · intro h w hw
+    obtain ⟨x, hx, y, hy, equal⟩ := ZFSet.mem_prod.1 (h hw)
+    obtain ⟨d, hd, v, hv, rfl⟩ := ZFSet.mem_prod.1 hy
+    exact ⟨x, hx, d, hd, v, hv, equal⟩
+
+theorem truth_functionToProductFormula {n} (a c q f : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (functionToProductFormula a c q f) env ↔
+      ZFSet.IsFunc (env a) (ZFSet.prod (env c) (env q)) (env f) := by
+  simp only [functionToProductFormula, Truth, truth_relationToProductFormula, truth_exMem,
+    truth_rightTripleMembershipFormula, truth_imp]
+  constructor
+  · rintro ⟨shape, total⟩
+    refine ⟨shape, ?_⟩
+    intro x hx
+    obtain ⟨d, _, v, _, entry, unique⟩ := total x hx
+    refine ⟨ZFSet.pair d v, entry, ?_⟩
+    intro y hy
+    obtain ⟨b, hb, z, hz, rfl⟩ := ZFSet.mem_prod.1 (ZFSet.pair_mem_prod.1 (shape hy)).2
+    have both : b = d ∧ z = v := unique b hb z hz hy
+    obtain ⟨rfl, rfl⟩ := both
+    rfl
+  · rintro ⟨shape, total⟩
+    refine ⟨shape, ?_⟩
+    intro x hx
+    obtain ⟨y, entry, unique⟩ := total x hx
+    obtain ⟨d, hd, v, hv, rfl⟩ := ZFSet.mem_prod.1 (ZFSet.pair_mem_prod.1 (shape entry)).2
+    refine ⟨d, hd, v, hv, entry, ?_⟩
+    intro b _ z _ hz
+    exact ZFSet.pair_injective (unique _ hz)
+
+end PartitionPilot.Forcing.BoundedFormula
+
+
+
+namespace PartitionPilot.Forcing
+
+open scoped ZFSet
+
+universe u
+
+structure ChoiceFunctionCode (A f : ZFSet.{u}) : Prop where
+  function : ZFSet.IsFunc A (⋃₀ A) f
+  chosen : ∀ x y, ZFSet.pair x y ∈ f → y ∈ x
+
+namespace BoundedFormula
+
+open SetFormula
+
+theorem truth_nonemptyFormula {n} (x : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (nonemptyFormula x) env ↔ (env x).Nonempty := by
+  simp only [nonemptyFormula, truth_exMem, Truth]
+  exact ⟨fun ⟨y, hy, _⟩ => ⟨y, hy⟩, fun ⟨y, hy⟩ => ⟨y, hy, True.intro⟩⟩
+
+theorem truth_choiceFunctionFormula {n} (a f : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (choiceFunctionFormula a f) env ↔ ChoiceFunctionCode (env a) (env f) := by
+  simp only [choiceFunctionFormula, Truth, truth_exMem, truth_orderedPairFormula,
+    truth_pairMembershipFormula, truth_imp]
+  change ((∀ z ∈ env f, ∃ x ∈ env a, ∃ y ∈ x, z = ZFSet.pair x y) ∧
+    ∀ x ∈ env a, ∃ y ∈ x, ZFSet.pair x y ∈ env f ∧
+      ∀ z ∈ x, ZFSet.pair x z ∈ env f → z = y) ↔ _
+  constructor
+  · rintro ⟨shape, total⟩
+    have chosen : ∀ x y, ZFSet.pair x y ∈ env f → y ∈ x := by
+      intro x y rel
+      obtain ⟨x', _, y', hy', eq⟩ := shape _ rel
+      obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 eq
+      exact hy'
+    refine ⟨⟨?_, ?_⟩, chosen⟩
+    · intro z hz
+      obtain ⟨x, hx, y, hy, rfl⟩ := shape z hz
+      exact ZFSet.pair_mem_prod.2 ⟨hx, ZFSet.mem_sUnion.2 ⟨x, hx, hy⟩⟩
+    · intro x hx
+      obtain ⟨y, _, rel, unique⟩ := total x hx
+      exact ⟨y, rel, fun z hz => unique z (chosen x z hz) hz⟩
+  · intro h
+    refine ⟨?_, ?_⟩
+    · intro z hz
+      obtain ⟨x, hx, y, _, eq⟩ := ZFSet.mem_prod.1 (h.function.1 hz)
+      exact ⟨x, hx, y, h.chosen x y (eq ▸ hz), eq⟩
+    · intro x hx
+      obtain ⟨y, rel, unique⟩ := h.function.2 x hx
+      exact ⟨y, h.chosen x y rel, rel, fun z _ hz => unique z hz⟩
+
+end BoundedFormula
+
+
+namespace TransitiveGround
+
+open SetFormula
+variable (M : TransitiveGround.{u})
+
+theorem choice_witness (choice : Realize M.sets SetFormula.choice Fin.elim0)
+    {A : ZFSet.{u}} (hA : A ∈ M.sets) (nonempty : ∀ x ∈ A, x.Nonempty) :
+    ∃ f ∈ M.sets, ChoiceFunctionCode A f := by
+  have selected := (realize_imp M.sets _ _ _).1 (choice A hA)
+  have premise : Realize M.sets
+      (BoundedFormula.allMem 0 (BoundedFormula.nonemptyFormula 0)).toFormula (extend A Fin.elim0) := by
+    apply (BoundedFormula.realize_toFormula M _ _ (Fin.cases hA (fun i => Fin.elim0 i))).2
+    intro x hx
+    exact (BoundedFormula.truth_nonemptyFormula 0 _).2 (nonempty x hx)
+  obtain ⟨f, hf, rel⟩ := (realize_ex M.sets _ _).1 (selected premise)
+  exact ⟨f, hf, (BoundedFormula.truth_choiceFunctionFormula 1 0 _).1
+    ((BoundedFormula.realize_toFormula M _ _ (Fin.cases hf (Fin.cases hA (fun i => Fin.elim0 i)))).1 rel)⟩
+
+end TransitiveGround
+
+end PartitionPilot.Forcing
+
+
+
+namespace PartitionPilot.Forcing
+
+universe u
+
+noncomputable def relationFiber (B r x : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun y => ZFSet.pair x y ∈ r) B
+
+theorem mem_relationFiber (B r x y : ZFSet.{u}) :
+    y ∈ relationFiber B r x ↔ y ∈ B ∧ ZFSet.pair x y ∈ r := ZFSet.mem_sep
+
+noncomputable def choiceUniformGraph (A B r F c : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => ∃ x ∈ A, ∃ y ∈ B, z = ZFSet.pair x y ∧
+    relationFiber B r x ∈ F ∧ ZFSet.pair (relationFiber B r x) y ∈ c) (ZFSet.prod A B)
+
+theorem pair_mem_choiceUniformGraph (A B r F c x y : ZFSet.{u}) :
+    ZFSet.pair x y ∈ choiceUniformGraph A B r F c ↔
+      x ∈ A ∧ y ∈ B ∧ relationFiber B r x ∈ F ∧ ZFSet.pair (relationFiber B r x) y ∈ c := by
+  rw [choiceUniformGraph, ZFSet.mem_sep]
+  constructor
+  · rintro ⟨_, a, ha, b, hb, eq, hf, rel⟩
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 eq
+    exact ⟨ha, hb, hf, rel⟩
+  · rintro ⟨hx, hy, hf, rel⟩
+    exact ⟨ZFSet.pair_mem_prod.2 ⟨hx, hy⟩, x, hx, y, hy, rfl, hf, rel⟩
+
+theorem choiceUniformGraph_function {A B r F c : ZFSet.{u}} (choice : ChoiceFunctionCode F c)
+    (fibers : ∀ x ∈ A, relationFiber B r x ∈ F) :
+    ZFSet.IsFunc A B (choiceUniformGraph A B r F c) ∧ choiceUniformGraph A B r F c ⊆ r := by
+  refine ⟨⟨fun _ hz => (ZFSet.mem_sep.1 hz).1, ?_⟩, ?_⟩
+  · intro x hx
+    obtain ⟨y, rel, unique⟩ := choice.function.2 (relationFiber B r x) (fibers x hx)
+    have hy := (mem_relationFiber B r x y).1 (choice.chosen _ _ rel)
+    exact ⟨y, (pair_mem_choiceUniformGraph A B r F c x y).2 ⟨hx, hy.1, fibers x hx, rel⟩,
+      fun z hz => unique z ((pair_mem_choiceUniformGraph A B r F c x z).1 hz).2.2.2⟩
+  · intro z hz
+    obtain ⟨_, x, _, y, _, eq, _, rel⟩ := ZFSet.mem_sep.1 hz
+    exact eq.symm ▸ ((mem_relationFiber B r x y).1 (choice.chosen _ _ rel)).2
+
+namespace BoundedFormula
+
+open SetFormula
+
+def fiberFormula {n} (f x b r : Fin n) : BoundedFormula n :=
+  .conj (.allMem f (.mem 0 b.succ)) (.allMem b
+    (.conj (imp (.mem 0 f.succ) (pairMembershipFormula x.succ 0 r.succ))
+      (imp (pairMembershipFormula x.succ 0 r.succ) (.mem 0 f.succ))))
+
+theorem truth_fiberFormula {n} (f x b r : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (fiberFormula f x b r) env ↔ env f = relationFiber (env b) (env r) (env x) := by
+  simp only [fiberFormula, Truth, truth_imp, truth_pairMembershipFormula]
+  change ((∀ y ∈ env f, y ∈ env b) ∧ ∀ y ∈ env b,
+    (y ∈ env f → ZFSet.pair (env x) y ∈ env r) ∧ (ZFSet.pair (env x) y ∈ env r → y ∈ env f)) ↔ _
+  constructor
+  · rintro ⟨subset, spec⟩
+    apply ZFSet.ext
+    intro y
+    rw [mem_relationFiber]
+    exact ⟨fun hy => ⟨subset y hy, (spec y (subset y hy)).1 hy⟩,
+      fun ⟨hy, rel⟩ => (spec y hy).2 rel⟩
+  · intro eq
+    rw [eq]
+    exact ⟨fun _ hy => (ZFSet.mem_sep.1 hy).1,
+      fun y hy => ⟨fun rel => (ZFSet.mem_sep.1 rel).2, fun rel => ZFSet.mem_sep.2 ⟨hy, rel⟩⟩⟩
+
+def choiceUniformEntryFormula {n} (z a b r f c : Fin n) : BoundedFormula n :=
+  exMem a (exMem b.succ (exMem f.succ.succ
+    (.conj (orderedPairFormula z.succ.succ.succ 2 1)
+      (.conj (fiberFormula 0 2 b.succ.succ.succ r.succ.succ.succ)
+        (pairMembershipFormula 0 1 c.succ.succ.succ)))))
+
+theorem truth_choiceUniformEntryFormula {n} (z a b r f c : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (choiceUniformEntryFormula z a b r f c) env ↔
+      ∃ x ∈ env a, ∃ y ∈ env b, env z = ZFSet.pair x y ∧
+        relationFiber (env b) (env r) x ∈ env f ∧ ZFSet.pair (relationFiber (env b) (env r) x) y ∈ env c := by
+  simp only [choiceUniformEntryFormula, truth_exMem, Truth,
+    truth_orderedPairFormula, truth_fiberFormula, truth_pairMembershipFormula]
+  change (∃ x ∈ env a, ∃ y ∈ env b, ∃ F ∈ env f, env z = ZFSet.pair x y ∧
+    F = relationFiber (env b) (env r) x ∧ ZFSet.pair F y ∈ env c) ↔ _
+  constructor
+  · rintro ⟨x, hx, y, hy, F, hF, eq, rfl, rel⟩
+    exact ⟨x, hx, y, hy, eq, hF, rel⟩
+  · rintro ⟨x, hx, y, hy, eq, hF, rel⟩
+    exact ⟨x, hx, y, hy, relationFiber (env b) (env r) x, hF, eq, rfl, rel⟩
+
+end BoundedFormula
+
+namespace TransitiveGround
+
+open SetFormula
+variable (M : TransitiveGround.{u})
+
+theorem relationFiber_mem (separation : SeparationSchema M.sets) {B r x : ZFSet.{u}}
+    (hB : B ∈ M.sets) (hr : r ∈ M.sets) (hx : x ∈ M.sets) : relationFiber B r x ∈ M.sets := by
+  let params := extend x (extend r Fin.elim0)
+  have selected := M.bounded_separation_mem separation (BoundedFormula.pairMembershipFormula 1 0 2)
+    params (Fin.cases hx (Fin.cases hr (fun i => Fin.elim0 i))) hB
+  have eq : ZFSet.sep (fun y => BoundedFormula.Truth (BoundedFormula.pairMembershipFormula 1 0 2)
+      (extend y params)) B = relationFiber B r x := by
+    apply ZFSet.ext
+    intro y
+    rw [ZFSet.mem_sep, mem_relationFiber]
+    exact and_congr Iff.rfl (BoundedFormula.truth_pairMembershipFormula 1 0 2 _)
+  exact eq ▸ selected
+
+noncomputable def nonemptyGroundSubsets (B : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep ZFSet.Nonempty (M.groundPower B)
+
+theorem mem_nonemptyGroundSubsets (B F : ZFSet.{u}) :
+    F ∈ M.nonemptyGroundSubsets B ↔ F ∈ M.sets ∧ F ⊆ B ∧ F.Nonempty := by
+  rw [nonemptyGroundSubsets, ZFSet.mem_sep, M.mem_groundPower]
+  exact and_assoc
+
+theorem nonemptyGroundSubsets_mem (powers : Realize M.sets powerSet Fin.elim0)
+    (separation : SeparationSchema M.sets) {B : ZFSet.{u}} (hB : B ∈ M.sets) :
+    M.nonemptyGroundSubsets B ∈ M.sets := by
+  have selected := M.bounded_separation_mem separation (BoundedFormula.nonemptyFormula 0)
+    Fin.elim0 (fun i => Fin.elim0 i) (M.groundPower_mem powers hB)
+  have eq : ZFSet.sep (fun F => BoundedFormula.Truth (BoundedFormula.nonemptyFormula 0)
+      (extend F Fin.elim0)) (M.groundPower B) = M.nonemptyGroundSubsets B := by
+    apply ZFSet.ext
+    intro F
+    rw [ZFSet.mem_sep, nonemptyGroundSubsets, ZFSet.mem_sep]
+    exact and_congr Iff.rfl (BoundedFormula.truth_nonemptyFormula 0 _)
+  exact eq ▸ selected
+
+theorem choiceUniformGraph_mem
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    {A B r F c : ZFSet.{u}} (hA : A ∈ M.sets) (hB : B ∈ M.sets)
+    (hr : r ∈ M.sets) (hF : F ∈ M.sets) (hc : c ∈ M.sets) : choiceUniformGraph A B r F c ∈ M.sets := by
+  let params := extend A (extend B (extend r (extend F (extend c Fin.elim0))))
+  have selected := M.bounded_separation_mem separation (BoundedFormula.choiceUniformEntryFormula 0 1 2 3 4 5)
+    params (Fin.cases hA (Fin.cases hB (Fin.cases hr (Fin.cases hF (Fin.cases hc (fun i => Fin.elim0 i))))))
+    (M.prod_mem pairing unions powers separation hA hB)
+  have eq : ZFSet.sep (fun z => BoundedFormula.Truth (BoundedFormula.choiceUniformEntryFormula 0 1 2 3 4 5)
+      (extend z params)) (ZFSet.prod A B) = choiceUniformGraph A B r F c := by
+    apply ZFSet.ext
+    intro z
+    rw [ZFSet.mem_sep, choiceUniformGraph, ZFSet.mem_sep]
+    exact and_congr Iff.rfl (BoundedFormula.truth_choiceUniformEntryFormula 0 1 2 3 4 5 _)
+  exact eq ▸ selected
+
+theorem uniformize_relation
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    (choice : Realize M.sets SetFormula.choice Fin.elim0)
+    {A B r : ZFSet.{u}} (hA : A ∈ M.sets) (hB : B ∈ M.sets) (hr : r ∈ M.sets)
+    (total : ∀ x ∈ A, ∃ y ∈ B, ZFSet.pair x y ∈ r) :
+    ∃ f ∈ M.sets, ZFSet.IsFunc A B f ∧ f ⊆ r := by
+  have family := M.nonemptyGroundSubsets_mem powers separation hB
+  obtain ⟨c, hc, code⟩ := M.choice_witness choice family
+    (fun F hF => ((M.mem_nonemptyGroundSubsets B F).1 hF).2.2)
+  have fibers (x : ZFSet.{u}) (hx : x ∈ A) : relationFiber B r x ∈ M.nonemptyGroundSubsets B := by
+    obtain ⟨y, hy, rel⟩ := total x hx
+    exact (M.mem_nonemptyGroundSubsets B _).2
+      ⟨M.relationFiber_mem separation hB hr (M.transitive hA hx), fun _ hz => (ZFSet.mem_sep.1 hz).1,
+        y, (mem_relationFiber B r x y).2 ⟨hy, rel⟩⟩
+  exact ⟨choiceUniformGraph A B r (M.nonemptyGroundSubsets B) c,
+    M.choiceUniformGraph_mem pairing unions powers separation hA hB hr family hc,
+    choiceUniformGraph_function code fibers⟩
+
+end TransitiveGround
+
+end PartitionPilot.Forcing
+
+
+
+namespace PartitionPilot.Forcing
+open SetFormula
+universe u
+
+namespace BoundedFormula
+def relationFiberFamilyEntryFormula {n} (z I W B R : Fin n) : BoundedFormula n :=
+  exMem I (exMem W.succ (.conj (orderedPairFormula z.succ.succ 1 0)
+    (fiberFormula 0 1 B.succ.succ R.succ.succ)))
+
+theorem truth_relationFiberFamilyEntryFormula {n} (z I W B R : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (relationFiberFamilyEntryFormula z I W B R) env ↔
+      ∃ i ∈ env I, ∃ f ∈ env W, env z = ZFSet.pair i f ∧
+        f = relationFiber (env B) (env R) i := by
+  simp only [relationFiberFamilyEntryFormula, truth_exMem, Truth,
+    truth_orderedPairFormula, truth_fiberFormula]
+  rfl
+end BoundedFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+
+noncomputable def relationFiberFamily (I B R : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => ∃ i ∈ I, ∃ f ∈ M.groundPower B,
+    z = ZFSet.pair i f ∧ f = relationFiber B R i) (ZFSet.prod I (M.groundPower B))
+
+theorem pair_mem_relationFiberFamily (I B R i f : ZFSet.{u}) :
+    ZFSet.pair i f ∈ M.relationFiberFamily I B R ↔
+      i ∈ I ∧ f ∈ M.groundPower B ∧ f = relationFiber B R i := by
+  rw [relationFiberFamily, ZFSet.mem_sep, ZFSet.pair_mem_prod]
+  constructor
+  · rintro ⟨_, j, hj, g, hg, equal, value⟩
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
+    exact ⟨hj, hg, value⟩
+  · rintro ⟨hi, hf, equal⟩
+    exact ⟨⟨hi, hf⟩, i, hi, f, hf, rfl, equal⟩
+
+variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+variable (unions : Realize M.sets SetFormula.union Fin.elim0)
+variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+variable {I B R : ZFSet.{u}} (hI : I ∈ M.sets) (hB : B ∈ M.sets) (hR : R ∈ M.sets)
+
+include pairing unions powers separation hI hB hR in
+theorem relationFiberFamily_mem : M.relationFiberFamily I B R ∈ M.sets := by
+  have hW := M.groundPower_mem powers hB
+  let params := extend I (extend (M.groundPower B) (extend B (extend R Fin.elim0)))
+  have selected := M.bounded_separation_mem separation
+    (BoundedFormula.relationFiberFamilyEntryFormula 0 1 2 3 4) params
+    (Fin.cases hI (Fin.cases hW (Fin.cases hB (Fin.cases hR (fun j => Fin.elim0 j)))))
+    (M.prod_mem pairing unions powers separation hI hW)
+  have equal : ZFSet.sep (fun z => BoundedFormula.Truth
+      (BoundedFormula.relationFiberFamilyEntryFormula 0 1 2 3 4) (extend z params))
+      (ZFSet.prod I (M.groundPower B)) = M.relationFiberFamily I B R := by
+    apply ZFSet.ext
+    intro z
+    rw [ZFSet.mem_sep, relationFiberFamily, ZFSet.mem_sep]
+    exact and_congr Iff.rfl (BoundedFormula.truth_relationFiberFamilyEntryFormula 0 1 2 3 4 _)
+  exact equal ▸ selected
+
+include separation hI hB hR in
+theorem relationFiberFamily_function :
+    ZFSet.IsFunc I (M.groundPower B) (M.relationFiberFamily I B R) := by
+  refine ⟨fun _ hz => (ZFSet.mem_sep.1 hz).1, ?_⟩
+  intro i hi
+  have bound := (M.mem_groundPower B (relationFiber B R i)).2
+    ⟨M.relationFiber_mem separation hB hR (M.transitive hI hi),
+      fun _ hz => (mem_relationFiber _ _ _ _).1 hz |>.1⟩
+  exact ⟨relationFiber B R i,
+    (M.pair_mem_relationFiberFamily I B R i _).2 ⟨hi, bound, rfl⟩,
+    fun f entry => ((M.pair_mem_relationFiberFamily I B R i f).1 entry).2.2⟩
+
+include separation hI hB hR in
+theorem relationFiberFamily_entries (i f : ZFSet.{u}) :
+    ZFSet.pair i f ∈ M.relationFiberFamily I B R ↔ i ∈ I ∧ f = relationFiber B R i := by
+  constructor
+  · intro entry
+    have parts := (M.pair_mem_relationFiberFamily I B R i f).1 entry
+    exact ⟨parts.1, parts.2.2⟩
+  · rintro ⟨hi, rfl⟩
+    obtain ⟨f, entry, _⟩ := (M.relationFiberFamily_function separation hI hB hR).2 i hi
+    have equal := ((M.pair_mem_relationFiberFamily I B R i f).1 entry).2.2
+    exact equal ▸ entry
+
+end TransitiveGround
+
+
+
+
+
+def ExternalCosetSupport (E U C classifier copies zero v y : ZFSet.{u}) : Prop :=
+  ∃ c ∈ C, ∃ w ∈ E, ∃ x ∈ U, v = ZFSet.pair zero c ∧
+    ZFSet.pair w c ∈ classifier ∧ ZFSet.pair (ZFSet.pair w x) y ∈ copies
+
+def ExternalTileSupport (E Q Requests localPoints action first v y : ZFSet.{u}) : Prop :=
+  ∃ w ∈ E, ∃ r ∈ Requests, ∃ x ∈ Q, v = ZFSet.pair first (ZFSet.pair w r) ∧
+    ZFSet.pair r x ∈ localPoints ∧ ZFSet.pair (ZFSet.pair w x) y ∈ action
+
+def externalStarSupportGraph (V Q E U C Requests classifier copies localPoints action zero first : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => ∃ v ∈ V, ∃ y ∈ Q, z = ZFSet.pair v y ∧
+    (ExternalCosetSupport E U C classifier copies zero v y ∨
+      ExternalTileSupport E Q Requests localPoints action first v y)) (ZFSet.prod V Q)
+
+theorem pair_mem_externalStarSupportGraph (V Q E U C Requests classifier copies localPoints action zero first v y : ZFSet.{u}) :
+    ZFSet.pair v y ∈ externalStarSupportGraph V Q E U C Requests classifier copies localPoints action zero first ↔
+      v ∈ V ∧ y ∈ Q ∧ (ExternalCosetSupport E U C classifier copies zero v y ∨
+        ExternalTileSupport E Q Requests localPoints action first v y) := by
+  rw [externalStarSupportGraph, ZFSet.mem_sep]
+  constructor
+  · rintro ⟨_, v', hv, y', hy, equal, body⟩
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
+    exact ⟨hv, hy, body⟩
+  · rintro ⟨hv, hy, body⟩
+    exact ⟨ZFSet.pair_mem_prod.2 ⟨hv, hy⟩, v, hv, y, hy, rfl, body⟩
+
+namespace BoundedFormula
+
+def externalCosetSupportFormula {n} (E U C classifier copies zero v y : Fin n) : BoundedFormula n :=
+  exMem C (exMem E.succ (exMem U.succ.succ
+    (.conj (orderedPairFormula v.succ.succ.succ zero.succ.succ.succ 2)
+      (.conj (pairMembershipFormula 1 2 classifier.succ.succ.succ)
+        (tripleMembershipFormula 1 0 y.succ.succ.succ copies.succ.succ.succ)))))
+
+theorem truth_externalCosetSupportFormula {n} (E U C classifier copies zero v y : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (externalCosetSupportFormula E U C classifier copies zero v y) env ↔
+      ExternalCosetSupport (env E) (env U) (env C) (env classifier) (env copies) (env zero) (env v) (env y) := by
+  simp only [externalCosetSupportFormula, truth_exMem, Truth, truth_orderedPairFormula,
+    truth_pairMembershipFormula, truth_tripleMembershipFormula, ExternalCosetSupport]
+  rfl
+
+def externalTileSupportFormula {n} (E Q Requests localPoints action first v y : Fin n) : BoundedFormula n :=
+  exMem E (exMem Requests.succ (exMem Q.succ.succ
+    (.conj (orderedRightTripleFormula v.succ.succ.succ first.succ.succ.succ 2 1)
+      (.conj (pairMembershipFormula 1 0 localPoints.succ.succ.succ)
+        (tripleMembershipFormula 2 0 y.succ.succ.succ action.succ.succ.succ)))))
+
+theorem truth_externalTileSupportFormula {n} (E Q Requests localPoints action first v y : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (externalTileSupportFormula E Q Requests localPoints action first v y) env ↔
+      ExternalTileSupport (env E) (env Q) (env Requests) (env localPoints) (env action) (env first) (env v) (env y) := by
+  simp only [externalTileSupportFormula, truth_exMem, Truth, truth_orderedRightTripleFormula,
+    truth_pairMembershipFormula, truth_tripleMembershipFormula, ExternalTileSupport]
+  rfl
+
+def externalStarSupportEntryFormula {n} (z V Q E U C Requests classifier copies localPoints action zero first : Fin n) : BoundedFormula n :=
+  exMem V (exMem Q.succ (.conj (orderedPairFormula z.succ.succ 1 0)
+    (.disj (externalCosetSupportFormula E.succ.succ U.succ.succ C.succ.succ
+      classifier.succ.succ copies.succ.succ zero.succ.succ 1 0)
+      (externalTileSupportFormula E.succ.succ Q.succ.succ Requests.succ.succ
+        localPoints.succ.succ action.succ.succ first.succ.succ 1 0))))
+
+theorem truth_externalStarSupportEntryFormula {n} (z V Q E U C Requests classifier copies localPoints action zero first : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (externalStarSupportEntryFormula z V Q E U C Requests classifier copies localPoints action zero first) env ↔
+      env z ∈ externalStarSupportGraph (env V) (env Q) (env E) (env U) (env C) (env Requests)
+        (env classifier) (env copies) (env localPoints) (env action) (env zero) (env first) := by
+  simp only [externalStarSupportEntryFormula, truth_exMem, Truth, truth_disj, truth_orderedPairFormula,
+    truth_externalCosetSupportFormula, truth_externalTileSupportFormula, externalStarSupportGraph, ZFSet.mem_sep]
+  refine ⟨fun body => ⟨?_, body⟩, And.right⟩
+  obtain ⟨v, hv, y, hy, equal, _⟩ := body
+  change env z = ZFSet.pair v y at equal
+  rw [equal]
+  exact ZFSet.pair_mem_prod.2 ⟨hv, hy⟩
+end BoundedFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+theorem externalStarSupportGraph_mem
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    {V Q E U C Requests classifier copies localPoints action zero first : ZFSet.{u}}
+    (hV : V ∈ M.sets) (hQ : Q ∈ M.sets) (hE : E ∈ M.sets) (hU : U ∈ M.sets)
+    (hC : C ∈ M.sets) (hRequests : Requests ∈ M.sets) (hClassifier : classifier ∈ M.sets)
+    (hCopies : copies ∈ M.sets) (hLocal : localPoints ∈ M.sets) (hAction : action ∈ M.sets)
+    (hZero : zero ∈ M.sets) (hFirst : first ∈ M.sets) :
+    externalStarSupportGraph V Q E U C Requests classifier copies localPoints action zero first ∈ M.sets := by
+  let params := extend V (extend Q (extend E (extend U (extend C (extend Requests (extend classifier (extend copies (extend localPoints (extend action (extend zero (extend first (Fin.elim0))))))))))))
+  have members : ∀ i, params i ∈ M.sets := Fin.cases hV (Fin.cases hQ (Fin.cases hE (Fin.cases hU (Fin.cases hC (Fin.cases hRequests (Fin.cases hClassifier (Fin.cases hCopies (Fin.cases hLocal (Fin.cases hAction (Fin.cases hZero (Fin.cases hFirst ((fun i => Fin.elim0 i)))))))))))))
+  have selected := M.bounded_separation_mem separation
+    (BoundedFormula.externalStarSupportEntryFormula 0 1 2 3 4 5 6 7 8 9 10 11 12) params members
+    (M.prod_mem pairing unions powers separation hV hQ)
+  have equal : ZFSet.sep (fun z => BoundedFormula.Truth
+      (BoundedFormula.externalStarSupportEntryFormula 0 1 2 3 4 5 6 7 8 9 10 11 12) (extend z params))
+      (ZFSet.prod V Q) = externalStarSupportGraph V Q E U C Requests classifier copies localPoints action zero first := by
+    apply ZFSet.ext
+    intro z
+    rw [ZFSet.mem_sep, BoundedFormula.truth_externalStarSupportEntryFormula]
+    change (z ∈ ZFSet.prod V Q ∧ z ∈ externalStarSupportGraph V Q E U C Requests classifier copies localPoints action zero first) ↔ _
+    exact ⟨And.right, fun hz => ⟨(ZFSet.mem_sep.1 hz).1, hz⟩⟩
+  exact equal ▸ selected
+
+end TransitiveGround
+
+
+
+
+
+def parentSupportGraph (V Q supports parents : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => ∃ v ∈ V, ∃ y ∈ Q, z = ZFSet.pair v y ∧ ZFSet.pair v y ∈ supports ∧
+    ∃ p ∈ V, ZFSet.pair v p ∈ parents ∧ ZFSet.pair p y ∈ supports) (ZFSet.prod V Q)
+
+def freshSupportGraph (V Q supports parents : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => z ∉ parentSupportGraph V Q supports parents) supports
+
+theorem pair_mem_parentSupportGraph (V Q supports parents v y : ZFSet.{u}) :
+    ZFSet.pair v y ∈ parentSupportGraph V Q supports parents ↔ v ∈ V ∧ y ∈ Q ∧
+      ZFSet.pair v y ∈ supports ∧ ∃ p ∈ V, ZFSet.pair v p ∈ parents ∧ ZFSet.pair p y ∈ supports := by
+  rw [parentSupportGraph, ZFSet.mem_sep]
+  constructor
+  · rintro ⟨_, v', hv, y', hy, equal, body⟩
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
+    exact ⟨hv, hy, body⟩
+  · rintro ⟨hv, hy, body⟩
+    exact ⟨ZFSet.pair_mem_prod.2 ⟨hv, hy⟩, v, hv, y, hy, rfl, body⟩
+
+theorem pair_mem_parentSupportGraph_of_parent {V Q supports parents v p y : ZFSet.{u}}
+    (function : ZFSet.IsFunc V V parents) (parent : ZFSet.pair v p ∈ parents) :
+    ZFSet.pair v y ∈ parentSupportGraph V Q supports parents ↔
+      y ∈ Q ∧ ZFSet.pair v y ∈ supports ∧ ZFSet.pair p y ∈ supports := by
+  have shape := ZFSet.pair_mem_prod.1 (function.1 parent)
+  rw [pair_mem_parentSupportGraph]
+  constructor
+  · rintro ⟨_, hy, supported, p', _, atParent, supportedParent⟩
+    have equal := (show FunctionGraphOn V parents from ⟨V, function⟩).unique atParent parent
+    exact ⟨hy, supported, equal ▸ supportedParent⟩
+  · rintro ⟨hy, supported, supportedParent⟩
+    exact ⟨shape.1, hy, supported, p, shape.2, parent, supportedParent⟩
+
+theorem pair_mem_freshSupportGraph (V Q supports parents v y : ZFSet.{u}) :
+    ZFSet.pair v y ∈ freshSupportGraph V Q supports parents ↔
+      ZFSet.pair v y ∈ supports ∧ ZFSet.pair v y ∉ parentSupportGraph V Q supports parents := by
+  exact ZFSet.mem_sep
+
+namespace BoundedFormula
+def parentSupportEntryFormula {n} (z V Q supports parents : Fin n) : BoundedFormula n :=
+  exMem V (exMem Q.succ (.conj (orderedPairFormula z.succ.succ 1 0)
+    (.conj (pairMembershipFormula 1 0 supports.succ.succ)
+      (exMem V.succ.succ (.conj (pairMembershipFormula 2 0 parents.succ.succ.succ)
+        (pairMembershipFormula 0 1 supports.succ.succ.succ))))))
+
+theorem truth_parentSupportEntryFormula {n} (z V Q supports parents : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (parentSupportEntryFormula z V Q supports parents) env ↔
+      env z ∈ parentSupportGraph (env V) (env Q) (env supports) (env parents) := by
+  simp only [parentSupportEntryFormula, truth_exMem, Truth, truth_orderedPairFormula,
+    truth_pairMembershipFormula, parentSupportGraph, ZFSet.mem_sep]
+  refine ⟨fun h => ⟨?_, h⟩, And.right⟩
+  obtain ⟨v, hv, y, hy, equal, _⟩ := h
+  change env z = ZFSet.pair v y at equal
+  rw [equal]
+  exact ZFSet.pair_mem_prod.2 ⟨hv, hy⟩
+end BoundedFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+variable (unions : Realize M.sets SetFormula.union Fin.elim0)
+variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+variable {V Q supports parents : ZFSet.{u}} (hV : V ∈ M.sets) (hQ : Q ∈ M.sets)
+variable (hSupports : supports ∈ M.sets) (hParents : parents ∈ M.sets)
+include pairing unions powers separation hV hQ hSupports hParents
+
+theorem parentSupportGraph_mem : parentSupportGraph V Q supports parents ∈ M.sets := by
+  let params := extend V (extend Q (extend supports (extend parents Fin.elim0)))
+  have selected := M.bounded_separation_mem separation
+    (BoundedFormula.parentSupportEntryFormula 0 1 2 3 4) params
+    (Fin.cases hV (Fin.cases hQ (Fin.cases hSupports (Fin.cases hParents (fun i => Fin.elim0 i)))))
+    (M.prod_mem pairing unions powers separation hV hQ)
+  have equal : ZFSet.sep (fun z => BoundedFormula.Truth
+      (BoundedFormula.parentSupportEntryFormula 0 1 2 3 4) (extend z params)) (ZFSet.prod V Q) =
+      parentSupportGraph V Q supports parents := by
+    apply ZFSet.ext
+    intro z
+    rw [ZFSet.mem_sep, BoundedFormula.truth_parentSupportEntryFormula]
+    exact ⟨And.right, fun hz => ⟨(ZFSet.mem_sep.1 hz).1, hz⟩⟩
+  exact equal ▸ selected
+
+theorem freshSupportGraph_mem : freshSupportGraph V Q supports parents ∈ M.sets := by
+  have parentGround := M.parentSupportGraph_mem pairing unions powers separation hV hQ hSupports hParents
+  exact M.bounded_separation_mem separation (BoundedFormula.neg (.mem 0 1))
+    (extend (parentSupportGraph V Q supports parents) Fin.elim0)
+    (Fin.cases parentGround (fun i => Fin.elim0 i)) hSupports
+
+end TransitiveGround
+
+end PartitionPilot.Forcing
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/PartitionPrincipleFormula.lean

@@ -1,50 +1,50 @@
-import OAI.SetTheory.PartitionPrinciple.Forcing.GroundSizeWitnesses
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing.BoundedFormula
-open SetFormula
-universe u
-
-theorem truth_surjectionFormula {n : Nat} (a b f : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (surjectionFormula a b f) env ↔ ZFSet.IsFunc (env a) (env b) (env f) ∧
-      ∀ y ∈ env b, ∃ x ∈ env a, ZFSet.pair x y ∈ env f := by
-  simp only [surjectionFormula, Truth, truth_functionFormula, truth_exMem,
-    truth_pairMembershipFormula]
-  rfl
-
-end PartitionPilot.Forcing.BoundedFormula
-
-namespace PartitionPilot.Forcing.SetFormula
-
-end PartitionPilot.Forcing.SetFormula
-
-namespace PartitionPilot.Forcing.TransitiveGround
-open SetFormula
-universe u
-
-theorem realize_partitionPrinciple (M : TransitiveGround.{u}) :
-    Realize M.sets partitionPrinciple Fin.elim0 ↔
-      ∀ X ∈ M.sets, ∀ Y ∈ M.sets, ∀ f ∈ M.sets, ZFSet.IsFunc X Y f →
-        (∀ y ∈ Y, ∃ x ∈ X, ZFSet.pair x y ∈ f) → M.groundEmbeddable Y X := by
-  change (∀ X ∈ M.sets, ∀ Y ∈ M.sets, ∀ f ∈ M.sets,
-    Realize M.sets (imp (BoundedFormula.surjectionFormula (n := 3) 2 1 0).toFormula
-      (hasInjectionFormula (n := 3) 1 2)) (extend f (extend Y (extend X Fin.elim0)))) ↔ _
-  apply forall_congr' fun X => forall_congr' fun hX =>
-    forall_congr' fun Y => forall_congr' fun hY =>
-    forall_congr' fun f => forall_congr' fun hf => ?_
-  let env := extend f (extend Y (extend X Fin.elim0))
-  have members : ∀ j, env j ∈ M.sets :=
-    Fin.cases hf (Fin.cases hY (Fin.cases hX (fun j => Fin.elim0 j)))
-  rw [realize_imp, M.realize_hasInjectionFormula 1 2 env members,
-    BoundedFormula.realize_toFormula M _ env members, BoundedFormula.truth_surjectionFormula]
-  exact ⟨fun h function onto => h ⟨function, onto⟩,
-    fun h ⟨function, onto⟩ => h function onto⟩
-
-end PartitionPilot.Forcing.TransitiveGround
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Forcing.GroundSizeWitnesses
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing.BoundedFormula
+open SetFormula
+universe u
+
+theorem truth_surjectionFormula {n : Nat} (a b f : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (surjectionFormula a b f) env ↔ ZFSet.IsFunc (env a) (env b) (env f) ∧
+      ∀ y ∈ env b, ∃ x ∈ env a, ZFSet.pair x y ∈ env f := by
+  simp only [surjectionFormula, Truth, truth_functionFormula, truth_exMem,
+    truth_pairMembershipFormula]
+  rfl
+
+end PartitionPilot.Forcing.BoundedFormula
+
+namespace PartitionPilot.Forcing.SetFormula
+
+end PartitionPilot.Forcing.SetFormula
+
+namespace PartitionPilot.Forcing.TransitiveGround
+open SetFormula
+universe u
+
+theorem realize_partitionPrinciple (M : TransitiveGround.{u}) :
+    Realize M.sets partitionPrinciple Fin.elim0 ↔
+      ∀ X ∈ M.sets, ∀ Y ∈ M.sets, ∀ f ∈ M.sets, ZFSet.IsFunc X Y f →
+        (∀ y ∈ Y, ∃ x ∈ X, ZFSet.pair x y ∈ f) → M.groundEmbeddable Y X := by
+  change (∀ X ∈ M.sets, ∀ Y ∈ M.sets, ∀ f ∈ M.sets,
+    Realize M.sets (imp (BoundedFormula.surjectionFormula (n := 3) 2 1 0).toFormula
+      (hasInjectionFormula (n := 3) 1 2)) (extend f (extend Y (extend X Fin.elim0)))) ↔ _
+  apply forall_congr' fun X => forall_congr' fun hX =>
+    forall_congr' fun Y => forall_congr' fun hY =>
+    forall_congr' fun f => forall_congr' fun hf => ?_
+  let env := extend f (extend Y (extend X Fin.elim0))
+  have members : ∀ j, env j ∈ M.sets :=
+    Fin.cases hf (Fin.cases hY (Fin.cases hX (fun j => Fin.elim0 j)))
+  rw [realize_imp, M.realize_hasInjectionFormula 1 2 env members,
+    BoundedFormula.realize_toFormula M _ env members, BoundedFormula.truth_surjectionFormula]
+  exact ⟨fun h function onto => h ⟨function, onto⟩,
+    fun h ⟨function, onto⟩ => h function onto⟩
+
+end PartitionPilot.Forcing.TransitiveGround
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/PreparedCertificateCodes.lean

@@ -1,181 +1,181 @@
-import OAI.SetTheory.PartitionPrinciple.Geometry.GroundVisibilitySupportIncidence
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing
-universe u
-
-def SynchronizedEnumerationCode (omega N B f e names : ZFSet.{u}) : Prop :=
-  ZFSet.IsFunc B N f ∧ ZFSet.IsFunc omega B e ∧ ZFSet.IsFunc omega N names ∧
-    (∀ v ∈ B, ∃ n ∈ omega, ZFSet.pair n v ∈ e) ∧
-    (∀ n ∈ omega, ∀ v tau, ZFSet.pair n v ∈ e →
-      ZFSet.pair n tau ∈ names → ZFSet.pair v tau ∈ f) ∧
-    (∀ n ∈ omega, ∀ v tau, ZFSet.pair n v ∈ e →
-      ZFSet.pair v tau ∈ f → ZFSet.pair n tau ∈ names)
-
-namespace BoundedFormula
-open SetFormula
-
-def synchronizedEnumerationFormula {n} (omega N B f e names : Fin n) : BoundedFormula n :=
-  .conj (functionFormula B N f)
-    (.conj (functionFormula omega B e)
-      (.conj (functionFormula omega N names)
-        (.conj (.allMem B (exMem omega.succ (pairMembershipFormula 0 1 e.succ.succ)))
-          (.conj
-            (.allMem omega (.allMem B.succ (.allMem N.succ.succ
-              (imp (pairMembershipFormula 2 1 e.succ.succ.succ)
-                (imp (pairMembershipFormula 2 0 names.succ.succ.succ)
-                  (pairMembershipFormula 1 0 f.succ.succ.succ))))))
-            (.allMem omega (.allMem B.succ (.allMem N.succ.succ
-              (imp (pairMembershipFormula 2 1 e.succ.succ.succ)
-                (imp (pairMembershipFormula 1 0 f.succ.succ.succ)
-                  (pairMembershipFormula 2 0 names.succ.succ.succ))))))))))
-
-theorem truth_synchronizedEnumerationFormula {n} (omega N B f e names : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (synchronizedEnumerationFormula omega N B f e names) env ↔
-      SynchronizedEnumerationCode (env omega) (env N) (env B) (env f) (env e) (env names) := by
-  simp only [synchronizedEnumerationFormula, Truth, truth_functionFormula,
-    truth_exMem, truth_pairMembershipFormula, truth_imp]
-  change (ZFSet.IsFunc (env B) (env N) (env f) ∧
-    ZFSet.IsFunc (env omega) (env B) (env e) ∧
-    ZFSet.IsFunc (env omega) (env N) (env names) ∧
-    (∀ v ∈ env B, ∃ n ∈ env omega, ZFSet.pair n v ∈ env e) ∧
-    (∀ n ∈ env omega, ∀ v ∈ env B, ∀ tau ∈ env N, ZFSet.pair n v ∈ env e →
-      ZFSet.pair n tau ∈ env names → ZFSet.pair v tau ∈ env f) ∧
-    (∀ n ∈ env omega, ∀ v ∈ env B, ∀ tau ∈ env N, ZFSet.pair n v ∈ env e →
-      ZFSet.pair v tau ∈ env f → ZFSet.pair n tau ∈ env names)) ↔ _
-  constructor
-  · rintro ⟨ff, ef, nf, onto, forward, backward⟩
-    refine ⟨ff, ef, nf, onto, ?_, ?_⟩
-    · intro n hn v tau nv nt
-      exact forward n hn v (ZFSet.pair_mem_prod.1 (ef.1 nv)).2
-        tau (ZFSet.pair_mem_prod.1 (nf.1 nt)).2 nv nt
-    · intro n hn v tau nv vt
-      exact backward n hn v (ZFSet.pair_mem_prod.1 (ef.1 nv)).2
-        tau (ZFSet.pair_mem_prod.1 (ff.1 vt)).2 nv vt
-  · rintro ⟨ff, ef, nf, onto, forward, backward⟩
-    exact ⟨ff, ef, nf, onto, fun n hn v _ tau _ => forward n hn v tau,
-      fun n hn v _ tau _ => backward n hn v tau⟩
-
-def certificateEnumerationEntryFormula {n} (entry J E Names omega N k : Fin n) :
-    BoundedFormula n :=
-  exPairFields entry (exPairFields 0
-    (exGraphFields k.succ.succ.succ.succ (exPairFields 0 (exPairFields 0
-      (.conj (.equal 5 9)
-        (.conj (.mem 9 J.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ)
-          (.conj (.mem 7 E.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ)
-            (.conj (.mem 6 Names.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ)
-              (synchronizedEnumerationFormula
-                omega.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ
-                N.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ 1 0 7 6)))))))))
-
-theorem truth_certificateEnumerationEntryFormula {n} (entry J E Names omega N k : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (certificateEnumerationEntryFormula entry J E Names omega N k) env ↔
-      ∃ j ∈ env J, ∃ e ∈ env E, ∃ names ∈ env Names,
-        env entry = ZFSet.pair j (ZFSet.pair e names) ∧
-        ∃ F B f, ZFSet.pair j (ZFSet.pair F (ZFSet.pair B f)) ∈ env k ∧
-          SynchronizedEnumerationCode (env omega) (env N) B f e names := by
-  simp only [certificateEnumerationEntryFormula, truth_exPairFields, truth_exGraphFields,
-    Truth, truth_synchronizedEnumerationFormula]
-  change (∃ j pair, env entry = ZFSet.pair j pair ∧
-    ∃ e names, pair = ZFSet.pair e names ∧
-    ∃ j' certificate, ZFSet.pair j' certificate ∈ env k ∧
-    ∃ F tail, certificate = ZFSet.pair F tail ∧
-    ∃ B f, tail = ZFSet.pair B f ∧ j' = j ∧
-      j ∈ env J ∧ e ∈ env E ∧ names ∈ env Names ∧
-      SynchronizedEnumerationCode (env omega) (env N) B f e names) ↔ _
-  constructor
-  · rintro ⟨j, pair, eq, e, names, rfl, j', certificate, stored,
-      F, tail, rfl, B, f, rfl, rfl, hj, he, hn, code⟩
-    exact ���j', hj, e, he, names, hn, eq, F, B, f, stored, code⟩
-  · rintro ⟨j, hj, e, he, names, hn, eq, F, B, f, stored, code⟩
-    exact ⟨j, _, eq, e, names, rfl, j, _, stored, F, _, rfl,
-      B, f, rfl, rfl, hj, he, hn, code⟩
-
-end BoundedFormula
-
-end PartitionPilot.Forcing
-
-
-
-namespace PartitionPilot.Forcing
-open SetFormula
-universe u
-
-def PreparedCertificateCode (M : TransitiveGround.{u})
-    (P order q nodes nodeOrder meet N visibility top omega z F B f e names : ZFSet.{u}) : Prop :=
-  MeetFilterCode nodes nodeOrder meet F ∧
-  CoinitialBelowCode nodeOrder F F B ∧ B.Nonempty ∧
-  SynchronizedEnumerationCode omega N B f e names ∧
-  (∀ v tau, ZFSet.pair v tau ∈ f →
-    ZFSet.pair v tau ∈ visibilitySupportIncidence nodes N visibility top) ∧
-  PreparationForcingCode M P order q nodes visibility z F f
-
-namespace SetFormula
-
-def preparedCertificateFormula {n}
-    (P order q nodes nodeOrder meet N visibility top omega z F B f e names : Fin n) : SetFormula n :=
-  .conj (BoundedFormula.meetFilterFormula nodes nodeOrder meet F).toFormula
-    (.conj (BoundedFormula.coinitialBelowFormula nodeOrder F F B).toFormula
-      (.conj (BoundedFormula.exMem B (.equal 0 0)).toFormula
-        (.conj (BoundedFormula.synchronizedEnumerationFormula omega N B f e names).toFormula
-          (.conj (allGraphFields f
-            (BoundedFormula.visibilitySupportAt 1 0 nodes.succ.succ N.succ.succ
-              visibility.succ.succ top.succ.succ).toFormula)
-            (preparationForcingFormula P order q nodes visibility z F f)))))
-
-end SetFormula
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-
-theorem realize_preparedCertificateFormula {n}
-    (P order q nodes nodeOrder meet N visibility top omega z F B f e names : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets)
-    (meetCode : MeetOrderCode (env nodes) (env nodeOrder) (env meet)) :
-    Realize M.sets
-      (preparedCertificateFormula P order q nodes nodeOrder meet N visibility top omega z F B f e names) env ↔
-      PreparedCertificateCode M (env P) (env order) (env q) (env nodes) (env nodeOrder)
-        (env meet) (env N) (env visibility) (env top) (env omega) (env z)
-        (env F) (env B) (env f) (env e) (env names) := by
-  have nonempty : Realize M.sets (BoundedFormula.exMem B (.equal 0 0)).toFormula env ↔
-      (env B).Nonempty := by
-    rw [BoundedFormula.realize_toFormula M _ env members, BoundedFormula.truth_exMem]
-    simp only [BoundedFormula.Truth, and_true]
-    rfl
-  have supported : Realize M.sets (allGraphFields f
-      (BoundedFormula.visibilitySupportAt 1 0 nodes.succ.succ N.succ.succ
-        visibility.succ.succ top.succ.succ).toFormula) env ↔
-      ∀ v tau, ZFSet.pair v tau ∈ env f →
-        ZFSet.pair v tau ∈ visibilitySupportIncidence (env nodes) (env N) (env visibility) (env top) := by
-    rw [M.realize_allGraphFields _ _ env members]
-    constructor
-    · intro holds v tau entry
-      have pairGround := M.transitive (members f) entry
-      exact (BoundedFormula.truth_visibilitySupportAt _ _ _ _ _ _ _).1
-        ((BoundedFormula.realize_toFormula M _ _
-          (Fin.cases (M.pair_right pairGround) (Fin.cases (M.pair_left pairGround) members))).1
-            (holds v tau entry))
-    · intro holds v tau entry
-      have pairGround := M.transitive (members f) entry
-      exact (BoundedFormula.realize_toFormula M _ _
-        (Fin.cases (M.pair_right pairGround) (Fin.cases (M.pair_left pairGround) members))).2
-          ((BoundedFormula.truth_visibilitySupportAt _ _ _ _ _ _ _).2 (holds v tau entry))
-  simp only [preparedCertificateFormula, Realize]
-  rw [BoundedFormula.realize_meetFilterFormula M _ _ _ _ env members meetCode,
-    BoundedFormula.realize_coinitialBelowFormula M _ _ _ _ env members,
-    nonempty, BoundedFormula.realize_toFormula M _ env members,
-    BoundedFormula.truth_synchronizedEnumerationFormula, supported,
-    M.realize_preparationForcingFormula _ _ _ _ _ _ _ _ env members]
-  rfl
-
-end TransitiveGround
-
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Geometry.GroundVisibilitySupportIncidence
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing
+universe u
+
+def SynchronizedEnumerationCode (omega N B f e names : ZFSet.{u}) : Prop :=
+  ZFSet.IsFunc B N f ∧ ZFSet.IsFunc omega B e ∧ ZFSet.IsFunc omega N names ∧
+    (∀ v ∈ B, ∃ n ∈ omega, ZFSet.pair n v ∈ e) ∧
+    (∀ n ∈ omega, ∀ v tau, ZFSet.pair n v ∈ e →
+      ZFSet.pair n tau ∈ names → ZFSet.pair v tau ∈ f) ∧
+    (∀ n ∈ omega, ∀ v tau, ZFSet.pair n v ∈ e →
+      ZFSet.pair v tau ∈ f → ZFSet.pair n tau ∈ names)
+
+namespace BoundedFormula
+open SetFormula
+
+def synchronizedEnumerationFormula {n} (omega N B f e names : Fin n) : BoundedFormula n :=
+  .conj (functionFormula B N f)
+    (.conj (functionFormula omega B e)
+      (.conj (functionFormula omega N names)
+        (.conj (.allMem B (exMem omega.succ (pairMembershipFormula 0 1 e.succ.succ)))
+          (.conj
+            (.allMem omega (.allMem B.succ (.allMem N.succ.succ
+              (imp (pairMembershipFormula 2 1 e.succ.succ.succ)
+                (imp (pairMembershipFormula 2 0 names.succ.succ.succ)
+                  (pairMembershipFormula 1 0 f.succ.succ.succ))))))
+            (.allMem omega (.allMem B.succ (.allMem N.succ.succ
+              (imp (pairMembershipFormula 2 1 e.succ.succ.succ)
+                (imp (pairMembershipFormula 1 0 f.succ.succ.succ)
+                  (pairMembershipFormula 2 0 names.succ.succ.succ))))))))))
+
+theorem truth_synchronizedEnumerationFormula {n} (omega N B f e names : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (synchronizedEnumerationFormula omega N B f e names) env ↔
+      SynchronizedEnumerationCode (env omega) (env N) (env B) (env f) (env e) (env names) := by
+  simp only [synchronizedEnumerationFormula, Truth, truth_functionFormula,
+    truth_exMem, truth_pairMembershipFormula, truth_imp]
+  change (ZFSet.IsFunc (env B) (env N) (env f) ∧
+    ZFSet.IsFunc (env omega) (env B) (env e) ∧
+    ZFSet.IsFunc (env omega) (env N) (env names) ∧
+    (∀ v ∈ env B, ∃ n ∈ env omega, ZFSet.pair n v ∈ env e) ∧
+    (∀ n ∈ env omega, ∀ v ∈ env B, ∀ tau ∈ env N, ZFSet.pair n v ∈ env e →
+      ZFSet.pair n tau ∈ env names → ZFSet.pair v tau ∈ env f) ∧
+    (∀ n ∈ env omega, ∀ v ∈ env B, ∀ tau ∈ env N, ZFSet.pair n v ∈ env e →
+      ZFSet.pair v tau ∈ env f → ZFSet.pair n tau ∈ env names)) ↔ _
+  constructor
+  · rintro ⟨ff, ef, nf, onto, forward, backward⟩
+    refine ⟨ff, ef, nf, onto, ?_, ?_⟩
+    · intro n hn v tau nv nt
+      exact forward n hn v (ZFSet.pair_mem_prod.1 (ef.1 nv)).2
+        tau (ZFSet.pair_mem_prod.1 (nf.1 nt)).2 nv nt
+    · intro n hn v tau nv vt
+      exact backward n hn v (ZFSet.pair_mem_prod.1 (ef.1 nv)).2
+        tau (ZFSet.pair_mem_prod.1 (ff.1 vt)).2 nv vt
+  · rintro ⟨ff, ef, nf, onto, forward, backward⟩
+    exact ⟨ff, ef, nf, onto, fun n hn v _ tau _ => forward n hn v tau,
+      fun n hn v _ tau _ => backward n hn v tau⟩
+
+def certificateEnumerationEntryFormula {n} (entry J E Names omega N k : Fin n) :
+    BoundedFormula n :=
+  exPairFields entry (exPairFields 0
+    (exGraphFields k.succ.succ.succ.succ (exPairFields 0 (exPairFields 0
+      (.conj (.equal 5 9)
+        (.conj (.mem 9 J.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ)
+          (.conj (.mem 7 E.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ)
+            (.conj (.mem 6 Names.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ)
+              (synchronizedEnumerationFormula
+                omega.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ
+                N.succ.succ.succ.succ.succ.succ.succ.succ.succ.succ 1 0 7 6)))))))))
+
+theorem truth_certificateEnumerationEntryFormula {n} (entry J E Names omega N k : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (certificateEnumerationEntryFormula entry J E Names omega N k) env ↔
+      ∃ j ∈ env J, ∃ e ∈ env E, ∃ names ∈ env Names,
+        env entry = ZFSet.pair j (ZFSet.pair e names) ∧
+        ∃ F B f, ZFSet.pair j (ZFSet.pair F (ZFSet.pair B f)) ∈ env k ∧
+          SynchronizedEnumerationCode (env omega) (env N) B f e names := by
+  simp only [certificateEnumerationEntryFormula, truth_exPairFields, truth_exGraphFields,
+    Truth, truth_synchronizedEnumerationFormula]
+  change (∃ j pair, env entry = ZFSet.pair j pair ∧
+    ∃ e names, pair = ZFSet.pair e names ∧
+    ∃ j' certificate, ZFSet.pair j' certificate ∈ env k ∧
+    ∃ F tail, certificate = ZFSet.pair F tail ∧
+    ∃ B f, tail = ZFSet.pair B f ∧ j' = j ∧
+      j ∈ env J ∧ e ∈ env E ∧ names ∈ env Names ∧
+      SynchronizedEnumerationCode (env omega) (env N) B f e names) ↔ _
+  constructor
+  · rintro ⟨j, pair, eq, e, names, rfl, j', certificate, stored,
+      F, tail, rfl, B, f, rfl, rfl, hj, he, hn, code⟩
+    exact ⟨j', hj, e, he, names, hn, eq, F, B, f, stored, code⟩
+  · rintro ⟨j, hj, e, he, names, hn, eq, F, B, f, stored, code⟩
+    exact ⟨j, _, eq, e, names, rfl, j, _, stored, F, _, rfl,
+      B, f, rfl, rfl, hj, he, hn, code⟩
+
+end BoundedFormula
+
+end PartitionPilot.Forcing
+
+
+
+namespace PartitionPilot.Forcing
+open SetFormula
+universe u
+
+def PreparedCertificateCode (M : TransitiveGround.{u})
+    (P order q nodes nodeOrder meet N visibility top omega z F B f e names : ZFSet.{u}) : Prop :=
+  MeetFilterCode nodes nodeOrder meet F ∧
+  CoinitialBelowCode nodeOrder F F B ∧ B.Nonempty ∧
+  SynchronizedEnumerationCode omega N B f e names ∧
+  (∀ v tau, ZFSet.pair v tau ∈ f →
+    ZFSet.pair v tau ∈ visibilitySupportIncidence nodes N visibility top) ∧
+  PreparationForcingCode M P order q nodes visibility z F f
+
+namespace SetFormula
+
+def preparedCertificateFormula {n}
+    (P order q nodes nodeOrder meet N visibility top omega z F B f e names : Fin n) : SetFormula n :=
+  .conj (BoundedFormula.meetFilterFormula nodes nodeOrder meet F).toFormula
+    (.conj (BoundedFormula.coinitialBelowFormula nodeOrder F F B).toFormula
+      (.conj (BoundedFormula.exMem B (.equal 0 0)).toFormula
+        (.conj (BoundedFormula.synchronizedEnumerationFormula omega N B f e names).toFormula
+          (.conj (allGraphFields f
+            (BoundedFormula.visibilitySupportAt 1 0 nodes.succ.succ N.succ.succ
+              visibility.succ.succ top.succ.succ).toFormula)
+            (preparationForcingFormula P order q nodes visibility z F f)))))
+
+end SetFormula
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+
+theorem realize_preparedCertificateFormula {n}
+    (P order q nodes nodeOrder meet N visibility top omega z F B f e names : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets)
+    (meetCode : MeetOrderCode (env nodes) (env nodeOrder) (env meet)) :
+    Realize M.sets
+      (preparedCertificateFormula P order q nodes nodeOrder meet N visibility top omega z F B f e names) env ↔
+      PreparedCertificateCode M (env P) (env order) (env q) (env nodes) (env nodeOrder)
+        (env meet) (env N) (env visibility) (env top) (env omega) (env z)
+        (env F) (env B) (env f) (env e) (env names) := by
+  have nonempty : Realize M.sets (BoundedFormula.exMem B (.equal 0 0)).toFormula env ↔
+      (env B).Nonempty := by
+    rw [BoundedFormula.realize_toFormula M _ env members, BoundedFormula.truth_exMem]
+    simp only [BoundedFormula.Truth, and_true]
+    rfl
+  have supported : Realize M.sets (allGraphFields f
+      (BoundedFormula.visibilitySupportAt 1 0 nodes.succ.succ N.succ.succ
+        visibility.succ.succ top.succ.succ).toFormula) env ↔
+      ∀ v tau, ZFSet.pair v tau ∈ env f →
+        ZFSet.pair v tau ∈ visibilitySupportIncidence (env nodes) (env N) (env visibility) (env top) := by
+    rw [M.realize_allGraphFields _ _ env members]
+    constructor
+    · intro holds v tau entry
+      have pairGround := M.transitive (members f) entry
+      exact (BoundedFormula.truth_visibilitySupportAt _ _ _ _ _ _ _).1
+        ((BoundedFormula.realize_toFormula M _ _
+          (Fin.cases (M.pair_right pairGround) (Fin.cases (M.pair_left pairGround) members))).1
+            (holds v tau entry))
+    · intro holds v tau entry
+      have pairGround := M.transitive (members f) entry
+      exact (BoundedFormula.realize_toFormula M _ _
+        (Fin.cases (M.pair_right pairGround) (Fin.cases (M.pair_left pairGround) members))).2
+          ((BoundedFormula.truth_visibilitySupportAt _ _ _ _ _ _ _).2 (holds v tau entry))
+  simp only [preparedCertificateFormula, Realize]
+  rw [BoundedFormula.realize_meetFilterFormula M _ _ _ _ env members meetCode,
+    BoundedFormula.realize_coinitialBelowFormula M _ _ _ _ env members,
+    nonempty, BoundedFormula.realize_toFormula M _ env members,
+    BoundedFormula.truth_synchronizedEnumerationFormula, supported,
+    M.realize_preparationForcingFormula _ _ _ _ _ _ _ _ env members]
+  rfl
+
+end TransitiveGround
+
+end PartitionPilot.Forcing
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/PresentedGroupCodes.lean

@@ -1,688 +1,688 @@
-import OAI.SetTheory.PartitionPrinciple.Definability.UnionEntryFormula
-import OAI.SetTheory.PartitionPrinciple.Transfinite.OrdinalRecursionTraces
-
-namespace OAI
-
-
-namespace PartitionPilot.Forcing
-
-namespace BoundedFormula
-
-open SetFormula
-universe u
-
-def Truth : {n : Nat} → BoundedFormula n → (Fin n → ZFSet.{u}) → Prop
-  | _, .equal i j, env => env i = env j
-  | _, .mem i j, env => env i ∈ env j
-  | _, .neg φ, env => ¬ Truth φ env
-  | _, .conj φ ψ, env => Truth φ env ∧ Truth ψ env
-  | _, .allMem b φ, env => ∀ x ∈ env b, Truth φ (extend x env)
-
-theorem truth_imp {n} (φ ψ : BoundedFormula n) (env : Fin n → ZFSet.{u}) :
-    Truth (imp φ ψ) env ↔ (Truth φ env → Truth ψ env) := by
-  classical
-  simp only [imp, Truth, not_and, not_not]
-
-theorem truth_disj {n} (φ ψ : BoundedFormula n) (env : Fin n → ZFSet.{u}) :
-    Truth (disj φ ψ) env ↔ (Truth φ env ∨ Truth ψ env) := by
-  classical
-  simp only [disj, Truth, not_and_or, not_not]
-
-theorem truth_exMem {n} (b : Fin n) (φ : BoundedFormula (n + 1)) (env : Fin n → ZFSet.{u}) :
-    Truth (exMem b φ) env ↔ ∃ x ∈ env b, Truth φ (extend x env) := by
-  classical
-  simp only [exMem, Truth, not_forall, not_not, exists_prop]
-
-theorem realize_toFormula (M : TransitiveGround.{u}) {n} (φ : BoundedFormula n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets) :
-    Realize M.sets φ.toFormula env ↔ Truth φ env := by
-  induction φ with
-  | equal i j => rfl
-  | mem i j => rfl
-  | neg φ ih => exact not_congr (ih env members)
-  | conj φ ψ ihφ ihψ => exact and_congr (ihφ env members) (ihψ env members)
-  | allMem b φ ih =>
-    change (∀ x ∈ M.sets, Realize M.sets (SetFormula.imp (.mem 0 b.succ) φ.toFormula) (extend x env)) ↔ _
-    constructor
-    · intro h x hx
-      have hxM := M.transitive (members b) hx
-      exact (ih (extend x env) (Fin.cases hxM members)).1
-        ((realize_imp M.sets _ _ _).1 (h x hxM) hx)
-    · intro h x hxM
-      apply (realize_imp M.sets _ _ _).2
-      intro hx
-      exact (ih (extend x env) (Fin.cases hxM members)).2 (h x hx)
-
-theorem absolute (M N : TransitiveGround.{u}) {n} (φ : BoundedFormula n)
-    (env : Fin n → ZFSet.{u}) (inM : ∀ i, env i ∈ M.sets) (inN : ∀ i, env i ∈ N.sets) :
-    Realize M.sets φ.toFormula env ↔ Realize N.sets φ.toFormula env :=
-  (realize_toFormula M φ env inM).trans (realize_toFormula N φ env inN).symm
-
-end BoundedFormula
-
-end PartitionPilot.Forcing
-
-
-
-namespace PartitionPilot.Forcing.BoundedFormula
-
-open SetFormula
-universe u
-
-def emptyFormula {n} (x : Fin n) : BoundedFormula n :=
-  .allMem x (.neg (.equal 0 0))
-
-def successorFormula {n} (y x : Fin n) : BoundedFormula n :=
-  .conj (.mem x y) (.conj (.allMem x (.mem 0 y.succ))
-    (.allMem y (disj (.equal 0 x.succ) (.mem 0 x.succ))))
-
-def setTransitiveFormula {n} (x : Fin n) : BoundedFormula n :=
-  .allMem x (.allMem 0 (.mem 0 x.succ.succ))
-
-def zeroOrSuccessorFormula {n} (x : Fin n) : BoundedFormula n :=
-  disj (emptyFormula x) (exMem x (successorFormula x.succ 0))
-
-def naturalFormula {n} (x : Fin n) : BoundedFormula n :=
-  .conj (setTransitiveFormula x) (.conj (zeroOrSuccessorFormula x)
-    (.allMem x (.conj (setTransitiveFormula 0) (zeroOrSuccessorFormula 0))))
-
-theorem truth_emptyFormula {n} (x : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (emptyFormula x) env ↔ env x = ∅ := by
-  change (∀ y ∈ env x, ¬ y = y) ↔ _
-  constructor
-  · intro h
-    exact (ZFSet.eq_empty _).2 (fun y hy => h y hy rfl)
-  · intro h y hy
-    exact False.elim ((ZFSet.eq_empty _).1 h y hy)
-
-theorem truth_successorFormula {n} (y x : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (successorFormula y x) env ↔ env y = insert (env x) (env x) := by
-  simp only [successorFormula, Truth, truth_disj]
-  change (env x ∈ env y ∧ (∀ z ∈ env x, z ∈ env y) ∧
-    ∀ z ∈ env y, z = env x ∨ z ∈ env x) ↔ _
-  constructor
-  · rintro ⟨hx, lower, upper⟩
-    apply ZFSet.ext
-    intro z
-    rw [ZFSet.mem_insert_iff]
-    exact ⟨upper z, fun h => h.elim (fun eq => eq.symm ▸ hx) (lower z)⟩
-  · intro eq
-    rw [eq]
-    exact ⟨ZFSet.mem_insert _ _, fun _ hz => ZFSet.mem_insert_of_mem _ hz,
-      fun _ hz => ZFSet.mem_insert_iff.1 hz⟩
-
-theorem truth_setTransitiveFormula {n} (x : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (setTransitiveFormula x) env ↔ setTransitive (env x) := Iff.rfl
-
-theorem truth_zeroOrSuccessorFormula {n} (x : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (zeroOrSuccessorFormula x) env ↔ zeroOrSuccessor (env x) := by
-  simp only [zeroOrSuccessorFormula, truth_disj, truth_emptyFormula, truth_exMem,
-    truth_successorFormula]
-  rfl
-
-theorem truth_naturalFormula {n} (x : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (naturalFormula x) env ↔ env x ∈ ZFSet.omega := by
-  simp only [naturalFormula, Truth, truth_setTransitiveFormula, truth_zeroOrSuccessorFormula]
-  exact naturalSetProperty_iff_mem_omega (env x)
-
-theorem realize_naturalFormula (M : TransitiveGround.{u}) {n}
-    (x : Fin n) (env : Fin n → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets) :
-    Realize M.sets (naturalFormula x).toFormula env ↔ env x ∈ ZFSet.omega :=
-  (realize_toFormula M _ env members).trans (truth_naturalFormula x env)
-
-
-
-
-
-
-theorem truth_singletonFormula {n} (z x : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (singletonFormula z x) env ↔ env z = {env x} := by
-  change (env x ∈ env z ∧ ∀ w ∈ env z, w = env x) ↔ _
-  constructor
-  · rintro ⟨member, only⟩
-    apply ZFSet.ext
-    intro w
-    rw [ZFSet.mem_singleton]
-    exact ⟨only w, fun eq => eq.symm ▸ member⟩
-  · intro eq
-    rw [eq]
-    exact ⟨ZFSet.mem_singleton.2 rfl, fun _ h => ZFSet.mem_singleton.1 h⟩
-
-theorem truth_unorderedPairFormula {n} (z x y : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (unorderedPairFormula z x y) env ↔ env z = {env x, env y} := by
-  simp only [unorderedPairFormula, Truth, truth_disj]
-  change (env x ∈ env z ∧ env y ∈ env z ∧ ∀ w ∈ env z, w = env x ∨ w = env y) ↔ _
-  constructor
-  · rintro ⟨hx, hy, only⟩
-    apply ZFSet.ext
-    intro w
-    rw [ZFSet.mem_pair]
-    refine ⟨only w, ?_⟩
-    rintro (rfl | rfl)
-    · exact hx
-    · exact hy
-  · intro eq
-    rw [eq]
-    exact ⟨ZFSet.mem_pair.2 (Or.inl rfl), ZFSet.mem_pair.2 (Or.inr rfl), fun _ h => ZFSet.mem_pair.1 h⟩
-
-theorem truth_orderedPairFormula {n} (z x y : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (orderedPairFormula z x y) env ↔ env z = ZFSet.pair (env x) (env y) := by
-  rw [orderedPairFormula, truth_exMem]
-  constructor
-  · rintro ⟨a, _, first, rest⟩
-    have ha := (truth_singletonFormula 0 x.succ (extend a env)).1 first
-    obtain ⟨b, _, second, shape⟩ := (truth_exMem _ _ _).1 rest
-    have hb := (truth_unorderedPairFormula 0 x.succ.succ y.succ.succ (extend b (extend a env))).1 second
-    have hz := (truth_unorderedPairFormula z.succ.succ 1 0 (extend b (extend a env))).1 shape
-    change a = {env x} at ha
-    change b = {env x, env y} at hb
-    change env z = {a, b} at hz
-    rw [hz, ha, hb]
-    rfl
-  · intro eq
-    have ha : ({env x} : ZFSet.{u}) ∈ env z := by
-      rw [eq]
-      exact ZFSet.mem_pair.2 (Or.inl rfl)
-    refine ⟨{env x}, ha, (truth_singletonFormula 0 x.succ _).2 rfl, ?_⟩
-    apply (truth_exMem _ _ _).2
-    have hb : ({env x, env y} : ZFSet.{u}) ∈ env z := by
-      rw [eq]
-      exact ZFSet.mem_pair.2 (Or.inr rfl)
-    exact ⟨{env x, env y}, hb, (truth_unorderedPairFormula 0 x.succ.succ y.succ.succ _).2 rfl,
-      (truth_unorderedPairFormula z.succ.succ 1 0 _).2 eq⟩
-
-theorem truth_pairMembershipFormula {n} (x y r : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (pairMembershipFormula x y r) env ↔ ZFSet.pair (env x) (env y) ∈ env r := by
-  rw [pairMembershipFormula, truth_exMem]
-  constructor
-  · rintro ⟨z, hz, shape⟩
-    have eq := (truth_orderedPairFormula 0 x.succ y.succ (extend z env)).1 shape
-    exact eq ▸ hz
-  · intro member
-    exact ⟨ZFSet.pair (env x) (env y), member, (truth_orderedPairFormula 0 x.succ y.succ _).2 rfl⟩
-
-end PartitionPilot.Forcing.BoundedFormula
-
-
-
-namespace PartitionPilot.Forcing
-
-universe u
-
-namespace SetFormula
-
-def exactSetFormula {n} (output : Fin n) (entry : SetFormula (n + 1)) : SetFormula n :=
-  .all (.conj (imp (.mem 0 output.succ) entry) (imp entry (.mem 0 output.succ)))
-
-end SetFormula
-
-namespace TransitiveGround
-
-open SetFormula
-variable (M : TransitiveGround.{u})
-
-theorem realize_exactSetFormula {n} (output : Fin n) (entry : SetFormula (n + 1))
-    (env : Fin n → ZFSet.{u}) {target : ZFSet.{u}}
-    (hOutput : env output ∈ M.sets) (elements : ∀ z ∈ target, z ∈ M.sets)
-    (meaning : ∀ z ∈ M.sets, Realize M.sets entry (extend z env) ↔ z ∈ target) :
-    Realize M.sets (exactSetFormula output entry) env ↔ env output = target := by
-  change (∀ z ∈ M.sets, Realize M.sets
-    (.conj (imp (.mem 0 output.succ) entry) (imp entry (.mem 0 output.succ))) (extend z env)) ↔ _
-  simp only [Realize, realize_imp]
-  change (∀ z ∈ M.sets, (z ∈ env output → Realize M.sets entry (extend z env)) ∧
-    (Realize M.sets entry (extend z env) → z ∈ env output)) ↔ _
-  constructor
-  · intro correct
-    apply ZFSet.ext
-    intro z
-    constructor
-    · intro member
-      have hz := M.transitive hOutput member
-      exact (meaning z hz).1 ((correct z hz).1 member)
-    · intro member
-      have hz := elements z member
-      exact (correct z hz).2 ((meaning z hz).2 member)
-  · intro equal z hz
-    exact ⟨fun member => (meaning z hz).2 (equal ▸ member),
-      fun predicate => equal.symm ▸ (meaning z hz).1 predicate⟩
-
-end TransitiveGround
-
-end PartitionPilot.Forcing
-
-
-
-namespace PartitionPilot.Forcing.BoundedFormula
-
-open SetFormula SetRealization
-universe u
-
-def ordinalFormula {n} (x : Fin n) : BoundedFormula n :=
-  .conj (setTransitiveFormula x) (.allMem x (setTransitiveFormula 0))
-
-theorem truth_ordinalFormula {n} (x : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (ordinalFormula x) env ↔ ∃ o : Ordinal.{u}, env x = ordinalCode o := by
-  simp only [ordinalFormula, Truth, truth_setTransitiveFormula]
-  exact ordinalSetProperty_iff (env x)
-
-theorem realize_ordinalFormula (M : TransitiveGround.{u}) {n}
-    (x : Fin n) (env : Fin n → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets) :
-    Realize M.sets (ordinalFormula x).toFormula env ↔ ∃ o : Ordinal.{u}, env x = ordinalCode o :=
-  (realize_toFormula M _ env members).trans (truth_ordinalFormula x env)
-
-end PartitionPilot.Forcing.BoundedFormula
-
-
-
-namespace PartitionPilot.Forcing.BoundedFormula
-open SetFormula
-universe u
-
-def graphFiberInclusionFormula {n} (x y f g : Fin n) : BoundedFormula n :=
-  .allMem f (.allMem 0 (.allMem 0
-    (imp (orderedPairFormula 2 x.succ.succ.succ 0)
-      (pairMembershipFormula y.succ.succ.succ 0 g.succ.succ.succ))))
-
-theorem truth_graphFiberInclusionFormula {n} (x y f g : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (graphFiberInclusionFormula x y f g) env ↔
-      ∀ z, ZFSet.pair (env x) z ∈ env f → ZFSet.pair (env y) z ∈ env g := by
-  simp only [graphFiberInclusionFormula, Truth, truth_imp,
-    truth_orderedPairFormula, truth_pairMembershipFormula]
-  change (∀ p ∈ env f, ∀ a ∈ p, ∀ z ∈ a,
-    p = ZFSet.pair (env x) z → ZFSet.pair (env y) z ∈ env g) ↔ _
-  constructor
-  · intro h z entry
-    exact h (ZFSet.pair (env x) z) entry {env x, z}
-      (ZFSet.mem_pair.2 (Or.inr rfl)) z (ZFSet.mem_pair.2 (Or.inr rfl)) rfl
-  · intro h p hp a _ z _ equal
-    exact h z (equal ▸ hp)
-
-def graphFiberEqualityFormula {n} (x y f g : Fin n) : BoundedFormula n :=
-  .conj (graphFiberInclusionFormula x y f g) (graphFiberInclusionFormula y x g f)
-
-theorem truth_graphFiberEqualityFormula {n} (x y f g : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (graphFiberEqualityFormula x y f g) env ↔
-      ∀ z, ZFSet.pair (env x) z ∈ env f ↔ ZFSet.pair (env y) z ∈ env g := by
-  simp only [graphFiberEqualityFormula, Truth, truth_graphFiberInclusionFormula]
-  exact ⟨fun h z => ⟨h.1 z, h.2 z⟩, fun h => ⟨fun z => (h z).1, fun z => (h z).2⟩⟩
-
-end PartitionPilot.Forcing.BoundedFormula
-
-
-
-namespace PartitionPilot.Forcing
-
-universe u
-
-structure PartialOrderCode (Q R : ZFSet.{u}) : Prop where
-  relation : R ⊆ ZFSet.prod Q Q
-  refl : ∀ x ∈ Q, ZFSet.pair x x ∈ R
-  antisymm : ∀ x ∈ Q, ∀ y ∈ Q, ZFSet.pair x y ∈ R → ZFSet.pair y x ∈ R → x = y
-  trans : ∀ x ∈ Q, ∀ y ∈ Q, ∀ z ∈ Q,
-    ZFSet.pair x y ∈ R → ZFSet.pair y z ∈ R → ZFSet.pair x z ∈ R
-
-namespace BoundedFormula
-
-open SetFormula
-
-def relationOnFormula {n} (c r : Fin n) : BoundedFormula n :=
-  .allMem r (exMem c.succ (exMem c.succ.succ (orderedPairFormula 2 1 0)))
-
-def reflexiveFormula {n} (c r : Fin n) : BoundedFormula n :=
-  .allMem c (pairMembershipFormula 0 0 r.succ)
-
-def antisymmetricFormula {n} (c r : Fin n) : BoundedFormula n :=
-  .allMem c (.allMem c.succ (imp
-    (.conj (pairMembershipFormula 1 0 r.succ.succ) (pairMembershipFormula 0 1 r.succ.succ)) (.equal 1 0)))
-
-def transitiveFormula {n} (c r : Fin n) : BoundedFormula n :=
-  .allMem c (.allMem c.succ (.allMem c.succ.succ (imp
-    (.conj (pairMembershipFormula 2 1 r.succ.succ.succ) (pairMembershipFormula 1 0 r.succ.succ.succ))
-    (pairMembershipFormula 2 0 r.succ.succ.succ))))
-
-def partialOrderFormula {n} (c r : Fin n) : BoundedFormula n :=
-  .conj (relationOnFormula c r) (.conj (reflexiveFormula c r)
-    (.conj (antisymmetricFormula c r) (transitiveFormula c r)))
-
-def topFormula {n} (c r t : Fin n) : BoundedFormula n :=
-  .conj (.mem t c) (.allMem c (pairMembershipFormula 0 t.succ r.succ))
-
-theorem truth_relationOnFormula {n} (c r : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (relationOnFormula c r) env ↔ env r ⊆ ZFSet.prod (env c) (env c) := by
-  simp only [relationOnFormula, Truth, truth_exMem, truth_orderedPairFormula]
-  exact forall_congr' (fun _ => forall_congr' (fun _ => ZFSet.mem_prod.symm))
-
-theorem truth_partialOrderFormula {n} (c r : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (partialOrderFormula c r) env ↔ PartialOrderCode (env c) (env r) := by
-  simp only [partialOrderFormula, Truth, truth_relationOnFormula, reflexiveFormula,
-    antisymmetricFormula, transitiveFormula, truth_imp, truth_pairMembershipFormula]
-  constructor
-  · rintro ⟨shape, refl, antisymm, trans⟩
-    exact ⟨shape, refl, fun x hx y hy xy yx => antisymm x hx y hy ⟨xy, yx⟩,
-      fun x hx y hy z hz xy yz => trans x hx y hy z hz ⟨xy, yz⟩⟩
-  · intro h
-    exact ⟨h.relation, h.refl, fun x hx y hy ⟨xy, yx⟩ => h.antisymm x hx y hy xy yx,
-      fun x hx y hy z hz ⟨xy, yz⟩ => h.trans x hx y hy z hz xy yz⟩
-
-theorem truth_topFormula {n} (c r t : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (topFormula c r t) env ↔ env t ∈ env c ∧ ∀ x ∈ env c, ZFSet.pair x (env t) ∈ env r := by
-  simp only [topFormula, Truth, truth_pairMembershipFormula]
-  rfl
-
-end BoundedFormula
-
-namespace TransitiveGround
-
-open SetFormula
-variable (M : TransitiveGround.{u})
-
-theorem realize_partialOrderCode {Q R : ZFSet.{u}} (hQ : Q ∈ M.sets) (hR : R ∈ M.sets) :
-    Realize M.sets (BoundedFormula.partialOrderFormula 0 1).toFormula (extend Q (extend R Fin.elim0)) ↔
-      PartialOrderCode Q R :=
-  (BoundedFormula.realize_toFormula M _ _ (Fin.cases hQ (Fin.cases hR (fun i => Fin.elim0 i)))).trans
-    (BoundedFormula.truth_partialOrderFormula 0 1 _)
-
-theorem partialOrderCode_absolute (N : TransitiveGround.{u}) {Q R : ZFSet.{u}}
-    (hQM : Q ∈ M.sets) (hRM : R ∈ M.sets) (hQN : Q ∈ N.sets) (hRN : R ∈ N.sets) :
-    Realize M.sets (BoundedFormula.partialOrderFormula 0 1).toFormula (extend Q (extend R Fin.elim0)) ↔
-      Realize N.sets (BoundedFormula.partialOrderFormula 0 1).toFormula (extend Q (extend R Fin.elim0)) :=
-  (M.realize_partialOrderCode hQM hRM).trans (N.realize_partialOrderCode hQN hRN).symm
-
-end TransitiveGround
-
-end PartitionPilot.Forcing
-
-
-
-namespace PartitionPilot.Forcing.BoundedFormula
-
-open SetFormula
-universe u
-
-def orderedTripleFormula {n} (w x y z : Fin n) : BoundedFormula n :=
-  exMem w (exMem 0 (.conj (orderedPairFormula 0 x.succ.succ y.succ.succ)
-    (orderedPairFormula w.succ.succ 0 z.succ.succ)))
-
-def tripleMembershipFormula {n} (x y z f : Fin n) : BoundedFormula n :=
-  exMem f (orderedTripleFormula 0 x.succ y.succ z.succ)
-
-theorem truth_orderedTripleFormula {n} (w x y z : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (orderedTripleFormula w x y z) env ↔
-      env w = ZFSet.pair (ZFSet.pair (env x) (env y)) (env z) := by
-  simp only [orderedTripleFormula, truth_exMem, Truth, truth_orderedPairFormula]
-  change (∃ a ∈ env w, ∃ b ∈ a, b = ZFSet.pair (env x) (env y) ∧
-    env w = ZFSet.pair b (env z)) ↔ _
-  constructor
-  · rintro ⟨a, _, b, _, rfl, eq⟩
-    exact eq
-  · intro eq
-    refine ⟨{ZFSet.pair (env x) (env y)}, ?_, ZFSet.pair (env x) (env y),
-      ZFSet.mem_singleton.2 rfl, rfl, eq⟩
-    rw [eq]
-    exact ZFSet.mem_pair.2 (Or.inl rfl)
-
-theorem truth_tripleMembershipFormula {n} (x y z f : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (tripleMembershipFormula x y z f) env ↔
-      ZFSet.pair (ZFSet.pair (env x) (env y)) (env z) ∈ env f := by
-  simp only [tripleMembershipFormula, truth_exMem, truth_orderedTripleFormula]
-  change (∃ w ∈ env f, w = ZFSet.pair (ZFSet.pair (env x) (env y)) (env z)) ↔ _
-  exact ⟨fun ⟨_, hw, eq⟩ => eq ▸ hw, fun hw => ⟨_, hw, rfl⟩⟩
-
-end PartitionPilot.Forcing.BoundedFormula
-
-
-section
-
-namespace PartitionPilot.Forcing.BoundedFormula
-
-open SetFormula
-universe u
-
-theorem truth_relationBetweenFormula {n} (a b f : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (relationBetweenFormula a b f) env ↔ env f ⊆ ZFSet.prod (env a) (env b) := by
-  simp only [relationBetweenFormula, Truth, truth_exMem, truth_orderedPairFormula]
-  exact forall_congr' (fun _ => forall_congr' (fun _ => ZFSet.mem_prod.symm))
-
-theorem truth_functionFormula {n} (a b f : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (functionFormula a b f) env ↔ ZFSet.IsFunc (env a) (env b) (env f) := by
-  simp only [functionFormula, Truth, truth_relationBetweenFormula, truth_exMem,
-    truth_pairMembershipFormula, truth_imp]
-  constructor
-  · rintro ⟨shape, total⟩
-    refine ⟨shape, ?_⟩
-    intro x hx
-    obtain ⟨y, _, pair, unique⟩ := total x hx
-    refine ⟨y, pair, ?_⟩
-    intro z rel
-    exact unique z (ZFSet.pair_mem_prod.1 (shape rel)).2 rel
-  · rintro ⟨shape, total⟩
-    refine ⟨shape, ?_⟩
-    intro x hx
-    obtain ⟨y, rel, unique⟩ := total x hx
-    exact ⟨y, (ZFSet.pair_mem_prod.1 (shape rel)).2, rel, fun z _ hz => unique z hz⟩
-
-end PartitionPilot.Forcing.BoundedFormula
-
-namespace PartitionPilot.Forcing.TransitiveGround
-
-open SetFormula
-universe u
-variable (M : TransitiveGround.{u})
-
-theorem realize_functionCode {A B f : ZFSet.{u}}
-    (hA : A ∈ M.sets) (hB : B ∈ M.sets) (hf : f ∈ M.sets) :
-    Realize M.sets (BoundedFormula.functionFormula 0 1 2).toFormula
-      (extend A (extend B (extend f Fin.elim0))) ↔ ZFSet.IsFunc A B f :=
-  (BoundedFormula.realize_toFormula M _ _ (Fin.cases hA (Fin.cases hB (Fin.cases hf (fun i => Fin.elim0 i))))).trans
-    (BoundedFormula.truth_functionFormula 0 1 2 _)
-
-end PartitionPilot.Forcing.TransitiveGround
-
-end
-
-
-namespace PartitionPilot.Forcing.BoundedFormula
-
-open SetFormula
-universe u
-
-def nestedActionTripleFormula {n} (z g a b c d : Fin n) : BoundedFormula n :=
-  let lift4 (j : Fin n) := j.succ.succ.succ.succ
-  let lift6 (j : Fin n) := j.succ.succ.succ.succ.succ.succ
-  exMem z (exMem 0 (exMem z.succ.succ (exMem 0
-    (.conj (orderedPairFormula (lift4 z) 2 0)
-      (.conj (orderedPairFormula 0 (lift4 c) (lift4 d))
-        (exMem 2 (exMem 0 (.conj (orderedPairFormula 4 (lift6 g) 0)
-          (orderedPairFormula 0 (lift6 a) (lift6 b))))))))))
-
-theorem truth_nestedActionTripleFormula {n} (z g a b c d : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (nestedActionTripleFormula z g a b c d) env ↔
-      env z = ZFSet.pair (ZFSet.pair (env g) (ZFSet.pair (env a) (env b)))
-        (ZFSet.pair (env c) (env d)) := by
-  simp only [nestedActionTripleFormula, truth_exMem, Truth, truth_orderedPairFormula]
-  change (∃ s ∈ env z, ∃ x ∈ s, ∃ t ∈ env z, ∃ y ∈ t,
-    env z = ZFSet.pair x y ∧ y = ZFSet.pair (env c) (env d) ∧
-      ∃ w ∈ x, ∃ v ∈ w, x = ZFSet.pair (env g) v ∧ v = ZFSet.pair (env a) (env b)) ↔ _
-  constructor
-  · rintro ⟨_, _, x, _, _, _, y, _, outer, hy, _, _, v, _, hx, hv⟩
-    rw [outer, hy, hx, hv]
-  · intro equal
-    let v := ZFSet.pair (env a) (env b)
-    let x := ZFSet.pair (env g) v
-    let y := ZFSet.pair (env c) (env d)
-    refine ⟨{x}, ?_, x, ZFSet.mem_singleton.2 rfl, {x, y}, ?_, y,
-      ZFSet.mem_pair.2 (Or.inr rfl), equal, rfl, {env g, v},
-      ZFSet.mem_pair.2 (Or.inr rfl), v, ZFSet.mem_pair.2 (Or.inr rfl), rfl, rfl⟩
-    · rw [equal]
-      exact ZFSet.mem_pair.2 (Or.inl rfl)
-    · rw [equal]
-      exact ZFSet.mem_pair.2 (Or.inr rfl)
-
-
-
-
-
-
-def binaryRelationFormula {n} (g f : Fin n) : BoundedFormula n :=
-  .allMem f (exMem g.succ (exMem g.succ.succ
-    (exMem g.succ.succ.succ (orderedTripleFormula 3 2 1 0))))
-
-def binaryFunctionFormula {n} (g f : Fin n) : BoundedFormula n :=
-  .conj (binaryRelationFormula g f) (.allMem g (.allMem g.succ
-    (exMem g.succ.succ (.conj (tripleMembershipFormula 2 1 0 f.succ.succ.succ)
-      (.allMem g.succ.succ.succ (imp
-        (tripleMembershipFormula 3 2 0 f.succ.succ.succ.succ) (.equal 0 1)))))))
-
-theorem truth_binaryRelationFormula {n} (g f : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (binaryRelationFormula g f) env ↔
-      env f ⊆ ZFSet.prod (ZFSet.prod (env g) (env g)) (env g) := by
-  simp only [binaryRelationFormula, Truth, truth_exMem, truth_orderedTripleFormula]
-  constructor
-  · intro h w hw
-    obtain ⟨x, hx, y, hy, z, hz, eq⟩ := h w hw
-    exact ZFSet.mem_prod.2 ⟨ZFSet.pair x y, ZFSet.pair_mem_prod.2 ⟨hx, hy⟩, z, hz, eq⟩
-  · intro h w hw
-    obtain ⟨xy, hxy, z, hz, eq⟩ := ZFSet.mem_prod.1 (h hw)
-    obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 hxy
-    exact ⟨x, hx, y, hy, z, hz, eq⟩
-
-theorem truth_binaryFunctionFormula {n} (g f : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (binaryFunctionFormula g f) env ↔
-      ZFSet.IsFunc (ZFSet.prod (env g) (env g)) (env g) (env f) := by
-  simp only [binaryFunctionFormula, Truth, truth_binaryRelationFormula, truth_exMem,
-    truth_tripleMembershipFormula, truth_imp]
-  constructor
-  · rintro ⟨shape, total⟩
-    refine ⟨shape, ?_⟩
-    intro xy hxy
-    obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 hxy
-    obtain ⟨z, _, rel, unique⟩ := total x hx y hy
-    refine ⟨z, rel, ?_⟩
-    intro w hw
-    exact unique w (ZFSet.pair_mem_prod.1 (shape hw)).2 hw
-  · rintro ⟨shape, total⟩
-    refine ⟨shape, ?_⟩
-    intro x hx y hy
-    obtain ⟨z, rel, unique⟩ := total (ZFSet.pair x y) (ZFSet.pair_mem_prod.2 ⟨hx, hy⟩)
-    exact ⟨z, (ZFSet.pair_mem_prod.1 (shape rel)).2, rel, fun w _ hw => unique w hw⟩
-
-end PartitionPilot.Forcing.BoundedFormula
-
-
-
-namespace PartitionPilot.Forcing
-
-universe u
-
-structure GroupCode (G m i e : ZFSet.{u}) : Prop where
-  mul_function : ZFSet.IsFunc (ZFSet.prod G G) G m
-  inv_function : ZFSet.IsFunc G G i
-  identity_mem : e ∈ G
-  one_mul : ∀ x ∈ G, ZFSet.pair (ZFSet.pair e x) x ∈ m
-  mul_one : ∀ x ∈ G, ZFSet.pair (ZFSet.pair x e) x ∈ m
-  inv_mul : ∀ x ∈ G, ∀ y ∈ G, ZFSet.pair x y ∈ i → ZFSet.pair (ZFSet.pair y x) e ∈ m
-  mul_assoc : ∀ x ∈ G, ∀ y ∈ G, ∀ z ∈ G, ∀ a ∈ G, ∀ b ∈ G, ∀ c ∈ G,
-    ZFSet.pair (ZFSet.pair x y) a ∈ m → ZFSet.pair (ZFSet.pair y z) b ∈ m →
-    ZFSet.pair (ZFSet.pair a z) c ∈ m → ZFSet.pair (ZFSet.pair x b) c ∈ m
-
-namespace BoundedFormula
-
-open SetFormula
-
-def groupIdentityFormula {n} (g m e : Fin n) : BoundedFormula n :=
-  .allMem g (.conj (tripleMembershipFormula e.succ 0 0 m.succ)
-    (tripleMembershipFormula 0 e.succ 0 m.succ))
-
-def groupInverseFormula {n} (g m i e : Fin n) : BoundedFormula n :=
-  .allMem g (.allMem g.succ (imp (pairMembershipFormula 1 0 i.succ.succ)
-    (tripleMembershipFormula 0 1 e.succ.succ m.succ.succ)))
-
-def groupAssociativeFormula {n} (g m : Fin n) : BoundedFormula n :=
-  .allMem g (.allMem g.succ (.allMem g.succ.succ (.allMem g.succ.succ.succ
-    (.allMem g.succ.succ.succ.succ (.allMem g.succ.succ.succ.succ.succ
-      (imp (.conj (tripleMembershipFormula 5 4 2 m.succ.succ.succ.succ.succ.succ)
-        (.conj (tripleMembershipFormula 4 3 1 m.succ.succ.succ.succ.succ.succ)
-          (tripleMembershipFormula 2 3 0 m.succ.succ.succ.succ.succ.succ)))
-        (tripleMembershipFormula 5 1 0 m.succ.succ.succ.succ.succ.succ)))))))
-
-def groupFormula {n} (g m i e : Fin n) : BoundedFormula n :=
-  .conj (binaryFunctionFormula g m) (.conj (functionFormula g g i)
-    (.conj (.mem e g) (.conj (groupIdentityFormula g m e)
-      (.conj (groupInverseFormula g m i e) (groupAssociativeFormula g m)))))
-
-theorem truth_groupFormula {n} (g m i e : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (groupFormula g m i e) env ↔ GroupCode (env g) (env m) (env i) (env e) := by
-  simp only [groupFormula, Truth, truth_binaryFunctionFormula, truth_functionFormula,
-    groupIdentityFormula, groupInverseFormula, groupAssociativeFormula,
-    truth_tripleMembershipFormula, truth_pairMembershipFormula, truth_imp]
-  constructor
-  · rintro ⟨mul, inv, one, identity, inverse, assoc⟩
-    exact ⟨mul, inv, one, fun x hx => (identity x hx).1,
-      fun x hx => (identity x hx).2, inverse,
-      fun x hx y hy z hz a ha b hb c hc xy yz az => assoc x hx y hy z hz a ha b hb c hc ⟨xy, yz, az⟩⟩
-  · intro h
-    exact ⟨h.mul_function, h.inv_function, h.identity_mem,
-      fun x hx => ⟨h.one_mul x hx, h.mul_one x hx⟩, h.inv_mul,
-      fun x hx y hy z hz a ha b hb c hc ⟨xy, yz, az⟩ => h.mul_assoc x hx y hy z hz a ha b hb c hc xy yz az⟩
-
-end BoundedFormula
-
-namespace TransitiveGround
-
-open SetFormula
-variable (M : TransitiveGround.{u})
-
-theorem realize_groupCode {G m i e : ZFSet.{u}}
-    (hG : G ∈ M.sets) (hm : m ∈ M.sets) (hi : i ∈ M.sets) (he : e ∈ M.sets) :
-    Realize M.sets (BoundedFormula.groupFormula 0 1 2 3).toFormula
-      (extend G (extend m (extend i (extend e Fin.elim0)))) ↔ GroupCode G m i e :=
-  (BoundedFormula.realize_toFormula M _ _
-    (Fin.cases hG (Fin.cases hm (Fin.cases hi (Fin.cases he (fun j => Fin.elim0 j)))))).trans
-      (BoundedFormula.truth_groupFormula 0 1 2 3 _)
-
-end TransitiveGround
-
-end PartitionPilot.Forcing
-
-
-
-namespace PartitionPilot.SetRealization.Presentation
-open Forcing
-universe u
-variable {G : Type u} [Group G] (s : Presentation G)
-
-theorem groupCode : GroupCode s.carrier
-    ((s.product s).graph s (fun xy => xy.1 * xy.2))
-    (s.graph s (fun x => x⁻¹)) (s.encode 1) := by
-  refine ⟨(s.product s).graph_isFunc s _, s.graph_isFunc s _, s.encode_mem 1, ?_, ?_, ?_, ?_⟩
-  · intro x hx
-    obtain ⟨a, rfl⟩ := (s.mem_carrier x).1 hx
-    exact ((s.product s).pair_mem_graph s _ (1, a) a).2 (one_mul a)
-  · intro x hx
-    obtain ⟨a, rfl⟩ := (s.mem_carrier x).1 hx
-    exact ((s.product s).pair_mem_graph s _ (a, 1) a).2 (mul_one a)
-  · intro x hx y hy entry
-    obtain ⟨a, rfl⟩ := (s.mem_carrier x).1 hx
-    obtain ⟨b, rfl⟩ := (s.mem_carrier y).1 hy
-    have inverse := (s.pair_mem_graph s _ a b).1 entry
-    apply ((s.product s).pair_mem_graph s _ (b, a) 1).2
-    rw [← inverse, inv_mul_cancel]
-  · intro x hx y hy z hz a ha b hb c hc xy yz az
-    obtain ⟨x, rfl⟩ := (s.mem_carrier x).1 hx
-    obtain ⟨y, rfl⟩ := (s.mem_carrier y).1 hy
-    obtain ⟨z, rfl⟩ := (s.mem_carrier z).1 hz
-    obtain ⟨a, rfl⟩ := (s.mem_carrier a).1 ha
-    obtain ⟨b, rfl⟩ := (s.mem_carrier b).1 hb
-    obtain ⟨c, rfl⟩ := (s.mem_carrier c).1 hc
-    have first := ((s.product s).pair_mem_graph s _ (x, y) a).1 xy
-    have second := ((s.product s).pair_mem_graph s _ (y, z) b).1 yz
-    have third := ((s.product s).pair_mem_graph s _ (a, z) c).1 az
-    apply ((s.product s).pair_mem_graph s _ (x, b) c).2
-    rw [← second, ← mul_assoc, first, third]
-
-end PartitionPilot.SetRealization.Presentation
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Definability.UnionEntryFormula
+import OAI.SetTheory.PartitionPrinciple.Transfinite.OrdinalRecursionTraces
+
+namespace OAI
+
+
+namespace PartitionPilot.Forcing
+
+namespace BoundedFormula
+
+open SetFormula
+universe u
+
+def Truth : {n : Nat} → BoundedFormula n → (Fin n → ZFSet.{u}) → Prop
+  | _, .equal i j, env => env i = env j
+  | _, .mem i j, env => env i ∈ env j
+  | _, .neg φ, env => ¬ Truth φ env
+  | _, .conj φ ψ, env => Truth φ env ∧ Truth ψ env
+  | _, .allMem b φ, env => ∀ x ∈ env b, Truth φ (extend x env)
+
+theorem truth_imp {n} (φ ψ : BoundedFormula n) (env : Fin n → ZFSet.{u}) :
+    Truth (imp φ ψ) env ↔ (Truth φ env → Truth ψ env) := by
+  classical
+  simp only [imp, Truth, not_and, not_not]
+
+theorem truth_disj {n} (φ ψ : BoundedFormula n) (env : Fin n → ZFSet.{u}) :
+    Truth (disj φ ψ) env ↔ (Truth φ env ∨ Truth ψ env) := by
+  classical
+  simp only [disj, Truth, not_and_or, not_not]
+
+theorem truth_exMem {n} (b : Fin n) (φ : BoundedFormula (n + 1)) (env : Fin n → ZFSet.{u}) :
+    Truth (exMem b φ) env ↔ ∃ x ∈ env b, Truth φ (extend x env) := by
+  classical
+  simp only [exMem, Truth, not_forall, not_not, exists_prop]
+
+theorem realize_toFormula (M : TransitiveGround.{u}) {n} (φ : BoundedFormula n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets) :
+    Realize M.sets φ.toFormula env ↔ Truth φ env := by
+  induction φ with
+  | equal i j => rfl
+  | mem i j => rfl
+  | neg φ ih => exact not_congr (ih env members)
+  | conj φ ψ ihφ ihψ => exact and_congr (ihφ env members) (ihψ env members)
+  | allMem b φ ih =>
+    change (∀ x ∈ M.sets, Realize M.sets (SetFormula.imp (.mem 0 b.succ) φ.toFormula) (extend x env)) ↔ _
+    constructor
+    · intro h x hx
+      have hxM := M.transitive (members b) hx
+      exact (ih (extend x env) (Fin.cases hxM members)).1
+        ((realize_imp M.sets _ _ _).1 (h x hxM) hx)
+    · intro h x hxM
+      apply (realize_imp M.sets _ _ _).2
+      intro hx
+      exact (ih (extend x env) (Fin.cases hxM members)).2 (h x hx)
+
+theorem absolute (M N : TransitiveGround.{u}) {n} (φ : BoundedFormula n)
+    (env : Fin n → ZFSet.{u}) (inM : ∀ i, env i ∈ M.sets) (inN : ∀ i, env i ∈ N.sets) :
+    Realize M.sets φ.toFormula env ↔ Realize N.sets φ.toFormula env :=
+  (realize_toFormula M φ env inM).trans (realize_toFormula N φ env inN).symm
+
+end BoundedFormula
+
+end PartitionPilot.Forcing
+
+
+
+namespace PartitionPilot.Forcing.BoundedFormula
+
+open SetFormula
+universe u
+
+def emptyFormula {n} (x : Fin n) : BoundedFormula n :=
+  .allMem x (.neg (.equal 0 0))
+
+def successorFormula {n} (y x : Fin n) : BoundedFormula n :=
+  .conj (.mem x y) (.conj (.allMem x (.mem 0 y.succ))
+    (.allMem y (disj (.equal 0 x.succ) (.mem 0 x.succ))))
+
+def setTransitiveFormula {n} (x : Fin n) : BoundedFormula n :=
+  .allMem x (.allMem 0 (.mem 0 x.succ.succ))
+
+def zeroOrSuccessorFormula {n} (x : Fin n) : BoundedFormula n :=
+  disj (emptyFormula x) (exMem x (successorFormula x.succ 0))
+
+def naturalFormula {n} (x : Fin n) : BoundedFormula n :=
+  .conj (setTransitiveFormula x) (.conj (zeroOrSuccessorFormula x)
+    (.allMem x (.conj (setTransitiveFormula 0) (zeroOrSuccessorFormula 0))))
+
+theorem truth_emptyFormula {n} (x : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (emptyFormula x) env ↔ env x = ∅ := by
+  change (∀ y ∈ env x, ¬ y = y) ↔ _
+  constructor
+  · intro h
+    exact (ZFSet.eq_empty _).2 (fun y hy => h y hy rfl)
+  · intro h y hy
+    exact False.elim ((ZFSet.eq_empty _).1 h y hy)
+
+theorem truth_successorFormula {n} (y x : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (successorFormula y x) env ↔ env y = insert (env x) (env x) := by
+  simp only [successorFormula, Truth, truth_disj]
+  change (env x ∈ env y ∧ (∀ z ∈ env x, z ∈ env y) ∧
+    ∀ z ∈ env y, z = env x ∨ z ∈ env x) ↔ _
+  constructor
+  · rintro ⟨hx, lower, upper⟩
+    apply ZFSet.ext
+    intro z
+    rw [ZFSet.mem_insert_iff]
+    exact ⟨upper z, fun h => h.elim (fun eq => eq.symm ▸ hx) (lower z)⟩
+  · intro eq
+    rw [eq]
+    exact ⟨ZFSet.mem_insert _ _, fun _ hz => ZFSet.mem_insert_of_mem _ hz,
+      fun _ hz => ZFSet.mem_insert_iff.1 hz⟩
+
+theorem truth_setTransitiveFormula {n} (x : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (setTransitiveFormula x) env ↔ setTransitive (env x) := Iff.rfl
+
+theorem truth_zeroOrSuccessorFormula {n} (x : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (zeroOrSuccessorFormula x) env ↔ zeroOrSuccessor (env x) := by
+  simp only [zeroOrSuccessorFormula, truth_disj, truth_emptyFormula, truth_exMem,
+    truth_successorFormula]
+  rfl
+
+theorem truth_naturalFormula {n} (x : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (naturalFormula x) env ↔ env x ∈ ZFSet.omega := by
+  simp only [naturalFormula, Truth, truth_setTransitiveFormula, truth_zeroOrSuccessorFormula]
+  exact naturalSetProperty_iff_mem_omega (env x)
+
+theorem realize_naturalFormula (M : TransitiveGround.{u}) {n}
+    (x : Fin n) (env : Fin n → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets) :
+    Realize M.sets (naturalFormula x).toFormula env ↔ env x ∈ ZFSet.omega :=
+  (realize_toFormula M _ env members).trans (truth_naturalFormula x env)
+
+
+
+
+
+
+theorem truth_singletonFormula {n} (z x : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (singletonFormula z x) env ↔ env z = {env x} := by
+  change (env x ∈ env z ∧ ∀ w ∈ env z, w = env x) ↔ _
+  constructor
+  · rintro ⟨member, only⟩
+    apply ZFSet.ext
+    intro w
+    rw [ZFSet.mem_singleton]
+    exact ⟨only w, fun eq => eq.symm ▸ member⟩
+  · intro eq
+    rw [eq]
+    exact ⟨ZFSet.mem_singleton.2 rfl, fun _ h => ZFSet.mem_singleton.1 h⟩
+
+theorem truth_unorderedPairFormula {n} (z x y : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (unorderedPairFormula z x y) env ↔ env z = {env x, env y} := by
+  simp only [unorderedPairFormula, Truth, truth_disj]
+  change (env x ∈ env z ∧ env y ∈ env z ∧ ∀ w ∈ env z, w = env x ∨ w = env y) ↔ _
+  constructor
+  · rintro ⟨hx, hy, only⟩
+    apply ZFSet.ext
+    intro w
+    rw [ZFSet.mem_pair]
+    refine ⟨only w, ?_⟩
+    rintro (rfl | rfl)
+    · exact hx
+    · exact hy
+  · intro eq
+    rw [eq]
+    exact ⟨ZFSet.mem_pair.2 (Or.inl rfl), ZFSet.mem_pair.2 (Or.inr rfl), fun _ h => ZFSet.mem_pair.1 h⟩
+
+theorem truth_orderedPairFormula {n} (z x y : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (orderedPairFormula z x y) env ↔ env z = ZFSet.pair (env x) (env y) := by
+  rw [orderedPairFormula, truth_exMem]
+  constructor
+  · rintro ⟨a, _, first, rest⟩
+    have ha := (truth_singletonFormula 0 x.succ (extend a env)).1 first
+    obtain ⟨b, _, second, shape⟩ := (truth_exMem _ _ _).1 rest
+    have hb := (truth_unorderedPairFormula 0 x.succ.succ y.succ.succ (extend b (extend a env))).1 second
+    have hz := (truth_unorderedPairFormula z.succ.succ 1 0 (extend b (extend a env))).1 shape
+    change a = {env x} at ha
+    change b = {env x, env y} at hb
+    change env z = {a, b} at hz
+    rw [hz, ha, hb]
+    rfl
+  · intro eq
+    have ha : ({env x} : ZFSet.{u}) ∈ env z := by
+      rw [eq]
+      exact ZFSet.mem_pair.2 (Or.inl rfl)
+    refine ⟨{env x}, ha, (truth_singletonFormula 0 x.succ _).2 rfl, ?_⟩
+    apply (truth_exMem _ _ _).2
+    have hb : ({env x, env y} : ZFSet.{u}) ∈ env z := by
+      rw [eq]
+      exact ZFSet.mem_pair.2 (Or.inr rfl)
+    exact ⟨{env x, env y}, hb, (truth_unorderedPairFormula 0 x.succ.succ y.succ.succ _).2 rfl,
+      (truth_unorderedPairFormula z.succ.succ 1 0 _).2 eq⟩
+
+theorem truth_pairMembershipFormula {n} (x y r : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (pairMembershipFormula x y r) env ↔ ZFSet.pair (env x) (env y) ∈ env r := by
+  rw [pairMembershipFormula, truth_exMem]
+  constructor
+  · rintro ⟨z, hz, shape⟩
+    have eq := (truth_orderedPairFormula 0 x.succ y.succ (extend z env)).1 shape
+    exact eq ▸ hz
+  · intro member
+    exact ⟨ZFSet.pair (env x) (env y), member, (truth_orderedPairFormula 0 x.succ y.succ _).2 rfl⟩
+
+end PartitionPilot.Forcing.BoundedFormula
+
+
+
+namespace PartitionPilot.Forcing
+
+universe u
+
+namespace SetFormula
+
+def exactSetFormula {n} (output : Fin n) (entry : SetFormula (n + 1)) : SetFormula n :=
+  .all (.conj (imp (.mem 0 output.succ) entry) (imp entry (.mem 0 output.succ)))
+
+end SetFormula
+
+namespace TransitiveGround
+
+open SetFormula
+variable (M : TransitiveGround.{u})
+
+theorem realize_exactSetFormula {n} (output : Fin n) (entry : SetFormula (n + 1))
+    (env : Fin n → ZFSet.{u}) {target : ZFSet.{u}}
+    (hOutput : env output ∈ M.sets) (elements : ∀ z ∈ target, z ∈ M.sets)
+    (meaning : ∀ z ∈ M.sets, Realize M.sets entry (extend z env) ↔ z ∈ target) :
+    Realize M.sets (exactSetFormula output entry) env ↔ env output = target := by
+  change (∀ z ∈ M.sets, Realize M.sets
+    (.conj (imp (.mem 0 output.succ) entry) (imp entry (.mem 0 output.succ))) (extend z env)) ↔ _
+  simp only [Realize, realize_imp]
+  change (∀ z ∈ M.sets, (z ∈ env output → Realize M.sets entry (extend z env)) ∧
+    (Realize M.sets entry (extend z env) → z ∈ env output)) ↔ _
+  constructor
+  · intro correct
+    apply ZFSet.ext
+    intro z
+    constructor
+    · intro member
+      have hz := M.transitive hOutput member
+      exact (meaning z hz).1 ((correct z hz).1 member)
+    · intro member
+      have hz := elements z member
+      exact (correct z hz).2 ((meaning z hz).2 member)
+  · intro equal z hz
+    exact ⟨fun member => (meaning z hz).2 (equal ▸ member),
+      fun predicate => equal.symm ▸ (meaning z hz).1 predicate⟩
+
+end TransitiveGround
+
+end PartitionPilot.Forcing
+
+
+
+namespace PartitionPilot.Forcing.BoundedFormula
+
+open SetFormula SetRealization
+universe u
+
+def ordinalFormula {n} (x : Fin n) : BoundedFormula n :=
+  .conj (setTransitiveFormula x) (.allMem x (setTransitiveFormula 0))
+
+theorem truth_ordinalFormula {n} (x : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (ordinalFormula x) env ↔ ∃ o : Ordinal.{u}, env x = ordinalCode o := by
+  simp only [ordinalFormula, Truth, truth_setTransitiveFormula]
+  exact ordinalSetProperty_iff (env x)
+
+theorem realize_ordinalFormula (M : TransitiveGround.{u}) {n}
+    (x : Fin n) (env : Fin n → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets) :
+    Realize M.sets (ordinalFormula x).toFormula env ↔ ∃ o : Ordinal.{u}, env x = ordinalCode o :=
+  (realize_toFormula M _ env members).trans (truth_ordinalFormula x env)
+
+end PartitionPilot.Forcing.BoundedFormula
+
+
+
+namespace PartitionPilot.Forcing.BoundedFormula
+open SetFormula
+universe u
+
+def graphFiberInclusionFormula {n} (x y f g : Fin n) : BoundedFormula n :=
+  .allMem f (.allMem 0 (.allMem 0
+    (imp (orderedPairFormula 2 x.succ.succ.succ 0)
+      (pairMembershipFormula y.succ.succ.succ 0 g.succ.succ.succ))))
+
+theorem truth_graphFiberInclusionFormula {n} (x y f g : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (graphFiberInclusionFormula x y f g) env ↔
+      ∀ z, ZFSet.pair (env x) z ∈ env f → ZFSet.pair (env y) z ∈ env g := by
+  simp only [graphFiberInclusionFormula, Truth, truth_imp,
+    truth_orderedPairFormula, truth_pairMembershipFormula]
+  change (∀ p ∈ env f, ∀ a ∈ p, ∀ z ∈ a,
+    p = ZFSet.pair (env x) z → ZFSet.pair (env y) z ∈ env g) ↔ _
+  constructor
+  · intro h z entry
+    exact h (ZFSet.pair (env x) z) entry {env x, z}
+      (ZFSet.mem_pair.2 (Or.inr rfl)) z (ZFSet.mem_pair.2 (Or.inr rfl)) rfl
+  · intro h p hp a _ z _ equal
+    exact h z (equal ▸ hp)
+
+def graphFiberEqualityFormula {n} (x y f g : Fin n) : BoundedFormula n :=
+  .conj (graphFiberInclusionFormula x y f g) (graphFiberInclusionFormula y x g f)
+
+theorem truth_graphFiberEqualityFormula {n} (x y f g : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (graphFiberEqualityFormula x y f g) env ↔
+      ∀ z, ZFSet.pair (env x) z ∈ env f ↔ ZFSet.pair (env y) z ∈ env g := by
+  simp only [graphFiberEqualityFormula, Truth, truth_graphFiberInclusionFormula]
+  exact ⟨fun h z => ⟨h.1 z, h.2 z⟩, fun h => ⟨fun z => (h z).1, fun z => (h z).2⟩⟩
+
+end PartitionPilot.Forcing.BoundedFormula
+
+
+
+namespace PartitionPilot.Forcing
+
+universe u
+
+structure PartialOrderCode (Q R : ZFSet.{u}) : Prop where
+  relation : R ⊆ ZFSet.prod Q Q
+  refl : ∀ x ∈ Q, ZFSet.pair x x ∈ R
+  antisymm : ∀ x ∈ Q, ∀ y ∈ Q, ZFSet.pair x y ∈ R → ZFSet.pair y x ∈ R → x = y
+  trans : ∀ x ∈ Q, ∀ y ∈ Q, ∀ z ∈ Q,
+    ZFSet.pair x y ∈ R → ZFSet.pair y z ∈ R → ZFSet.pair x z ∈ R
+
+namespace BoundedFormula
+
+open SetFormula
+
+def relationOnFormula {n} (c r : Fin n) : BoundedFormula n :=
+  .allMem r (exMem c.succ (exMem c.succ.succ (orderedPairFormula 2 1 0)))
+
+def reflexiveFormula {n} (c r : Fin n) : BoundedFormula n :=
+  .allMem c (pairMembershipFormula 0 0 r.succ)
+
+def antisymmetricFormula {n} (c r : Fin n) : BoundedFormula n :=
+  .allMem c (.allMem c.succ (imp
+    (.conj (pairMembershipFormula 1 0 r.succ.succ) (pairMembershipFormula 0 1 r.succ.succ)) (.equal 1 0)))
+
+def transitiveFormula {n} (c r : Fin n) : BoundedFormula n :=
+  .allMem c (.allMem c.succ (.allMem c.succ.succ (imp
+    (.conj (pairMembershipFormula 2 1 r.succ.succ.succ) (pairMembershipFormula 1 0 r.succ.succ.succ))
+    (pairMembershipFormula 2 0 r.succ.succ.succ))))
+
+def partialOrderFormula {n} (c r : Fin n) : BoundedFormula n :=
+  .conj (relationOnFormula c r) (.conj (reflexiveFormula c r)
+    (.conj (antisymmetricFormula c r) (transitiveFormula c r)))
+
+def topFormula {n} (c r t : Fin n) : BoundedFormula n :=
+  .conj (.mem t c) (.allMem c (pairMembershipFormula 0 t.succ r.succ))
+
+theorem truth_relationOnFormula {n} (c r : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (relationOnFormula c r) env ↔ env r ⊆ ZFSet.prod (env c) (env c) := by
+  simp only [relationOnFormula, Truth, truth_exMem, truth_orderedPairFormula]
+  exact forall_congr' (fun _ => forall_congr' (fun _ => ZFSet.mem_prod.symm))
+
+theorem truth_partialOrderFormula {n} (c r : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (partialOrderFormula c r) env ↔ PartialOrderCode (env c) (env r) := by
+  simp only [partialOrderFormula, Truth, truth_relationOnFormula, reflexiveFormula,
+    antisymmetricFormula, transitiveFormula, truth_imp, truth_pairMembershipFormula]
+  constructor
+  · rintro ⟨shape, refl, antisymm, trans⟩
+    exact ⟨shape, refl, fun x hx y hy xy yx => antisymm x hx y hy ⟨xy, yx⟩,
+      fun x hx y hy z hz xy yz => trans x hx y hy z hz ⟨xy, yz⟩⟩
+  · intro h
+    exact ⟨h.relation, h.refl, fun x hx y hy ⟨xy, yx⟩ => h.antisymm x hx y hy xy yx,
+      fun x hx y hy z hz ⟨xy, yz⟩ => h.trans x hx y hy z hz xy yz⟩
+
+theorem truth_topFormula {n} (c r t : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (topFormula c r t) env ↔ env t ∈ env c ∧ ∀ x ∈ env c, ZFSet.pair x (env t) ∈ env r := by
+  simp only [topFormula, Truth, truth_pairMembershipFormula]
+  rfl
+
+end BoundedFormula
+
+namespace TransitiveGround
+
+open SetFormula
+variable (M : TransitiveGround.{u})
+
+theorem realize_partialOrderCode {Q R : ZFSet.{u}} (hQ : Q ∈ M.sets) (hR : R ∈ M.sets) :
+    Realize M.sets (BoundedFormula.partialOrderFormula 0 1).toFormula (extend Q (extend R Fin.elim0)) ↔
+      PartialOrderCode Q R :=
+  (BoundedFormula.realize_toFormula M _ _ (Fin.cases hQ (Fin.cases hR (fun i => Fin.elim0 i)))).trans
+    (BoundedFormula.truth_partialOrderFormula 0 1 _)
+
+theorem partialOrderCode_absolute (N : TransitiveGround.{u}) {Q R : ZFSet.{u}}
+    (hQM : Q ∈ M.sets) (hRM : R ∈ M.sets) (hQN : Q ∈ N.sets) (hRN : R ∈ N.sets) :
+    Realize M.sets (BoundedFormula.partialOrderFormula 0 1).toFormula (extend Q (extend R Fin.elim0)) ↔
+      Realize N.sets (BoundedFormula.partialOrderFormula 0 1).toFormula (extend Q (extend R Fin.elim0)) :=
+  (M.realize_partialOrderCode hQM hRM).trans (N.realize_partialOrderCode hQN hRN).symm
+
+end TransitiveGround
+
+end PartitionPilot.Forcing
+
+
+
+namespace PartitionPilot.Forcing.BoundedFormula
+
+open SetFormula
+universe u
+
+def orderedTripleFormula {n} (w x y z : Fin n) : BoundedFormula n :=
+  exMem w (exMem 0 (.conj (orderedPairFormula 0 x.succ.succ y.succ.succ)
+    (orderedPairFormula w.succ.succ 0 z.succ.succ)))
+
+def tripleMembershipFormula {n} (x y z f : Fin n) : BoundedFormula n :=
+  exMem f (orderedTripleFormula 0 x.succ y.succ z.succ)
+
+theorem truth_orderedTripleFormula {n} (w x y z : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (orderedTripleFormula w x y z) env ↔
+      env w = ZFSet.pair (ZFSet.pair (env x) (env y)) (env z) := by
+  simp only [orderedTripleFormula, truth_exMem, Truth, truth_orderedPairFormula]
+  change (∃ a ∈ env w, ∃ b ∈ a, b = ZFSet.pair (env x) (env y) ∧
+    env w = ZFSet.pair b (env z)) ↔ _
+  constructor
+  · rintro ⟨a, _, b, _, rfl, eq⟩
+    exact eq
+  · intro eq
+    refine ⟨{ZFSet.pair (env x) (env y)}, ?_, ZFSet.pair (env x) (env y),
+      ZFSet.mem_singleton.2 rfl, rfl, eq⟩
+    rw [eq]
+    exact ZFSet.mem_pair.2 (Or.inl rfl)
+
+theorem truth_tripleMembershipFormula {n} (x y z f : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (tripleMembershipFormula x y z f) env ↔
+      ZFSet.pair (ZFSet.pair (env x) (env y)) (env z) ∈ env f := by
+  simp only [tripleMembershipFormula, truth_exMem, truth_orderedTripleFormula]
+  change (∃ w ∈ env f, w = ZFSet.pair (ZFSet.pair (env x) (env y)) (env z)) ↔ _
+  exact ⟨fun ⟨_, hw, eq⟩ => eq ▸ hw, fun hw => ⟨_, hw, rfl⟩⟩
+
+end PartitionPilot.Forcing.BoundedFormula
+
+
+section
+
+namespace PartitionPilot.Forcing.BoundedFormula
+
+open SetFormula
+universe u
+
+theorem truth_relationBetweenFormula {n} (a b f : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (relationBetweenFormula a b f) env ↔ env f ⊆ ZFSet.prod (env a) (env b) := by
+  simp only [relationBetweenFormula, Truth, truth_exMem, truth_orderedPairFormula]
+  exact forall_congr' (fun _ => forall_congr' (fun _ => ZFSet.mem_prod.symm))
+
+theorem truth_functionFormula {n} (a b f : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (functionFormula a b f) env ↔ ZFSet.IsFunc (env a) (env b) (env f) := by
+  simp only [functionFormula, Truth, truth_relationBetweenFormula, truth_exMem,
+    truth_pairMembershipFormula, truth_imp]
+  constructor
+  · rintro ⟨shape, total⟩
+    refine ⟨shape, ?_⟩
+    intro x hx
+    obtain ⟨y, _, pair, unique⟩ := total x hx
+    refine ⟨y, pair, ?_⟩
+    intro z rel
+    exact unique z (ZFSet.pair_mem_prod.1 (shape rel)).2 rel
+  · rintro ⟨shape, total⟩
+    refine ⟨shape, ?_⟩
+    intro x hx
+    obtain ⟨y, rel, unique⟩ := total x hx
+    exact ⟨y, (ZFSet.pair_mem_prod.1 (shape rel)).2, rel, fun z _ hz => unique z hz⟩
+
+end PartitionPilot.Forcing.BoundedFormula
+
+namespace PartitionPilot.Forcing.TransitiveGround
+
+open SetFormula
+universe u
+variable (M : TransitiveGround.{u})
+
+theorem realize_functionCode {A B f : ZFSet.{u}}
+    (hA : A ∈ M.sets) (hB : B ∈ M.sets) (hf : f ∈ M.sets) :
+    Realize M.sets (BoundedFormula.functionFormula 0 1 2).toFormula
+      (extend A (extend B (extend f Fin.elim0))) ↔ ZFSet.IsFunc A B f :=
+  (BoundedFormula.realize_toFormula M _ _ (Fin.cases hA (Fin.cases hB (Fin.cases hf (fun i => Fin.elim0 i))))).trans
+    (BoundedFormula.truth_functionFormula 0 1 2 _)
+
+end PartitionPilot.Forcing.TransitiveGround
+
+end
+
+
+namespace PartitionPilot.Forcing.BoundedFormula
+
+open SetFormula
+universe u
+
+def nestedActionTripleFormula {n} (z g a b c d : Fin n) : BoundedFormula n :=
+  let lift4 (j : Fin n) := j.succ.succ.succ.succ
+  let lift6 (j : Fin n) := j.succ.succ.succ.succ.succ.succ
+  exMem z (exMem 0 (exMem z.succ.succ (exMem 0
+    (.conj (orderedPairFormula (lift4 z) 2 0)
+      (.conj (orderedPairFormula 0 (lift4 c) (lift4 d))
+        (exMem 2 (exMem 0 (.conj (orderedPairFormula 4 (lift6 g) 0)
+          (orderedPairFormula 0 (lift6 a) (lift6 b))))))))))
+
+theorem truth_nestedActionTripleFormula {n} (z g a b c d : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (nestedActionTripleFormula z g a b c d) env ↔
+      env z = ZFSet.pair (ZFSet.pair (env g) (ZFSet.pair (env a) (env b)))
+        (ZFSet.pair (env c) (env d)) := by
+  simp only [nestedActionTripleFormula, truth_exMem, Truth, truth_orderedPairFormula]
+  change (∃ s ∈ env z, ∃ x ∈ s, ∃ t ∈ env z, ∃ y ∈ t,
+    env z = ZFSet.pair x y ∧ y = ZFSet.pair (env c) (env d) ∧
+      ∃ w ∈ x, ∃ v ∈ w, x = ZFSet.pair (env g) v ∧ v = ZFSet.pair (env a) (env b)) ↔ _
+  constructor
+  · rintro ⟨_, _, x, _, _, _, y, _, outer, hy, _, _, v, _, hx, hv⟩
+    rw [outer, hy, hx, hv]
+  · intro equal
+    let v := ZFSet.pair (env a) (env b)
+    let x := ZFSet.pair (env g) v
+    let y := ZFSet.pair (env c) (env d)
+    refine ⟨{x}, ?_, x, ZFSet.mem_singleton.2 rfl, {x, y}, ?_, y,
+      ZFSet.mem_pair.2 (Or.inr rfl), equal, rfl, {env g, v},
+      ZFSet.mem_pair.2 (Or.inr rfl), v, ZFSet.mem_pair.2 (Or.inr rfl), rfl, rfl⟩
+    · rw [equal]
+      exact ZFSet.mem_pair.2 (Or.inl rfl)
+    · rw [equal]
+      exact ZFSet.mem_pair.2 (Or.inr rfl)
+
+
+
+
+
+
+def binaryRelationFormula {n} (g f : Fin n) : BoundedFormula n :=
+  .allMem f (exMem g.succ (exMem g.succ.succ
+    (exMem g.succ.succ.succ (orderedTripleFormula 3 2 1 0))))
+
+def binaryFunctionFormula {n} (g f : Fin n) : BoundedFormula n :=
+  .conj (binaryRelationFormula g f) (.allMem g (.allMem g.succ
+    (exMem g.succ.succ (.conj (tripleMembershipFormula 2 1 0 f.succ.succ.succ)
+      (.allMem g.succ.succ.succ (imp
+        (tripleMembershipFormula 3 2 0 f.succ.succ.succ.succ) (.equal 0 1)))))))
+
+theorem truth_binaryRelationFormula {n} (g f : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (binaryRelationFormula g f) env ↔
+      env f ⊆ ZFSet.prod (ZFSet.prod (env g) (env g)) (env g) := by
+  simp only [binaryRelationFormula, Truth, truth_exMem, truth_orderedTripleFormula]
+  constructor
+  · intro h w hw
+    obtain ⟨x, hx, y, hy, z, hz, eq⟩ := h w hw
+    exact ZFSet.mem_prod.2 ⟨ZFSet.pair x y, ZFSet.pair_mem_prod.2 ⟨hx, hy⟩, z, hz, eq⟩
+  · intro h w hw
+    obtain ⟨xy, hxy, z, hz, eq⟩ := ZFSet.mem_prod.1 (h hw)
+    obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 hxy
+    exact ⟨x, hx, y, hy, z, hz, eq⟩
+
+theorem truth_binaryFunctionFormula {n} (g f : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (binaryFunctionFormula g f) env ↔
+      ZFSet.IsFunc (ZFSet.prod (env g) (env g)) (env g) (env f) := by
+  simp only [binaryFunctionFormula, Truth, truth_binaryRelationFormula, truth_exMem,
+    truth_tripleMembershipFormula, truth_imp]
+  constructor
+  · rintro ⟨shape, total⟩
+    refine ⟨shape, ?_⟩
+    intro xy hxy
+    obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 hxy
+    obtain ⟨z, _, rel, unique⟩ := total x hx y hy
+    refine ⟨z, rel, ?_⟩
+    intro w hw
+    exact unique w (ZFSet.pair_mem_prod.1 (shape hw)).2 hw
+  · rintro ⟨shape, total⟩
+    refine ⟨shape, ?_⟩
+    intro x hx y hy
+    obtain ⟨z, rel, unique⟩ := total (ZFSet.pair x y) (ZFSet.pair_mem_prod.2 ⟨hx, hy⟩)
+    exact ⟨z, (ZFSet.pair_mem_prod.1 (shape rel)).2, rel, fun w _ hw => unique w hw⟩
+
+end PartitionPilot.Forcing.BoundedFormula
+
+
+
+namespace PartitionPilot.Forcing
+
+universe u
+
+structure GroupCode (G m i e : ZFSet.{u}) : Prop where
+  mul_function : ZFSet.IsFunc (ZFSet.prod G G) G m
+  inv_function : ZFSet.IsFunc G G i
+  identity_mem : e ∈ G
+  one_mul : ∀ x ∈ G, ZFSet.pair (ZFSet.pair e x) x ∈ m
+  mul_one : ∀ x ∈ G, ZFSet.pair (ZFSet.pair x e) x ∈ m
+  inv_mul : ∀ x ∈ G, ∀ y ∈ G, ZFSet.pair x y ∈ i → ZFSet.pair (ZFSet.pair y x) e ∈ m
+  mul_assoc : ∀ x ∈ G, ∀ y ∈ G, ∀ z ∈ G, ∀ a ∈ G, ∀ b ∈ G, ∀ c ∈ G,
+    ZFSet.pair (ZFSet.pair x y) a ∈ m → ZFSet.pair (ZFSet.pair y z) b ∈ m →
+    ZFSet.pair (ZFSet.pair a z) c ∈ m → ZFSet.pair (ZFSet.pair x b) c ∈ m
+
+namespace BoundedFormula
+
+open SetFormula
+
+def groupIdentityFormula {n} (g m e : Fin n) : BoundedFormula n :=
+  .allMem g (.conj (tripleMembershipFormula e.succ 0 0 m.succ)
+    (tripleMembershipFormula 0 e.succ 0 m.succ))
+
+def groupInverseFormula {n} (g m i e : Fin n) : BoundedFormula n :=
+  .allMem g (.allMem g.succ (imp (pairMembershipFormula 1 0 i.succ.succ)
+    (tripleMembershipFormula 0 1 e.succ.succ m.succ.succ)))
+
+def groupAssociativeFormula {n} (g m : Fin n) : BoundedFormula n :=
+  .allMem g (.allMem g.succ (.allMem g.succ.succ (.allMem g.succ.succ.succ
+    (.allMem g.succ.succ.succ.succ (.allMem g.succ.succ.succ.succ.succ
+      (imp (.conj (tripleMembershipFormula 5 4 2 m.succ.succ.succ.succ.succ.succ)
+        (.conj (tripleMembershipFormula 4 3 1 m.succ.succ.succ.succ.succ.succ)
+          (tripleMembershipFormula 2 3 0 m.succ.succ.succ.succ.succ.succ)))
+        (tripleMembershipFormula 5 1 0 m.succ.succ.succ.succ.succ.succ)))))))
+
+def groupFormula {n} (g m i e : Fin n) : BoundedFormula n :=
+  .conj (binaryFunctionFormula g m) (.conj (functionFormula g g i)
+    (.conj (.mem e g) (.conj (groupIdentityFormula g m e)
+      (.conj (groupInverseFormula g m i e) (groupAssociativeFormula g m)))))
+
+theorem truth_groupFormula {n} (g m i e : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (groupFormula g m i e) env ↔ GroupCode (env g) (env m) (env i) (env e) := by
+  simp only [groupFormula, Truth, truth_binaryFunctionFormula, truth_functionFormula,
+    groupIdentityFormula, groupInverseFormula, groupAssociativeFormula,
+    truth_tripleMembershipFormula, truth_pairMembershipFormula, truth_imp]
+  constructor
+  · rintro ⟨mul, inv, one, identity, inverse, assoc⟩
+    exact ⟨mul, inv, one, fun x hx => (identity x hx).1,
+      fun x hx => (identity x hx).2, inverse,
+      fun x hx y hy z hz a ha b hb c hc xy yz az => assoc x hx y hy z hz a ha b hb c hc ⟨xy, yz, az⟩⟩
+  · intro h
+    exact ⟨h.mul_function, h.inv_function, h.identity_mem,
+      fun x hx => ⟨h.one_mul x hx, h.mul_one x hx⟩, h.inv_mul,
+      fun x hx y hy z hz a ha b hb c hc ⟨xy, yz, az⟩ => h.mul_assoc x hx y hy z hz a ha b hb c hc xy yz az⟩
+
+end BoundedFormula
+
+namespace TransitiveGround
+
+open SetFormula
+variable (M : TransitiveGround.{u})
+
+theorem realize_groupCode {G m i e : ZFSet.{u}}
+    (hG : G ∈ M.sets) (hm : m ∈ M.sets) (hi : i ∈ M.sets) (he : e ∈ M.sets) :
+    Realize M.sets (BoundedFormula.groupFormula 0 1 2 3).toFormula
+      (extend G (extend m (extend i (extend e Fin.elim0)))) ↔ GroupCode G m i e :=
+  (BoundedFormula.realize_toFormula M _ _
+    (Fin.cases hG (Fin.cases hm (Fin.cases hi (Fin.cases he (fun j => Fin.elim0 j)))))).trans
+      (BoundedFormula.truth_groupFormula 0 1 2 3 _)
+
+end TransitiveGround
+
+end PartitionPilot.Forcing
+
+
+
+namespace PartitionPilot.SetRealization.Presentation
+open Forcing
+universe u
+variable {G : Type u} [Group G] (s : Presentation G)
+
+theorem groupCode : GroupCode s.carrier
+    ((s.product s).graph s (fun xy => xy.1 * xy.2))
+    (s.graph s (fun x => x⁻¹)) (s.encode 1) := by
+  refine ⟨(s.product s).graph_isFunc s _, s.graph_isFunc s _, s.encode_mem 1, ?_, ?_, ?_, ?_⟩
+  · intro x hx
+    obtain ⟨a, rfl⟩ := (s.mem_carrier x).1 hx
+    exact ((s.product s).pair_mem_graph s _ (1, a) a).2 (one_mul a)
+  · intro x hx
+    obtain ⟨a, rfl⟩ := (s.mem_carrier x).1 hx
+    exact ((s.product s).pair_mem_graph s _ (a, 1) a).2 (mul_one a)
+  · intro x hx y hy entry
+    obtain ⟨a, rfl⟩ := (s.mem_carrier x).1 hx
+    obtain ⟨b, rfl⟩ := (s.mem_carrier y).1 hy
+    have inverse := (s.pair_mem_graph s _ a b).1 entry
+    apply ((s.product s).pair_mem_graph s _ (b, a) 1).2
+    rw [← inverse, inv_mul_cancel]
+  · intro x hx y hy z hz a ha b hb c hc xy yz az
+    obtain ⟨x, rfl⟩ := (s.mem_carrier x).1 hx
+    obtain ⟨y, rfl⟩ := (s.mem_carrier y).1 hy
+    obtain ⟨z, rfl⟩ := (s.mem_carrier z).1 hz
+    obtain ⟨a, rfl⟩ := (s.mem_carrier a).1 ha
+    obtain ⟨b, rfl⟩ := (s.mem_carrier b).1 hb
+    obtain ⟨c, rfl⟩ := (s.mem_carrier c).1 hc
+    have first := ((s.product s).pair_mem_graph s _ (x, y) a).1 xy
+    have second := ((s.product s).pair_mem_graph s _ (y, z) b).1 yz
+    have third := ((s.product s).pair_mem_graph s _ (a, z) c).1 az
+    apply ((s.product s).pair_mem_graph s _ (x, b) c).2
+    rw [← second, ← mul_assoc, first, third]
+
+end PartitionPilot.SetRealization.Presentation
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/PresentedRowAssignmentGraphs.lean

@@ -1,70 +1,70 @@
-import OAI.SetTheory.PartitionPrinciple.Forcing.GroundRawRefinementStageWitnesses
-
-namespace OAI
-
-open scoped ZFSet
-
-section
-
-namespace PartitionPilot.Forcing
-open SetRealization
-universe u
-variable {G R : Type u} [Group G] [PartialOrder R]
-variable (a : PosetAction G R) (c : Presentation R) (t : Presentation G)
-variable (Q J B : ZFSet.{u})
-
-theorem presentedRowAssignmentGraph_entry (g : G) (r q : R) (A D : ZFSet.{u}) :
-    ZFSet.pair (ZFSet.pair (t.encode g) (ZFSet.pair (c.encode r) A)) (ZFSet.pair (c.encode q) D) ∈
-      rawRowAssignmentActionGraph t.carrier Q c.carrier (⋃₀ ⋃₀ Q) J (a.actionGraph c t) B ↔
-    ZFSet.pair (c.encode r) A ∈ Q ∧ ZFSet.pair (c.encode q) D ∈ Q ∧
-      a.iso g r = q ∧ D = relationImage A J (rawActionSection (t.encode g) B J) := by
-  rw [pair_mem_rawRowAssignmentActionGraph]
-  constructor
-  · rintro ⟨_, first, second, _, _, _, _, row, image⟩
-    exact ⟨first, second, (a.triple_mem_actionGraph c t g r q).1 row, image⟩
-  · rintro ⟨first, second, row, image⟩
-    exact ⟨t.encode_mem g, first, second, c.encode_mem r, pair_second_mem_doubleUnion first,
-      c.encode_mem q, pair_second_mem_doubleUnion second,
-      (a.triple_mem_actionGraph c t g r q).2 row, image⟩
-
-theorem presentedRowAssignmentGraph_bound :
-    rawRowAssignmentActionGraph t.carrier Q c.carrier (⋃₀ ⋃₀ Q) J (a.actionGraph c t) B ⊆
-      ZFSet.prod (ZFSet.prod t.carrier Q) Q := by
-  intro z hz
-  unfold rawRowAssignmentActionGraph rowAssignmentActionGraph at hz
-  exact (ZFSet.mem_sep.1 hz).1
-
-omit [PartialOrder R] in
-theorem exists_presentedRowAssignmentCoordinates
-    {Q V z : ZFSet.{u}} (shape : Q ⊆ ZFSet.prod c.carrier V) (member : z ∈ Q) :
-    ∃ r : R, ∃ A ∈ V, z = ZFSet.pair (c.encode r) A := by
-  obtain ⟨r, hr, A, hA, rfl⟩ := ZFSet.mem_prod.1 (shape member)
-  obtain ⟨r, rfl⟩ := (c.mem_carrier r).1 hr
-  exact ⟨r, A, hA, rfl⟩
-
-theorem presentedRowAssignmentGraph_function {V : ZFSet.{u}}
-    (shape : Q ⊆ ZFSet.prod c.carrier V)
-    (preserves : ∀ g : G, ∀ r : R, ∀ A,
-      ZFSet.pair (c.encode r) A ∈ Q →
-      ZFSet.pair (c.encode (a.iso g r)) (relationImage A J (rawActionSection (t.encode g) B J)) ∈ Q) :
-    ZFSet.IsFunc (ZFSet.prod t.carrier Q) Q
-      (rawRowAssignmentActionGraph t.carrier Q c.carrier (⋃₀ ⋃₀ Q) J (a.actionGraph c t) B) := by
-  refine ⟨presentedRowAssignmentGraph_bound a c t Q J B, ?_⟩
-  intro z hz
-  obtain ⟨g, hg, p, hp, rfl⟩ := ZFSet.mem_prod.1 hz
-  obtain ⟨g, rfl⟩ := (t.mem_carrier g).1 hg
-  obtain ⟨r, A, _, rfl⟩ := exists_presentedRowAssignmentCoordinates c shape hp
-  refine ⟨ZFSet.pair (c.encode (a.iso g r)) (relationImage A J (rawActionSection (t.encode g) B J)),
-    (presentedRowAssignmentGraph_entry a c t Q J B g r _ A _).2
-      ⟨hp, preserves g r A hp, rfl, rfl⟩, ?_⟩
-  intro y edge
-  have hy := (ZFSet.pair_mem_prod.1 (presentedRowAssignmentGraph_bound a c t Q J B edge)).2
-  obtain ⟨q, D, _, rfl⟩ := exists_presentedRowAssignmentCoordinates c shape hy
-  obtain ⟨_, _, row, rfl⟩ := (presentedRowAssignmentGraph_entry a c t Q J B g r q A D).1 edge
-  rw [row]
-
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Forcing.GroundRawRefinementStageWitnesses
+
+namespace OAI
+
+open scoped ZFSet
+
+section
+
+namespace PartitionPilot.Forcing
+open SetRealization
+universe u
+variable {G R : Type u} [Group G] [PartialOrder R]
+variable (a : PosetAction G R) (c : Presentation R) (t : Presentation G)
+variable (Q J B : ZFSet.{u})
+
+theorem presentedRowAssignmentGraph_entry (g : G) (r q : R) (A D : ZFSet.{u}) :
+    ZFSet.pair (ZFSet.pair (t.encode g) (ZFSet.pair (c.encode r) A)) (ZFSet.pair (c.encode q) D) ∈
+      rawRowAssignmentActionGraph t.carrier Q c.carrier (⋃₀ ⋃₀ Q) J (a.actionGraph c t) B ↔
+    ZFSet.pair (c.encode r) A ∈ Q ∧ ZFSet.pair (c.encode q) D ∈ Q ∧
+      a.iso g r = q ∧ D = relationImage A J (rawActionSection (t.encode g) B J) := by
+  rw [pair_mem_rawRowAssignmentActionGraph]
+  constructor
+  · rintro ⟨_, first, second, _, _, _, _, row, image⟩
+    exact ⟨first, second, (a.triple_mem_actionGraph c t g r q).1 row, image⟩
+  · rintro ⟨first, second, row, image⟩
+    exact ⟨t.encode_mem g, first, second, c.encode_mem r, pair_second_mem_doubleUnion first,
+      c.encode_mem q, pair_second_mem_doubleUnion second,
+      (a.triple_mem_actionGraph c t g r q).2 row, image⟩
+
+theorem presentedRowAssignmentGraph_bound :
+    rawRowAssignmentActionGraph t.carrier Q c.carrier (⋃₀ ⋃₀ Q) J (a.actionGraph c t) B ⊆
+      ZFSet.prod (ZFSet.prod t.carrier Q) Q := by
+  intro z hz
+  unfold rawRowAssignmentActionGraph rowAssignmentActionGraph at hz
+  exact (ZFSet.mem_sep.1 hz).1
+
+omit [PartialOrder R] in
+theorem exists_presentedRowAssignmentCoordinates
+    {Q V z : ZFSet.{u}} (shape : Q ⊆ ZFSet.prod c.carrier V) (member : z ∈ Q) :
+    ∃ r : R, ∃ A ∈ V, z = ZFSet.pair (c.encode r) A := by
+  obtain ⟨r, hr, A, hA, rfl⟩ := ZFSet.mem_prod.1 (shape member)
+  obtain ⟨r, rfl⟩ := (c.mem_carrier r).1 hr
+  exact ⟨r, A, hA, rfl⟩
+
+theorem presentedRowAssignmentGraph_function {V : ZFSet.{u}}
+    (shape : Q ⊆ ZFSet.prod c.carrier V)
+    (preserves : ∀ g : G, ∀ r : R, ∀ A,
+      ZFSet.pair (c.encode r) A ∈ Q →
+      ZFSet.pair (c.encode (a.iso g r)) (relationImage A J (rawActionSection (t.encode g) B J)) ∈ Q) :
+    ZFSet.IsFunc (ZFSet.prod t.carrier Q) Q
+      (rawRowAssignmentActionGraph t.carrier Q c.carrier (⋃₀ ⋃₀ Q) J (a.actionGraph c t) B) := by
+  refine ⟨presentedRowAssignmentGraph_bound a c t Q J B, ?_⟩
+  intro z hz
+  obtain ⟨g, hg, p, hp, rfl⟩ := ZFSet.mem_prod.1 hz
+  obtain ⟨g, rfl⟩ := (t.mem_carrier g).1 hg
+  obtain ⟨r, A, _, rfl⟩ := exists_presentedRowAssignmentCoordinates c shape hp
+  refine ⟨ZFSet.pair (c.encode (a.iso g r)) (relationImage A J (rawActionSection (t.encode g) B J)),
+    (presentedRowAssignmentGraph_entry a c t Q J B g r _ A _).2
+      ⟨hp, preserves g r A hp, rfl, rfl⟩, ?_⟩
+  intro y edge
+  have hy := (ZFSet.pair_mem_prod.1 (presentedRowAssignmentGraph_bound a c t Q J B edge)).2
+  obtain ⟨q, D, _, rfl⟩ := exists_presentedRowAssignmentCoordinates c shape hy
+  obtain ⟨_, _, row, rfl⟩ := (presentedRowAssignmentGraph_entry a c t Q J B g r q A D).1 edge
+  rw [row]
+
+end PartitionPilot.Forcing
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/PreservedMainPrefixHistoryFormulas.lean

@@ -1,428 +1,428 @@
-import OAI.SetTheory.PartitionPrinciple.Forcing.MainPrefixConditionalStepCodes
-import OAI.SetTheory.PartitionPrinciple.Transfinite.PreservedMainPrefixHistoryValues
-
-namespace OAI
-
-namespace PartitionPilot.Forcing
-
-namespace BoundedFormula
-open SetFormula
-universe u
-
-def nonzeroLimitOrdinalFormula {n} (T : Fin n) : BoundedFormula n :=
-  .conj (.neg (emptyFormula T)) (.allMem T (exMem T.succ (.mem 1 0)))
-
-theorem truth_nonzeroLimitOrdinalFormula {n} (T : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (nonzeroLimitOrdinalFormula T) env ↔ NonzeroLimitOrdinalCode (env T) := by
-  simp only [nonzeroLimitOrdinalFormula, Truth, truth_emptyFormula, truth_exMem]
-  rfl
-
-theorem realize_nonzeroLimitOrdinalFormula (M : TransitiveGround.{u}) {n}
-    (T : Fin n) (env : Fin n → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets) :
-    Realize M.sets (nonzeroLimitOrdinalFormula T).toFormula env ↔
-      NonzeroLimitOrdinalCode (env T) :=
-  (realize_toFormula M _ env members).trans (truth_nonzeroLimitOrdinalFormula T env)
-
-end BoundedFormula
-
-open SetFormula
-universe u
-
-namespace BoundedFormula
-def mainPrefixFieldExtensionFormula {n} (T S E T' S' E' : Fin n) : BoundedFormula n :=
-  .conj (subsetFormula T T') (.conj (subsetFormula S S') (subsetFormula E E'))
-
-theorem truth_mainPrefixFieldExtensionFormula {n} (T S E T' S' E' : Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (mainPrefixFieldExtensionFormula T S E T' S' E') env ↔
-      env T ⊆ env T' ∧ env S ⊆ env S' ∧ env E ⊆ env E' := by
-  simp only [mainPrefixFieldExtensionFormula, Truth, truth_subsetFormula]
-
-end BoundedFormula
-
-namespace SetFormula
-def mainPrefixExtensionFormula {n} (old next : Fin n) : SetFormula n :=
-  let outer := suffixIndex n 6
-  let field := prefixIndex n 6
-  exBlock 6 (.conj
-    (BoundedFormula.mainPrefixTupleFormula (outer old) (field 0) (field 1) (field 2)).toFormula
-    (.conj (BoundedFormula.mainPrefixTupleFormula (outer next) (field 3) (field 4) (field 5)).toFormula
-      (BoundedFormula.mainPrefixFieldExtensionFormula
-        (field 0) (field 1) (field 2) (field 3) (field 4) (field 5)).toFormula))
-
-end SetFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-
-theorem realize_mainPrefixExtensionFormula {n} (old next : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets) :
-    Realize M.sets (mainPrefixExtensionFormula old next) env ↔
-      MainPrefixExtends (env old) (env next) := by
-  rw [mainPrefixExtensionFormula, realize_exBlock]
-  let outer := suffixIndex n 6
-  let field := prefixIndex n 6
-  have actual (f : Fin 6 → ZFSet.{u}) (ground : ∀ j, f j ∈ M.sets) :
-      (Realize M.sets (BoundedFormula.mainPrefixTupleFormula (outer old) (field 0) (field 1) (field 2)).toFormula
-        (extendMany 6 f env) ∧
-      Realize M.sets (BoundedFormula.mainPrefixTupleFormula (outer next) (field 3) (field 4) (field 5)).toFormula
-        (extendMany 6 f env) ∧
-      Realize M.sets (BoundedFormula.mainPrefixFieldExtensionFormula
-        (field 0) (field 1) (field 2) (field 3) (field 4) (field 5)).toFormula (extendMany 6 f env)) ↔
-      env old = mainPrefixCode (f 0) (f 1) (f 2) ∧
-        env next = mainPrefixCode (f 3) (f 4) (f 5) ∧ f 0 ⊆ f 3 ∧ f 1 ⊆ f 4 ∧ f 2 ⊆ f 5 := by
-    have mems := extendMany_members 6 f env ground members
-    rw [BoundedFormula.realize_mainPrefixTupleFormula M _ _ _ _ _ mems,
-      BoundedFormula.realize_mainPrefixTupleFormula M _ _ _ _ _ mems,
-      BoundedFormula.realize_toFormula M _ _ mems, BoundedFormula.truth_mainPrefixFieldExtensionFormula]
-    simp only [outer, field, extendMany_prefix, extendMany_suffix]
-  constructor
-  · rintro ⟨f, ground, clauses⟩
-    have result := (actual f ground).1 clauses
-    exact ⟨f 0, f 1, f 2, f 3, f 4, f 5, result⟩
-  · rintro ⟨T, S, E, U, F, G, first, second, indices, stages, transitions⟩
-    have left := M.mainPrefixCode_fields_mem (first ▸ members old)
-    have right := M.mainPrefixCode_fields_mem (second ▸ members next)
-    let f : Fin 6 → ZFSet.{u} := Fin.cases T (Fin.cases S (Fin.cases E
-      (Fin.cases U (Fin.cases F (fun _ => G)))))
-    have ground : ∀ j, f j ∈ M.sets := Fin.cases left.1 (Fin.cases left.2.1
-      (Fin.cases left.2.2 (Fin.cases right.1 (Fin.cases right.2.1 (fun _ => right.2.2)))))
-    exact ⟨f, ground, (actual f ground).2 ⟨first, second, indices, stages, transitions⟩⟩
-
-end TransitiveGround
-
-namespace SetFormula
-
-def mainPrefixLimitStepRawFormula {n} (K Labels C D rD N old next : Fin n)
-    (w : Fin 32 → Fin n) : SetFormula n :=
-  let v := mainPrefixLimitTargetFields w
-  .conj (BoundedFormula.successorFormula (w 7) (w 0)).toFormula
-  (.conj (BoundedFormula.mainPrefixTupleFormula old (w 0) (w 1) (w 2)).toFormula
-  (.conj (BoundedFormula.mainPrefixTupleFormula next (w 7) (w 3) (w 4)).toFormula
-  (.conj (mainPrefixExtensionFormula old next)
-  (.conj (BoundedFormula.pairMembershipFormula (w 0) (w 5) (w 3)).toFormula
-  (.conj (linkedMainStageRawFormula K Labels C D rD N (w 5) v)
-  (.conj (BoundedFormula.pairMembershipFormula (v 11) (w 6) (v 17)).toFormula
-    (BoundedFormula.mainLimitCoverageFormula (w 0) (w 1) (w 4)
-      (v 0) (v 3) (v 1) (v 9) (v 11) (w 6)).toFormula))))))
-
-def mainPrefixLimitStepFormula {n} (K Labels C D rD N old next : Fin n) : SetFormula n :=
-  let outer := suffixIndex n 32
-  exBlock 32 (mainPrefixLimitStepRawFormula (outer K) (outer Labels) (outer C)
-    (outer D) (outer rD) (outer N) (outer old) (outer next) (prefixIndex n 32))
-
-end SetFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-
-theorem realize_mainPrefixLimitStepRawFormula
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    (collection : CollectionSchema M.sets) {n} (K Labels C D rD N old next : Fin n)
-    (w : Fin 32 → Fin n) (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
-    (omega : env N = ZFSet.omega) (ordinal : ordinalSetProperty (env K)) :
-    Realize M.sets (mainPrefixLimitStepRawFormula K Labels C D rD N old next w) env ↔
-      MainPrefixLimitStepRawCode M (env K) (env Labels) (env C) (env D) (env rD) (env N)
-        (env old) (env next) (fun j => env (w j)) := by
-  have linked := M.realize_linkedMainStageRawFormula pairing unions powers separation collection
-    K Labels C D rD N (w 5) (mainPrefixLimitTargetFields w) env members omega ordinal
-  have extension := M.realize_mainPrefixExtensionFormula old next env members
-  simp only [mainPrefixLimitStepRawFormula, Realize, BoundedFormula.realize_toFormula M _ env members,
-    BoundedFormula.truth_successorFormula, BoundedFormula.truth_mainPrefixTupleFormula,
-    extension, BoundedFormula.truth_pairMembershipFormula, linked,
-    BoundedFormula.truth_mainLimitCoverageFormula]
-  rfl
-
-theorem realize_mainPrefixLimitStepFormula
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    (collection : CollectionSchema M.sets) {n} (K Labels C D rD N old next : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
-    (omega : env N = ZFSet.omega) (ordinal : ordinalSetProperty (env K)) :
-    Realize M.sets (mainPrefixLimitStepFormula K Labels C D rD N old next) env ↔
-      MainPrefixLimitStepCode M (env K) (env Labels) (env C) (env D) (env rD) (env N)
-        (env old) (env next) := by
-  rw [mainPrefixLimitStepFormula, realize_exBlock]
-  have actual (w : Fin 32 → ZFSet.{u}) (ground : ∀ j, w j ∈ M.sets) :=
-    M.realize_mainPrefixLimitStepRawFormula pairing unions powers separation collection
-      (suffixIndex n 32 K) (suffixIndex n 32 Labels) (suffixIndex n 32 C) (suffixIndex n 32 D)
-      (suffixIndex n 32 rD) (suffixIndex n 32 N) (suffixIndex n 32 old) (suffixIndex n 32 next)
-      (prefixIndex n 32) (extendMany 32 w env) (extendMany_members 32 w env ground members)
-      (by simpa only [extendMany_suffix] using omega)
-      (by simpa only [extendMany_suffix] using ordinal)
-  simp only [extendMany_prefix, extendMany_suffix] at actual
-  exact ⟨fun ⟨w, ground, recognized⟩ => ⟨w, ground, (actual w ground).1 recognized⟩,
-    fun ⟨w, ground, raw⟩ => ⟨w, ground, (actual w ground).2 raw⟩⟩
-
-end TransitiveGround
-
-namespace BoundedFormula
-def mainPrefixSelectedStepBody {n} (f old next : Fin n) (v : Fin 10 → Fin n) : BoundedFormula n :=
-  .conj (successorFormula (v 8) (v 0))
-  (.conj (successorFormula (v 9) (v 8))
-  (.conj (mainPrefixTupleFormula old (v 8) (v 1) (v 2))
-  (.conj (mainPrefixTupleFormula next (v 9) (v 3) (v 4))
-  (.conj (mainPrefixFieldExtensionFormula (v 8) (v 1) (v 2) (v 9) (v 3) (v 4))
-  (.conj (pairMembershipFormula (v 0) (v 5) (v 1))
-  (.conj (rightTripleMembershipFormula (v 5) (v 6) (v 7) f)
-  (.conj (pairMembershipFormula (v 8) (v 6) (v 3))
-    (tripleMembershipFormula (v 8) (v 0) (v 7) (v 4)))))))))
-
-theorem truth_mainPrefixSelectedStepBody {n} (f old next : Fin n) (v : Fin 10 → Fin n)
-    (env : Fin n → ZFSet.{u}) :
-    Truth (mainPrefixSelectedStepBody f old next v) env ↔
-      env (v 8) = insert (env (v 0)) (env (v 0)) ∧
-      env (v 9) = insert (env (v 8)) (env (v 8)) ∧
-      env old = mainPrefixCode (env (v 8)) (env (v 1)) (env (v 2)) ∧
-      env next = mainPrefixCode (env (v 9)) (env (v 3)) (env (v 4)) ∧
-      (env (v 8) ⊆ env (v 9) ∧ env (v 1) ⊆ env (v 3) ∧ env (v 2) ⊆ env (v 4)) ∧
-      ZFSet.pair (env (v 0)) (env (v 5)) ∈ env (v 1) ∧
-      ZFSet.pair (env (v 5)) (ZFSet.pair (env (v 6)) (env (v 7))) ∈ env f ∧
-      ZFSet.pair (env (v 8)) (env (v 6)) ∈ env (v 3) ∧
-      ZFSet.pair (ZFSet.pair (env (v 8)) (env (v 0))) (env (v 7)) ∈ env (v 4) := by
-  simp only [mainPrefixSelectedStepBody, Truth, truth_successorFormula,
-    truth_mainPrefixTupleFormula, truth_mainPrefixFieldExtensionFormula,
-    truth_pairMembershipFormula, truth_rightTripleMembershipFormula, truth_tripleMembershipFormula]
-
-end BoundedFormula
-
-namespace SetFormula
-def mainPrefixSelectedStepFormula {n} (f old next : Fin n) : SetFormula n :=
-  exBlock 10 (BoundedFormula.mainPrefixSelectedStepBody
-    (suffixIndex n 10 f) (suffixIndex n 10 old) (suffixIndex n 10 next)
-    (prefixIndex n 10)).toFormula
-
-end SetFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-
-theorem realize_mainPrefixSelectedStepFormula {n} (f old next : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets) :
-    Realize M.sets (mainPrefixSelectedStepFormula f old next) env ↔
-      MainPrefixSelectedStepCode (env f) (env old) (env next) := by
-  rw [mainPrefixSelectedStepFormula, realize_exBlock]
-  have actual (v : Fin 10 → ZFSet.{u}) (ground : ∀ j, v j ∈ M.sets) :=
-    (BoundedFormula.realize_toFormula M _ (extendMany 10 v env)
-      (extendMany_members 10 v env ground members)).trans
-      (BoundedFormula.truth_mainPrefixSelectedStepBody
-        (suffixIndex n 10 f) (suffixIndex n 10 old) (suffixIndex n 10 next)
-        (prefixIndex n 10) (extendMany 10 v env))
-  simp only [extendMany_prefix, extendMany_suffix] at actual
-  constructor
-  · rintro ⟨v, ground, recognized⟩
-    obtain ⟨first, second, oldCode, nextCode, extension, source, selected, target, crossing⟩ :=
-      (actual v ground).1 recognized
-    refine ⟨v 0, v 1, v 2, v 3, v 4, v 5, v 6, v 7, ?_, ?_, ?_, source, selected, ?_, ?_⟩
-    · simpa only [first] using oldCode
-    · simpa only [second, first] using nextCode
-    · rw [oldCode, nextCode]
-      exact mainPrefixExtends_iff.2 extension
-    · simpa only [first] using target
-    · simpa only [first] using crossing
-  · rintro ⟨b, S, E, S', E', a, target, z, oldCode, nextCode,
-      extension, source, selected, targetEntry, crossing⟩
-    have left := M.mainPrefixCode_fields_mem (oldCode ▸ members old)
-    have right := M.mainPrefixCode_fields_mem (nextCode ▸ members next)
-    have sourceGround := M.transitive left.2.1 source
-    have selectedGround := M.transitive (members f) selected
-    let v : Fin 10 → ZFSet.{u} := Fin.cases b (Fin.cases S (Fin.cases E
-      (Fin.cases S' (Fin.cases E' (Fin.cases a (Fin.cases target (Fin.cases z
-        (Fin.cases (insert b b) (fun _ => insert (insert b b) (insert b b))))))))))
-    have ground : ∀ j, v j ∈ M.sets := Fin.cases (M.pair_left sourceGround)
-      (Fin.cases left.2.1 (Fin.cases left.2.2 (Fin.cases right.2.1 (Fin.cases right.2.2
-      (Fin.cases (M.pair_right sourceGround) (Fin.cases (M.pair_left (M.pair_right selectedGround))
-      (Fin.cases (M.pair_right (M.pair_right selectedGround)) (Fin.cases left.1 (fun _ => right.1)))))))))
-    rw [oldCode, nextCode] at extension
-    exact ⟨v, ground, (actual v ground).2 ⟨rfl, rfl, oldCode, nextCode,
-      mainPrefixExtends_iff.1 extension, source, selected, targetEntry, crossing⟩⟩
-
-end TransitiveGround
-
-namespace SetFormula
-def mainPrefixConditionalStepFormula {n} (K Labels C D rD N f old next : Fin n) : SetFormula n :=
-  let outer := suffixIndex n 3
-  let field := prefixIndex n 3
-  disj (mainPrefixSelectedStepFormula f old next)
-    (exBlock 3 (.conj
-      (BoundedFormula.mainPrefixTupleFormula (outer old) (field 0) (field 1) (field 2)).toFormula
-      (.conj (BoundedFormula.nonzeroLimitOrdinalFormula (field 0)).toFormula
-        (mainPrefixLimitStepFormula (outer K) (outer Labels) (outer C) (outer D)
-          (outer rD) (outer N) (outer old) (outer next)))))
-
-end SetFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-
-theorem realize_mainPrefixConditionalStepFormula
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    (collection : CollectionSchema M.sets) {n}
-    (K Labels C D rD N f old next : Fin n) (env : Fin n → ZFSet.{u})
-    (members : ∀ j, env j ∈ M.sets) (omega : env N = ZFSet.omega)
-    (ordinal : ordinalSetProperty (env K)) :
-    Realize M.sets (mainPrefixConditionalStepFormula K Labels C D rD N f old next) env ↔
-      MainPrefixConditionalStepCode M (env K) (env Labels) (env C) (env D) (env rD)
-        (env N) (env f) (env old) (env next) := by
-  rw [mainPrefixConditionalStepFormula, realize_disj,
-    M.realize_mainPrefixSelectedStepFormula f old next env members, realize_exBlock]
-  apply or_congr Iff.rfl
-  let outer := suffixIndex n 3
-  let field := prefixIndex n 3
-  have actual (w : Fin 3 → ZFSet.{u}) (ground : ∀ j, w j ∈ M.sets) :
-      Realize M.sets (.conj
-        (BoundedFormula.mainPrefixTupleFormula (outer old) (field 0) (field 1) (field 2)).toFormula
-        (.conj (BoundedFormula.nonzeroLimitOrdinalFormula (field 0)).toFormula
-          (mainPrefixLimitStepFormula (outer K) (outer Labels) (outer C) (outer D)
-            (outer rD) (outer N) (outer old) (outer next)))) (extendMany 3 w env) ↔
-      env old = mainPrefixCode (w 0) (w 1) (w 2) ∧ NonzeroLimitOrdinalCode (w 0) ∧
-        MainPrefixLimitStepCode M (env K) (env Labels) (env C) (env D) (env rD) (env N)
-          (env old) (env next) := by
-    have mems := extendMany_members 3 w env ground members
-    change (Realize M.sets _ _ ∧ Realize M.sets _ _ ∧ Realize M.sets _ _) ↔ _
-    rw [BoundedFormula.realize_mainPrefixTupleFormula M _ _ _ _ _ mems,
-      BoundedFormula.realize_nonzeroLimitOrdinalFormula M _ _ mems,
-      M.realize_mainPrefixLimitStepFormula pairing unions powers separation collection
-        _ _ _ _ _ _ _ _ _ mems (by simpa only [outer, extendMany_suffix] using omega)
-          (by simpa only [outer, extendMany_suffix] using ordinal)]
-    simp only [outer, field, extendMany_suffix, extendMany_prefix]
-  constructor
-  · rintro ⟨w, ground, recognized⟩
-    exact ⟨w 0, w 1, w 2, (actual w ground).1 recognized⟩
-  · rintro ⟨T, S, E, oldCode, nonzero, code⟩
-    have fields := M.mainPrefixCode_fields_mem (oldCode ▸ members old)
-    let w : Fin 3 → ZFSet.{u} := Fin.cases T (Fin.cases S (fun _ => E))
-    have ground : ∀ j, w j ∈ M.sets := Fin.cases fields.1 (Fin.cases fields.2.1 (fun _ => fields.2.2))
-    exact ⟨w, ground, (actual w ground).2 ⟨oldCode, nonzero, code⟩⟩
-
-end TransitiveGround
-
-namespace SetFormula
-def preservedMainPrefixHistoryValuesFormula {n} (K Labels C D rD N p : Fin n) : SetFormula n :=
-  let old := suffixIndex n 2
-  let field := prefixIndex n 2
-  allBlock 2 (imp (BoundedFormula.pairMembershipFormula (field 0) (field 1) (old p)).toFormula
-    (preservedMainPrefixHistoryValueFormula (old K) (old Labels) (old C) (old D) (old rD) (old N)
-      (field 0) (field 1)))
-
-def preservedMainPrefixHistoryCompatibilityFormula {n} (p : Fin n) : SetFormula n :=
-  let old := suffixIndex n 4
-  let field := prefixIndex n 4
-  allBlock 4 (imp (BoundedFormula.conj
-    (BoundedFormula.pairMembershipFormula (field 0) (field 2) (old p))
-    (.conj (BoundedFormula.pairMembershipFormula (field 1) (field 3) (old p))
-      (BoundedFormula.disj (.equal (field 0) (field 1)) (.mem (field 0) (field 1))))).toFormula
-    (mainPrefixExtensionFormula (field 2) (field 3)))
-
-def preservedMainPrefixHistoryFormula {n} (K Labels C D rD N A p : Fin n) : SetFormula n :=
-  .conj (functionGraphOnFormula A p)
-    (.conj (preservedMainPrefixHistoryValuesFormula K Labels C D rD N p)
-      (preservedMainPrefixHistoryCompatibilityFormula p))
-
-end SetFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-
-theorem realize_preservedMainPrefixHistoryValuesFormula
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    (collection : CollectionSchema M.sets) {n} (K Labels C D rD N p : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
-    (omega : env N = ZFSet.omega) (ordinal : ordinalSetProperty (env K)) :
-    Realize M.sets (preservedMainPrefixHistoryValuesFormula K Labels C D rD N p) env ↔
-      ∀ i q, ZFSet.pair i q ∈ env p →
-        ∃ S E, q = mainPrefixCode (insert i i) S E ∧
-          MainPrefixGraphCode M (env K) (env Labels) (env C) (env D) (env rD) (insert i i) S E ∧
-          MainPrefixProfileGraphCode M (env K) (env Labels) (env C) (env D) (env rD) S E := by
-  rw [preservedMainPrefixHistoryValuesFormula, realize_allBlock]
-  have actual (f : Fin 2 → ZFSet.{u}) (ground : ∀ j, f j ∈ M.sets) :
-      Realize M.sets
-        (imp (BoundedFormula.pairMembershipFormula (prefixIndex n 2 0) (prefixIndex n 2 1)
-          (suffixIndex n 2 p)).toFormula
-          (preservedMainPrefixHistoryValueFormula (suffixIndex n 2 K) (suffixIndex n 2 Labels)
-            (suffixIndex n 2 C) (suffixIndex n 2 D) (suffixIndex n 2 rD) (suffixIndex n 2 N)
-            (prefixIndex n 2 0) (prefixIndex n 2 1))) (extendMany 2 f env) ↔
-        (ZFSet.pair (f 0) (f 1) ∈ env p →
-          ∃ S E, f 1 = mainPrefixCode (insert (f 0) (f 0)) S E ∧
-            MainPrefixGraphCode M (env K) (env Labels) (env C) (env D) (env rD)
-              (insert (f 0) (f 0)) S E ∧
-            MainPrefixProfileGraphCode M (env K) (env Labels) (env C) (env D) (env rD) S E) := by
-    have mems := extendMany_members 2 f env ground members
-    rw [realize_imp, BoundedFormula.realize_toFormula M _ _ mems,
-      BoundedFormula.truth_pairMembershipFormula]
-    rw [M.realize_preservedMainPrefixHistoryValueFormula pairing unions powers separation collection
-      _ _ _ _ _ _ _ _ _ mems
-      (by simpa only [extendMany_suffix] using omega)
-      (by simpa only [extendMany_suffix] using ordinal)]
-    simp only [extendMany_prefix, extendMany_suffix]
-  constructor
-  · intro recognized i q entry
-    have ground := M.transitive (members p) entry
-    let f : Fin 2 → ZFSet.{u} := Fin.cases i (fun _ => q)
-    have grounds : ∀ j, f j ∈ M.sets := Fin.cases (M.pair_left ground) (fun _ => M.pair_right ground)
-    exact (actual f grounds).1 (recognized f grounds) entry
-  · intro law f ground
-    exact (actual f ground).2 (law (f 0) (f 1))
-
-theorem realize_preservedMainPrefixHistoryCompatibilityFormula {n} (p : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets) :
-    Realize M.sets (preservedMainPrefixHistoryCompatibilityFormula p) env ↔
-      ∀ i j q r, ZFSet.pair i q ∈ env p → ZFSet.pair j r ∈ env p →
-        (i = j ∨ i ∈ j) → MainPrefixExtends q r := by
-  rw [preservedMainPrefixHistoryCompatibilityFormula, realize_allBlock]
-  have actual (f : Fin 4 → ZFSet.{u}) (ground : ∀ j, f j ∈ M.sets) :
-      Realize M.sets (imp (BoundedFormula.conj
-        (BoundedFormula.pairMembershipFormula (prefixIndex n 4 0) (prefixIndex n 4 2) (suffixIndex n 4 p))
-        (.conj (BoundedFormula.pairMembershipFormula (prefixIndex n 4 1) (prefixIndex n 4 3) (suffixIndex n 4 p))
-          (BoundedFormula.disj (.equal (prefixIndex n 4 0) (prefixIndex n 4 1))
-            (.mem (prefixIndex n 4 0) (prefixIndex n 4 1))))).toFormula
-        (mainPrefixExtensionFormula (prefixIndex n 4 2) (prefixIndex n 4 3))) (extendMany 4 f env) ↔
-      ((ZFSet.pair (f 0) (f 2) ∈ env p ∧ ZFSet.pair (f 1) (f 3) ∈ env p ∧
-        (f 0 = f 1 ∨ f 0 ∈ f 1)) → MainPrefixExtends (f 2) (f 3)) := by
-    have mems := extendMany_members 4 f env ground members
-    rw [realize_imp, BoundedFormula.realize_toFormula M _ _ mems]
-    simp only [BoundedFormula.Truth, BoundedFormula.truth_pairMembershipFormula, BoundedFormula.truth_disj]
-    rw [M.realize_mainPrefixExtensionFormula _ _ _ mems]
-    simp only [extendMany_prefix, extendMany_suffix]
-  constructor
-  · intro recognized i j q r first second before
-    have hfirst := M.transitive (members p) first
-    have hsecond := M.transitive (members p) second
-    let f : Fin 4 → ZFSet.{u} := Fin.cases i (Fin.cases j (Fin.cases q (fun _ => r)))
-    have grounds : ∀ k, f k ∈ M.sets := Fin.cases (M.pair_left hfirst)
-      (Fin.cases (M.pair_left hsecond) (Fin.cases (M.pair_right hfirst) (fun _ => M.pair_right hsecond)))
-    exact (actual f grounds).1 (recognized f grounds) ⟨first, second, before⟩
-  · intro law f ground
-    exact (actual f ground).2 (fun entries => law (f 0) (f 1) (f 2) (f 3) entries.1 entries.2.1 entries.2.2)
-
-theorem realize_preservedMainPrefixHistoryFormula
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    (collection : CollectionSchema M.sets) {n} (K Labels C D rD N A p : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
-    (omega : env N = ZFSet.omega) (ordinal : ordinalSetProperty (env K)) :
-    Realize M.sets (preservedMainPrefixHistoryFormula K Labels C D rD N A p) env ↔
-      PreservedMainPrefixHistoryCode M (env K) (env Labels) (env C) (env D) (env rD) (env A) (env p) := by
-  change (Realize M.sets (functionGraphOnFormula A p) env ∧
-    Realize M.sets (preservedMainPrefixHistoryValuesFormula K Labels C D rD N p) env ∧
-    Realize M.sets (preservedMainPrefixHistoryCompatibilityFormula p) env) ↔ _
-  rw [M.realize_functionGraphOnFormula unions A p env members,
-    M.realize_preservedMainPrefixHistoryValuesFormula pairing unions powers separation collection
-      K Labels C D rD N p env members omega ordinal,
-    M.realize_preservedMainPrefixHistoryCompatibilityFormula p env members]
-  exact ⟨fun h => ⟨h.1, h.2.1, h.2.2⟩, fun h => ⟨h.function, h.values, h.compatible⟩⟩
-
-end TransitiveGround
-
-end PartitionPilot.Forcing
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Forcing.MainPrefixConditionalStepCodes
+import OAI.SetTheory.PartitionPrinciple.Transfinite.PreservedMainPrefixHistoryValues
+
+namespace OAI
+
+namespace PartitionPilot.Forcing
+
+namespace BoundedFormula
+open SetFormula
+universe u
+
+def nonzeroLimitOrdinalFormula {n} (T : Fin n) : BoundedFormula n :=
+  .conj (.neg (emptyFormula T)) (.allMem T (exMem T.succ (.mem 1 0)))
+
+theorem truth_nonzeroLimitOrdinalFormula {n} (T : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (nonzeroLimitOrdinalFormula T) env ↔ NonzeroLimitOrdinalCode (env T) := by
+  simp only [nonzeroLimitOrdinalFormula, Truth, truth_emptyFormula, truth_exMem]
+  rfl
+
+theorem realize_nonzeroLimitOrdinalFormula (M : TransitiveGround.{u}) {n}
+    (T : Fin n) (env : Fin n → ZFSet.{u}) (members : ∀ i, env i ∈ M.sets) :
+    Realize M.sets (nonzeroLimitOrdinalFormula T).toFormula env ↔
+      NonzeroLimitOrdinalCode (env T) :=
+  (realize_toFormula M _ env members).trans (truth_nonzeroLimitOrdinalFormula T env)
+
+end BoundedFormula
+
+open SetFormula
+universe u
+
+namespace BoundedFormula
+def mainPrefixFieldExtensionFormula {n} (T S E T' S' E' : Fin n) : BoundedFormula n :=
+  .conj (subsetFormula T T') (.conj (subsetFormula S S') (subsetFormula E E'))
+
+theorem truth_mainPrefixFieldExtensionFormula {n} (T S E T' S' E' : Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (mainPrefixFieldExtensionFormula T S E T' S' E') env ↔
+      env T ⊆ env T' ∧ env S ⊆ env S' ∧ env E ⊆ env E' := by
+  simp only [mainPrefixFieldExtensionFormula, Truth, truth_subsetFormula]
+
+end BoundedFormula
+
+namespace SetFormula
+def mainPrefixExtensionFormula {n} (old next : Fin n) : SetFormula n :=
+  let outer := suffixIndex n 6
+  let field := prefixIndex n 6
+  exBlock 6 (.conj
+    (BoundedFormula.mainPrefixTupleFormula (outer old) (field 0) (field 1) (field 2)).toFormula
+    (.conj (BoundedFormula.mainPrefixTupleFormula (outer next) (field 3) (field 4) (field 5)).toFormula
+      (BoundedFormula.mainPrefixFieldExtensionFormula
+        (field 0) (field 1) (field 2) (field 3) (field 4) (field 5)).toFormula))
+
+end SetFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+
+theorem realize_mainPrefixExtensionFormula {n} (old next : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets) :
+    Realize M.sets (mainPrefixExtensionFormula old next) env ↔
+      MainPrefixExtends (env old) (env next) := by
+  rw [mainPrefixExtensionFormula, realize_exBlock]
+  let outer := suffixIndex n 6
+  let field := prefixIndex n 6
+  have actual (f : Fin 6 → ZFSet.{u}) (ground : ∀ j, f j ∈ M.sets) :
+      (Realize M.sets (BoundedFormula.mainPrefixTupleFormula (outer old) (field 0) (field 1) (field 2)).toFormula
+        (extendMany 6 f env) ∧
+      Realize M.sets (BoundedFormula.mainPrefixTupleFormula (outer next) (field 3) (field 4) (field 5)).toFormula
+        (extendMany 6 f env) ∧
+      Realize M.sets (BoundedFormula.mainPrefixFieldExtensionFormula
+        (field 0) (field 1) (field 2) (field 3) (field 4) (field 5)).toFormula (extendMany 6 f env)) ↔
+      env old = mainPrefixCode (f 0) (f 1) (f 2) ∧
+        env next = mainPrefixCode (f 3) (f 4) (f 5) ∧ f 0 ⊆ f 3 ∧ f 1 ⊆ f 4 ∧ f 2 ⊆ f 5 := by
+    have mems := extendMany_members 6 f env ground members
+    rw [BoundedFormula.realize_mainPrefixTupleFormula M _ _ _ _ _ mems,
+      BoundedFormula.realize_mainPrefixTupleFormula M _ _ _ _ _ mems,
+      BoundedFormula.realize_toFormula M _ _ mems, BoundedFormula.truth_mainPrefixFieldExtensionFormula]
+    simp only [outer, field, extendMany_prefix, extendMany_suffix]
+  constructor
+  · rintro ⟨f, ground, clauses⟩
+    have result := (actual f ground).1 clauses
+    exact ⟨f 0, f 1, f 2, f 3, f 4, f 5, result⟩
+  · rintro ⟨T, S, E, U, F, G, first, second, indices, stages, transitions⟩
+    have left := M.mainPrefixCode_fields_mem (first ▸ members old)
+    have right := M.mainPrefixCode_fields_mem (second ▸ members next)
+    let f : Fin 6 → ZFSet.{u} := Fin.cases T (Fin.cases S (Fin.cases E
+      (Fin.cases U (Fin.cases F (fun _ => G)))))
+    have ground : ∀ j, f j ∈ M.sets := Fin.cases left.1 (Fin.cases left.2.1
+      (Fin.cases left.2.2 (Fin.cases right.1 (Fin.cases right.2.1 (fun _ => right.2.2)))))
+    exact ⟨f, ground, (actual f ground).2 ⟨first, second, indices, stages, transitions⟩⟩
+
+end TransitiveGround
+
+namespace SetFormula
+
+def mainPrefixLimitStepRawFormula {n} (K Labels C D rD N old next : Fin n)
+    (w : Fin 32 → Fin n) : SetFormula n :=
+  let v := mainPrefixLimitTargetFields w
+  .conj (BoundedFormula.successorFormula (w 7) (w 0)).toFormula
+  (.conj (BoundedFormula.mainPrefixTupleFormula old (w 0) (w 1) (w 2)).toFormula
+  (.conj (BoundedFormula.mainPrefixTupleFormula next (w 7) (w 3) (w 4)).toFormula
+  (.conj (mainPrefixExtensionFormula old next)
+  (.conj (BoundedFormula.pairMembershipFormula (w 0) (w 5) (w 3)).toFormula
+  (.conj (linkedMainStageRawFormula K Labels C D rD N (w 5) v)
+  (.conj (BoundedFormula.pairMembershipFormula (v 11) (w 6) (v 17)).toFormula
+    (BoundedFormula.mainLimitCoverageFormula (w 0) (w 1) (w 4)
+      (v 0) (v 3) (v 1) (v 9) (v 11) (w 6)).toFormula))))))
+
+def mainPrefixLimitStepFormula {n} (K Labels C D rD N old next : Fin n) : SetFormula n :=
+  let outer := suffixIndex n 32
+  exBlock 32 (mainPrefixLimitStepRawFormula (outer K) (outer Labels) (outer C)
+    (outer D) (outer rD) (outer N) (outer old) (outer next) (prefixIndex n 32))
+
+end SetFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+
+theorem realize_mainPrefixLimitStepRawFormula
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    (collection : CollectionSchema M.sets) {n} (K Labels C D rD N old next : Fin n)
+    (w : Fin 32 → Fin n) (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
+    (omega : env N = ZFSet.omega) (ordinal : ordinalSetProperty (env K)) :
+    Realize M.sets (mainPrefixLimitStepRawFormula K Labels C D rD N old next w) env ↔
+      MainPrefixLimitStepRawCode M (env K) (env Labels) (env C) (env D) (env rD) (env N)
+        (env old) (env next) (fun j => env (w j)) := by
+  have linked := M.realize_linkedMainStageRawFormula pairing unions powers separation collection
+    K Labels C D rD N (w 5) (mainPrefixLimitTargetFields w) env members omega ordinal
+  have extension := M.realize_mainPrefixExtensionFormula old next env members
+  simp only [mainPrefixLimitStepRawFormula, Realize, BoundedFormula.realize_toFormula M _ env members,
+    BoundedFormula.truth_successorFormula, BoundedFormula.truth_mainPrefixTupleFormula,
+    extension, BoundedFormula.truth_pairMembershipFormula, linked,
+    BoundedFormula.truth_mainLimitCoverageFormula]
+  rfl
+
+theorem realize_mainPrefixLimitStepFormula
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    (collection : CollectionSchema M.sets) {n} (K Labels C D rD N old next : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
+    (omega : env N = ZFSet.omega) (ordinal : ordinalSetProperty (env K)) :
+    Realize M.sets (mainPrefixLimitStepFormula K Labels C D rD N old next) env ↔
+      MainPrefixLimitStepCode M (env K) (env Labels) (env C) (env D) (env rD) (env N)
+        (env old) (env next) := by
+  rw [mainPrefixLimitStepFormula, realize_exBlock]
+  have actual (w : Fin 32 → ZFSet.{u}) (ground : ∀ j, w j ∈ M.sets) :=
+    M.realize_mainPrefixLimitStepRawFormula pairing unions powers separation collection
+      (suffixIndex n 32 K) (suffixIndex n 32 Labels) (suffixIndex n 32 C) (suffixIndex n 32 D)
+      (suffixIndex n 32 rD) (suffixIndex n 32 N) (suffixIndex n 32 old) (suffixIndex n 32 next)
+      (prefixIndex n 32) (extendMany 32 w env) (extendMany_members 32 w env ground members)
+      (by simpa only [extendMany_suffix] using omega)
+      (by simpa only [extendMany_suffix] using ordinal)
+  simp only [extendMany_prefix, extendMany_suffix] at actual
+  exact ⟨fun ⟨w, ground, recognized⟩ => ⟨w, ground, (actual w ground).1 recognized⟩,
+    fun ⟨w, ground, raw⟩ => ⟨w, ground, (actual w ground).2 raw⟩⟩
+
+end TransitiveGround
+
+namespace BoundedFormula
+def mainPrefixSelectedStepBody {n} (f old next : Fin n) (v : Fin 10 → Fin n) : BoundedFormula n :=
+  .conj (successorFormula (v 8) (v 0))
+  (.conj (successorFormula (v 9) (v 8))
+  (.conj (mainPrefixTupleFormula old (v 8) (v 1) (v 2))
+  (.conj (mainPrefixTupleFormula next (v 9) (v 3) (v 4))
+  (.conj (mainPrefixFieldExtensionFormula (v 8) (v 1) (v 2) (v 9) (v 3) (v 4))
+  (.conj (pairMembershipFormula (v 0) (v 5) (v 1))
+  (.conj (rightTripleMembershipFormula (v 5) (v 6) (v 7) f)
+  (.conj (pairMembershipFormula (v 8) (v 6) (v 3))
+    (tripleMembershipFormula (v 8) (v 0) (v 7) (v 4)))))))))
+
+theorem truth_mainPrefixSelectedStepBody {n} (f old next : Fin n) (v : Fin 10 → Fin n)
+    (env : Fin n → ZFSet.{u}) :
+    Truth (mainPrefixSelectedStepBody f old next v) env ↔
+      env (v 8) = insert (env (v 0)) (env (v 0)) ∧
+      env (v 9) = insert (env (v 8)) (env (v 8)) ∧
+      env old = mainPrefixCode (env (v 8)) (env (v 1)) (env (v 2)) ∧
+      env next = mainPrefixCode (env (v 9)) (env (v 3)) (env (v 4)) ∧
+      (env (v 8) ⊆ env (v 9) ∧ env (v 1) ⊆ env (v 3) ∧ env (v 2) ⊆ env (v 4)) ∧
+      ZFSet.pair (env (v 0)) (env (v 5)) ∈ env (v 1) ∧
+      ZFSet.pair (env (v 5)) (ZFSet.pair (env (v 6)) (env (v 7))) ∈ env f ∧
+      ZFSet.pair (env (v 8)) (env (v 6)) ∈ env (v 3) ∧
+      ZFSet.pair (ZFSet.pair (env (v 8)) (env (v 0))) (env (v 7)) ∈ env (v 4) := by
+  simp only [mainPrefixSelectedStepBody, Truth, truth_successorFormula,
+    truth_mainPrefixTupleFormula, truth_mainPrefixFieldExtensionFormula,
+    truth_pairMembershipFormula, truth_rightTripleMembershipFormula, truth_tripleMembershipFormula]
+
+end BoundedFormula
+
+namespace SetFormula
+def mainPrefixSelectedStepFormula {n} (f old next : Fin n) : SetFormula n :=
+  exBlock 10 (BoundedFormula.mainPrefixSelectedStepBody
+    (suffixIndex n 10 f) (suffixIndex n 10 old) (suffixIndex n 10 next)
+    (prefixIndex n 10)).toFormula
+
+end SetFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+
+theorem realize_mainPrefixSelectedStepFormula {n} (f old next : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets) :
+    Realize M.sets (mainPrefixSelectedStepFormula f old next) env ↔
+      MainPrefixSelectedStepCode (env f) (env old) (env next) := by
+  rw [mainPrefixSelectedStepFormula, realize_exBlock]
+  have actual (v : Fin 10 → ZFSet.{u}) (ground : ∀ j, v j ∈ M.sets) :=
+    (BoundedFormula.realize_toFormula M _ (extendMany 10 v env)
+      (extendMany_members 10 v env ground members)).trans
+      (BoundedFormula.truth_mainPrefixSelectedStepBody
+        (suffixIndex n 10 f) (suffixIndex n 10 old) (suffixIndex n 10 next)
+        (prefixIndex n 10) (extendMany 10 v env))
+  simp only [extendMany_prefix, extendMany_suffix] at actual
+  constructor
+  · rintro ⟨v, ground, recognized⟩
+    obtain ⟨first, second, oldCode, nextCode, extension, source, selected, target, crossing⟩ :=
+      (actual v ground).1 recognized
+    refine ⟨v 0, v 1, v 2, v 3, v 4, v 5, v 6, v 7, ?_, ?_, ?_, source, selected, ?_, ?_⟩
+    · simpa only [first] using oldCode
+    · simpa only [second, first] using nextCode
+    · rw [oldCode, nextCode]
+      exact mainPrefixExtends_iff.2 extension
+    · simpa only [first] using target
+    · simpa only [first] using crossing
+  · rintro ⟨b, S, E, S', E', a, target, z, oldCode, nextCode,
+      extension, source, selected, targetEntry, crossing⟩
+    have left := M.mainPrefixCode_fields_mem (oldCode ▸ members old)
+    have right := M.mainPrefixCode_fields_mem (nextCode ▸ members next)
+    have sourceGround := M.transitive left.2.1 source
+    have selectedGround := M.transitive (members f) selected
+    let v : Fin 10 → ZFSet.{u} := Fin.cases b (Fin.cases S (Fin.cases E
+      (Fin.cases S' (Fin.cases E' (Fin.cases a (Fin.cases target (Fin.cases z
+        (Fin.cases (insert b b) (fun _ => insert (insert b b) (insert b b))))))))))
+    have ground : ∀ j, v j ∈ M.sets := Fin.cases (M.pair_left sourceGround)
+      (Fin.cases left.2.1 (Fin.cases left.2.2 (Fin.cases right.2.1 (Fin.cases right.2.2
+      (Fin.cases (M.pair_right sourceGround) (Fin.cases (M.pair_left (M.pair_right selectedGround))
+      (Fin.cases (M.pair_right (M.pair_right selectedGround)) (Fin.cases left.1 (fun _ => right.1)))))))))
+    rw [oldCode, nextCode] at extension
+    exact ⟨v, ground, (actual v ground).2 ⟨rfl, rfl, oldCode, nextCode,
+      mainPrefixExtends_iff.1 extension, source, selected, targetEntry, crossing⟩⟩
+
+end TransitiveGround
+
+namespace SetFormula
+def mainPrefixConditionalStepFormula {n} (K Labels C D rD N f old next : Fin n) : SetFormula n :=
+  let outer := suffixIndex n 3
+  let field := prefixIndex n 3
+  disj (mainPrefixSelectedStepFormula f old next)
+    (exBlock 3 (.conj
+      (BoundedFormula.mainPrefixTupleFormula (outer old) (field 0) (field 1) (field 2)).toFormula
+      (.conj (BoundedFormula.nonzeroLimitOrdinalFormula (field 0)).toFormula
+        (mainPrefixLimitStepFormula (outer K) (outer Labels) (outer C) (outer D)
+          (outer rD) (outer N) (outer old) (outer next)))))
+
+end SetFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+
+theorem realize_mainPrefixConditionalStepFormula
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    (collection : CollectionSchema M.sets) {n}
+    (K Labels C D rD N f old next : Fin n) (env : Fin n → ZFSet.{u})
+    (members : ∀ j, env j ∈ M.sets) (omega : env N = ZFSet.omega)
+    (ordinal : ordinalSetProperty (env K)) :
+    Realize M.sets (mainPrefixConditionalStepFormula K Labels C D rD N f old next) env ↔
+      MainPrefixConditionalStepCode M (env K) (env Labels) (env C) (env D) (env rD)
+        (env N) (env f) (env old) (env next) := by
+  rw [mainPrefixConditionalStepFormula, realize_disj,
+    M.realize_mainPrefixSelectedStepFormula f old next env members, realize_exBlock]
+  apply or_congr Iff.rfl
+  let outer := suffixIndex n 3
+  let field := prefixIndex n 3
+  have actual (w : Fin 3 → ZFSet.{u}) (ground : ∀ j, w j ∈ M.sets) :
+      Realize M.sets (.conj
+        (BoundedFormula.mainPrefixTupleFormula (outer old) (field 0) (field 1) (field 2)).toFormula
+        (.conj (BoundedFormula.nonzeroLimitOrdinalFormula (field 0)).toFormula
+          (mainPrefixLimitStepFormula (outer K) (outer Labels) (outer C) (outer D)
+            (outer rD) (outer N) (outer old) (outer next)))) (extendMany 3 w env) ↔
+      env old = mainPrefixCode (w 0) (w 1) (w 2) ∧ NonzeroLimitOrdinalCode (w 0) ∧
+        MainPrefixLimitStepCode M (env K) (env Labels) (env C) (env D) (env rD) (env N)
+          (env old) (env next) := by
+    have mems := extendMany_members 3 w env ground members
+    change (Realize M.sets _ _ ∧ Realize M.sets _ _ ∧ Realize M.sets _ _) ↔ _
+    rw [BoundedFormula.realize_mainPrefixTupleFormula M _ _ _ _ _ mems,
+      BoundedFormula.realize_nonzeroLimitOrdinalFormula M _ _ mems,
+      M.realize_mainPrefixLimitStepFormula pairing unions powers separation collection
+        _ _ _ _ _ _ _ _ _ mems (by simpa only [outer, extendMany_suffix] using omega)
+          (by simpa only [outer, extendMany_suffix] using ordinal)]
+    simp only [outer, field, extendMany_suffix, extendMany_prefix]
+  constructor
+  · rintro ⟨w, ground, recognized⟩
+    exact ⟨w 0, w 1, w 2, (actual w ground).1 recognized⟩
+  · rintro ⟨T, S, E, oldCode, nonzero, code⟩
+    have fields := M.mainPrefixCode_fields_mem (oldCode ▸ members old)
+    let w : Fin 3 → ZFSet.{u} := Fin.cases T (Fin.cases S (fun _ => E))
+    have ground : ∀ j, w j ∈ M.sets := Fin.cases fields.1 (Fin.cases fields.2.1 (fun _ => fields.2.2))
+    exact ⟨w, ground, (actual w ground).2 ⟨oldCode, nonzero, code⟩⟩
+
+end TransitiveGround
+
+namespace SetFormula
+def preservedMainPrefixHistoryValuesFormula {n} (K Labels C D rD N p : Fin n) : SetFormula n :=
+  let old := suffixIndex n 2
+  let field := prefixIndex n 2
+  allBlock 2 (imp (BoundedFormula.pairMembershipFormula (field 0) (field 1) (old p)).toFormula
+    (preservedMainPrefixHistoryValueFormula (old K) (old Labels) (old C) (old D) (old rD) (old N)
+      (field 0) (field 1)))
+
+def preservedMainPrefixHistoryCompatibilityFormula {n} (p : Fin n) : SetFormula n :=
+  let old := suffixIndex n 4
+  let field := prefixIndex n 4
+  allBlock 4 (imp (BoundedFormula.conj
+    (BoundedFormula.pairMembershipFormula (field 0) (field 2) (old p))
+    (.conj (BoundedFormula.pairMembershipFormula (field 1) (field 3) (old p))
+      (BoundedFormula.disj (.equal (field 0) (field 1)) (.mem (field 0) (field 1))))).toFormula
+    (mainPrefixExtensionFormula (field 2) (field 3)))
+
+def preservedMainPrefixHistoryFormula {n} (K Labels C D rD N A p : Fin n) : SetFormula n :=
+  .conj (functionGraphOnFormula A p)
+    (.conj (preservedMainPrefixHistoryValuesFormula K Labels C D rD N p)
+      (preservedMainPrefixHistoryCompatibilityFormula p))
+
+end SetFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+
+theorem realize_preservedMainPrefixHistoryValuesFormula
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    (collection : CollectionSchema M.sets) {n} (K Labels C D rD N p : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
+    (omega : env N = ZFSet.omega) (ordinal : ordinalSetProperty (env K)) :
+    Realize M.sets (preservedMainPrefixHistoryValuesFormula K Labels C D rD N p) env ↔
+      ∀ i q, ZFSet.pair i q ∈ env p →
+        ∃ S E, q = mainPrefixCode (insert i i) S E ∧
+          MainPrefixGraphCode M (env K) (env Labels) (env C) (env D) (env rD) (insert i i) S E ∧
+          MainPrefixProfileGraphCode M (env K) (env Labels) (env C) (env D) (env rD) S E := by
+  rw [preservedMainPrefixHistoryValuesFormula, realize_allBlock]
+  have actual (f : Fin 2 → ZFSet.{u}) (ground : ∀ j, f j ∈ M.sets) :
+      Realize M.sets
+        (imp (BoundedFormula.pairMembershipFormula (prefixIndex n 2 0) (prefixIndex n 2 1)
+          (suffixIndex n 2 p)).toFormula
+          (preservedMainPrefixHistoryValueFormula (suffixIndex n 2 K) (suffixIndex n 2 Labels)
+            (suffixIndex n 2 C) (suffixIndex n 2 D) (suffixIndex n 2 rD) (suffixIndex n 2 N)
+            (prefixIndex n 2 0) (prefixIndex n 2 1))) (extendMany 2 f env) ↔
+        (ZFSet.pair (f 0) (f 1) ∈ env p →
+          ∃ S E, f 1 = mainPrefixCode (insert (f 0) (f 0)) S E ∧
+            MainPrefixGraphCode M (env K) (env Labels) (env C) (env D) (env rD)
+              (insert (f 0) (f 0)) S E ∧
+            MainPrefixProfileGraphCode M (env K) (env Labels) (env C) (env D) (env rD) S E) := by
+    have mems := extendMany_members 2 f env ground members
+    rw [realize_imp, BoundedFormula.realize_toFormula M _ _ mems,
+      BoundedFormula.truth_pairMembershipFormula]
+    rw [M.realize_preservedMainPrefixHistoryValueFormula pairing unions powers separation collection
+      _ _ _ _ _ _ _ _ _ mems
+      (by simpa only [extendMany_suffix] using omega)
+      (by simpa only [extendMany_suffix] using ordinal)]
+    simp only [extendMany_prefix, extendMany_suffix]
+  constructor
+  · intro recognized i q entry
+    have ground := M.transitive (members p) entry
+    let f : Fin 2 → ZFSet.{u} := Fin.cases i (fun _ => q)
+    have grounds : ∀ j, f j ∈ M.sets := Fin.cases (M.pair_left ground) (fun _ => M.pair_right ground)
+    exact (actual f grounds).1 (recognized f grounds) entry
+  · intro law f ground
+    exact (actual f ground).2 (law (f 0) (f 1))
+
+theorem realize_preservedMainPrefixHistoryCompatibilityFormula {n} (p : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets) :
+    Realize M.sets (preservedMainPrefixHistoryCompatibilityFormula p) env ↔
+      ∀ i j q r, ZFSet.pair i q ∈ env p → ZFSet.pair j r ∈ env p →
+        (i = j ∨ i ∈ j) → MainPrefixExtends q r := by
+  rw [preservedMainPrefixHistoryCompatibilityFormula, realize_allBlock]
+  have actual (f : Fin 4 → ZFSet.{u}) (ground : ∀ j, f j ∈ M.sets) :
+      Realize M.sets (imp (BoundedFormula.conj
+        (BoundedFormula.pairMembershipFormula (prefixIndex n 4 0) (prefixIndex n 4 2) (suffixIndex n 4 p))
+        (.conj (BoundedFormula.pairMembershipFormula (prefixIndex n 4 1) (prefixIndex n 4 3) (suffixIndex n 4 p))
+          (BoundedFormula.disj (.equal (prefixIndex n 4 0) (prefixIndex n 4 1))
+            (.mem (prefixIndex n 4 0) (prefixIndex n 4 1))))).toFormula
+        (mainPrefixExtensionFormula (prefixIndex n 4 2) (prefixIndex n 4 3))) (extendMany 4 f env) ↔
+      ((ZFSet.pair (f 0) (f 2) ∈ env p ∧ ZFSet.pair (f 1) (f 3) ∈ env p ∧
+        (f 0 = f 1 ∨ f 0 ∈ f 1)) → MainPrefixExtends (f 2) (f 3)) := by
+    have mems := extendMany_members 4 f env ground members
+    rw [realize_imp, BoundedFormula.realize_toFormula M _ _ mems]
+    simp only [BoundedFormula.Truth, BoundedFormula.truth_pairMembershipFormula, BoundedFormula.truth_disj]
+    rw [M.realize_mainPrefixExtensionFormula _ _ _ mems]
+    simp only [extendMany_prefix, extendMany_suffix]
+  constructor
+  · intro recognized i j q r first second before
+    have hfirst := M.transitive (members p) first
+    have hsecond := M.transitive (members p) second
+    let f : Fin 4 → ZFSet.{u} := Fin.cases i (Fin.cases j (Fin.cases q (fun _ => r)))
+    have grounds : ∀ k, f k ∈ M.sets := Fin.cases (M.pair_left hfirst)
+      (Fin.cases (M.pair_left hsecond) (Fin.cases (M.pair_right hfirst) (fun _ => M.pair_right hsecond)))
+    exact (actual f grounds).1 (recognized f grounds) ⟨first, second, before⟩
+  · intro law f ground
+    exact (actual f ground).2 (fun entries => law (f 0) (f 1) (f 2) (f 3) entries.1 entries.2.1 entries.2.2)
+
+theorem realize_preservedMainPrefixHistoryFormula
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    (collection : CollectionSchema M.sets) {n} (K Labels C D rD N A p : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
+    (omega : env N = ZFSet.omega) (ordinal : ordinalSetProperty (env K)) :
+    Realize M.sets (preservedMainPrefixHistoryFormula K Labels C D rD N A p) env ↔
+      PreservedMainPrefixHistoryCode M (env K) (env Labels) (env C) (env D) (env rD) (env A) (env p) := by
+  change (Realize M.sets (functionGraphOnFormula A p) env ∧
+    Realize M.sets (preservedMainPrefixHistoryValuesFormula K Labels C D rD N p) env ∧
+    Realize M.sets (preservedMainPrefixHistoryCompatibilityFormula p) env) ↔ _
+  rw [M.realize_functionGraphOnFormula unions A p env members,
+    M.realize_preservedMainPrefixHistoryValuesFormula pairing unions powers separation collection
+      K Labels C D rD N p env members omega ordinal,
+    M.realize_preservedMainPrefixHistoryCompatibilityFormula p env members]
+  exact ⟨fun h => ⟨h.1, h.2.1, h.2.2⟩, fun h => ⟨h.function, h.values, h.compatible⟩⟩
+
+end TransitiveGround
+
+end PartitionPilot.Forcing
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/PrincipalSupportFormulas.lean

@@ -1,76 +1,76 @@
-import OAI.SetTheory.PartitionPrinciple.Forcing.FinitePrincipalNameSupports
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing.BoundedFormula
-
-open SetFormula SetRealization
-universe u
-
-def principalSupportFormula {n} (g c l r a : Fin n) : BoundedFormula n :=
-  .allMem l (imp (pairMembershipFormula 0 c.succ r.succ)
-    (tripleMembershipFormula g.succ 0 0 a.succ))
-
-def principalSupportEntryFormula {n} (z l g r a : Fin n) : BoundedFormula n :=
-  exMem l (exMem g.succ (.conj (orderedPairFormula z.succ.succ 1 0)
-    (principalSupportFormula 0 1 l.succ.succ r.succ.succ a.succ.succ)))
-
-theorem truth_principalSupportFormula {n} (g c l r a : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (principalSupportFormula g c l r a) env ↔
-      ∀ x ∈ env l, ZFSet.pair x (env c) ∈ env r → ZFSet.pair (ZFSet.pair (env g) x) x ∈ env a := by
-  simp only [principalSupportFormula, Truth, truth_imp, truth_pairMembershipFormula,
-    truth_tripleMembershipFormula]
-  rfl
-
-theorem truth_principalSupportEntryFormula {n} (z l g r a : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (principalSupportEntryFormula z l g r a) env ↔
-      ∃ c ∈ env l, ∃ h ∈ env g, env z = ZFSet.pair c h ∧
-        ∀ x ∈ env l, ZFSet.pair x c ∈ env r → ZFSet.pair (ZFSet.pair h x) x ∈ env a := by
-  simp only [principalSupportEntryFormula, truth_exMem, Truth, truth_orderedPairFormula,
-    truth_principalSupportFormula]
-  rfl
-
-variable {G I : Type u} [Group G] [PartialOrder I]
-
-theorem principalSupport_correct (d : PosetAction G I) (b : Presentation I) (t : Presentation G)
-    (C : I) (g : G) :
-    Truth (principalSupportFormula 0 1 2 3 4)
-      (extend (t.encode g) (extend (b.encode C) (extend b.carrier
-        (extend b.conditionOrder (extend (d.actionGraph b t) Fin.elim0))))) ↔ g ∈ d.principalFix C := by
-  rw [truth_principalSupportFormula]
-  constructor
-  · intro fixed x lower
-    exact (d.triple_mem_actionGraph b t g x x).1
-      (fixed _ (b.encode_mem x) ((b.pair_mem_conditionOrder x C).2 lower))
-  · intro fixed x hx lower
-    obtain ⟨y, rfl⟩ := (b.mem_carrier x).1 hx
-    exact (d.triple_mem_actionGraph b t g y y).2 (fixed y ((b.pair_mem_conditionOrder y C).1 lower))
-
-theorem principalSupportEntry_correct (d : PosetAction G I) (b : Presentation I) (t : Presentation G)
-    (z : ZFSet.{u}) :
-    Truth (principalSupportEntryFormula 0 1 2 3 4)
-      (extend z (extend b.carrier (extend t.carrier
-        (extend b.conditionOrder (extend (d.actionGraph b t) Fin.elim0))))) ↔
-      z ∈ supportBasisCode b t d.principalFix := by
-  rw [truth_principalSupportEntryFormula, supportBasisCode, Presentation.mem_subset]
-  constructor
-  · rintro ⟨c, hc, h, hh, eq, fixed⟩
-    obtain ⟨C, rfl⟩ := (b.mem_carrier c).1 hc
-    obtain ⟨g, rfl⟩ := (t.mem_carrier h).1 hh
-    refine ⟨(C, g), ?_, eq.symm⟩
-    intro x lower
-    exact (d.triple_mem_actionGraph b t g x x).1
-      (fixed _ (b.encode_mem x) ((b.pair_mem_conditionOrder x C).2 lower))
-  · rintro ⟨⟨C, g⟩, fixed, eq⟩
-    refine ⟨b.encode C, b.encode_mem C, t.encode g, t.encode_mem g, eq.symm, ?_⟩
-    intro x hx lower
-    obtain ⟨y, rfl⟩ := (b.mem_carrier x).1 hx
-    exact (d.triple_mem_actionGraph b t g y y).2 (fixed y ((b.pair_mem_conditionOrder y C).1 lower))
-
-end PartitionPilot.Forcing.BoundedFormula
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Forcing.FinitePrincipalNameSupports
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing.BoundedFormula
+
+open SetFormula SetRealization
+universe u
+
+def principalSupportFormula {n} (g c l r a : Fin n) : BoundedFormula n :=
+  .allMem l (imp (pairMembershipFormula 0 c.succ r.succ)
+    (tripleMembershipFormula g.succ 0 0 a.succ))
+
+def principalSupportEntryFormula {n} (z l g r a : Fin n) : BoundedFormula n :=
+  exMem l (exMem g.succ (.conj (orderedPairFormula z.succ.succ 1 0)
+    (principalSupportFormula 0 1 l.succ.succ r.succ.succ a.succ.succ)))
+
+theorem truth_principalSupportFormula {n} (g c l r a : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (principalSupportFormula g c l r a) env ↔
+      ∀ x ∈ env l, ZFSet.pair x (env c) ∈ env r → ZFSet.pair (ZFSet.pair (env g) x) x ∈ env a := by
+  simp only [principalSupportFormula, Truth, truth_imp, truth_pairMembershipFormula,
+    truth_tripleMembershipFormula]
+  rfl
+
+theorem truth_principalSupportEntryFormula {n} (z l g r a : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (principalSupportEntryFormula z l g r a) env ↔
+      ∃ c ∈ env l, ∃ h ∈ env g, env z = ZFSet.pair c h ∧
+        ∀ x ∈ env l, ZFSet.pair x c ∈ env r → ZFSet.pair (ZFSet.pair h x) x ∈ env a := by
+  simp only [principalSupportEntryFormula, truth_exMem, Truth, truth_orderedPairFormula,
+    truth_principalSupportFormula]
+  rfl
+
+variable {G I : Type u} [Group G] [PartialOrder I]
+
+theorem principalSupport_correct (d : PosetAction G I) (b : Presentation I) (t : Presentation G)
+    (C : I) (g : G) :
+    Truth (principalSupportFormula 0 1 2 3 4)
+      (extend (t.encode g) (extend (b.encode C) (extend b.carrier
+        (extend b.conditionOrder (extend (d.actionGraph b t) Fin.elim0))))) ↔ g ∈ d.principalFix C := by
+  rw [truth_principalSupportFormula]
+  constructor
+  · intro fixed x lower
+    exact (d.triple_mem_actionGraph b t g x x).1
+      (fixed _ (b.encode_mem x) ((b.pair_mem_conditionOrder x C).2 lower))
+  · intro fixed x hx lower
+    obtain ⟨y, rfl⟩ := (b.mem_carrier x).1 hx
+    exact (d.triple_mem_actionGraph b t g y y).2 (fixed y ((b.pair_mem_conditionOrder y C).1 lower))
+
+theorem principalSupportEntry_correct (d : PosetAction G I) (b : Presentation I) (t : Presentation G)
+    (z : ZFSet.{u}) :
+    Truth (principalSupportEntryFormula 0 1 2 3 4)
+      (extend z (extend b.carrier (extend t.carrier
+        (extend b.conditionOrder (extend (d.actionGraph b t) Fin.elim0))))) ↔
+      z ∈ supportBasisCode b t d.principalFix := by
+  rw [truth_principalSupportEntryFormula, supportBasisCode, Presentation.mem_subset]
+  constructor
+  · rintro ⟨c, hc, h, hh, eq, fixed⟩
+    obtain ⟨C, rfl⟩ := (b.mem_carrier c).1 hc
+    obtain ⟨g, rfl⟩ := (t.mem_carrier h).1 hh
+    refine ⟨(C, g), ?_, eq.symm⟩
+    intro x lower
+    exact (d.triple_mem_actionGraph b t g x x).1
+      (fixed _ (b.encode_mem x) ((b.pair_mem_conditionOrder x C).2 lower))
+  · rintro ⟨⟨C, g⟩, fixed, eq⟩
+    refine ⟨b.encode C, b.encode_mem C, t.encode g, t.encode_mem g, eq.symm, ?_⟩
+    intro x hx lower
+    obtain ⟨y, rfl⟩ := (b.mem_carrier x).1 hx
+    exact (d.triple_mem_actionGraph b t g y y).2 (fixed y ((b.pair_mem_conditionOrder y C).1 lower))
+
+end PartitionPilot.Forcing.BoundedFormula
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/PrincipalTileRealization.lean

@@ -1,75 +1,75 @@
-import OAI.SetTheory.PartitionPrinciple.Geometry.SeparationTileCodes
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing.CodedPrincipalTile
-open Compression.RecursiveMaps
-universe u
-variable {P Q rP rQ μP μQ ell : ZFSet.{u}}
-variable {old : MeetOrderCode P rP μP} {right : MeetOrderCode Q rQ μQ}
-variable {g : PrincipalAmalgamation.Input old.toMeetOrder right.toMeetOrder}
-variable (d : CodedPrincipalTile old right g ell)
-
-noncomputable def decode (x : {x : ZFSet.{u} // x ∈ d.carrier}) : g.Node :=
-  Classical.choose (d.encode_surjective x.val x.property)
-
-theorem encode_decode (x : {x : ZFSet.{u} // x ∈ d.carrier}) : d.encode (d.decode x) = x.val :=
-  Classical.choose_spec (d.encode_surjective x.val x.property)
-
-theorem decode_encode (x : g.Node) : d.decode ⟨d.encode x, d.encode_mem x⟩ = x :=
-  d.encode_injective (d.encode_decode _)
-
-noncomputable def encodingIso : Compression.MeetIso g.order d.meetOrder.toMeetOrder :=
-  isoOfOrder (fun x => ⟨d.encode x, d.encode_mem x⟩) d.decode d.decode_encode
-    (fun x => Subtype.ext (d.encode_decode x)) d.le_encode
-
-noncomputable def decodingIso : Compression.MeetIso d.meetOrder.toMeetOrder g.order :=
-  inverseIso d.encodingIso
-
-theorem encodingIso_value (x : g.Node) :
-    (d.encodingIso.toFun x).val = d.encode x := rfl
-
-theorem decodingIso_encode (x : {x : ZFSet.{u} // x ∈ d.carrier}) :
-    d.encode (d.decodingIso.toFun x) = x.val := d.encode_decode x
-
-theorem vertex_cover (z : ZFSet.{u}) (hz : z ∈ d.carrier) :
-    (∃ p ∈ P, ZFSet.pair p z ∈ attachmentOldEmbeddingGraph P) ∨
-    ∃ q ∈ Q, ZFSet.pair q z ∈ attachmentTemplateEmbeddingGraph P Q rQ ell g.rightAnchor.val := by
-  obtain ⟨x, rfl⟩ := d.encode_surjective z hz
-  rcases g.cover x with ⟨p, rfl⟩ | ⟨q, rfl⟩
-  · exact Or.inl ⟨p.val, p.property, (pair_mem_attachmentOldEmbeddingGraph _ _ _).2 ⟨p.property, rfl⟩⟩
-  · exact Or.inr ⟨q.val, q.property, d.template_entry q⟩
-
-theorem cross_meet_entry (p : {p : ZFSet.{u} // p ∈ P})
-    (q : {q : ZFSet.{u} // q ∈ Q}) :
-    ZFSet.pair (ZFSet.pair p.val (d.encode (g.right.toFun q)))
-      (old.toMeetOrder.meet p (g.shadow q)).val ∈ d.meetGraph := by
-  have entry := d.encoded_meet_entry (g.left.toFun p) (g.right.toFun q)
-  rw [g.cross_meet] at entry
-  exact entry
-
-theorem old_graph_ideal {p z : ZFSet.{u}} (hp : p ∈ P) (hz : z ∈ d.carrier)
-    (lower : ZFSet.pair z p ∈ d.order) :
-    ∃ x ∈ P, ZFSet.pair x z ∈ attachmentOldEmbeddingGraph P := by
-  obtain ⟨x, rfl⟩ := d.encode_surjective z hz
-  obtain ⟨q, rfl⟩ := d.old_ideal ⟨p, hp⟩ x lower
-  exact ⟨q.val, q.property, (pair_mem_attachmentOldEmbeddingGraph _ _ _).2 ⟨q.property, rfl⟩⟩
-
-theorem template_graph_ideal {q y z : ZFSet.{u}}
-    (entry : ZFSet.pair q y ∈ attachmentTemplateEmbeddingGraph P Q rQ ell g.rightAnchor.val)
-    (hz : z ∈ d.carrier) (lower : ZFSet.pair z y ∈ d.order) :
-    ∃ x ∈ Q, ZFSet.pair x z ∈ attachmentTemplateEmbeddingGraph P Q rQ ell g.rightAnchor.val := by
-  have hq := (ZFSet.pair_mem_prod.1 ((attachmentTemplateEmbeddingGraph_isFunc d.base_function).1 entry)).1
-  have eq := (d.template_entry_iff ⟨q, hq⟩ y).1 entry
-  rw [eq] at lower
-  obtain ⟨x, rfl⟩ := d.encode_surjective z hz
-  obtain ⟨p, rfl⟩ := d.template_ideal ⟨q, hq⟩ x lower
-  exact ⟨p.val, p.property, d.template_entry p⟩
-
-end PartitionPilot.Forcing.CodedPrincipalTile
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Geometry.SeparationTileCodes
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing.CodedPrincipalTile
+open Compression.RecursiveMaps
+universe u
+variable {P Q rP rQ μP μQ ell : ZFSet.{u}}
+variable {old : MeetOrderCode P rP μP} {right : MeetOrderCode Q rQ μQ}
+variable {g : PrincipalAmalgamation.Input old.toMeetOrder right.toMeetOrder}
+variable (d : CodedPrincipalTile old right g ell)
+
+noncomputable def decode (x : {x : ZFSet.{u} // x ∈ d.carrier}) : g.Node :=
+  Classical.choose (d.encode_surjective x.val x.property)
+
+theorem encode_decode (x : {x : ZFSet.{u} // x ∈ d.carrier}) : d.encode (d.decode x) = x.val :=
+  Classical.choose_spec (d.encode_surjective x.val x.property)
+
+theorem decode_encode (x : g.Node) : d.decode ⟨d.encode x, d.encode_mem x⟩ = x :=
+  d.encode_injective (d.encode_decode _)
+
+noncomputable def encodingIso : Compression.MeetIso g.order d.meetOrder.toMeetOrder :=
+  isoOfOrder (fun x => ⟨d.encode x, d.encode_mem x⟩) d.decode d.decode_encode
+    (fun x => Subtype.ext (d.encode_decode x)) d.le_encode
+
+noncomputable def decodingIso : Compression.MeetIso d.meetOrder.toMeetOrder g.order :=
+  inverseIso d.encodingIso
+
+theorem encodingIso_value (x : g.Node) :
+    (d.encodingIso.toFun x).val = d.encode x := rfl
+
+theorem decodingIso_encode (x : {x : ZFSet.{u} // x ∈ d.carrier}) :
+    d.encode (d.decodingIso.toFun x) = x.val := d.encode_decode x
+
+theorem vertex_cover (z : ZFSet.{u}) (hz : z ∈ d.carrier) :
+    (∃ p ∈ P, ZFSet.pair p z ∈ attachmentOldEmbeddingGraph P) ∨
+    ∃ q ∈ Q, ZFSet.pair q z ∈ attachmentTemplateEmbeddingGraph P Q rQ ell g.rightAnchor.val := by
+  obtain ⟨x, rfl⟩ := d.encode_surjective z hz
+  rcases g.cover x with ⟨p, rfl⟩ | ⟨q, rfl⟩
+  · exact Or.inl ⟨p.val, p.property, (pair_mem_attachmentOldEmbeddingGraph _ _ _).2 ⟨p.property, rfl⟩⟩
+  · exact Or.inr ⟨q.val, q.property, d.template_entry q⟩
+
+theorem cross_meet_entry (p : {p : ZFSet.{u} // p ∈ P})
+    (q : {q : ZFSet.{u} // q ∈ Q}) :
+    ZFSet.pair (ZFSet.pair p.val (d.encode (g.right.toFun q)))
+      (old.toMeetOrder.meet p (g.shadow q)).val ∈ d.meetGraph := by
+  have entry := d.encoded_meet_entry (g.left.toFun p) (g.right.toFun q)
+  rw [g.cross_meet] at entry
+  exact entry
+
+theorem old_graph_ideal {p z : ZFSet.{u}} (hp : p ∈ P) (hz : z ∈ d.carrier)
+    (lower : ZFSet.pair z p ∈ d.order) :
+    ∃ x ∈ P, ZFSet.pair x z ∈ attachmentOldEmbeddingGraph P := by
+  obtain ⟨x, rfl⟩ := d.encode_surjective z hz
+  obtain ⟨q, rfl⟩ := d.old_ideal ⟨p, hp⟩ x lower
+  exact ⟨q.val, q.property, (pair_mem_attachmentOldEmbeddingGraph _ _ _).2 ⟨q.property, rfl⟩⟩
+
+theorem template_graph_ideal {q y z : ZFSet.{u}}
+    (entry : ZFSet.pair q y ∈ attachmentTemplateEmbeddingGraph P Q rQ ell g.rightAnchor.val)
+    (hz : z ∈ d.carrier) (lower : ZFSet.pair z y ∈ d.order) :
+    ∃ x ∈ Q, ZFSet.pair x z ∈ attachmentTemplateEmbeddingGraph P Q rQ ell g.rightAnchor.val := by
+  have hq := (ZFSet.pair_mem_prod.1 ((attachmentTemplateEmbeddingGraph_isFunc d.base_function).1 entry)).1
+  have eq := (d.template_entry_iff ⟨q, hq⟩ y).1 entry
+  rw [eq] at lower
+  obtain ⟨x, rfl⟩ := d.encode_surjective z hz
+  obtain ⟨p, rfl⟩ := d.template_ideal ⟨q, hq⟩ x lower
+  exact ⟨p.val, p.property, d.template_entry p⟩
+
+end PartitionPilot.Forcing.CodedPrincipalTile
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/RationalCodeLaws.lean

@@ -1,169 +1,169 @@
-import OAI.SetTheory.PartitionPrinciple.Forcing.CodedDenseOrders
-
-namespace OAI
-
-
-namespace PartitionPilot.Forcing
-
-open SetRealization Compression.RecursiveMaps.RationalHeights
-universe u
-
-theorem fractionEquivalence_code : EquivalenceRelationCode fractionCarrier.{u} fractionEquivGraph := by
-  refine ⟨fractionEquivGraph_subset, ?_, ?_, ?_⟩
-  · intro x hx
-    obtain ⟨a, rfl⟩ := (mem_fractionCarrier x).1 hx
-    exact (pair_mem_fractionEquivGraph a a).2 rfl
-  · intro x y hxy
-    have shape := ZFSet.pair_mem_prod.1 (fractionEquivGraph_subset hxy)
-    obtain ⟨a, rfl⟩ := (mem_fractionCarrier x).1 shape.1
-    obtain ⟨b, rfl⟩ := (mem_fractionCarrier y).1 shape.2
-    exact (pair_mem_fractionEquivGraph b a).2 ((pair_mem_fractionEquivGraph a b).1 hxy).symm
-  · intro x y z hxy hyz
-    have shape := ZFSet.pair_mem_prod.1 (fractionEquivGraph_subset hxy)
-    have zmem := (ZFSet.pair_mem_prod.1 (fractionEquivGraph_subset hyz)).2
-    obtain ⟨a, rfl⟩ := (mem_fractionCarrier x).1 shape.1
-    obtain ⟨b, rfl⟩ := (mem_fractionCarrier y).1 shape.2
-    obtain ⟨d, rfl⟩ := (mem_fractionCarrier z).1 zmem
-    exact (pair_mem_fractionEquivGraph a d).2 (Fraction.equiv_trans
-      ((pair_mem_fractionEquivGraph a b).1 hxy) ((pair_mem_fractionEquivGraph b d).1 hyz))
-
-noncomputable def rationalCarrier (c : ZFSet.{u}) : ZFSet.{u} :=
-  canonicalRepresentatives fractionCarrier fractionEquivGraph c
-
-theorem rationalCarrier_subset (c : ZFSet.{u}) : rationalCarrier c ⊆ fractionCarrier :=
-  canonicalRepresentatives_subset _ _ _
-
-noncomputable def rationalEncode {c : ZFSet.{u}}
-    (hc : InjectionCode fractionCarrier ZFSet.omega c) (r : Rational) : ZFSet.{u} :=
-  Classical.choose (canonical_exists_unique fractionEquivalence_code hc
-    (fractionEncode_mem (Rational.representative r)))
-
-theorem rationalEncode_spec {c : ZFSet.{u}}
-    (hc : InjectionCode fractionCarrier ZFSet.omega c) (r : Rational) :
-    rationalEncode hc r ∈ rationalCarrier c ∧
-      ZFSet.pair (fractionEncode (Rational.representative r)) (rationalEncode hc r) ∈ fractionEquivGraph :=
-  (Classical.choose_spec (canonical_exists_unique fractionEquivalence_code hc
-    (fractionEncode_mem (Rational.representative r)))).1
-
-theorem rationalEncode_class {c : ZFSet.{u}}
-    (hc : InjectionCode fractionCarrier ZFSet.omega c) (r : Rational) :
-    ∃ a : Fraction, fractionEncode a = rationalEncode hc r ∧ Rational.mk a = r := by
-  have spec := rationalEncode_spec hc r
-  obtain ⟨a, ha⟩ := (mem_fractionCarrier _).1 (rationalCarrier_subset c spec.1)
-  refine ⟨a, ha, ?_⟩
-  rw [← ha] at spec
-  have eq := (Rational.mk_eq_iff _ _).2 ((pair_mem_fractionEquivGraph _ _).1 spec.2)
-  exact eq.symm.trans (Rational.representative_eq r)
-
-theorem rationalEncode_injective {c : ZFSet.{u}}
-    (hc : InjectionCode fractionCarrier ZFSet.omega c) : Function.Injective (rationalEncode hc) := by
-  intro r s eq
-  obtain ⟨a, ha, ar⟩ := rationalEncode_class hc r
-  obtain ⟨b, hb, bs⟩ := rationalEncode_class hc s
-  have ab := fractionEncode_injective (ha.trans (eq.trans hb.symm))
-  exact ar.symm.trans ((congrArg Rational.mk ab).trans bs)
-
-theorem rationalEncode_of_canonical {c : ZFSet.{u}}
-    (hc : InjectionCode fractionCarrier ZFSet.omega c) (a : Fraction)
-    (ha : fractionEncode a ∈ rationalCarrier c) :
-    rationalEncode hc (Rational.mk a) = fractionEncode a := by
-  have unique := (Classical.choose_spec (canonical_exists_unique fractionEquivalence_code hc
-    (fractionEncode_mem (Rational.representative (Rational.mk a))))).2
-  exact (unique (fractionEncode a) ⟨ha,
-    (pair_mem_fractionEquivGraph _ _).2 (Rational.representative_equiv a)⟩).symm
-
-noncomputable def rationalPresentation {c : ZFSet.{u}}
-    (hc : InjectionCode fractionCarrier ZFSet.omega c) : Presentation (ULift.{u} Rational) where
-  carrier := rationalCarrier c
-  encode r := rationalEncode hc r.down
-  injective := fun _ _ eq => ULift.ext _ _ (rationalEncode_injective hc eq)
-  mem_carrier x := by
-    constructor
-    · intro hx
-      obtain ⟨a, rfl⟩ := (mem_fractionCarrier _).1 (rationalCarrier_subset c hx)
-      exact ⟨⟨Rational.mk a⟩, rationalEncode_of_canonical hc a hx⟩
-    · rintro ⟨r, rfl⟩
-      exact (rationalEncode_spec hc r.down).1
-
-noncomputable def rationalLtGraph (c : ZFSet.{u}) : ZFSet.{u} :=
-  ZFSet.sep (fun z => z ∈ ZFSet.prod (rationalCarrier c) (rationalCarrier c)) fractionLtGraph
-
-theorem rationalLtGraph_subset (c : ZFSet.{u}) :
-    rationalLtGraph c ⊆ ZFSet.prod (rationalCarrier c) (rationalCarrier c) :=
-  fun _ h => (ZFSet.mem_sep.1 h).2
-
-theorem pair_mem_rationalLtGraph {c : ZFSet.{u}}
-    (hc : InjectionCode fractionCarrier ZFSet.omega c) (r s : Rational) :
-    ZFSet.pair (rationalEncode hc r) (rationalEncode hc s) ∈ rationalLtGraph c ↔ Rational.lt r s := by
-  have first := (rationalEncode_spec hc r).1
-  have second := (rationalEncode_spec hc s).1
-  rw [rationalLtGraph, ZFSet.mem_sep]
-  have lookup : ZFSet.pair (rationalEncode hc r) (rationalEncode hc s) ∈ fractionLtGraph ↔
-      Rational.lt r s := by
-    obtain ⟨a, ha, ar⟩ := rationalEncode_class hc r
-    obtain ⟨b, hb, bs⟩ := rationalEncode_class hc s
-    rw [← ha, ← hb, pair_mem_fractionLtGraph, ← ar, ← bs]
-    exact Iff.rfl
-  exact ⟨fun h => lookup.1 h.1,
-    fun h => ⟨lookup.2 h, ZFSet.pair_mem_prod.2 ⟨first, second⟩⟩⟩
-
-end PartitionPilot.Forcing
-
-
-
-namespace PartitionPilot.Forcing
-
-open Compression.RecursiveMaps.RationalHeights
-universe u
-
-theorem rational_denseOrderCode {c : ZFSet.{u}}
-    (hc : InjectionCode fractionCarrier ZFSet.omega c) :
-    DenseOrderCode (rationalCarrier c) (rationalLtGraph c) := by
-  refine ⟨⟨rationalLtGraph_subset c, ?_, ?_, ?_⟩, ?_⟩
-  · intro x hx
-    obtain ⟨a, rfl⟩ := ((rationalPresentation hc).mem_carrier x).1 hx
-    exact fun h => Rational.irrefl a.down ((pair_mem_rationalLtGraph hc _ _).1 h)
-  · intro x y z xy yz
-    have shape := ZFSet.pair_mem_prod.1 (rationalLtGraph_subset c xy)
-    have hz := (ZFSet.pair_mem_prod.1 (rationalLtGraph_subset c yz)).2
-    obtain ⟨a, rfl⟩ := ((rationalPresentation hc).mem_carrier x).1 shape.1
-    obtain ⟨b, rfl⟩ := ((rationalPresentation hc).mem_carrier y).1 shape.2
-    obtain ⟨d, rfl⟩ := ((rationalPresentation hc).mem_carrier z).1 hz
-    exact (pair_mem_rationalLtGraph hc _ _).2 (Rational.trans
-      ((pair_mem_rationalLtGraph hc _ _).1 xy) ((pair_mem_rationalLtGraph hc _ _).1 yz))
-  · intro x hx y hy
-    obtain ⟨a, rfl⟩ := ((rationalPresentation hc).mem_carrier x).1 hx
-    obtain ⟨b, rfl⟩ := ((rationalPresentation hc).mem_carrier y).1 hy
-    rcases Rational.compare a.down b.down with less | same | more
-    · exact Or.inl ((pair_mem_rationalLtGraph hc _ _).2 less)
-    · exact Or.inr (Or.inl (congrArg (rationalEncode hc) same))
-    · exact Or.inr (Or.inr ((pair_mem_rationalLtGraph hc _ _).2 more))
-  · intro x y xy
-    have shape := ZFSet.pair_mem_prod.1 (rationalLtGraph_subset c xy)
-    obtain ⟨a, rfl⟩ := ((rationalPresentation hc).mem_carrier x).1 shape.1
-    obtain ⟨b, rfl⟩ := ((rationalPresentation hc).mem_carrier y).1 shape.2
-    obtain ⟨d, ad, db⟩ := Rational.between _ _ ((pair_mem_rationalLtGraph hc _ _).1 xy)
-    exact ⟨rationalEncode hc d, (rationalEncode_spec hc d).1,
-      (pair_mem_rationalLtGraph hc _ _).2 ad, (pair_mem_rationalLtGraph hc _ _).2 db⟩
-
-theorem rationalCarrier_nonempty {c : ZFSet.{u}}
-    (hc : InjectionCode fractionCarrier ZFSet.omega c) : ∃ x, x ∈ rationalCarrier c :=
-  ⟨rationalEncode hc (Rational.mk ⟨0, 1, by decide⟩), (rationalEncode_spec hc _).1⟩
-
-theorem rational_no_endpoints {c : ZFSet.{u}}
-    (hc : InjectionCode fractionCarrier ZFSet.omega c) :
-    ∀ x ∈ rationalCarrier c,
-      (∃ y ∈ rationalCarrier c, ZFSet.pair y x ∈ rationalLtGraph c) ∧
-      (∃ y ∈ rationalCarrier c, ZFSet.pair x y ∈ rationalLtGraph c) := by
-  intro x hx
-  obtain ⟨a, rfl⟩ := ((rationalPresentation hc).mem_carrier x).1 hx
-  obtain ⟨b, ba⟩ := Rational.unbounded_below a.down
-  obtain ⟨d, ad⟩ := Rational.unbounded_above a.down
-  exact ⟨⟨rationalEncode hc b, (rationalEncode_spec hc b).1,
-      (pair_mem_rationalLtGraph hc _ _).2 ba⟩,
-    ⟨rationalEncode hc d, (rationalEncode_spec hc d).1,
-      (pair_mem_rationalLtGraph hc _ _).2 ad⟩⟩
-
-end PartitionPilot.Forcing
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Forcing.CodedDenseOrders
+
+namespace OAI
+
+
+namespace PartitionPilot.Forcing
+
+open SetRealization Compression.RecursiveMaps.RationalHeights
+universe u
+
+theorem fractionEquivalence_code : EquivalenceRelationCode fractionCarrier.{u} fractionEquivGraph := by
+  refine ⟨fractionEquivGraph_subset, ?_, ?_, ?_⟩
+  · intro x hx
+    obtain ⟨a, rfl⟩ := (mem_fractionCarrier x).1 hx
+    exact (pair_mem_fractionEquivGraph a a).2 rfl
+  · intro x y hxy
+    have shape := ZFSet.pair_mem_prod.1 (fractionEquivGraph_subset hxy)
+    obtain ⟨a, rfl⟩ := (mem_fractionCarrier x).1 shape.1
+    obtain ⟨b, rfl⟩ := (mem_fractionCarrier y).1 shape.2
+    exact (pair_mem_fractionEquivGraph b a).2 ((pair_mem_fractionEquivGraph a b).1 hxy).symm
+  · intro x y z hxy hyz
+    have shape := ZFSet.pair_mem_prod.1 (fractionEquivGraph_subset hxy)
+    have zmem := (ZFSet.pair_mem_prod.1 (fractionEquivGraph_subset hyz)).2
+    obtain ⟨a, rfl⟩ := (mem_fractionCarrier x).1 shape.1
+    obtain ⟨b, rfl⟩ := (mem_fractionCarrier y).1 shape.2
+    obtain ⟨d, rfl⟩ := (mem_fractionCarrier z).1 zmem
+    exact (pair_mem_fractionEquivGraph a d).2 (Fraction.equiv_trans
+      ((pair_mem_fractionEquivGraph a b).1 hxy) ((pair_mem_fractionEquivGraph b d).1 hyz))
+
+noncomputable def rationalCarrier (c : ZFSet.{u}) : ZFSet.{u} :=
+  canonicalRepresentatives fractionCarrier fractionEquivGraph c
+
+theorem rationalCarrier_subset (c : ZFSet.{u}) : rationalCarrier c ⊆ fractionCarrier :=
+  canonicalRepresentatives_subset _ _ _
+
+noncomputable def rationalEncode {c : ZFSet.{u}}
+    (hc : InjectionCode fractionCarrier ZFSet.omega c) (r : Rational) : ZFSet.{u} :=
+  Classical.choose (canonical_exists_unique fractionEquivalence_code hc
+    (fractionEncode_mem (Rational.representative r)))
+
+theorem rationalEncode_spec {c : ZFSet.{u}}
+    (hc : InjectionCode fractionCarrier ZFSet.omega c) (r : Rational) :
+    rationalEncode hc r ∈ rationalCarrier c ∧
+      ZFSet.pair (fractionEncode (Rational.representative r)) (rationalEncode hc r) ∈ fractionEquivGraph :=
+  (Classical.choose_spec (canonical_exists_unique fractionEquivalence_code hc
+    (fractionEncode_mem (Rational.representative r)))).1
+
+theorem rationalEncode_class {c : ZFSet.{u}}
+    (hc : InjectionCode fractionCarrier ZFSet.omega c) (r : Rational) :
+    ∃ a : Fraction, fractionEncode a = rationalEncode hc r ∧ Rational.mk a = r := by
+  have spec := rationalEncode_spec hc r
+  obtain ⟨a, ha⟩ := (mem_fractionCarrier _).1 (rationalCarrier_subset c spec.1)
+  refine ⟨a, ha, ?_⟩
+  rw [← ha] at spec
+  have eq := (Rational.mk_eq_iff _ _).2 ((pair_mem_fractionEquivGraph _ _).1 spec.2)
+  exact eq.symm.trans (Rational.representative_eq r)
+
+theorem rationalEncode_injective {c : ZFSet.{u}}
+    (hc : InjectionCode fractionCarrier ZFSet.omega c) : Function.Injective (rationalEncode hc) := by
+  intro r s eq
+  obtain ⟨a, ha, ar⟩ := rationalEncode_class hc r
+  obtain ⟨b, hb, bs⟩ := rationalEncode_class hc s
+  have ab := fractionEncode_injective (ha.trans (eq.trans hb.symm))
+  exact ar.symm.trans ((congrArg Rational.mk ab).trans bs)
+
+theorem rationalEncode_of_canonical {c : ZFSet.{u}}
+    (hc : InjectionCode fractionCarrier ZFSet.omega c) (a : Fraction)
+    (ha : fractionEncode a ∈ rationalCarrier c) :
+    rationalEncode hc (Rational.mk a) = fractionEncode a := by
+  have unique := (Classical.choose_spec (canonical_exists_unique fractionEquivalence_code hc
+    (fractionEncode_mem (Rational.representative (Rational.mk a))))).2
+  exact (unique (fractionEncode a) ⟨ha,
+    (pair_mem_fractionEquivGraph _ _).2 (Rational.representative_equiv a)⟩).symm
+
+noncomputable def rationalPresentation {c : ZFSet.{u}}
+    (hc : InjectionCode fractionCarrier ZFSet.omega c) : Presentation (ULift.{u} Rational) where
+  carrier := rationalCarrier c
+  encode r := rationalEncode hc r.down
+  injective := fun _ _ eq => ULift.ext _ _ (rationalEncode_injective hc eq)
+  mem_carrier x := by
+    constructor
+    · intro hx
+      obtain ⟨a, rfl⟩ := (mem_fractionCarrier _).1 (rationalCarrier_subset c hx)
+      exact ⟨⟨Rational.mk a⟩, rationalEncode_of_canonical hc a hx⟩
+    · rintro ⟨r, rfl⟩
+      exact (rationalEncode_spec hc r.down).1
+
+noncomputable def rationalLtGraph (c : ZFSet.{u}) : ZFSet.{u} :=
+  ZFSet.sep (fun z => z ∈ ZFSet.prod (rationalCarrier c) (rationalCarrier c)) fractionLtGraph
+
+theorem rationalLtGraph_subset (c : ZFSet.{u}) :
+    rationalLtGraph c ⊆ ZFSet.prod (rationalCarrier c) (rationalCarrier c) :=
+  fun _ h => (ZFSet.mem_sep.1 h).2
+
+theorem pair_mem_rationalLtGraph {c : ZFSet.{u}}
+    (hc : InjectionCode fractionCarrier ZFSet.omega c) (r s : Rational) :
+    ZFSet.pair (rationalEncode hc r) (rationalEncode hc s) ∈ rationalLtGraph c ↔ Rational.lt r s := by
+  have first := (rationalEncode_spec hc r).1
+  have second := (rationalEncode_spec hc s).1
+  rw [rationalLtGraph, ZFSet.mem_sep]
+  have lookup : ZFSet.pair (rationalEncode hc r) (rationalEncode hc s) ∈ fractionLtGraph ↔
+      Rational.lt r s := by
+    obtain ⟨a, ha, ar⟩ := rationalEncode_class hc r
+    obtain ⟨b, hb, bs⟩ := rationalEncode_class hc s
+    rw [← ha, ← hb, pair_mem_fractionLtGraph, ← ar, ← bs]
+    exact Iff.rfl
+  exact ⟨fun h => lookup.1 h.1,
+    fun h => ⟨lookup.2 h, ZFSet.pair_mem_prod.2 ⟨first, second⟩⟩⟩
+
+end PartitionPilot.Forcing
+
+
+
+namespace PartitionPilot.Forcing
+
+open Compression.RecursiveMaps.RationalHeights
+universe u
+
+theorem rational_denseOrderCode {c : ZFSet.{u}}
+    (hc : InjectionCode fractionCarrier ZFSet.omega c) :
+    DenseOrderCode (rationalCarrier c) (rationalLtGraph c) := by
+  refine ⟨⟨rationalLtGraph_subset c, ?_, ?_, ?_⟩, ?_⟩
+  · intro x hx
+    obtain ⟨a, rfl⟩ := ((rationalPresentation hc).mem_carrier x).1 hx
+    exact fun h => Rational.irrefl a.down ((pair_mem_rationalLtGraph hc _ _).1 h)
+  · intro x y z xy yz
+    have shape := ZFSet.pair_mem_prod.1 (rationalLtGraph_subset c xy)
+    have hz := (ZFSet.pair_mem_prod.1 (rationalLtGraph_subset c yz)).2
+    obtain ⟨a, rfl⟩ := ((rationalPresentation hc).mem_carrier x).1 shape.1
+    obtain ⟨b, rfl⟩ := ((rationalPresentation hc).mem_carrier y).1 shape.2
+    obtain ⟨d, rfl⟩ := ((rationalPresentation hc).mem_carrier z).1 hz
+    exact (pair_mem_rationalLtGraph hc _ _).2 (Rational.trans
+      ((pair_mem_rationalLtGraph hc _ _).1 xy) ((pair_mem_rationalLtGraph hc _ _).1 yz))
+  · intro x hx y hy
+    obtain ⟨a, rfl⟩ := ((rationalPresentation hc).mem_carrier x).1 hx
+    obtain ⟨b, rfl⟩ := ((rationalPresentation hc).mem_carrier y).1 hy
+    rcases Rational.compare a.down b.down with less | same | more
+    · exact Or.inl ((pair_mem_rationalLtGraph hc _ _).2 less)
+    · exact Or.inr (Or.inl (congrArg (rationalEncode hc) same))
+    · exact Or.inr (Or.inr ((pair_mem_rationalLtGraph hc _ _).2 more))
+  · intro x y xy
+    have shape := ZFSet.pair_mem_prod.1 (rationalLtGraph_subset c xy)
+    obtain ⟨a, rfl⟩ := ((rationalPresentation hc).mem_carrier x).1 shape.1
+    obtain ⟨b, rfl⟩ := ((rationalPresentation hc).mem_carrier y).1 shape.2
+    obtain ⟨d, ad, db⟩ := Rational.between _ _ ((pair_mem_rationalLtGraph hc _ _).1 xy)
+    exact ⟨rationalEncode hc d, (rationalEncode_spec hc d).1,
+      (pair_mem_rationalLtGraph hc _ _).2 ad, (pair_mem_rationalLtGraph hc _ _).2 db⟩
+
+theorem rationalCarrier_nonempty {c : ZFSet.{u}}
+    (hc : InjectionCode fractionCarrier ZFSet.omega c) : ∃ x, x ∈ rationalCarrier c :=
+  ⟨rationalEncode hc (Rational.mk ⟨0, 1, by decide⟩), (rationalEncode_spec hc _).1⟩
+
+theorem rational_no_endpoints {c : ZFSet.{u}}
+    (hc : InjectionCode fractionCarrier ZFSet.omega c) :
+    ∀ x ∈ rationalCarrier c,
+      (∃ y ∈ rationalCarrier c, ZFSet.pair y x ∈ rationalLtGraph c) ∧
+      (∃ y ∈ rationalCarrier c, ZFSet.pair x y ∈ rationalLtGraph c) := by
+  intro x hx
+  obtain ⟨a, rfl⟩ := ((rationalPresentation hc).mem_carrier x).1 hx
+  obtain ⟨b, ba⟩ := Rational.unbounded_below a.down
+  obtain ⟨d, ad⟩ := Rational.unbounded_above a.down
+  exact ⟨⟨rationalEncode hc b, (rationalEncode_spec hc b).1,
+      (pair_mem_rationalLtGraph hc _ _).2 ba⟩,
+    ⟨rationalEncode hc d, (rationalEncode_spec hc d).1,
+      (pair_mem_rationalLtGraph hc _ _).2 ad⟩⟩
+
+end PartitionPilot.Forcing
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/RawCheckFormulas.lean

@@ -1,123 +1,123 @@
-import OAI.SetTheory.PartitionPrinciple.Forcing.GroundSymmetricPowerSet
-
-namespace OAI
-
-
-namespace PartitionPilot.Forcing.Name
-
-open SetRealization
-universe u
-variable {P : Type u} (s : Presentation P)
-
-theorem mem_check_code (one : P) (x z : ZFSet.{u}) :
-    z ∈ (check s one x).val ↔ ∃ y ∈ x, z = ZFSet.pair (check s one y).val (s.encode one) := by
-  rw [check]
-  change z ∈ ZFSet.range _ ↔ _
-  rw [ZFSet.mem_range]
-  constructor
-  · rintro ⟨y, eq⟩
-    exact ⟨y.val, y.property, eq.symm⟩
-  · rintro ⟨y, hy, eq⟩
-    exact ⟨⟨y, hy⟩, eq.symm⟩
-
-end PartitionPilot.Forcing.Name
-
-namespace PartitionPilot.Forcing.SetFormula
-
-def checkStepFormula {n : Nat} (top r x y : Fin n) : SetFormula n :=
-  .conj
-    (.all (imp (.mem 0 x.succ) (ex (.conj (pairMembershipFormula 1 0 r.succ.succ)
-      (pairMembershipFormula 0 top.succ.succ y.succ.succ)))))
-    (.all (imp (.mem 0 y.succ) (ex (ex (.conj (.mem 1 x.succ.succ.succ)
-      (.conj (pairMembershipFormula 1 0 r.succ.succ.succ)
-        (orderedPairFormula 2 0 top.succ.succ.succ)))))))
-
-end PartitionPilot.Forcing.SetFormula
-
-namespace PartitionPilot.Forcing.TransitiveGround
-
-open SetRealization SetFormula
-universe u
-variable (M : TransitiveGround.{u})
-
-def RawCheckStep (top R x y : ZFSet.{u}) : Prop :=
-  (∀ v ∈ x, ∃ w ∈ M.sets, ZFSet.pair v w ∈ R ∧ ZFSet.pair w top ∈ y) ∧
-  (∀ z ∈ y, ∃ v ∈ x, ∃ w ∈ M.sets, ZFSet.pair v w ∈ R ∧ z = ZFSet.pair w top)
-
-theorem rawCheckStep_mono {top R S x y : ZFSet.{u}} (sub : R ⊆ S)
-    (h : M.RawCheckStep top R x y) : M.RawCheckStep top S x y := by
-  constructor
-  · intro v hv
-    obtain ⟨w, hw, rel, entry⟩ := h.1 v hv
-    exact ⟨w, hw, sub rel, entry⟩
-  · intro z hz
-    obtain ⟨v, hv, w, hw, rel, eq⟩ := h.2 z hz
-    exact ⟨v, hv, w, hw, sub rel, eq⟩
-
-theorem realize_checkStepFormula
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    {n : Nat} (top r x y : Fin n) (env : Fin n → ZFSet.{u})
-    (htop : env top ∈ M.sets) (hr : env r ∈ M.sets)
-    (hx : env x ∈ M.sets) (hy : env y ∈ M.sets) :
-    Realize M.sets (checkStepFormula top r x y) env ↔
-      M.RawCheckStep (env top) (env r) (env x) (env y) := by
-  change (Realize M.sets _ env ∧ Realize M.sets _ env) ↔ _
-  constructor
-  · rintro ⟨forward, backward⟩
-    constructor
-    · intro v hv
-      have step := (realize_imp M.sets _ _ _).1 (forward v (M.transitive hx hv)) hv
-      obtain ⟨w, hw, rel, entry⟩ := (realize_ex M.sets _ _).1 step
-      let e := extend w (extend v env)
-      exact ⟨w, hw,
-        (M.realize_pairMembershipFormula pairing 1 0 r.succ.succ e (M.transitive hx hv) hw hr).1 rel,
-        (M.realize_pairMembershipFormula pairing 0 top.succ.succ y.succ.succ e hw htop hy).1 entry⟩
-    · intro z hz
-      have step := (realize_imp M.sets _ _ _).1 (backward z (M.transitive hy hz)) hz
-      obtain ⟨v, hv, step⟩ := (realize_ex M.sets _ _).1 step
-      obtain ⟨w, hw, member, rel, shape⟩ := (realize_ex M.sets _ _).1 step
-      let e := extend w (extend v (extend z env))
-      exact ⟨v, member, w, hw,
-        (M.realize_pairMembershipFormula pairing 1 0 r.succ.succ.succ e hv hw hr).1 rel,
-        (M.realize_orderedPairFormula pairing 2 0 top.succ.succ.succ e (M.transitive hy hz) hw htop).1 shape⟩
-  · rintro ⟨forward, backward⟩
-    constructor
-    · intro v hv
-      rw [realize_imp]
-      intro member
-      obtain ⟨w, hw, rel, entry⟩ := forward v member
-      rw [realize_ex]
-      let e := extend w (extend v env)
-      exact ⟨w, hw,
-        (M.realize_pairMembershipFormula pairing 1 0 r.succ.succ e hv hw hr).2 rel,
-        (M.realize_pairMembershipFormula pairing 0 top.succ.succ y.succ.succ e hw htop hy).2 entry⟩
-    · intro z hz
-      rw [realize_imp]
-      intro member
-      obtain ⟨v, hv, w, hw, rel, shape⟩ := backward z member
-      rw [realize_ex]
-      refine ⟨v, M.transitive hx hv, ?_⟩
-      rw [realize_ex]
-      let e := extend w (extend v (extend z env))
-      exact ⟨w, hw, hv,
-        (M.realize_pairMembershipFormula pairing 1 0 r.succ.succ.succ e (M.transitive hx hv) hw hr).2 rel,
-        (M.realize_orderedPairFormula pairing 2 0 top.succ.succ.succ e hz hw htop).2 shape⟩
-
-theorem rawCheckStep_eq {P : Type u} (s : Presentation P) (one : P) {R x y : ZFSet.{u}}
-    (step : M.RawCheckStep (s.encode one) R x y)
-    (children : ∀ v ∈ x, ∀ w ∈ M.sets, ZFSet.pair v w ∈ R → w = (Name.check s one v).val) :
-    y = (Name.check s one x).val := by
-  apply ZFSet.ext
-  intro z
-  rw [Name.mem_check_code]
-  constructor
-  · intro hz
-    obtain ⟨v, hv, w, hw, rel, eq⟩ := step.2 z hz
-    exact ⟨v, hv, eq.trans (congrArg (fun q => ZFSet.pair q (s.encode one)) (children v hv w hw rel))⟩
-  · rintro ⟨v, hv, rfl⟩
-    obtain ⟨w, hw, rel, entry⟩ := step.1 v hv
-    rwa [children v hv w hw rel] at entry
-
-end PartitionPilot.Forcing.TransitiveGround
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Forcing.GroundSymmetricPowerSet
+
+namespace OAI
+
+
+namespace PartitionPilot.Forcing.Name
+
+open SetRealization
+universe u
+variable {P : Type u} (s : Presentation P)
+
+theorem mem_check_code (one : P) (x z : ZFSet.{u}) :
+    z ∈ (check s one x).val ↔ ∃ y ∈ x, z = ZFSet.pair (check s one y).val (s.encode one) := by
+  rw [check]
+  change z ∈ ZFSet.range _ ↔ _
+  rw [ZFSet.mem_range]
+  constructor
+  · rintro ⟨y, eq⟩
+    exact ⟨y.val, y.property, eq.symm⟩
+  · rintro ⟨y, hy, eq⟩
+    exact ⟨⟨y, hy⟩, eq.symm⟩
+
+end PartitionPilot.Forcing.Name
+
+namespace PartitionPilot.Forcing.SetFormula
+
+def checkStepFormula {n : Nat} (top r x y : Fin n) : SetFormula n :=
+  .conj
+    (.all (imp (.mem 0 x.succ) (ex (.conj (pairMembershipFormula 1 0 r.succ.succ)
+      (pairMembershipFormula 0 top.succ.succ y.succ.succ)))))
+    (.all (imp (.mem 0 y.succ) (ex (ex (.conj (.mem 1 x.succ.succ.succ)
+      (.conj (pairMembershipFormula 1 0 r.succ.succ.succ)
+        (orderedPairFormula 2 0 top.succ.succ.succ)))))))
+
+end PartitionPilot.Forcing.SetFormula
+
+namespace PartitionPilot.Forcing.TransitiveGround
+
+open SetRealization SetFormula
+universe u
+variable (M : TransitiveGround.{u})
+
+def RawCheckStep (top R x y : ZFSet.{u}) : Prop :=
+  (∀ v ∈ x, ∃ w ∈ M.sets, ZFSet.pair v w ∈ R ∧ ZFSet.pair w top ∈ y) ∧
+  (∀ z ∈ y, ∃ v ∈ x, ∃ w ∈ M.sets, ZFSet.pair v w ∈ R ∧ z = ZFSet.pair w top)
+
+theorem rawCheckStep_mono {top R S x y : ZFSet.{u}} (sub : R ⊆ S)
+    (h : M.RawCheckStep top R x y) : M.RawCheckStep top S x y := by
+  constructor
+  · intro v hv
+    obtain ⟨w, hw, rel, entry⟩ := h.1 v hv
+    exact ⟨w, hw, sub rel, entry⟩
+  · intro z hz
+    obtain ⟨v, hv, w, hw, rel, eq⟩ := h.2 z hz
+    exact ⟨v, hv, w, hw, sub rel, eq⟩
+
+theorem realize_checkStepFormula
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    {n : Nat} (top r x y : Fin n) (env : Fin n → ZFSet.{u})
+    (htop : env top ∈ M.sets) (hr : env r ∈ M.sets)
+    (hx : env x ∈ M.sets) (hy : env y ∈ M.sets) :
+    Realize M.sets (checkStepFormula top r x y) env ↔
+      M.RawCheckStep (env top) (env r) (env x) (env y) := by
+  change (Realize M.sets _ env ∧ Realize M.sets _ env) ↔ _
+  constructor
+  · rintro ⟨forward, backward⟩
+    constructor
+    · intro v hv
+      have step := (realize_imp M.sets _ _ _).1 (forward v (M.transitive hx hv)) hv
+      obtain ⟨w, hw, rel, entry⟩ := (realize_ex M.sets _ _).1 step
+      let e := extend w (extend v env)
+      exact ⟨w, hw,
+        (M.realize_pairMembershipFormula pairing 1 0 r.succ.succ e (M.transitive hx hv) hw hr).1 rel,
+        (M.realize_pairMembershipFormula pairing 0 top.succ.succ y.succ.succ e hw htop hy).1 entry⟩
+    · intro z hz
+      have step := (realize_imp M.sets _ _ _).1 (backward z (M.transitive hy hz)) hz
+      obtain ⟨v, hv, step⟩ := (realize_ex M.sets _ _).1 step
+      obtain ⟨w, hw, member, rel, shape⟩ := (realize_ex M.sets _ _).1 step
+      let e := extend w (extend v (extend z env))
+      exact ⟨v, member, w, hw,
+        (M.realize_pairMembershipFormula pairing 1 0 r.succ.succ.succ e hv hw hr).1 rel,
+        (M.realize_orderedPairFormula pairing 2 0 top.succ.succ.succ e (M.transitive hy hz) hw htop).1 shape⟩
+  · rintro ⟨forward, backward⟩
+    constructor
+    · intro v hv
+      rw [realize_imp]
+      intro member
+      obtain ⟨w, hw, rel, entry⟩ := forward v member
+      rw [realize_ex]
+      let e := extend w (extend v env)
+      exact ⟨w, hw,
+        (M.realize_pairMembershipFormula pairing 1 0 r.succ.succ e hv hw hr).2 rel,
+        (M.realize_pairMembershipFormula pairing 0 top.succ.succ y.succ.succ e hw htop hy).2 entry⟩
+    · intro z hz
+      rw [realize_imp]
+      intro member
+      obtain ⟨v, hv, w, hw, rel, shape⟩ := backward z member
+      rw [realize_ex]
+      refine ⟨v, M.transitive hx hv, ?_⟩
+      rw [realize_ex]
+      let e := extend w (extend v (extend z env))
+      exact ⟨w, hw, hv,
+        (M.realize_pairMembershipFormula pairing 1 0 r.succ.succ.succ e (M.transitive hx hv) hw hr).2 rel,
+        (M.realize_orderedPairFormula pairing 2 0 top.succ.succ.succ e hz hw htop).2 shape⟩
+
+theorem rawCheckStep_eq {P : Type u} (s : Presentation P) (one : P) {R x y : ZFSet.{u}}
+    (step : M.RawCheckStep (s.encode one) R x y)
+    (children : ∀ v ∈ x, ∀ w ∈ M.sets, ZFSet.pair v w ∈ R → w = (Name.check s one v).val) :
+    y = (Name.check s one x).val := by
+  apply ZFSet.ext
+  intro z
+  rw [Name.mem_check_code]
+  constructor
+  · intro hz
+    obtain ⟨v, hv, w, hw, rel, eq⟩ := step.2 z hz
+    exact ⟨v, hv, eq.trans (congrArg (fun q => ZFSet.pair q (s.encode one)) (children v hv w hw rel))⟩
+  · rintro ⟨v, hv, rfl⟩
+    obtain ⟨w, hw, rel, entry⟩ := step.1 v hv
+    rwa [children v hv w hw rel] at entry
+
+end PartitionPilot.Forcing.TransitiveGround
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/RawRenameFormulas.lean

@@ -1,141 +1,141 @@
-import OAI.SetTheory.PartitionPrinciple.Forcing.NameRenameSteps
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing.SetFormula
-
-def orientedPairFormula {n : Nat} (reverse : Bool) (x y r : Fin n) : SetFormula n :=
-  if reverse then pairMembershipFormula y x r else pairMembershipFormula x y r
-
-end PartitionPilot.Forcing.SetFormula
-
-namespace PartitionPilot.Forcing.TransitiveGround
-
-open SetFormula
-universe u
-variable (M : TransitiveGround.{u})
-
-theorem realize_orientedPairFormula
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    {n : Nat} (reverse : Bool) (x y r : Fin n) (env : Fin n → ZFSet.{u})
-    (hx : env x ∈ M.sets) (hy : env y ∈ M.sets) (hr : env r ∈ M.sets) :
-    Realize M.sets (orientedPairFormula reverse x y r) env ↔
-      if reverse then ZFSet.pair (env y) (env x) ∈ env r else ZFSet.pair (env x) (env y) ∈ env r := by
-  cases reverse
-  · exact M.realize_pairMembershipFormula pairing x y r env hx hy hr
-  · exact M.realize_pairMembershipFormula pairing y x r env hy hx hr
-
-end PartitionPilot.Forcing.TransitiveGround
-
-
-
-namespace PartitionPilot.Forcing.SetFormula
-
-def renameMatchFormula {n : Nat} (reverse : Bool) (c f r x y : Fin n) : SetFormula n :=
-  .all (allConditions c.succ (imp (pairMembershipFormula 1 0 x.succ.succ)
-    (ex (exConditions c.succ.succ.succ
-      (.conj (pairMembershipFormula 1 0 y.succ.succ.succ.succ)
-        (.conj (orientedPairFormula reverse 2 0 f.succ.succ.succ.succ)
-          (orientedPairFormula reverse 3 1 r.succ.succ.succ.succ)))))))
-
-def renameStepFormula {n : Nat} (c f r x y : Fin n) : SetFormula n :=
-  .conj (renameMatchFormula false c f r x y) (renameMatchFormula true c f r y x)
-
-end PartitionPilot.Forcing.SetFormula
-
-namespace PartitionPilot.Forcing.TransitiveGround
-
-open SetRealization SetFormula
-universe u
-variable (M : TransitiveGround.{u}) {P : Type u} (s : Presentation P)
-
-def RawRenameMatch (reverse : Bool) (f : P → P) (R x y : ZFSet.{u}) : Prop :=
-  ∀ v ∈ M.sets, ∀ p, ZFSet.pair v (s.encode p) ∈ x →
-    ∃ w ∈ M.sets, ∃ q, ZFSet.pair w (s.encode q) ∈ y ∧
-      (if reverse then f q = p else f p = q) ∧
-      (if reverse then ZFSet.pair w v ∈ R else ZFSet.pair v w ∈ R)
-
-def RawRenameStep (f : P → P) (R x y : ZFSet.{u}) : Prop :=
-  M.RawRenameMatch s false f R x y ∧ M.RawRenameMatch s true f R y x
-
-theorem rawRenameStep_mono (f : P → P) {R S x y : ZFSet.{u}} (sub : R ⊆ S)
-    (h : M.RawRenameStep s f R x y) : M.RawRenameStep s f S x y := by
-  constructor
-  · intro v hv p entry
-    obtain ⟨w, hw, q, matched, cond, rel⟩ := h.1 v hv p entry
-    exact ⟨w, hw, q, matched, cond, sub rel⟩
-  · intro w hw q entry
-    obtain ⟨v, hv, p, matched, cond, rel⟩ := h.2 w hw q entry
-    exact ⟨v, hv, p, matched, cond, sub rel⟩
-
-theorem realize_orientedMapFormula
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (carrier : s.carrier ∈ M.sets) (f : P → P) (graph : s.graph s f ∈ M.sets)
-    {n : Nat} (reverse : Bool) (i j k : Fin n) (env : Fin n → ZFSet.{u}) (p q : P)
-    (hi : env i = s.encode p) (hj : env j = s.encode q) (hk : env k = s.graph s f) :
-    Realize M.sets (orientedPairFormula reverse i j k) env ↔
-      if reverse then f q = p else f p = q := by
-  rw [M.realize_orientedPairFormula pairing reverse i j k env
-    (hi ▸ M.transitive carrier (s.encode_mem p)) (hj ▸ M.transitive carrier (s.encode_mem q))
-    (hk ▸ graph), hi, hj, hk]
-  cases reverse
-  · exact s.pair_mem_graph s f p q
-  · exact s.pair_mem_graph s f q p
-
-theorem realize_renameMatchFormula
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (carrier : s.carrier ∈ M.sets) (f : P → P) (graph : s.graph s f ∈ M.sets)
-    {n : Nat} (reverse : Bool) (c g r x y : Fin n) (env : Fin n → ZFSet.{u})
-    (hc : env c = s.carrier) (hg : env g = s.graph s f)
-    (hr : env r ∈ M.sets) (hx : env x ∈ M.sets) (hy : env y ∈ M.sets) :
-    Realize M.sets (renameMatchFormula reverse c g r x y) env ↔
-      M.RawRenameMatch s reverse f (env r) (env x) (env y) := by
-  change (∀ v ∈ M.sets, Realize M.sets _ (extend v env)) ↔ _
-  apply forall_congr'
-  intro v
-  apply forall_congr'
-  intro hv
-  rw [M.realize_allConditions s c.succ _ (extend v env) carrier hc]
-  apply forall_congr'
-  intro p
-  rw [realize_imp, M.realize_pairMembershipFormula pairing 1 0 x.succ.succ
-    (extend (s.encode p) (extend v env)) hv (M.transitive carrier (s.encode_mem p)) hx]
-  apply forall_congr'
-  intro _
-  rw [realize_ex]
-  apply exists_congr
-  intro w
-  apply and_congr_right
-  intro hw
-  rw [M.realize_exConditions s c.succ.succ.succ _ (extend w (extend (s.encode p) (extend v env)))
-    carrier hc]
-  apply exists_congr
-  intro q
-  let e := extend (s.encode q) (extend w (extend (s.encode p) (extend v env)))
-  change (Realize M.sets _ e ∧ Realize M.sets _ e ∧ Realize M.sets _ e) �� _
-  rw [M.realize_pairMembershipFormula pairing 1 0 y.succ.succ.succ.succ e hw
-    (M.transitive carrier (s.encode_mem q)) hy,
-    M.realize_orientedMapFormula s pairing carrier f graph reverse 2 0 g.succ.succ.succ.succ e p q rfl rfl hg,
-    M.realize_orientedPairFormula pairing reverse 3 1 r.succ.succ.succ.succ e hv hw hr]
-  rfl
-
-theorem realize_renameStepFormula
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (carrier : s.carrier ∈ M.sets) (f : P → P) (graph : s.graph s f ∈ M.sets)
-    {n : Nat} (c g r x y : Fin n) (env : Fin n → ZFSet.{u})
-    (hc : env c = s.carrier) (hg : env g = s.graph s f)
-    (hr : env r ∈ M.sets) (hx : env x ∈ M.sets) (hy : env y ∈ M.sets) :
-    Realize M.sets (renameStepFormula c g r x y) env ↔
-      M.RawRenameStep s f (env r) (env x) (env y) := by
-  change (Realize M.sets _ env ∧ Realize M.sets _ env) ↔ _
-  rw [M.realize_renameMatchFormula s pairing carrier f graph false c g r x y env hc hg hr hx hy,
-    M.realize_renameMatchFormula s pairing carrier f graph true c g r y x env hc hg hr hy hx]
-  rfl
-
-end PartitionPilot.Forcing.TransitiveGround
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Forcing.NameRenameSteps
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing.SetFormula
+
+def orientedPairFormula {n : Nat} (reverse : Bool) (x y r : Fin n) : SetFormula n :=
+  if reverse then pairMembershipFormula y x r else pairMembershipFormula x y r
+
+end PartitionPilot.Forcing.SetFormula
+
+namespace PartitionPilot.Forcing.TransitiveGround
+
+open SetFormula
+universe u
+variable (M : TransitiveGround.{u})
+
+theorem realize_orientedPairFormula
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    {n : Nat} (reverse : Bool) (x y r : Fin n) (env : Fin n → ZFSet.{u})
+    (hx : env x ∈ M.sets) (hy : env y ∈ M.sets) (hr : env r ∈ M.sets) :
+    Realize M.sets (orientedPairFormula reverse x y r) env ↔
+      if reverse then ZFSet.pair (env y) (env x) ∈ env r else ZFSet.pair (env x) (env y) ∈ env r := by
+  cases reverse
+  · exact M.realize_pairMembershipFormula pairing x y r env hx hy hr
+  · exact M.realize_pairMembershipFormula pairing y x r env hy hx hr
+
+end PartitionPilot.Forcing.TransitiveGround
+
+
+
+namespace PartitionPilot.Forcing.SetFormula
+
+def renameMatchFormula {n : Nat} (reverse : Bool) (c f r x y : Fin n) : SetFormula n :=
+  .all (allConditions c.succ (imp (pairMembershipFormula 1 0 x.succ.succ)
+    (ex (exConditions c.succ.succ.succ
+      (.conj (pairMembershipFormula 1 0 y.succ.succ.succ.succ)
+        (.conj (orientedPairFormula reverse 2 0 f.succ.succ.succ.succ)
+          (orientedPairFormula reverse 3 1 r.succ.succ.succ.succ)))))))
+
+def renameStepFormula {n : Nat} (c f r x y : Fin n) : SetFormula n :=
+  .conj (renameMatchFormula false c f r x y) (renameMatchFormula true c f r y x)
+
+end PartitionPilot.Forcing.SetFormula
+
+namespace PartitionPilot.Forcing.TransitiveGround
+
+open SetRealization SetFormula
+universe u
+variable (M : TransitiveGround.{u}) {P : Type u} (s : Presentation P)
+
+def RawRenameMatch (reverse : Bool) (f : P → P) (R x y : ZFSet.{u}) : Prop :=
+  ∀ v ∈ M.sets, ∀ p, ZFSet.pair v (s.encode p) ∈ x →
+    ∃ w ∈ M.sets, ∃ q, ZFSet.pair w (s.encode q) ∈ y ∧
+      (if reverse then f q = p else f p = q) ∧
+      (if reverse then ZFSet.pair w v ∈ R else ZFSet.pair v w ∈ R)
+
+def RawRenameStep (f : P → P) (R x y : ZFSet.{u}) : Prop :=
+  M.RawRenameMatch s false f R x y ∧ M.RawRenameMatch s true f R y x
+
+theorem rawRenameStep_mono (f : P → P) {R S x y : ZFSet.{u}} (sub : R ⊆ S)
+    (h : M.RawRenameStep s f R x y) : M.RawRenameStep s f S x y := by
+  constructor
+  · intro v hv p entry
+    obtain ⟨w, hw, q, matched, cond, rel⟩ := h.1 v hv p entry
+    exact ⟨w, hw, q, matched, cond, sub rel⟩
+  · intro w hw q entry
+    obtain ⟨v, hv, p, matched, cond, rel⟩ := h.2 w hw q entry
+    exact ⟨v, hv, p, matched, cond, sub rel⟩
+
+theorem realize_orientedMapFormula
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (carrier : s.carrier ∈ M.sets) (f : P → P) (graph : s.graph s f ∈ M.sets)
+    {n : Nat} (reverse : Bool) (i j k : Fin n) (env : Fin n → ZFSet.{u}) (p q : P)
+    (hi : env i = s.encode p) (hj : env j = s.encode q) (hk : env k = s.graph s f) :
+    Realize M.sets (orientedPairFormula reverse i j k) env ↔
+      if reverse then f q = p else f p = q := by
+  rw [M.realize_orientedPairFormula pairing reverse i j k env
+    (hi ▸ M.transitive carrier (s.encode_mem p)) (hj ▸ M.transitive carrier (s.encode_mem q))
+    (hk ▸ graph), hi, hj, hk]
+  cases reverse
+  · exact s.pair_mem_graph s f p q
+  · exact s.pair_mem_graph s f q p
+
+theorem realize_renameMatchFormula
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (carrier : s.carrier ∈ M.sets) (f : P → P) (graph : s.graph s f ∈ M.sets)
+    {n : Nat} (reverse : Bool) (c g r x y : Fin n) (env : Fin n → ZFSet.{u})
+    (hc : env c = s.carrier) (hg : env g = s.graph s f)
+    (hr : env r ∈ M.sets) (hx : env x ∈ M.sets) (hy : env y ∈ M.sets) :
+    Realize M.sets (renameMatchFormula reverse c g r x y) env ↔
+      M.RawRenameMatch s reverse f (env r) (env x) (env y) := by
+  change (∀ v ∈ M.sets, Realize M.sets _ (extend v env)) ↔ _
+  apply forall_congr'
+  intro v
+  apply forall_congr'
+  intro hv
+  rw [M.realize_allConditions s c.succ _ (extend v env) carrier hc]
+  apply forall_congr'
+  intro p
+  rw [realize_imp, M.realize_pairMembershipFormula pairing 1 0 x.succ.succ
+    (extend (s.encode p) (extend v env)) hv (M.transitive carrier (s.encode_mem p)) hx]
+  apply forall_congr'
+  intro _
+  rw [realize_ex]
+  apply exists_congr
+  intro w
+  apply and_congr_right
+  intro hw
+  rw [M.realize_exConditions s c.succ.succ.succ _ (extend w (extend (s.encode p) (extend v env)))
+    carrier hc]
+  apply exists_congr
+  intro q
+  let e := extend (s.encode q) (extend w (extend (s.encode p) (extend v env)))
+  change (Realize M.sets _ e ∧ Realize M.sets _ e ∧ Realize M.sets _ e) ↔ _
+  rw [M.realize_pairMembershipFormula pairing 1 0 y.succ.succ.succ.succ e hw
+    (M.transitive carrier (s.encode_mem q)) hy,
+    M.realize_orientedMapFormula s pairing carrier f graph reverse 2 0 g.succ.succ.succ.succ e p q rfl rfl hg,
+    M.realize_orientedPairFormula pairing reverse 3 1 r.succ.succ.succ.succ e hv hw hr]
+  rfl
+
+theorem realize_renameStepFormula
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (carrier : s.carrier ∈ M.sets) (f : P → P) (graph : s.graph s f ∈ M.sets)
+    {n : Nat} (c g r x y : Fin n) (env : Fin n → ZFSet.{u})
+    (hc : env c = s.carrier) (hg : env g = s.graph s f)
+    (hr : env r ∈ M.sets) (hx : env x ∈ M.sets) (hy : env y ∈ M.sets) :
+    Realize M.sets (renameStepFormula c g r x y) env ↔
+      M.RawRenameStep s f (env r) (env x) (env y) := by
+  change (Realize M.sets _ env ∧ Realize M.sets _ env) ↔ _
+  rw [M.realize_renameMatchFormula s pairing carrier f graph false c g r x y env hc hg hr hx hy,
+    M.realize_renameMatchFormula s pairing carrier f graph true c g r y x env hc hg hr hy hx]
+  rfl
+
+end PartitionPilot.Forcing.TransitiveGround
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/RecursiveActionRealization.lean

@@ -1,227 +1,227 @@
-import OAI.SetTheory.PartitionPrinciple.Forcing.GroundRecursiveActions
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing.CodedRecursiveMapInputs
-
-open Compression.RecursiveMaps
-universe u
-variable {D rD μD J Qs rs μs As Es Fs Ss I Maps Sources Reps G m inv one A : ZFSet.{u}}
-variable {d : AttachmentBatchInputs D rD μD J Qs rs μs As Es Fs Ss}
-variable (h : CodedRecursiveMapInputs d I Maps Sources Reps G m inv one A)
-variable (M : TransitiveGround.{u}) (next : h.NextInputs M)
-
-theorem next_upper (label : h.toInputs.Labels)
-    (x : {x : ZFSet.{u} // x ∈ D} ⊕ d.templates.Fresh) :
-    next.templates.upper (h.nextIndex label) ⟨d.coding.encode x, d.coding.encode_mem x⟩ ↔
-      h.toInputs.nextBatch.upper label x := by
-  change d.coding.encode x ∈ next.filter (h.nextIndex label) ↔ _
-  rw [h.next_filter M next, mem_pushFilterCode]
-  constructor
-  · rintro ⟨_, a, ha, z, _, entry, lower⟩
-    let a' : {a : ZFSet.{u} // a ∈ D} := ⟨a, (d.fiber label.2.val).filter.subset ha⟩
-    have equal := (show FunctionGraphOn D (h.maps.value label.1) from
-      ⟨d.batchCarrier, (h.valid _ _ (h.maps.value_entry label.1)).injection.function⟩).unique
-      entry (h.toInputs_previous_entry label.1 a')
-    exact ⟨a', ha, (d.coding.le_encode _ x).1 (equal ▸ lower)⟩
-  · rintro ⟨a, ha, lower⟩
-    exact ⟨d.coding.encode_mem x, a.val, ha,
-      d.coding.encode ((h.toInputs.previous label.1).toFun a), d.coding.encode_mem _,
-      h.toInputs_previous_entry label.1 a, (d.coding.le_encode _ x).2 lower⟩
-
-theorem nextFresh_shadow (q : h.toInputs.nextBatch.Fresh) :
-    (next.templates.shadow (h.nextFresh M next q)).val =
-      d.coding.encode (h.toInputs.nextBatch.shadow q) := by
-  have oldEntry := (d.fiber q.1.2.val).shadow_entry ⟨(), q.2⟩
-  obtain ⟨_, _, c, hc, meetEntry, baseEntry⟩ :=
-    (pair_mem_attachmentShadowGraph _ _ _ _ _ _ _).1 oldEntry
-  apply Eq.symm
-  apply next.freshCode_shadow_value (h.nextFresh M next q)
-  apply (next.batch_shadow_entry_iff (h.nextIndex q.1) q.2.val.val _).2
-  rw [h.next_space M next, h.next_meet M next, h.next_embed M next, h.next_anchor M next]
-  apply (pair_mem_attachmentShadowGraph _ _ _ _ _ _ _).2
-  refine ⟨q.2.val.property, d.coding.encode_mem _, c, hc, meetEntry, ?_⟩
-  apply (pair_mem_relationCompose _ _ _ _ _ _ _).2
-  refine ⟨mem_familyPointBound_of_entry (d.space_entry q.1.2.val) hc,
-    d.coding.encode_mem _, (d.templates.shadow ⟨q.1.2.val, q.2⟩).val,
-    (d.templates.shadow ⟨q.1.2.val, q.2⟩).property, baseEntry, ?_⟩
-  exact h.toInputs_previous_entry q.1.1 (d.templates.shadow ⟨q.1.2.val, q.2⟩)
-
-noncomputable def nextNodes :
-    ({x : ZFSet.{u} // x ∈ D} ⊕ d.templates.Fresh) ⊕ h.toInputs.nextBatch.Fresh →
-      {x : ZFSet.{u} // x ∈ d.batchCarrier} ⊕ next.templates.Fresh
-  | .inl x => .inl ⟨d.coding.encode x, d.coding.encode_mem x⟩
-  | .inr q => .inr (h.nextFresh M next q)
-
-noncomputable def nextEncode
-    (x : ({x : ZFSet.{u} // x ∈ D} ⊕ d.templates.Fresh) ⊕ h.toInputs.nextBatch.Fresh) :
-    ZFSet.{u} := next.coding.encode (h.nextNodes M next x)
-
-theorem nextEncode_old (x : {x : ZFSet.{u} // x ∈ D} ⊕ d.templates.Fresh) :
-    h.nextEncode M next (.inl x) = d.coding.encode x := rfl
-
-theorem nextEncode_fresh (q : h.toInputs.nextBatch.Fresh) :
-    h.nextEncode M next (.inr q) = ZFSet.pair d.batchCarrier
-      (ZFSet.pair (ZFSet.pair q.1.1.val q.1.2.val.val) q.2.val.val) := rfl
-
-theorem nextEncode_mem
-    (x : ({x : ZFSet.{u} // x ∈ D} ⊕ d.templates.Fresh) ⊕ h.toInputs.nextBatch.Fresh) :
-    h.nextEncode M next x ∈ next.batchCarrier := next.coding.encode_mem _
-
-theorem nextNodes_injective : Function.Injective (h.nextNodes M next) := by
-  intro x y equal
-  cases x with
-  | inl x =>
-    cases y with
-    | inl y =>
-      exact congrArg Sum.inl (d.coding.encode_injective
-        (congrArg Subtype.val (Sum.inl.inj equal)))
-    | inr y => cases equal
-  | inr x =>
-    cases y with
-    | inl y => cases equal
-    | inr y => exact congrArg Sum.inr (h.nextFresh_injective M next (Sum.inr.inj equal))
-
-theorem nextNodes_surjective : Function.Surjective (h.nextNodes M next) := by
-  intro x
-  cases x with
-  | inl x =>
-    obtain ⟨y, equal⟩ := d.coding.encode_surjective x.val x.property
-    exact ⟨.inl y, congrArg Sum.inl (Subtype.ext equal)⟩
-  | inr q =>
-    obtain ⟨p, equal⟩ := h.nextFresh_surjective M next q
-    exact ⟨.inr p, congrArg Sum.inr equal⟩
-
-theorem nextEncode_injective : Function.Injective (h.nextEncode M next) :=
-  fun _ _ equal => h.nextNodes_injective M next (next.coding.encode_injective equal)
-
-theorem nextEncode_surjective : ∀ z ∈ next.batchCarrier,
-    ∃ x, h.nextEncode M next x = z := by
-  intro z hz
-  obtain ⟨y, equal⟩ := next.coding.encode_surjective z hz
-  obtain ⟨x, rfl⟩ := h.nextNodes_surjective M next y
-  exact ⟨x, equal⟩
-
-theorem next_le_encode
-    (x y : ({x : ZFSet.{u} // x ∈ D} ⊕ d.templates.Fresh) ⊕ h.toInputs.nextBatch.Fresh) :
-    ZFSet.pair (h.nextEncode M next x) (h.nextEncode M next y) ∈ next.batchOrder ↔
-      h.toInputs.nextBatch.extension.le x y := by
-  change ZFSet.pair (next.coding.encode (h.nextNodes M next x))
-    (next.coding.encode (h.nextNodes M next y)) ∈ next.batchOrder ↔ _
-  rw [next.coding.le_encode]
-  cases x with
-  | inl x =>
-    cases y with
-    | inl y => exact d.coding.le_encode x y
-    | inr q =>
-      change ZFSet.pair (d.coding.encode x) (next.templates.shadow (h.nextFresh M next q)).val ∈
-        d.batchOrder ↔ d.templates.extension.le x (h.toInputs.nextBatch.shadow q)
-      rw [h.nextFresh_shadow M next]
-      exact d.coding.le_encode x _
-  | inr q =>
-    cases y with
-    | inl y => exact h.next_upper M next q.1 y
-    | inr t =>
-      change (next.templates.Inside (h.nextFresh M next q) (h.nextFresh M next t) ∨
-        next.templates.upper (h.nextIndex q.1) (next.templates.shadow (h.nextFresh M next t))) ↔
-        (h.toInputs.nextBatch.Inside q t ∨
-          h.toInputs.nextBatch.upper q.1 (h.toInputs.nextBatch.shadow t))
-      apply or_congr (h.nextFresh_inside_iff M next q t)
-      have equal : next.templates.shadow (h.nextFresh M next t) =
-          ⟨d.coding.encode (h.toInputs.nextBatch.shadow t), d.coding.encode_mem _⟩ :=
-        Subtype.ext (h.nextFresh_shadow M next t)
-      rw [equal]
-      exact h.next_upper M next q.1 _
-
-theorem next_meet_entry
-    (x y : ({x : ZFSet.{u} // x ∈ D} ⊕ d.templates.Fresh) ⊕ h.toInputs.nextBatch.Fresh) :
-    ZFSet.pair (ZFSet.pair (h.nextEncode M next x) (h.nextEncode M next y))
-      (h.nextEncode M next (h.toInputs.nextBatch.extension.meet x y)) ∈ next.batchMeetGraph := by
-  apply next.batch_meetOrder.pair_iff.2
-  refine ⟨h.nextEncode_mem M next x, h.nextEncode_mem M next y, h.nextEncode_mem M next _,
-    (h.next_le_encode M next _ x).2 (h.toInputs.nextBatch.extension.meet_le_left x y),
-    (h.next_le_encode M next _ y).2 (h.toInputs.nextBatch.extension.meet_le_right x y), ?_⟩
-  intro z hz zx zy
-  obtain ⟨w, rfl⟩ := h.nextEncode_surjective M next z hz
-  exact (h.next_le_encode M next _ _).2 (h.toInputs.nextBatch.extension.le_meet
-    ((h.next_le_encode M next _ _).1 zx) ((h.next_le_encode M next _ _).1 zy))
-
-end PartitionPilot.Forcing.CodedRecursiveMapInputs
-
-
-
-namespace PartitionPilot.Forcing.CodedRecursiveTaskAction
-
-universe u
-variable {D rD μD J Qs rs μs As Es Fs Ss I Maps Sources Reps G m inv one A T : ZFSet.{u}}
-variable {d : AttachmentBatchInputs D rD μD J Qs rs μs As Es Fs Ss}
-variable {h : CodedRecursiveMapInputs d I Maps Sources Reps G m inv one A}
-variable (s : CodedRecursiveTaskAction h T)
-variable (M : TransitiveGround.{u}) (next : h.NextInputs M)
-
-theorem nextAction_entry (g : {g : ZFSet.{u} // g ∈ G})
-    (x : ({x : ZFSet.{u} // x ∈ D} ⊕ d.templates.Fresh) ⊕ h.toInputs.nextBatch.Fresh) :
-    ZFSet.pair (ZFSet.pair g.val (h.nextEncode M next x))
-      (h.nextEncode M next ((s.toTaskSymmetry g).nextIso.toFun x)) ∈ h.nextActionGraph T := by
-  cases x with
-  | inl x =>
-    rw [(s.toTaskSymmetry g).nextIso_old, h.nextEncode_old, h.nextEncode_old]
-    exact (h.nextAction_old_iff (d.coding.encode_mem x)).2 (s.toTaskSymmetry_current_entry g x)
-  | inr q =>
-    rw [(s.toTaskSymmetry g).nextIso_fresh, h.nextEncode_fresh, h.nextEncode_fresh]
-    exact h.nextAction_fresh_entry s.taskAction s.source
-      (s.toTaskSymmetry_perm_entry g q.1.1) (next.freshCode_mem (h.nextFresh M next q))
-
-theorem nextAction_entry_iff (g : {g : ZFSet.{u} // g ∈ G})
-    (x : ({x : ZFSet.{u} // x ∈ D} ⊕ d.templates.Fresh) ⊕ h.toInputs.nextBatch.Fresh)
-    (y : ZFSet.{u}) :
-    ZFSet.pair (ZFSet.pair g.val (h.nextEncode M next x)) y ∈ h.nextActionGraph T ↔
-      y = h.nextEncode M next ((s.toTaskSymmetry g).nextIso.toFun x) := by
-  constructor
-  · intro entry
-    exact (h.nextAction_setAction s.taskAction s.source M next).entry_unique entry
-      (s.nextAction_entry M next g x)
-  · intro equal
-    exact equal.symm ▸ s.nextAction_entry M next g x
-
-include s in
-theorem nextAction_order_iff {g x y x' y' : ZFSet.{u}}
-    (first : ZFSet.pair (ZFSet.pair g x) x' ∈ h.nextActionGraph T)
-    (second : ZFSet.pair (ZFSet.pair g y) y' ∈ h.nextActionGraph T) :
-    ZFSet.pair x' y' ∈ next.batchOrder ↔ ZFSet.pair x y ∈ next.batchOrder := by
-  have sx := (h.nextAction_setAction s.taskAction s.source M next).entry_shape first
-  have sy := (h.nextAction_setAction s.taskAction s.source M next).entry_shape second
-  let actor : {g : ZFSet.{u} // g ∈ G} := ⟨g, sx.1⟩
-  obtain ⟨a, rfl⟩ := h.nextEncode_surjective M next x sx.2.1
-  obtain ⟨b, rfl⟩ := h.nextEncode_surjective M next y sy.2.1
-  rw [(s.nextAction_entry_iff M next actor a x').1 first,
-    (s.nextAction_entry_iff M next actor b y').1 second, h.next_le_encode, h.next_le_encode]
-  exact (s.toTaskSymmetry actor).nextIso.le_iff a b
-
-include s in
-theorem nextAction_code :
-    PosetActionCode G next.batchCarrier m one next.batchOrder (h.nextActionGraph T) where
-  function := (h.nextAction_setAction s.taskAction s.source M next).function
-  one := (h.nextAction_setAction s.taskAction s.source M next).one
-  mul := (h.nextAction_setAction s.taskAction s.source M next).mul
-  monotone := fun _ _ _ _ _ _ _ _ _ _ first second lower =>
-    (s.nextAction_order_iff M next first second).2 lower
-
-include s in
-theorem nextAction_map_meet {g x y z x' y' z' : ZFSet.{u}}
-    (meet : ZFSet.pair (ZFSet.pair x y) z ∈ next.batchMeetGraph)
-    (first : ZFSet.pair (ZFSet.pair g x) x' ∈ h.nextActionGraph T)
-    (second : ZFSet.pair (ZFSet.pair g y) y' ∈ h.nextActionGraph T)
-    (third : ZFSet.pair (ZFSet.pair g z) z' ∈ h.nextActionGraph T) :
-    ZFSet.pair (ZFSet.pair x' y') z' ∈ next.batchMeetGraph :=
-  (s.nextAction_code M next).raw_map_meet h.group next.batch_meetOrder
-    ((h.nextAction_setAction s.taskAction s.source M next).entry_shape first).1
-    meet first second third
-
-end PartitionPilot.Forcing.CodedRecursiveTaskAction
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Forcing.GroundRecursiveActions
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing.CodedRecursiveMapInputs
+
+open Compression.RecursiveMaps
+universe u
+variable {D rD μD J Qs rs μs As Es Fs Ss I Maps Sources Reps G m inv one A : ZFSet.{u}}
+variable {d : AttachmentBatchInputs D rD μD J Qs rs μs As Es Fs Ss}
+variable (h : CodedRecursiveMapInputs d I Maps Sources Reps G m inv one A)
+variable (M : TransitiveGround.{u}) (next : h.NextInputs M)
+
+theorem next_upper (label : h.toInputs.Labels)
+    (x : {x : ZFSet.{u} // x ∈ D} ⊕ d.templates.Fresh) :
+    next.templates.upper (h.nextIndex label) ⟨d.coding.encode x, d.coding.encode_mem x⟩ ↔
+      h.toInputs.nextBatch.upper label x := by
+  change d.coding.encode x ∈ next.filter (h.nextIndex label) ↔ _
+  rw [h.next_filter M next, mem_pushFilterCode]
+  constructor
+  · rintro ⟨_, a, ha, z, _, entry, lower⟩
+    let a' : {a : ZFSet.{u} // a ∈ D} := ⟨a, (d.fiber label.2.val).filter.subset ha⟩
+    have equal := (show FunctionGraphOn D (h.maps.value label.1) from
+      ⟨d.batchCarrier, (h.valid _ _ (h.maps.value_entry label.1)).injection.function⟩).unique
+      entry (h.toInputs_previous_entry label.1 a')
+    exact ⟨a', ha, (d.coding.le_encode _ x).1 (equal ▸ lower)⟩
+  · rintro ⟨a, ha, lower⟩
+    exact ⟨d.coding.encode_mem x, a.val, ha,
+      d.coding.encode ((h.toInputs.previous label.1).toFun a), d.coding.encode_mem _,
+      h.toInputs_previous_entry label.1 a, (d.coding.le_encode _ x).2 lower⟩
+
+theorem nextFresh_shadow (q : h.toInputs.nextBatch.Fresh) :
+    (next.templates.shadow (h.nextFresh M next q)).val =
+      d.coding.encode (h.toInputs.nextBatch.shadow q) := by
+  have oldEntry := (d.fiber q.1.2.val).shadow_entry ⟨(), q.2⟩
+  obtain ⟨_, _, c, hc, meetEntry, baseEntry⟩ :=
+    (pair_mem_attachmentShadowGraph _ _ _ _ _ _ _).1 oldEntry
+  apply Eq.symm
+  apply next.freshCode_shadow_value (h.nextFresh M next q)
+  apply (next.batch_shadow_entry_iff (h.nextIndex q.1) q.2.val.val _).2
+  rw [h.next_space M next, h.next_meet M next, h.next_embed M next, h.next_anchor M next]
+  apply (pair_mem_attachmentShadowGraph _ _ _ _ _ _ _).2
+  refine ⟨q.2.val.property, d.coding.encode_mem _, c, hc, meetEntry, ?_⟩
+  apply (pair_mem_relationCompose _ _ _ _ _ _ _).2
+  refine ⟨mem_familyPointBound_of_entry (d.space_entry q.1.2.val) hc,
+    d.coding.encode_mem _, (d.templates.shadow ⟨q.1.2.val, q.2⟩).val,
+    (d.templates.shadow ⟨q.1.2.val, q.2⟩).property, baseEntry, ?_⟩
+  exact h.toInputs_previous_entry q.1.1 (d.templates.shadow ⟨q.1.2.val, q.2⟩)
+
+noncomputable def nextNodes :
+    ({x : ZFSet.{u} // x ∈ D} ⊕ d.templates.Fresh) ⊕ h.toInputs.nextBatch.Fresh →
+      {x : ZFSet.{u} // x ∈ d.batchCarrier} ⊕ next.templates.Fresh
+  | .inl x => .inl ⟨d.coding.encode x, d.coding.encode_mem x⟩
+  | .inr q => .inr (h.nextFresh M next q)
+
+noncomputable def nextEncode
+    (x : ({x : ZFSet.{u} // x ∈ D} ⊕ d.templates.Fresh) ⊕ h.toInputs.nextBatch.Fresh) :
+    ZFSet.{u} := next.coding.encode (h.nextNodes M next x)
+
+theorem nextEncode_old (x : {x : ZFSet.{u} // x ∈ D} ⊕ d.templates.Fresh) :
+    h.nextEncode M next (.inl x) = d.coding.encode x := rfl
+
+theorem nextEncode_fresh (q : h.toInputs.nextBatch.Fresh) :
+    h.nextEncode M next (.inr q) = ZFSet.pair d.batchCarrier
+      (ZFSet.pair (ZFSet.pair q.1.1.val q.1.2.val.val) q.2.val.val) := rfl
+
+theorem nextEncode_mem
+    (x : ({x : ZFSet.{u} // x ∈ D} ⊕ d.templates.Fresh) ⊕ h.toInputs.nextBatch.Fresh) :
+    h.nextEncode M next x ∈ next.batchCarrier := next.coding.encode_mem _
+
+theorem nextNodes_injective : Function.Injective (h.nextNodes M next) := by
+  intro x y equal
+  cases x with
+  | inl x =>
+    cases y with
+    | inl y =>
+      exact congrArg Sum.inl (d.coding.encode_injective
+        (congrArg Subtype.val (Sum.inl.inj equal)))
+    | inr y => cases equal
+  | inr x =>
+    cases y with
+    | inl y => cases equal
+    | inr y => exact congrArg Sum.inr (h.nextFresh_injective M next (Sum.inr.inj equal))
+
+theorem nextNodes_surjective : Function.Surjective (h.nextNodes M next) := by
+  intro x
+  cases x with
+  | inl x =>
+    obtain ⟨y, equal⟩ := d.coding.encode_surjective x.val x.property
+    exact ⟨.inl y, congrArg Sum.inl (Subtype.ext equal)⟩
+  | inr q =>
+    obtain ⟨p, equal⟩ := h.nextFresh_surjective M next q
+    exact ⟨.inr p, congrArg Sum.inr equal⟩
+
+theorem nextEncode_injective : Function.Injective (h.nextEncode M next) :=
+  fun _ _ equal => h.nextNodes_injective M next (next.coding.encode_injective equal)
+
+theorem nextEncode_surjective : ∀ z ∈ next.batchCarrier,
+    ∃ x, h.nextEncode M next x = z := by
+  intro z hz
+  obtain ⟨y, equal⟩ := next.coding.encode_surjective z hz
+  obtain ⟨x, rfl⟩ := h.nextNodes_surjective M next y
+  exact ⟨x, equal⟩
+
+theorem next_le_encode
+    (x y : ({x : ZFSet.{u} // x ∈ D} ⊕ d.templates.Fresh) ⊕ h.toInputs.nextBatch.Fresh) :
+    ZFSet.pair (h.nextEncode M next x) (h.nextEncode M next y) ∈ next.batchOrder ↔
+      h.toInputs.nextBatch.extension.le x y := by
+  change ZFSet.pair (next.coding.encode (h.nextNodes M next x))
+    (next.coding.encode (h.nextNodes M next y)) ∈ next.batchOrder ↔ _
+  rw [next.coding.le_encode]
+  cases x with
+  | inl x =>
+    cases y with
+    | inl y => exact d.coding.le_encode x y
+    | inr q =>
+      change ZFSet.pair (d.coding.encode x) (next.templates.shadow (h.nextFresh M next q)).val ∈
+        d.batchOrder ↔ d.templates.extension.le x (h.toInputs.nextBatch.shadow q)
+      rw [h.nextFresh_shadow M next]
+      exact d.coding.le_encode x _
+  | inr q =>
+    cases y with
+    | inl y => exact h.next_upper M next q.1 y
+    | inr t =>
+      change (next.templates.Inside (h.nextFresh M next q) (h.nextFresh M next t) ∨
+        next.templates.upper (h.nextIndex q.1) (next.templates.shadow (h.nextFresh M next t))) ↔
+        (h.toInputs.nextBatch.Inside q t ∨
+          h.toInputs.nextBatch.upper q.1 (h.toInputs.nextBatch.shadow t))
+      apply or_congr (h.nextFresh_inside_iff M next q t)
+      have equal : next.templates.shadow (h.nextFresh M next t) =
+          ⟨d.coding.encode (h.toInputs.nextBatch.shadow t), d.coding.encode_mem _⟩ :=
+        Subtype.ext (h.nextFresh_shadow M next t)
+      rw [equal]
+      exact h.next_upper M next q.1 _
+
+theorem next_meet_entry
+    (x y : ({x : ZFSet.{u} // x ∈ D} ⊕ d.templates.Fresh) ⊕ h.toInputs.nextBatch.Fresh) :
+    ZFSet.pair (ZFSet.pair (h.nextEncode M next x) (h.nextEncode M next y))
+      (h.nextEncode M next (h.toInputs.nextBatch.extension.meet x y)) ∈ next.batchMeetGraph := by
+  apply next.batch_meetOrder.pair_iff.2
+  refine ⟨h.nextEncode_mem M next x, h.nextEncode_mem M next y, h.nextEncode_mem M next _,
+    (h.next_le_encode M next _ x).2 (h.toInputs.nextBatch.extension.meet_le_left x y),
+    (h.next_le_encode M next _ y).2 (h.toInputs.nextBatch.extension.meet_le_right x y), ?_⟩
+  intro z hz zx zy
+  obtain ⟨w, rfl⟩ := h.nextEncode_surjective M next z hz
+  exact (h.next_le_encode M next _ _).2 (h.toInputs.nextBatch.extension.le_meet
+    ((h.next_le_encode M next _ _).1 zx) ((h.next_le_encode M next _ _).1 zy))
+
+end PartitionPilot.Forcing.CodedRecursiveMapInputs
+
+
+
+namespace PartitionPilot.Forcing.CodedRecursiveTaskAction
+
+universe u
+variable {D rD μD J Qs rs μs As Es Fs Ss I Maps Sources Reps G m inv one A T : ZFSet.{u}}
+variable {d : AttachmentBatchInputs D rD μD J Qs rs μs As Es Fs Ss}
+variable {h : CodedRecursiveMapInputs d I Maps Sources Reps G m inv one A}
+variable (s : CodedRecursiveTaskAction h T)
+variable (M : TransitiveGround.{u}) (next : h.NextInputs M)
+
+theorem nextAction_entry (g : {g : ZFSet.{u} // g ∈ G})
+    (x : ({x : ZFSet.{u} // x ∈ D} ⊕ d.templates.Fresh) ⊕ h.toInputs.nextBatch.Fresh) :
+    ZFSet.pair (ZFSet.pair g.val (h.nextEncode M next x))
+      (h.nextEncode M next ((s.toTaskSymmetry g).nextIso.toFun x)) ∈ h.nextActionGraph T := by
+  cases x with
+  | inl x =>
+    rw [(s.toTaskSymmetry g).nextIso_old, h.nextEncode_old, h.nextEncode_old]
+    exact (h.nextAction_old_iff (d.coding.encode_mem x)).2 (s.toTaskSymmetry_current_entry g x)
+  | inr q =>
+    rw [(s.toTaskSymmetry g).nextIso_fresh, h.nextEncode_fresh, h.nextEncode_fresh]
+    exact h.nextAction_fresh_entry s.taskAction s.source
+      (s.toTaskSymmetry_perm_entry g q.1.1) (next.freshCode_mem (h.nextFresh M next q))
+
+theorem nextAction_entry_iff (g : {g : ZFSet.{u} // g ∈ G})
+    (x : ({x : ZFSet.{u} // x ∈ D} ⊕ d.templates.Fresh) ⊕ h.toInputs.nextBatch.Fresh)
+    (y : ZFSet.{u}) :
+    ZFSet.pair (ZFSet.pair g.val (h.nextEncode M next x)) y ∈ h.nextActionGraph T ↔
+      y = h.nextEncode M next ((s.toTaskSymmetry g).nextIso.toFun x) := by
+  constructor
+  · intro entry
+    exact (h.nextAction_setAction s.taskAction s.source M next).entry_unique entry
+      (s.nextAction_entry M next g x)
+  · intro equal
+    exact equal.symm ▸ s.nextAction_entry M next g x
+
+include s in
+theorem nextAction_order_iff {g x y x' y' : ZFSet.{u}}
+    (first : ZFSet.pair (ZFSet.pair g x) x' ∈ h.nextActionGraph T)
+    (second : ZFSet.pair (ZFSet.pair g y) y' ∈ h.nextActionGraph T) :
+    ZFSet.pair x' y' ∈ next.batchOrder ↔ ZFSet.pair x y ∈ next.batchOrder := by
+  have sx := (h.nextAction_setAction s.taskAction s.source M next).entry_shape first
+  have sy := (h.nextAction_setAction s.taskAction s.source M next).entry_shape second
+  let actor : {g : ZFSet.{u} // g ∈ G} := ⟨g, sx.1⟩
+  obtain ⟨a, rfl⟩ := h.nextEncode_surjective M next x sx.2.1
+  obtain ⟨b, rfl⟩ := h.nextEncode_surjective M next y sy.2.1
+  rw [(s.nextAction_entry_iff M next actor a x').1 first,
+    (s.nextAction_entry_iff M next actor b y').1 second, h.next_le_encode, h.next_le_encode]
+  exact (s.toTaskSymmetry actor).nextIso.le_iff a b
+
+include s in
+theorem nextAction_code :
+    PosetActionCode G next.batchCarrier m one next.batchOrder (h.nextActionGraph T) where
+  function := (h.nextAction_setAction s.taskAction s.source M next).function
+  one := (h.nextAction_setAction s.taskAction s.source M next).one
+  mul := (h.nextAction_setAction s.taskAction s.source M next).mul
+  monotone := fun _ _ _ _ _ _ _ _ _ _ first second lower =>
+    (s.nextAction_order_iff M next first second).2 lower
+
+include s in
+theorem nextAction_map_meet {g x y z x' y' z' : ZFSet.{u}}
+    (meet : ZFSet.pair (ZFSet.pair x y) z ∈ next.batchMeetGraph)
+    (first : ZFSet.pair (ZFSet.pair g x) x' ∈ h.nextActionGraph T)
+    (second : ZFSet.pair (ZFSet.pair g y) y' ∈ h.nextActionGraph T)
+    (third : ZFSet.pair (ZFSet.pair g z) z' ∈ h.nextActionGraph T) :
+    ZFSet.pair (ZFSet.pair x' y') z' ∈ next.batchMeetGraph :=
+  (s.nextAction_code M next).raw_map_meet h.group next.batch_meetOrder
+    ((h.nextAction_setAction s.taskAction s.source M next).entry_shape first).1
+    meet first second third
+
+end PartitionPilot.Forcing.CodedRecursiveTaskAction
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/RecursivePrimitiveFormulas.lean

@@ -1,114 +1,114 @@
-import OAI.SetTheory.PartitionPrinciple.Transfinite.RecursiveLiftAgreement
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing
-open SetFormula
-universe u
-
-namespace SetFormula
-def recursiveIndicesSetFormula {n} (output i j p bound sources filters : Fin n) : SetFormula n :=
-  exactSetFormula output (BoundedFormula.recursiveAttachmentIndexFormula 0 i.succ j.succ
-    p.succ bound.succ sources.succ filters.succ).toFormula
-
-def pairFieldSetFormula {n} (left : Bool) (output i j k bound family : Fin n) : SetFormula n :=
-  exactSetFormula output (BoundedFormula.pairFieldEntryFormula left 0 k.succ i.succ j.succ
-    bound.succ family.succ).toFormula
-
-def indexedFreshSetFormula {n} (output i qs rs anchors qb rb ab : Fin n) : SetFormula n :=
-  exactSetFormula output (BoundedFormula.indexedAttachmentFreshEntryFormula 0 i.succ qs.succ
-    rs.succ anchors.succ qb.succ rb.succ ab.succ).toFormula
-
-end SetFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-variable (unions : Realize M.sets SetFormula.union Fin.elim0)
-variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-include pairing unions powers separation
-
-theorem realize_recursiveIndicesSetFormula {n} (output i j p bound sources filters : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ x, env x ∈ M.sets) :
-    Realize M.sets (recursiveIndicesSetFormula output i j p bound sources filters) env ↔
-      env output = recursiveAttachmentIndices (env i) (env j) (env p) (env bound)
-        (env sources) (env filters) := by
-  apply M.realize_exactBoundedSetFormula output _ env members
-    (M.recursiveAttachmentIndices_mem pairing unions powers separation (members i) (members j)
-      (members p) (members bound) (members sources) (members filters))
-  intro z
-  rw [BoundedFormula.truth_recursiveAttachmentIndexFormula]
-  change (∃ x ∈ env i, ∃ y ∈ env j, ∃ a ∈ env p, ∃ F ∈ env bound,
-    z = ZFSet.pair x y ∧ ZFSet.pair x a ∈ env sources ∧
-      ZFSet.pair y F ∈ env filters ∧ a ∉ F) ↔ _
-  rw [recursiveAttachmentIndices, ZFSet.mem_sep]
-  constructor
-  · intro witness
-    refine ⟨?_, witness⟩
-    obtain ⟨x, hx, y, hy, _, _, _, _, equal, _⟩ := witness
-    rw [equal]
-    exact ZFSet.pair_mem_prod.2 ⟨hx, hy⟩
-  · exact And.right
-
-theorem realize_pairFieldSetFormula {n} (left : Bool) (output i j k bound family : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ x, env x ∈ M.sets) :
-    Realize M.sets (pairFieldSetFormula left output i j k bound family) env ↔
-      env output = pairFieldGraph left (env i) (env j) (env k) (env bound) (env family) := by
-  apply M.realize_exactBoundedSetFormula output _ env members
-    (M.pairFieldGraph_mem pairing unions powers separation left (members i) (members j)
-      (members k) (members bound) (members family))
-  intro z
-  rw [BoundedFormula.truth_pairFieldEntryFormula]
-  change (∃ t ∈ env k, ∃ x ∈ env i, ∃ y ∈ env j, ∃ v ∈ env bound,
-    z = ZFSet.pair t v ∧ t = ZFSet.pair x y ∧
-      ZFSet.pair (if left then x else y) v ∈ env family) ↔ _
-  rw [pairFieldGraph, ZFSet.mem_sep]
-  constructor
-  · intro witness
-    refine ⟨?_, witness⟩
-    obtain ⟨t, ht, _, _, _, _, v, hv, equal, _⟩ := witness
-    rw [equal]
-    exact ZFSet.pair_mem_prod.2 ⟨ht, hv⟩
-  · exact And.right
-
-theorem realize_pairSecondFieldSetFormula {n} (output i j k bound family : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ x, env x ∈ M.sets)
-    (bound_eq : env bound = ZFSet.sUnion (ZFSet.sUnion (env family))) :
-    Realize M.sets (pairFieldSetFormula false output i j k bound family) env ↔
-      env output = pairSecondField (env i) (env j) (env k) (env family) := by
-  rw [M.realize_pairFieldSetFormula pairing unions powers separation false output i j k bound family
-    env members, bound_eq]
-  rfl
-
-theorem realize_indexedFreshSetFormula {n} (output i qs rs anchors qb rb ab : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ x, env x ∈ M.sets)
-    (qBound : env qb = ZFSet.sUnion (ZFSet.sUnion (env qs)))
-    (rBound : env rb = ZFSet.sUnion (ZFSet.sUnion (env rs)))
-    (aBound : env ab = ZFSet.sUnion (ZFSet.sUnion (env anchors))) :
-    Realize M.sets (indexedFreshSetFormula output i qs rs anchors qb rb ab) env ↔
-      env output = indexedAttachmentFresh (env i) (env qs) (env rs) (env anchors) := by
-  apply M.realize_exactBoundedSetFormula output _ env members
-    (M.indexedAttachmentFresh_mem pairing unions powers separation (members i) (members qs)
-      (members rs) (members anchors))
-  intro z
-  rw [BoundedFormula.truth_indexedAttachmentFreshEntryFormula]
-  change (∃ j ∈ env i, ∃ Q ∈ env qb, ∃ r ∈ env rb, ∃ a ∈ env ab, ∃ q ∈ Q,
-    ZFSet.pair j Q ∈ env qs ∧ ZFSet.pair j r ∈ env rs ∧ ZFSet.pair j a ∈ env anchors ∧
-      z = ZFSet.pair j q ∧ ZFSet.pair q a ∉ r) ↔ _
-  rw [qBound, rBound, aBound, indexedAttachmentFresh, ZFSet.mem_sep]
-  constructor
-  · intro witness
-    refine ⟨?_, witness⟩
-    obtain ⟨j, hj, Q, _, _, _, _, _, q, hq, entry, _, _, equal, _⟩ := witness
-    rw [equal]
-    exact (pair_mem_indexedAttachmentDomain (env i) (env qs) j q).2 ⟨hj, Q, entry, hq⟩
-  · exact And.right
-
-end TransitiveGround
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Transfinite.RecursiveLiftAgreement
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing
+open SetFormula
+universe u
+
+namespace SetFormula
+def recursiveIndicesSetFormula {n} (output i j p bound sources filters : Fin n) : SetFormula n :=
+  exactSetFormula output (BoundedFormula.recursiveAttachmentIndexFormula 0 i.succ j.succ
+    p.succ bound.succ sources.succ filters.succ).toFormula
+
+def pairFieldSetFormula {n} (left : Bool) (output i j k bound family : Fin n) : SetFormula n :=
+  exactSetFormula output (BoundedFormula.pairFieldEntryFormula left 0 k.succ i.succ j.succ
+    bound.succ family.succ).toFormula
+
+def indexedFreshSetFormula {n} (output i qs rs anchors qb rb ab : Fin n) : SetFormula n :=
+  exactSetFormula output (BoundedFormula.indexedAttachmentFreshEntryFormula 0 i.succ qs.succ
+    rs.succ anchors.succ qb.succ rb.succ ab.succ).toFormula
+
+end SetFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+variable (unions : Realize M.sets SetFormula.union Fin.elim0)
+variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+include pairing unions powers separation
+
+theorem realize_recursiveIndicesSetFormula {n} (output i j p bound sources filters : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ x, env x ∈ M.sets) :
+    Realize M.sets (recursiveIndicesSetFormula output i j p bound sources filters) env ↔
+      env output = recursiveAttachmentIndices (env i) (env j) (env p) (env bound)
+        (env sources) (env filters) := by
+  apply M.realize_exactBoundedSetFormula output _ env members
+    (M.recursiveAttachmentIndices_mem pairing unions powers separation (members i) (members j)
+      (members p) (members bound) (members sources) (members filters))
+  intro z
+  rw [BoundedFormula.truth_recursiveAttachmentIndexFormula]
+  change (∃ x ∈ env i, ∃ y ∈ env j, ∃ a ∈ env p, ∃ F ∈ env bound,
+    z = ZFSet.pair x y ∧ ZFSet.pair x a ∈ env sources ∧
+      ZFSet.pair y F ∈ env filters ∧ a ∉ F) ↔ _
+  rw [recursiveAttachmentIndices, ZFSet.mem_sep]
+  constructor
+  · intro witness
+    refine ⟨?_, witness⟩
+    obtain ⟨x, hx, y, hy, _, _, _, _, equal, _⟩ := witness
+    rw [equal]
+    exact ZFSet.pair_mem_prod.2 ⟨hx, hy⟩
+  · exact And.right
+
+theorem realize_pairFieldSetFormula {n} (left : Bool) (output i j k bound family : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ x, env x ∈ M.sets) :
+    Realize M.sets (pairFieldSetFormula left output i j k bound family) env ↔
+      env output = pairFieldGraph left (env i) (env j) (env k) (env bound) (env family) := by
+  apply M.realize_exactBoundedSetFormula output _ env members
+    (M.pairFieldGraph_mem pairing unions powers separation left (members i) (members j)
+      (members k) (members bound) (members family))
+  intro z
+  rw [BoundedFormula.truth_pairFieldEntryFormula]
+  change (∃ t ∈ env k, ∃ x ∈ env i, ∃ y ∈ env j, ∃ v ∈ env bound,
+    z = ZFSet.pair t v ∧ t = ZFSet.pair x y ∧
+      ZFSet.pair (if left then x else y) v ∈ env family) ↔ _
+  rw [pairFieldGraph, ZFSet.mem_sep]
+  constructor
+  · intro witness
+    refine ⟨?_, witness⟩
+    obtain ⟨t, ht, _, _, _, _, v, hv, equal, _⟩ := witness
+    rw [equal]
+    exact ZFSet.pair_mem_prod.2 ⟨ht, hv⟩
+  · exact And.right
+
+theorem realize_pairSecondFieldSetFormula {n} (output i j k bound family : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ x, env x ∈ M.sets)
+    (bound_eq : env bound = ZFSet.sUnion (ZFSet.sUnion (env family))) :
+    Realize M.sets (pairFieldSetFormula false output i j k bound family) env ↔
+      env output = pairSecondField (env i) (env j) (env k) (env family) := by
+  rw [M.realize_pairFieldSetFormula pairing unions powers separation false output i j k bound family
+    env members, bound_eq]
+  rfl
+
+theorem realize_indexedFreshSetFormula {n} (output i qs rs anchors qb rb ab : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ x, env x ∈ M.sets)
+    (qBound : env qb = ZFSet.sUnion (ZFSet.sUnion (env qs)))
+    (rBound : env rb = ZFSet.sUnion (ZFSet.sUnion (env rs)))
+    (aBound : env ab = ZFSet.sUnion (ZFSet.sUnion (env anchors))) :
+    Realize M.sets (indexedFreshSetFormula output i qs rs anchors qb rb ab) env ↔
+      env output = indexedAttachmentFresh (env i) (env qs) (env rs) (env anchors) := by
+  apply M.realize_exactBoundedSetFormula output _ env members
+    (M.indexedAttachmentFresh_mem pairing unions powers separation (members i) (members qs)
+      (members rs) (members anchors))
+  intro z
+  rw [BoundedFormula.truth_indexedAttachmentFreshEntryFormula]
+  change (∃ j ∈ env i, ∃ Q ∈ env qb, ∃ r ∈ env rb, ∃ a ∈ env ab, ∃ q ∈ Q,
+    ZFSet.pair j Q ∈ env qs ∧ ZFSet.pair j r ∈ env rs ∧ ZFSet.pair j a ∈ env anchors ∧
+      z = ZFSet.pair j q ∧ ZFSet.pair q a ∉ r) ↔ _
+  rw [qBound, rBound, aBound, indexedAttachmentFresh, ZFSet.mem_sep]
+  constructor
+  · intro witness
+    refine ⟨?_, witness⟩
+    obtain ⟨j, hj, Q, _, _, _, _, _, q, hq, entry, _, _, equal, _⟩ := witness
+    rw [equal]
+    exact (pair_mem_indexedAttachmentDomain (env i) (env qs) j q).2 ⟨hj, Q, entry, hq⟩
+  · exact And.right
+
+end TransitiveGround
+end PartitionPilot.Forcing
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/RefinementDataHistoryEntryFormulas.lean

@@ -1,108 +1,108 @@
-import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundStructuralHistoryTestUnions
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing
-open SetFormula
-universe u
-
-theorem mem_refinementDataHistoryIndices (stages history x : ZFSet.{u}) :
-    x ∈ refinementDataHistoryIndices stages history ↔
-      ∃ alpha ∈ stages, ∃ d : Fin 15 → ZFSet.{u},
-        ZFSet.pair alpha (refinementFormulaDataCode d) ∈ history ∧ x ∈ d 0 := by
-  rw [refinementDataHistoryIndices, mem_refinementHistoryIndices]
-  constructor
-  · rintro ⟨alpha, halpha, I, entry, member⟩
-    obtain ⟨_, d, stored, rfl⟩ := (pair_mem_refinementDataHistoryField _ _ _ _ _).1 entry
-    exact ⟨alpha, halpha, d, stored, member⟩
-  · rintro ⟨alpha, halpha, d, entry, member⟩
-    exact ⟨alpha, halpha, d 0,
-      (pair_mem_refinementDataHistoryField _ _ _ _ _).2 ⟨halpha, d, entry, rfl⟩, member⟩
-
-theorem pair_mem_refinementDataHistoryLevels (stages history T assignment xi : ZFSet.{u}) :
-    ZFSet.pair assignment xi ∈ refinementDataHistoryLevels stages history T ↔
-      ∃ i ∈ refinementDataHistoryIndices stages history, ∃ u ∈ T, ∃ w ∈ T,
-        assignment = stageOneAssignment i u w ∧ xi ∈ stages ∧
-          ∃ fields : Fin 6 → ZFSet.{u}, i = nonemptyTupleCode 5 fields ∧ xi = fields 0 := by
-  change ZFSet.pair assignment xi ∈ assignmentIndexLevels
-    (refinementDataHistoryIndices stages history) T stages
-    (refinementIndexFieldGraph (refinementDataHistoryIndices stages history) stages 0) ↔ _
-  rw [pair_mem_assignmentIndexLevels]
-  constructor
-  · rintro ⟨i, hi, u, hu, w, hw, equal, hxi, entry⟩
-    exact ⟨i, hi, u, hu, w, hw, equal, hxi,
-      ((pair_mem_refinementIndexFieldGraph _ _ _ _ _).1 entry).2.2⟩
-  · rintro ⟨i, hi, u, hu, w, hw, equal, hxi, fields⟩
-    exact ⟨i, hi, u, hu, w, hw, equal, hxi,
-      (pair_mem_refinementIndexFieldGraph _ _ _ _ _).2 ⟨hi, hxi, fields⟩⟩
-
-namespace BoundedFormula
-noncomputable def refinementDataHistoryIndicesEntryFormula {n : Nat}
-    (stages history x : Fin n) : BoundedFormula n :=
-  exGraphFields history (.conj (.mem 1 stages.succ.succ)
-    (exPairFields 0 (.conj (tupleShapeFormula 13 0) (.mem x.succ.succ.succ.succ 1))))
-
-theorem truth_refinementDataHistoryIndicesEntryFormula {n : Nat}
-    (stages history x : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (refinementDataHistoryIndicesEntryFormula stages history x) env ↔
-      env x ∈ refinementDataHistoryIndices (env stages) (env history) := by
-  rw [mem_refinementDataHistoryIndices]
-  simp only [refinementDataHistoryIndicesEntryFormula, truth_exGraphFields, Truth,
-    truth_exPairFields, truth_tupleShapeFormula]
-  change (∃ alpha data, ZFSet.pair alpha data ∈ env history ∧ alpha ∈ env stages ∧
-    ∃ I tail, data = ZFSet.pair I tail ∧ (∃ fields : Fin 14 → ZFSet.{u},
-      tail = nonemptyTupleCode 13 fields) ∧ env x ∈ I) ↔ _
-  constructor
-  · rintro ⟨alpha, data, entry, halpha, I, tail, pair, ⟨fields, tuple⟩, member⟩
-    let d : Fin 15 → ZFSet.{u} := Fin.cases I fields
-    refine ⟨alpha, halpha, d, ?_, member⟩
-    have equal : data = refinementFormulaDataCode d := pair.trans (congrArg (ZFSet.pair I) tuple)
-    exact equal ▸ entry
-  · rintro ⟨alpha, halpha, d, entry, member⟩
-    exact ⟨alpha, refinementFormulaDataCode d, entry, halpha, d 0,
-      nonemptyTupleCode 13 (fun i => d i.succ), rfl,
-      ⟨fun i => d i.succ, rfl⟩, member⟩
-
-noncomputable def refinementDataHistoryLevelsEntryFormula {n : Nat}
-    (stages history T z : Fin n) : BoundedFormula n :=
-  let lift (i : Fin n) := i.succ.succ.succ.succ.succ.succ
-  exPairFields z (exPairFields 1 (exPairFields 0
-    (.conj (refinementDataHistoryIndicesEntryFormula (lift stages) (lift history) 3)
-      (.conj (.mem 1 (lift T)) (.conj (.mem 0 (lift T))
-        (.conj (.mem 4 (lift stages)) (tupleFieldFormula 5 3 4 0)))))))
-
-theorem truth_refinementDataHistoryLevelsEntryFormula {n : Nat}
-    (stages history T z : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (refinementDataHistoryLevelsEntryFormula stages history T z) env ↔
-      env z ∈ refinementDataHistoryLevels (env stages) (env history) (env T) := by
-  simp only [refinementDataHistoryLevelsEntryFormula, truth_exPairFields, Truth,
-    truth_refinementDataHistoryIndicesEntryFormula, truth_tupleFieldFormula]
-  change (∃ assignment xi, env z = ZFSet.pair assignment xi ∧
-    ∃ i tail, assignment = ZFSet.pair i tail ∧ ∃ u w, tail = ZFSet.pair u w ∧
-      i ∈ refinementDataHistoryIndices (env stages) (env history) ∧ u ∈ env T ∧ w ∈ env T ∧
-        xi ∈ env stages ∧ ∃ fields : Fin 6 → ZFSet.{u},
-          i = nonemptyTupleCode 5 fields ∧ xi = fields 0) ↔ _
-  constructor
-  · rintro ⟨assignment, xi, equal, i, tail, pair, u, w, tailEq, hi, hu, hw, hxi, fields⟩
-    rw [equal]
-    apply (pair_mem_refinementDataHistoryLevels _ _ _ _ _).2
-    exact ⟨i, hi, u, hu, w, hw, pair.trans (congrArg (ZFSet.pair i) tailEq), hxi, fields⟩
-  · intro member
-    have raw := member
-    unfold refinementDataHistoryLevels refinementHistoryAssignmentLevels assignmentIndexLevels relationCompose at raw
-    have shape := (ZFSet.mem_sep.1 raw).1
-    obtain ⟨assignment, _, xi, _, equal⟩ := ZFSet.mem_prod.1 shape
-    rw [equal] at member
-    obtain ⟨i, hi, u, hu, w, hw, pair, hxi, fields⟩ :=
-      (pair_mem_refinementDataHistoryLevels _ _ _ _ _).1 member
-    exact ⟨assignment, xi, equal, i, ZFSet.pair u w, pair, u, w, rfl, hi, hu, hw, hxi, fields⟩
-
-end BoundedFormula
-
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundStructuralHistoryTestUnions
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing
+open SetFormula
+universe u
+
+theorem mem_refinementDataHistoryIndices (stages history x : ZFSet.{u}) :
+    x ∈ refinementDataHistoryIndices stages history ↔
+      ∃ alpha ∈ stages, ∃ d : Fin 15 → ZFSet.{u},
+        ZFSet.pair alpha (refinementFormulaDataCode d) ∈ history ∧ x ∈ d 0 := by
+  rw [refinementDataHistoryIndices, mem_refinementHistoryIndices]
+  constructor
+  · rintro ⟨alpha, halpha, I, entry, member⟩
+    obtain ⟨_, d, stored, rfl⟩ := (pair_mem_refinementDataHistoryField _ _ _ _ _).1 entry
+    exact ⟨alpha, halpha, d, stored, member⟩
+  · rintro ⟨alpha, halpha, d, entry, member⟩
+    exact ⟨alpha, halpha, d 0,
+      (pair_mem_refinementDataHistoryField _ _ _ _ _).2 ⟨halpha, d, entry, rfl⟩, member⟩
+
+theorem pair_mem_refinementDataHistoryLevels (stages history T assignment xi : ZFSet.{u}) :
+    ZFSet.pair assignment xi ∈ refinementDataHistoryLevels stages history T ↔
+      ∃ i ∈ refinementDataHistoryIndices stages history, ∃ u ∈ T, ∃ w ∈ T,
+        assignment = stageOneAssignment i u w ∧ xi ∈ stages ∧
+          ∃ fields : Fin 6 → ZFSet.{u}, i = nonemptyTupleCode 5 fields ∧ xi = fields 0 := by
+  change ZFSet.pair assignment xi ∈ assignmentIndexLevels
+    (refinementDataHistoryIndices stages history) T stages
+    (refinementIndexFieldGraph (refinementDataHistoryIndices stages history) stages 0) ↔ _
+  rw [pair_mem_assignmentIndexLevels]
+  constructor
+  · rintro ⟨i, hi, u, hu, w, hw, equal, hxi, entry⟩
+    exact ⟨i, hi, u, hu, w, hw, equal, hxi,
+      ((pair_mem_refinementIndexFieldGraph _ _ _ _ _).1 entry).2.2⟩
+  · rintro ⟨i, hi, u, hu, w, hw, equal, hxi, fields⟩
+    exact ⟨i, hi, u, hu, w, hw, equal, hxi,
+      (pair_mem_refinementIndexFieldGraph _ _ _ _ _).2 ⟨hi, hxi, fields⟩⟩
+
+namespace BoundedFormula
+noncomputable def refinementDataHistoryIndicesEntryFormula {n : Nat}
+    (stages history x : Fin n) : BoundedFormula n :=
+  exGraphFields history (.conj (.mem 1 stages.succ.succ)
+    (exPairFields 0 (.conj (tupleShapeFormula 13 0) (.mem x.succ.succ.succ.succ 1))))
+
+theorem truth_refinementDataHistoryIndicesEntryFormula {n : Nat}
+    (stages history x : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (refinementDataHistoryIndicesEntryFormula stages history x) env ↔
+      env x ∈ refinementDataHistoryIndices (env stages) (env history) := by
+  rw [mem_refinementDataHistoryIndices]
+  simp only [refinementDataHistoryIndicesEntryFormula, truth_exGraphFields, Truth,
+    truth_exPairFields, truth_tupleShapeFormula]
+  change (∃ alpha data, ZFSet.pair alpha data ∈ env history ∧ alpha ∈ env stages ∧
+    ∃ I tail, data = ZFSet.pair I tail ∧ (∃ fields : Fin 14 → ZFSet.{u},
+      tail = nonemptyTupleCode 13 fields) ∧ env x ∈ I) ↔ _
+  constructor
+  · rintro ⟨alpha, data, entry, halpha, I, tail, pair, ⟨fields, tuple⟩, member⟩
+    let d : Fin 15 → ZFSet.{u} := Fin.cases I fields
+    refine ⟨alpha, halpha, d, ?_, member⟩
+    have equal : data = refinementFormulaDataCode d := pair.trans (congrArg (ZFSet.pair I) tuple)
+    exact equal ▸ entry
+  · rintro ⟨alpha, halpha, d, entry, member⟩
+    exact ⟨alpha, refinementFormulaDataCode d, entry, halpha, d 0,
+      nonemptyTupleCode 13 (fun i => d i.succ), rfl,
+      ⟨fun i => d i.succ, rfl⟩, member⟩
+
+noncomputable def refinementDataHistoryLevelsEntryFormula {n : Nat}
+    (stages history T z : Fin n) : BoundedFormula n :=
+  let lift (i : Fin n) := i.succ.succ.succ.succ.succ.succ
+  exPairFields z (exPairFields 1 (exPairFields 0
+    (.conj (refinementDataHistoryIndicesEntryFormula (lift stages) (lift history) 3)
+      (.conj (.mem 1 (lift T)) (.conj (.mem 0 (lift T))
+        (.conj (.mem 4 (lift stages)) (tupleFieldFormula 5 3 4 0)))))))
+
+theorem truth_refinementDataHistoryLevelsEntryFormula {n : Nat}
+    (stages history T z : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (refinementDataHistoryLevelsEntryFormula stages history T z) env ↔
+      env z ∈ refinementDataHistoryLevels (env stages) (env history) (env T) := by
+  simp only [refinementDataHistoryLevelsEntryFormula, truth_exPairFields, Truth,
+    truth_refinementDataHistoryIndicesEntryFormula, truth_tupleFieldFormula]
+  change (∃ assignment xi, env z = ZFSet.pair assignment xi ∧
+    ∃ i tail, assignment = ZFSet.pair i tail ∧ ∃ u w, tail = ZFSet.pair u w ∧
+      i ∈ refinementDataHistoryIndices (env stages) (env history) ∧ u ∈ env T ∧ w ∈ env T ∧
+        xi ∈ env stages ∧ ∃ fields : Fin 6 → ZFSet.{u},
+          i = nonemptyTupleCode 5 fields ∧ xi = fields 0) ↔ _
+  constructor
+  · rintro ⟨assignment, xi, equal, i, tail, pair, u, w, tailEq, hi, hu, hw, hxi, fields⟩
+    rw [equal]
+    apply (pair_mem_refinementDataHistoryLevels _ _ _ _ _).2
+    exact ⟨i, hi, u, hu, w, hw, pair.trans (congrArg (ZFSet.pair i) tailEq), hxi, fields⟩
+  · intro member
+    have raw := member
+    unfold refinementDataHistoryLevels refinementHistoryAssignmentLevels assignmentIndexLevels relationCompose at raw
+    have shape := (ZFSet.mem_sep.1 raw).1
+    obtain ⟨assignment, _, xi, _, equal⟩ := ZFSet.mem_prod.1 shape
+    rw [equal] at member
+    obtain ⟨i, hi, u, hu, w, hw, pair, hxi, fields⟩ :=
+      (pair_mem_refinementDataHistoryLevels _ _ _ _ _).1 member
+    exact ⟨assignment, xi, equal, i, ZFSet.pair u w, pair, u, w, rfl, hi, hu, hw, hxi, fields⟩
+
+end BoundedFormula
+
+end PartitionPilot.Forcing
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/RefinementHistoryOrderOutputFormulas.lean

@@ -1,180 +1,180 @@
-import OAI.SetTheory.PartitionPrinciple.Geometry.GroundDefinableRowAssignmentOrders
-import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundDefinableRefinementHistories
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing
-open SetRealization SetFormula
-universe u
-
-namespace SetFormula
-
-noncomputable def refinementHistoryForcingOutputFormula {n : Nat}
-    (output rows T stages history N : Fin n) : SetFormula n :=
-  let old := suffixIndex n 2
-  let v := prefixIndex n 2
-  exBlock 2 (.conj (refinementDataHistoryIndicesSetFormula (v 0) (old stages) (old history))
-    (.conj (refinementDataHistoryLevelsSetFormula (v 1) (old stages) (old history) (old T))
-      (forcingHistoryConditionsOutputFormula (old output) (old rows) (v 0) (old T)
-        (old stages) (old history) (v 1) (old N))))
-
-end SetFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-variable (unions : Realize M.sets SetFormula.union Fin.elim0)
-variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-include pairing unions powers separation
-
-theorem realize_refinementHistoryForcingOutputFormula {n : Nat}
-    (output rows T stages history N : Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
-    (naturals : env N = ZFSet.omega) :
-    Realize M.sets (refinementHistoryForcingOutputFormula output rows T stages history N) env ↔
-      env output = M.refinementHistoryForcing (env rows) (env T) (env stages) (env history) := by
-  rw [refinementHistoryForcingOutputFormula, realize_exBlock]
-  have actual (fields : Fin 2 → ZFSet.{u}) (ground : ∀ j, fields j ∈ M.sets) :
-      Realize M.sets (.conj
-        (refinementDataHistoryIndicesSetFormula (prefixIndex n 2 0)
-          (suffixIndex n 2 stages) (suffixIndex n 2 history))
-        (.conj (refinementDataHistoryLevelsSetFormula (prefixIndex n 2 1)
-          (suffixIndex n 2 stages) (suffixIndex n 2 history) (suffixIndex n 2 T))
-          (forcingHistoryConditionsOutputFormula (suffixIndex n 2 output) (suffixIndex n 2 rows)
-            (prefixIndex n 2 0) (suffixIndex n 2 T) (suffixIndex n 2 stages)
-            (suffixIndex n 2 history) (prefixIndex n 2 1) (suffixIndex n 2 N))))
-        (extendMany 2 fields env) ↔
-      fields 0 = refinementDataHistoryIndices (env stages) (env history) ∧
-        fields 1 = refinementDataHistoryLevels (env stages) (env history) (env T) ∧
-        env output = M.forcingHistoryConditions (env rows) (fields 0) (env T)
-          (env stages) (env history) (fields 1) := by
-    have bounds := extendMany_members 2 fields env ground members
-    apply and_congr
-    · simpa only [extendMany_prefix, extendMany_suffix] using
-        M.realize_refinementDataHistoryIndicesSetFormula pairing unions powers separation
-          (prefixIndex n 2 0) (suffixIndex n 2 stages) (suffixIndex n 2 history)
-          (extendMany 2 fields env) bounds
-    apply and_congr
-    · simpa only [extendMany_prefix, extendMany_suffix] using
-        M.realize_refinementDataHistoryLevelsSetFormula pairing unions powers separation
-          (prefixIndex n 2 1) (suffixIndex n 2 stages) (suffixIndex n 2 history) (suffixIndex n 2 T)
-          (extendMany 2 fields env) bounds
-    · simpa only [extendMany_prefix, extendMany_suffix] using
-        M.realize_forcingHistoryConditionsOutputFormula pairing separation
-          (suffixIndex n 2 output) (suffixIndex n 2 rows) (prefixIndex n 2 0)
-          (suffixIndex n 2 T) (suffixIndex n 2 stages) (suffixIndex n 2 history)
-          (prefixIndex n 2 1) (suffixIndex n 2 N) (extendMany 2 fields env) bounds
-          (by simpa only [extendMany_suffix] using naturals)
-  constructor
-  · rintro ⟨fields, ground, body⟩
-    obtain ⟨indices, levels, outputEq⟩ := (actual fields ground).1 body
-    rw [indices, levels] at outputEq
-    exact outputEq
-  · intro equal
-    let fields : Fin 2 → ZFSet.{u} :=
-      ![refinementDataHistoryIndices (env stages) (env history),
-        refinementDataHistoryLevels (env stages) (env history) (env T)]
-    have ground : ∀ j, fields j ∈ M.sets :=
-      Fin.cases (M.refinementDataHistoryIndices_mem pairing unions powers separation
-        (members stages) (members history))
-        (Fin.cases (M.refinementDataHistoryLevels_mem pairing unions powers separation
-          (members stages) (members history) (members T)) (fun j => Fin.elim0 j))
-    exact ⟨fields, ground, (actual fields ground).2 ⟨rfl, rfl, equal⟩⟩
-
-theorem exists_unique_refinementHistoryForcingOutput
-    {rows T stages history : ZFSet.{u}}
-    (hRows : rows ∈ M.sets) (hT : T ∈ M.sets)
-    (hStages : stages ∈ M.sets) (hHistory : history ∈ M.sets)
-    (omega : ZFSet.omega ∈ M.sets) :
-    ∃ output ∈ M.sets,
-      Realize M.sets (refinementHistoryForcingOutputFormula 0 1 2 3 4 5)
-        ![output, rows, T, stages, history, ZFSet.omega] ∧
-      ∀ other ∈ M.sets,
-        Realize M.sets (refinementHistoryForcingOutputFormula 0 1 2 3 4 5)
-          ![other, rows, T, stages, history, ZFSet.omega] → other = output := by
-  have ground := M.refinementHistoryForcing_mem pairing unions powers separation hRows hT hStages hHistory omega
-  have meaning (output : ZFSet.{u}) (hOutput : output ∈ M.sets) :
-      Realize M.sets (refinementHistoryForcingOutputFormula 0 1 2 3 4 5)
-        ![output, rows, T, stages, history, ZFSet.omega] ↔
-      output = M.refinementHistoryForcing rows T stages history :=
-    M.realize_refinementHistoryForcingOutputFormula pairing unions powers separation 0 1 2 3 4 5 _
-      (Fin.cases hOutput (Fin.cases hRows (Fin.cases hT (Fin.cases hStages
-        (Fin.cases hHistory (Fin.cases omega (fun j => Fin.elim0 j))))))) rfl
-  exact ⟨_, ground, (meaning _ ground).2 rfl, fun other member valid => (meaning other member).1 valid⟩
-
-end TransitiveGround
-end PartitionPilot.Forcing
-
-
-
-namespace PartitionPilot.Forcing.TransitiveGround
-open SetFormula
-universe u
-variable (M : TransitiveGround.{u})
-variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-variable (unions : Realize M.sets SetFormula.union Fin.elim0)
-variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-
-noncomputable def refinementHistoryOrderOutputFormula {n : Nat}
-    (output rows rowOrder T stages history N : Fin n) : SetFormula n :=
-  .ex (.conj (refinementHistoryForcingOutputFormula 0 rows.succ T.succ stages.succ history.succ N.succ)
-    (M.rawRowAssignmentOrderOutputFormula pairing unions powers separation output.succ 0 rowOrder.succ))
-
-theorem realize_refinementHistoryOrderOutputFormula {n : Nat}
-    (output rows rowOrder T stages history N : Fin n) (env : Fin n → ZFSet.{u})
-    (members : ∀ j, env j ∈ M.sets) (naturals : env N = ZFSet.omega) :
-    Realize M.sets (M.refinementHistoryOrderOutputFormula pairing unions powers separation
-      output rows rowOrder T stages history N) env ↔
-      env output = M.refinementHistoryOrder (env rows) (env rowOrder) (env T) (env stages) (env history) := by
-  unfold refinementHistoryOrderOutputFormula
-  rw [realize_ex]
-  have meaning (Q : ZFSet.{u}) (hQ : Q ∈ M.sets) :
-      Realize M.sets (.conj
-        (refinementHistoryForcingOutputFormula 0 rows.succ T.succ stages.succ history.succ N.succ)
-        (M.rawRowAssignmentOrderOutputFormula pairing unions powers separation output.succ 0 rowOrder.succ))
-        (extend Q env) ↔
-      Q = M.refinementHistoryForcing (env rows) (env T) (env stages) (env history) ∧
-        env output = rawRowAssignmentOrder Q (env rowOrder) :=
-    and_congr (M.realize_refinementHistoryForcingOutputFormula pairing unions powers separation
-      0 rows.succ T.succ stages.succ history.succ N.succ (extend Q env) (Fin.cases hQ members) naturals)
-      (M.realize_rawRowAssignmentOrderOutputFormula pairing unions powers separation
-        output.succ 0 rowOrder.succ (extend Q env) (Fin.cases hQ members))
-  constructor
-  · rintro ⟨Q, hQ, recognized⟩
-    obtain ⟨rfl, equal⟩ := (meaning Q hQ).1 recognized
-    rw [M.refinementHistoryOrder_raw]
-    exact equal
-  · intro equal
-    have ground := M.refinementHistoryForcing_mem pairing unions powers separation
-      (members rows) (members T) (members stages) (members history) (naturals ▸ members N)
-    refine ⟨_, ground, (meaning _ ground).2 ⟨rfl, ?_⟩⟩
-    rw [M.refinementHistoryOrder_raw] at equal
-    exact equal
-
-theorem exists_unique_refinementHistoryOrderOutput
-    {rows rowOrder T stages history : ZFSet.{u}}
-    (hRows : rows ∈ M.sets) (hOrder : rowOrder ∈ M.sets) (hT : T ∈ M.sets)
-    (hStages : stages ∈ M.sets) (hHistory : history ∈ M.sets) (omega : ZFSet.omega ∈ M.sets) :
-    ∃ output ∈ M.sets,
-      Realize M.sets (M.refinementHistoryOrderOutputFormula pairing unions powers separation 0 1 2 3 4 5 6)
-        ![output, rows, rowOrder, T, stages, history, ZFSet.omega] ∧
-      ∀ other ∈ M.sets,
-        Realize M.sets (M.refinementHistoryOrderOutputFormula pairing unions powers separation 0 1 2 3 4 5 6)
-          ![other, rows, rowOrder, T, stages, history, ZFSet.omega] → other = output := by
-  have ground := M.refinementHistoryOrder_mem pairing unions powers separation hRows hOrder hT hStages hHistory omega
-  have meaning (output : ZFSet.{u}) (hOutput : output ∈ M.sets) :
-      Realize M.sets (M.refinementHistoryOrderOutputFormula pairing unions powers separation 0 1 2 3 4 5 6)
-        ![output, rows, rowOrder, T, stages, history, ZFSet.omega] ↔
-      output = M.refinementHistoryOrder rows rowOrder T stages history :=
-    M.realize_refinementHistoryOrderOutputFormula pairing unions powers separation 0 1 2 3 4 5 6 _
-      (Fin.cases hOutput (Fin.cases hRows (Fin.cases hOrder (Fin.cases hT (Fin.cases hStages
-        (Fin.cases hHistory (Fin.cases omega (fun j => Fin.elim0 j)))))))) rfl
-  exact ⟨_, ground, (meaning _ ground).2 rfl, fun other member valid => (meaning other member).1 valid⟩
-
-end PartitionPilot.Forcing.TransitiveGround
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Geometry.GroundDefinableRowAssignmentOrders
+import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundDefinableRefinementHistories
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing
+open SetRealization SetFormula
+universe u
+
+namespace SetFormula
+
+noncomputable def refinementHistoryForcingOutputFormula {n : Nat}
+    (output rows T stages history N : Fin n) : SetFormula n :=
+  let old := suffixIndex n 2
+  let v := prefixIndex n 2
+  exBlock 2 (.conj (refinementDataHistoryIndicesSetFormula (v 0) (old stages) (old history))
+    (.conj (refinementDataHistoryLevelsSetFormula (v 1) (old stages) (old history) (old T))
+      (forcingHistoryConditionsOutputFormula (old output) (old rows) (v 0) (old T)
+        (old stages) (old history) (v 1) (old N))))
+
+end SetFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+variable (unions : Realize M.sets SetFormula.union Fin.elim0)
+variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+include pairing unions powers separation
+
+theorem realize_refinementHistoryForcingOutputFormula {n : Nat}
+    (output rows T stages history N : Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets)
+    (naturals : env N = ZFSet.omega) :
+    Realize M.sets (refinementHistoryForcingOutputFormula output rows T stages history N) env ↔
+      env output = M.refinementHistoryForcing (env rows) (env T) (env stages) (env history) := by
+  rw [refinementHistoryForcingOutputFormula, realize_exBlock]
+  have actual (fields : Fin 2 → ZFSet.{u}) (ground : ∀ j, fields j ∈ M.sets) :
+      Realize M.sets (.conj
+        (refinementDataHistoryIndicesSetFormula (prefixIndex n 2 0)
+          (suffixIndex n 2 stages) (suffixIndex n 2 history))
+        (.conj (refinementDataHistoryLevelsSetFormula (prefixIndex n 2 1)
+          (suffixIndex n 2 stages) (suffixIndex n 2 history) (suffixIndex n 2 T))
+          (forcingHistoryConditionsOutputFormula (suffixIndex n 2 output) (suffixIndex n 2 rows)
+            (prefixIndex n 2 0) (suffixIndex n 2 T) (suffixIndex n 2 stages)
+            (suffixIndex n 2 history) (prefixIndex n 2 1) (suffixIndex n 2 N))))
+        (extendMany 2 fields env) ↔
+      fields 0 = refinementDataHistoryIndices (env stages) (env history) ∧
+        fields 1 = refinementDataHistoryLevels (env stages) (env history) (env T) ∧
+        env output = M.forcingHistoryConditions (env rows) (fields 0) (env T)
+          (env stages) (env history) (fields 1) := by
+    have bounds := extendMany_members 2 fields env ground members
+    apply and_congr
+    · simpa only [extendMany_prefix, extendMany_suffix] using
+        M.realize_refinementDataHistoryIndicesSetFormula pairing unions powers separation
+          (prefixIndex n 2 0) (suffixIndex n 2 stages) (suffixIndex n 2 history)
+          (extendMany 2 fields env) bounds
+    apply and_congr
+    · simpa only [extendMany_prefix, extendMany_suffix] using
+        M.realize_refinementDataHistoryLevelsSetFormula pairing unions powers separation
+          (prefixIndex n 2 1) (suffixIndex n 2 stages) (suffixIndex n 2 history) (suffixIndex n 2 T)
+          (extendMany 2 fields env) bounds
+    · simpa only [extendMany_prefix, extendMany_suffix] using
+        M.realize_forcingHistoryConditionsOutputFormula pairing separation
+          (suffixIndex n 2 output) (suffixIndex n 2 rows) (prefixIndex n 2 0)
+          (suffixIndex n 2 T) (suffixIndex n 2 stages) (suffixIndex n 2 history)
+          (prefixIndex n 2 1) (suffixIndex n 2 N) (extendMany 2 fields env) bounds
+          (by simpa only [extendMany_suffix] using naturals)
+  constructor
+  · rintro ⟨fields, ground, body⟩
+    obtain ⟨indices, levels, outputEq⟩ := (actual fields ground).1 body
+    rw [indices, levels] at outputEq
+    exact outputEq
+  · intro equal
+    let fields : Fin 2 → ZFSet.{u} :=
+      ![refinementDataHistoryIndices (env stages) (env history),
+        refinementDataHistoryLevels (env stages) (env history) (env T)]
+    have ground : ∀ j, fields j ∈ M.sets :=
+      Fin.cases (M.refinementDataHistoryIndices_mem pairing unions powers separation
+        (members stages) (members history))
+        (Fin.cases (M.refinementDataHistoryLevels_mem pairing unions powers separation
+          (members stages) (members history) (members T)) (fun j => Fin.elim0 j))
+    exact ⟨fields, ground, (actual fields ground).2 ⟨rfl, rfl, equal⟩⟩
+
+theorem exists_unique_refinementHistoryForcingOutput
+    {rows T stages history : ZFSet.{u}}
+    (hRows : rows ∈ M.sets) (hT : T ∈ M.sets)
+    (hStages : stages ∈ M.sets) (hHistory : history ∈ M.sets)
+    (omega : ZFSet.omega ∈ M.sets) :
+    ∃ output ∈ M.sets,
+      Realize M.sets (refinementHistoryForcingOutputFormula 0 1 2 3 4 5)
+        ![output, rows, T, stages, history, ZFSet.omega] ∧
+      ∀ other ∈ M.sets,
+        Realize M.sets (refinementHistoryForcingOutputFormula 0 1 2 3 4 5)
+          ![other, rows, T, stages, history, ZFSet.omega] → other = output := by
+  have ground := M.refinementHistoryForcing_mem pairing unions powers separation hRows hT hStages hHistory omega
+  have meaning (output : ZFSet.{u}) (hOutput : output ∈ M.sets) :
+      Realize M.sets (refinementHistoryForcingOutputFormula 0 1 2 3 4 5)
+        ![output, rows, T, stages, history, ZFSet.omega] ↔
+      output = M.refinementHistoryForcing rows T stages history :=
+    M.realize_refinementHistoryForcingOutputFormula pairing unions powers separation 0 1 2 3 4 5 _
+      (Fin.cases hOutput (Fin.cases hRows (Fin.cases hT (Fin.cases hStages
+        (Fin.cases hHistory (Fin.cases omega (fun j => Fin.elim0 j))))))) rfl
+  exact ⟨_, ground, (meaning _ ground).2 rfl, fun other member valid => (meaning other member).1 valid⟩
+
+end TransitiveGround
+end PartitionPilot.Forcing
+
+
+
+namespace PartitionPilot.Forcing.TransitiveGround
+open SetFormula
+universe u
+variable (M : TransitiveGround.{u})
+variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+variable (unions : Realize M.sets SetFormula.union Fin.elim0)
+variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+
+noncomputable def refinementHistoryOrderOutputFormula {n : Nat}
+    (output rows rowOrder T stages history N : Fin n) : SetFormula n :=
+  .ex (.conj (refinementHistoryForcingOutputFormula 0 rows.succ T.succ stages.succ history.succ N.succ)
+    (M.rawRowAssignmentOrderOutputFormula pairing unions powers separation output.succ 0 rowOrder.succ))
+
+theorem realize_refinementHistoryOrderOutputFormula {n : Nat}
+    (output rows rowOrder T stages history N : Fin n) (env : Fin n → ZFSet.{u})
+    (members : ∀ j, env j ∈ M.sets) (naturals : env N = ZFSet.omega) :
+    Realize M.sets (M.refinementHistoryOrderOutputFormula pairing unions powers separation
+      output rows rowOrder T stages history N) env ↔
+      env output = M.refinementHistoryOrder (env rows) (env rowOrder) (env T) (env stages) (env history) := by
+  unfold refinementHistoryOrderOutputFormula
+  rw [realize_ex]
+  have meaning (Q : ZFSet.{u}) (hQ : Q ∈ M.sets) :
+      Realize M.sets (.conj
+        (refinementHistoryForcingOutputFormula 0 rows.succ T.succ stages.succ history.succ N.succ)
+        (M.rawRowAssignmentOrderOutputFormula pairing unions powers separation output.succ 0 rowOrder.succ))
+        (extend Q env) ↔
+      Q = M.refinementHistoryForcing (env rows) (env T) (env stages) (env history) ∧
+        env output = rawRowAssignmentOrder Q (env rowOrder) :=
+    and_congr (M.realize_refinementHistoryForcingOutputFormula pairing unions powers separation
+      0 rows.succ T.succ stages.succ history.succ N.succ (extend Q env) (Fin.cases hQ members) naturals)
+      (M.realize_rawRowAssignmentOrderOutputFormula pairing unions powers separation
+        output.succ 0 rowOrder.succ (extend Q env) (Fin.cases hQ members))
+  constructor
+  · rintro ⟨Q, hQ, recognized⟩
+    obtain ⟨rfl, equal⟩ := (meaning Q hQ).1 recognized
+    rw [M.refinementHistoryOrder_raw]
+    exact equal
+  · intro equal
+    have ground := M.refinementHistoryForcing_mem pairing unions powers separation
+      (members rows) (members T) (members stages) (members history) (naturals ▸ members N)
+    refine ⟨_, ground, (meaning _ ground).2 ⟨rfl, ?_⟩⟩
+    rw [M.refinementHistoryOrder_raw] at equal
+    exact equal
+
+theorem exists_unique_refinementHistoryOrderOutput
+    {rows rowOrder T stages history : ZFSet.{u}}
+    (hRows : rows ∈ M.sets) (hOrder : rowOrder ∈ M.sets) (hT : T ∈ M.sets)
+    (hStages : stages ∈ M.sets) (hHistory : history ∈ M.sets) (omega : ZFSet.omega ∈ M.sets) :
+    ∃ output ∈ M.sets,
+      Realize M.sets (M.refinementHistoryOrderOutputFormula pairing unions powers separation 0 1 2 3 4 5 6)
+        ![output, rows, rowOrder, T, stages, history, ZFSet.omega] ∧
+      ∀ other ∈ M.sets,
+        Realize M.sets (M.refinementHistoryOrderOutputFormula pairing unions powers separation 0 1 2 3 4 5 6)
+          ![other, rows, rowOrder, T, stages, history, ZFSet.omega] → other = output := by
+  have ground := M.refinementHistoryOrder_mem pairing unions powers separation hRows hOrder hT hStages hHistory omega
+  have meaning (output : ZFSet.{u}) (hOutput : output ∈ M.sets) :
+      Realize M.sets (M.refinementHistoryOrderOutputFormula pairing unions powers separation 0 1 2 3 4 5 6)
+        ![output, rows, rowOrder, T, stages, history, ZFSet.omega] ↔
+      output = M.refinementHistoryOrder rows rowOrder T stages history :=
+    M.realize_refinementHistoryOrderOutputFormula pairing unions powers separation 0 1 2 3 4 5 6 _
+      (Fin.cases hOutput (Fin.cases hRows (Fin.cases hOrder (Fin.cases hT (Fin.cases hStages
+        (Fin.cases hHistory (Fin.cases omega (fun j => Fin.elim0 j)))))))) rfl
+  exact ⟨_, ground, (meaning _ ground).2 rfl, fun other member valid => (meaning other member).1 valid⟩
+
+end PartitionPilot.Forcing.TransitiveGround
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/RefinementIndexActionFormulas.lean

@@ -1,60 +1,60 @@
-import OAI.SetTheory.PartitionPrinciple.Forcing.GroundProductActions
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing
-open SetFormula
-universe u
-namespace SetFormula
-
-def refinementIndexActionRawFormula {n}
-    (x y g P maps nodeMaps : Fin n) (w : Fin 13 → Fin n) : SetFormula n :=
-  .conj (BoundedFormula.nonemptyTupleFormula 5 x (fun j => w (j.castAdd 7))).toFormula
-  (.conj (BoundedFormula.nonemptyTupleFormula 5 y (fun j => w ((Fin.natAdd 6 j).castAdd 1))).toFormula
-  (.conj (.equal (w 0) (w 6))
-  (.conj (pairMembershipFormula g (w 12) nodeMaps)
-  (.conj (pairMembershipFormula (w 1) (w 7) (w 12))
-  (.conj (pairMembershipFormula (w 2) (w 8) (w 12))
-  (.conj (atomicApplication nameActionFormula (extend P (extend maps Fin.elim0)) g (w 3) (w 9))
-  (.conj (atomicApplication nameActionFormula (extend P (extend maps Fin.elim0)) g (w 4) (w 10))
-    (atomicApplication nameActionFormula (extend P (extend maps Fin.elim0)) g (w 5) (w 11)))))))))
-
-def refinementIndexActionFormula {n} (x y g P maps nodeMaps : Fin n) : SetFormula n :=
-  let old := suffixIndex n 13
-  exBlock 13 (refinementIndexActionRawFormula (old x) (old y) (old g) (old P)
-    (old maps) (old nodeMaps) (prefixIndex n 13))
-
-end SetFormula
-
-namespace TransitiveGround
-variable (M : TransitiveGround.{u})
-
-theorem realize_refinementIndexActionRawFormula
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    {n} (x y g P maps nodeMaps : Fin n) (w : Fin 13 → Fin n)
-    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets) :
-    Realize M.sets (refinementIndexActionRawFormula x y g P maps nodeMaps w) env ↔
-      env x = nonemptyTupleCode 5 (fun j => env (w (j.castAdd 7))) ∧
-      env y = nonemptyTupleCode 5 (fun j => env (w ((Fin.natAdd 6 j).castAdd 1))) ∧
-      env (w 0) = env (w 6) ∧ ZFSet.pair (env g) (env (w 12)) ∈ env nodeMaps ∧
-      ZFSet.pair (env (w 1)) (env (w 7)) ∈ env (w 12) ∧
-      ZFSet.pair (env (w 2)) (env (w 8)) ∈ env (w 12) ∧
-      Realize M.sets nameActionFormula (extend (env g) (extend (env (w 3))
-        (extend (env (w 9)) (extend (env P) (extend (env maps) Fin.elim0))))) ∧
-      Realize M.sets nameActionFormula (extend (env g) (extend (env (w 4))
-        (extend (env (w 10)) (extend (env P) (extend (env maps) Fin.elim0))))) ∧
-      Realize M.sets nameActionFormula (extend (env g) (extend (env (w 5))
-        (extend (env (w 11)) (extend (env P) (extend (env maps) Fin.elim0))))) := by
-  simp only [refinementIndexActionRawFormula, Realize,
-    BoundedFormula.realize_toFormula M _ env members, BoundedFormula.truth_nonemptyTupleFormula,
-    M.realize_pairMembershipFormula pairing _ _ _ env (members _) (members _) (members _),
-    realize_atomicApplication, map_extend, map_empty]
-
-end TransitiveGround
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Forcing.GroundProductActions
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing
+open SetFormula
+universe u
+namespace SetFormula
+
+def refinementIndexActionRawFormula {n}
+    (x y g P maps nodeMaps : Fin n) (w : Fin 13 → Fin n) : SetFormula n :=
+  .conj (BoundedFormula.nonemptyTupleFormula 5 x (fun j => w (j.castAdd 7))).toFormula
+  (.conj (BoundedFormula.nonemptyTupleFormula 5 y (fun j => w ((Fin.natAdd 6 j).castAdd 1))).toFormula
+  (.conj (.equal (w 0) (w 6))
+  (.conj (pairMembershipFormula g (w 12) nodeMaps)
+  (.conj (pairMembershipFormula (w 1) (w 7) (w 12))
+  (.conj (pairMembershipFormula (w 2) (w 8) (w 12))
+  (.conj (atomicApplication nameActionFormula (extend P (extend maps Fin.elim0)) g (w 3) (w 9))
+  (.conj (atomicApplication nameActionFormula (extend P (extend maps Fin.elim0)) g (w 4) (w 10))
+    (atomicApplication nameActionFormula (extend P (extend maps Fin.elim0)) g (w 5) (w 11)))))))))
+
+def refinementIndexActionFormula {n} (x y g P maps nodeMaps : Fin n) : SetFormula n :=
+  let old := suffixIndex n 13
+  exBlock 13 (refinementIndexActionRawFormula (old x) (old y) (old g) (old P)
+    (old maps) (old nodeMaps) (prefixIndex n 13))
+
+end SetFormula
+
+namespace TransitiveGround
+variable (M : TransitiveGround.{u})
+
+theorem realize_refinementIndexActionRawFormula
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    {n} (x y g P maps nodeMaps : Fin n) (w : Fin 13 → Fin n)
+    (env : Fin n → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets) :
+    Realize M.sets (refinementIndexActionRawFormula x y g P maps nodeMaps w) env ↔
+      env x = nonemptyTupleCode 5 (fun j => env (w (j.castAdd 7))) ∧
+      env y = nonemptyTupleCode 5 (fun j => env (w ((Fin.natAdd 6 j).castAdd 1))) ∧
+      env (w 0) = env (w 6) ∧ ZFSet.pair (env g) (env (w 12)) ∈ env nodeMaps ∧
+      ZFSet.pair (env (w 1)) (env (w 7)) ∈ env (w 12) ∧
+      ZFSet.pair (env (w 2)) (env (w 8)) ∈ env (w 12) ∧
+      Realize M.sets nameActionFormula (extend (env g) (extend (env (w 3))
+        (extend (env (w 9)) (extend (env P) (extend (env maps) Fin.elim0))))) ∧
+      Realize M.sets nameActionFormula (extend (env g) (extend (env (w 4))
+        (extend (env (w 10)) (extend (env P) (extend (env maps) Fin.elim0))))) ∧
+      Realize M.sets nameActionFormula (extend (env g) (extend (env (w 5))
+        (extend (env (w 11)) (extend (env P) (extend (env maps) Fin.elim0))))) := by
+  simp only [refinementIndexActionRawFormula, Realize,
+    BoundedFormula.realize_toFormula M _ env members, BoundedFormula.truth_nonemptyTupleFormula,
+    M.realize_pairMembershipFormula pairing _ _ _ env (members _) (members _) (members _),
+    realize_atomicApplication, map_extend, map_empty]
+
+end TransitiveGround
+end PartitionPilot.Forcing
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/RefinementValidityCodes.lean

@@ -1,77 +1,77 @@
-import OAI.SetTheory.PartitionPrinciple.Models.GroundCountableQuotients
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing
-universe u
-
-def RefinementValidityCode (T U Rf Rc : ZFSet.{u}) : Prop :=
-  U ⊆ T ∧ EquivalenceRelationCode U Rf ∧ EquivalenceRelationCode U Rc ∧ Rf ⊆ Rc
-
-namespace BoundedFormula
-open SetFormula
-
-def equivalenceRelationFormula {n} (S R : Fin n) : BoundedFormula n :=
-  .conj (relationBetweenFormula S S R)
-    (.conj (.allMem S (pairMembershipFormula 0 0 R.succ))
-      (.conj
-        (.allMem S (.allMem S.succ
-          (imp (pairMembershipFormula 1 0 R.succ.succ)
-            (pairMembershipFormula 0 1 R.succ.succ))))
-        (.allMem S (.allMem S.succ (.allMem S.succ.succ
-          (imp (.conj (pairMembershipFormula 2 1 R.succ.succ.succ)
-              (pairMembershipFormula 1 0 R.succ.succ.succ))
-            (pairMembershipFormula 2 0 R.succ.succ.succ)))))))
-
-theorem truth_equivalenceRelationFormula {n} (S R : Fin n) (env : Fin n → ZFSet.{u}) :
-    Truth (equivalenceRelationFormula S R) env ↔ EquivalenceRelationCode (env S) (env R) := by
-  simp only [equivalenceRelationFormula, Truth, truth_relationBetweenFormula,
-    truth_pairMembershipFormula, truth_imp]
-  constructor
-  · rintro ⟨shape, refl, symm, trans⟩
-    refine ⟨shape, refl, ?_, ?_⟩
-    · intro x y xy
-      obtain ⟨hx, hy⟩ := ZFSet.pair_mem_prod.1 (shape xy)
-      exact symm x hx y hy xy
-    · intro x y z xy yz
-      obtain ⟨hx, hy⟩ := ZFSet.pair_mem_prod.1 (shape xy)
-      have hz := (ZFSet.pair_mem_prod.1 (shape yz)).2
-      exact trans x hx y hy z hz ⟨xy, yz⟩
-  · intro relation
-    exact ⟨relation.shape, relation.refl,
-      fun x _ y _ xy => relation.symm x y xy,
-      fun x _ y _ z _ h => relation.trans x y z h.1 h.2⟩
-
-def refinementValidityFormula : BoundedFormula 4 :=
-  .conj (subsetFormula 0 3)
-    (.conj (equivalenceRelationFormula 0 1)
-      (.conj (equivalenceRelationFormula 0 2) (subsetFormula 1 2)))
-
-theorem truth_refinementValidityFormula (env : Fin 4 → ZFSet.{u}) :
-    Truth refinementValidityFormula env ↔
-      RefinementValidityCode (env 3) (env 0) (env 1) (env 2) := by
-  simp only [refinementValidityFormula, Truth, truth_subsetFormula,
-    truth_equivalenceRelationFormula, RefinementValidityCode]
-
-end BoundedFormula
-
-namespace TransitiveGround
-open SetFormula
-variable (M : TransitiveGround.{u})
-
-theorem realize_refinementValidityFormula (env : Fin 4 → ZFSet.{u})
-    (members : ∀ i, env i ∈ M.sets) :
-    Realize M.sets BoundedFormula.refinementValidityFormula.toFormula env ↔
-      RefinementValidityCode (env 3) (env 0) (env 1) (env 2) :=
-  (BoundedFormula.realize_toFormula M _ _ members).trans
-    (BoundedFormula.truth_refinementValidityFormula env)
-
-end TransitiveGround
-
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Models.GroundCountableQuotients
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing
+universe u
+
+def RefinementValidityCode (T U Rf Rc : ZFSet.{u}) : Prop :=
+  U ⊆ T ∧ EquivalenceRelationCode U Rf ∧ EquivalenceRelationCode U Rc ∧ Rf ⊆ Rc
+
+namespace BoundedFormula
+open SetFormula
+
+def equivalenceRelationFormula {n} (S R : Fin n) : BoundedFormula n :=
+  .conj (relationBetweenFormula S S R)
+    (.conj (.allMem S (pairMembershipFormula 0 0 R.succ))
+      (.conj
+        (.allMem S (.allMem S.succ
+          (imp (pairMembershipFormula 1 0 R.succ.succ)
+            (pairMembershipFormula 0 1 R.succ.succ))))
+        (.allMem S (.allMem S.succ (.allMem S.succ.succ
+          (imp (.conj (pairMembershipFormula 2 1 R.succ.succ.succ)
+              (pairMembershipFormula 1 0 R.succ.succ.succ))
+            (pairMembershipFormula 2 0 R.succ.succ.succ)))))))
+
+theorem truth_equivalenceRelationFormula {n} (S R : Fin n) (env : Fin n → ZFSet.{u}) :
+    Truth (equivalenceRelationFormula S R) env ↔ EquivalenceRelationCode (env S) (env R) := by
+  simp only [equivalenceRelationFormula, Truth, truth_relationBetweenFormula,
+    truth_pairMembershipFormula, truth_imp]
+  constructor
+  · rintro ⟨shape, refl, symm, trans⟩
+    refine ⟨shape, refl, ?_, ?_⟩
+    · intro x y xy
+      obtain ⟨hx, hy⟩ := ZFSet.pair_mem_prod.1 (shape xy)
+      exact symm x hx y hy xy
+    · intro x y z xy yz
+      obtain ⟨hx, hy⟩ := ZFSet.pair_mem_prod.1 (shape xy)
+      have hz := (ZFSet.pair_mem_prod.1 (shape yz)).2
+      exact trans x hx y hy z hz ⟨xy, yz⟩
+  · intro relation
+    exact ⟨relation.shape, relation.refl,
+      fun x _ y _ xy => relation.symm x y xy,
+      fun x _ y _ z _ h => relation.trans x y z h.1 h.2⟩
+
+def refinementValidityFormula : BoundedFormula 4 :=
+  .conj (subsetFormula 0 3)
+    (.conj (equivalenceRelationFormula 0 1)
+      (.conj (equivalenceRelationFormula 0 2) (subsetFormula 1 2)))
+
+theorem truth_refinementValidityFormula (env : Fin 4 → ZFSet.{u}) :
+    Truth refinementValidityFormula env ↔
+      RefinementValidityCode (env 3) (env 0) (env 1) (env 2) := by
+  simp only [refinementValidityFormula, Truth, truth_subsetFormula,
+    truth_equivalenceRelationFormula, RefinementValidityCode]
+
+end BoundedFormula
+
+namespace TransitiveGround
+open SetFormula
+variable (M : TransitiveGround.{u})
+
+theorem realize_refinementValidityFormula (env : Fin 4 → ZFSet.{u})
+    (members : ∀ i, env i ∈ M.sets) :
+    Realize M.sets BoundedFormula.refinementValidityFormula.toFormula env ↔
+      RefinementValidityCode (env 3) (env 0) (env 1) (env 2) :=
+  (BoundedFormula.realize_toFormula M _ _ members).trans
+    (BoundedFormula.truth_refinementValidityFormula env)
+
+end TransitiveGround
+
+end PartitionPilot.Forcing
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/RenamedEntryFormulas.lean

@@ -1,137 +1,137 @@
-import OAI.SetTheory.PartitionPrinciple.Forcing.GroundProductActions
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing.SetFormula
-
-def renamedChildFormula : SetFormula 4 :=
-  ex (exConditions 3 (.conj (orderedPairFormula 2 1 0)
-    (.conj (domainApplication uniformNameFormula (extend 4 Fin.elim0) 3)
-      (binaryApplication uniformRenameFormula (extend 4 (extend 5 Fin.elim0)) 1 3))))
-
-def renamedEntryFormula : SetFormula 4 :=
-  ex (exConditions 3 (.conj (pairMembershipFormula 1 0 3)
-    (ex (exConditions 5 (.conj (orderedPairFormula 4 1 0)
-      (.conj (pairMembershipFormula 2 0 7)
-        (.conj (domainApplication uniformNameFormula (extend 6 Fin.elim0) 1)
-          (binaryApplication uniformRenameFormula (extend 6 (extend 7 Fin.elim0)) 3 1))))))))
-
-end PartitionPilot.Forcing.SetFormula
-
-namespace PartitionPilot.Forcing.TransitiveGround
-
-open SetRealization SetFormula
-universe u
-variable (M : TransitiveGround.{u}) {P : Type u} (s : Presentation P)
-
-theorem realize_renamedChildFormula
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0)
-    (separation : SeparationSchema M.sets) (collection : CollectionSchema M.sets)
-    (carrier : s.carrier ∈ M.sets) (f : P → P) (graph : s.graph s f ∈ M.sets)
-    (σ : Name s) (hσ : σ.val ∈ M.sets) (p : P) (y : ZFSet.{u}) (hy : y ∈ M.sets) :
-    Realize M.sets renamedChildFormula
-      (extend (ZFSet.pair σ.val (s.encode p)) (extend y (renameParameters s f))) ↔
-      y = (Name.rename s f σ).val := by
-  let base := extend (ZFSet.pair σ.val (s.encode p)) (extend y (renameParameters s f))
-  have hp := M.transitive carrier (s.encode_mem p)
-  have hz := M.orderedPair_mem pairing hσ hp
-  rw [renamedChildFormula, realize_ex]
-  constructor
-  · rintro ⟨x, hx, rest⟩
-    obtain ⟨r, shape, name, renamed⟩ := (M.realize_exConditions s 3 _ (extend x base) carrier rfl).1 rest
-    let e := extend (s.encode r) (extend x base)
-    have raw := (M.realize_orderedPairFormula pairing 2 1 0 e hz hx
-      (M.transitive carrier (s.encode_mem r))).1 shape
-    change ZFSet.pair σ.val (s.encode p) = ZFSet.pair x (s.encode r) at raw
-    obtain ⟨sx, pr⟩ := ZFSet.pair_inj.1 raw
-    have cond := s.injective pr
-    subst x
-    subst r
-    rw [realize_domainApplication, map_extend, map_empty] at name
-    have nameY := (M.realize_uniformNameFormula s pairing unions powers separation collection carrier y hy).1 name
-    rw [realize_binaryApplication, map_extend, map_extend, map_empty] at renamed
-    have eq := (M.realize_uniformRenameFormula s pairing unions powers separation collection carrier f graph
-      σ ⟨y, nameY⟩ hσ hy).1 renamed
-    exact (congrArg Subtype.val eq).symm
-  · intro eq
-    subst y
-    refine ⟨σ.val, hσ, ?_⟩
-    apply (M.realize_exConditions s 3 _ (extend σ.val base) carrier rfl).2
-    refine ⟨p, ?_, ?_, ?_⟩
-    · exact (M.realize_orderedPairFormula pairing 2 1 0 _ hz hσ hp).2 rfl
-    · rw [realize_domainApplication, map_extend, map_empty]
-      exact (M.realize_uniformNameFormula s pairing unions powers separation collection carrier _ hy).2
-        (Name.rename s f σ).property
-    · rw [realize_binaryApplication, map_extend, map_extend, map_empty]
-      exact (M.realize_uniformRenameFormula s pairing unions powers separation collection carrier f graph
-        σ (Name.rename s f σ) hσ hy).2 rfl
-
-theorem realize_renamedEntryFormula
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0)
-    (separation : SeparationSchema M.sets) (collection : CollectionSchema M.sets)
-    (carrier : s.carrier ∈ M.sets) (f : P → P) (graph : s.graph s f ∈ M.sets)
-    (τ : Name s) (hτ : τ.val ∈ M.sets) (z : ZFSet.{u}) (hz : z ∈ M.sets) :
-    Realize M.sets renamedEntryFormula (extend z (extend τ.val (renameParameters s f))) ↔
-      z ∈ (Name.rename s f τ).val := by
-  let base := extend z (extend τ.val (renameParameters s f))
-  rw [renamedEntryFormula, realize_ex]
-  constructor
-  · rintro ⟨x, hx, rest⟩
-    obtain ⟨p, old, rest⟩ := (M.realize_exConditions s 3 _ (extend x base) carrier rfl).1 rest
-    have entry := (M.realize_pairMembershipFormula pairing 1 0 3
-      (extend (s.encode p) (extend x base)) hx (M.transitive carrier (s.encode_mem p)) hτ).1 old
-    let σ : Name s := ⟨x, Name.isName_of_pair_mem τ x p entry⟩
-    obtain ⟨y, hy, rest⟩ := (realize_ex M.sets _ _).1 rest
-    obtain ⟨q, shape, condition, name, renamed⟩ := (M.realize_exConditions s 5 _
-      (extend y (extend (s.encode p) (extend x base))) carrier rfl).1 rest
-    let e := extend (s.encode q) (extend y (extend (s.encode p) (extend x base)))
-    have raw := (M.realize_orderedPairFormula pairing 4 1 0 e hz hy
-      (M.transitive carrier (s.encode_mem q))).1 shape
-    have cond := (M.realize_pairMembershipFormula pairing 2 0 7 e
-      (M.transitive carrier (s.encode_mem p)) (M.transitive carrier (s.encode_mem q)) graph).1 condition
-    have pq := (s.pair_mem_graph s f p q).1 cond
-    rw [realize_domainApplication, map_extend, map_empty] at name
-    have nameY := (M.realize_uniformNameFormula s pairing unions powers separation collection carrier y hy).1 name
-    let ν : Name s := ⟨y, nameY⟩
-    rw [realize_binaryApplication, map_extend, map_extend, map_empty] at renamed
-    have eq := (M.realize_uniformRenameFormula s pairing unions powers separation collection carrier f graph σ ν hx hy).1 renamed
-    have member := (Name.entry_rename s f τ ν q).2 ⟨σ, p, entry, eq, pq⟩
-    change z = ZFSet.pair y (s.encode q) at raw
-    rw [raw]
-    exact member
-  · intro member
-    obtain ⟨ν, q, rfl⟩ := Name.entries_cover (Name.rename s f τ) member
-    obtain ⟨σ, p, entry, image, cond⟩ := (Name.entry_rename s f τ ν q).1 member
-    have hσ := (M.nameDomain s).children hτ entry
-    have hν := M.pair_left hz
-    refine ⟨σ.val, hσ, ?_⟩
-    apply (M.realize_exConditions s 3 _ (extend σ.val base) carrier rfl).2
-    refine ⟨p, ?_, ?_⟩
-    · exact (M.realize_pairMembershipFormula pairing 1 0 3 _ hσ
-        (M.transitive carrier (s.encode_mem p)) hτ).2 entry
-    · rw [realize_ex]
-      refine ⟨ν.val, hν, ?_⟩
-      apply (M.realize_exConditions s 5 _ (extend ν.val (extend (s.encode p) (extend σ.val base))) carrier rfl).2
-      let e := extend (s.encode q) (extend ν.val (extend (s.encode p) (extend σ.val base)))
-      refine ⟨q, ?_, ?_, ?_, ?_⟩
-      · exact (M.realize_orderedPairFormula pairing 4 1 0 e hz hν
-          (M.transitive carrier (s.encode_mem q))).2 rfl
-      · exact (M.realize_pairMembershipFormula pairing 2 0 7 e
-          (M.transitive carrier (s.encode_mem p)) (M.transitive carrier (s.encode_mem q)) graph).2
-          ((s.pair_mem_graph s f p q).2 cond)
-      · rw [realize_domainApplication, map_extend, map_empty]
-        exact (M.realize_uniformNameFormula s pairing unions powers separation collection carrier ν.val hν).2 ν.property
-      · rw [realize_binaryApplication, map_extend, map_extend, map_empty]
-        exact (M.realize_uniformRenameFormula s pairing unions powers separation collection carrier f graph σ ν hσ hν).2 image
-
-end PartitionPilot.Forcing.TransitiveGround
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Forcing.GroundProductActions
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing.SetFormula
+
+def renamedChildFormula : SetFormula 4 :=
+  ex (exConditions 3 (.conj (orderedPairFormula 2 1 0)
+    (.conj (domainApplication uniformNameFormula (extend 4 Fin.elim0) 3)
+      (binaryApplication uniformRenameFormula (extend 4 (extend 5 Fin.elim0)) 1 3))))
+
+def renamedEntryFormula : SetFormula 4 :=
+  ex (exConditions 3 (.conj (pairMembershipFormula 1 0 3)
+    (ex (exConditions 5 (.conj (orderedPairFormula 4 1 0)
+      (.conj (pairMembershipFormula 2 0 7)
+        (.conj (domainApplication uniformNameFormula (extend 6 Fin.elim0) 1)
+          (binaryApplication uniformRenameFormula (extend 6 (extend 7 Fin.elim0)) 3 1))))))))
+
+end PartitionPilot.Forcing.SetFormula
+
+namespace PartitionPilot.Forcing.TransitiveGround
+
+open SetRealization SetFormula
+universe u
+variable (M : TransitiveGround.{u}) {P : Type u} (s : Presentation P)
+
+theorem realize_renamedChildFormula
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0)
+    (separation : SeparationSchema M.sets) (collection : CollectionSchema M.sets)
+    (carrier : s.carrier ∈ M.sets) (f : P → P) (graph : s.graph s f ∈ M.sets)
+    (σ : Name s) (hσ : σ.val ∈ M.sets) (p : P) (y : ZFSet.{u}) (hy : y ∈ M.sets) :
+    Realize M.sets renamedChildFormula
+      (extend (ZFSet.pair σ.val (s.encode p)) (extend y (renameParameters s f))) ↔
+      y = (Name.rename s f σ).val := by
+  let base := extend (ZFSet.pair σ.val (s.encode p)) (extend y (renameParameters s f))
+  have hp := M.transitive carrier (s.encode_mem p)
+  have hz := M.orderedPair_mem pairing hσ hp
+  rw [renamedChildFormula, realize_ex]
+  constructor
+  · rintro ⟨x, hx, rest⟩
+    obtain ⟨r, shape, name, renamed⟩ := (M.realize_exConditions s 3 _ (extend x base) carrier rfl).1 rest
+    let e := extend (s.encode r) (extend x base)
+    have raw := (M.realize_orderedPairFormula pairing 2 1 0 e hz hx
+      (M.transitive carrier (s.encode_mem r))).1 shape
+    change ZFSet.pair σ.val (s.encode p) = ZFSet.pair x (s.encode r) at raw
+    obtain ⟨sx, pr⟩ := ZFSet.pair_inj.1 raw
+    have cond := s.injective pr
+    subst x
+    subst r
+    rw [realize_domainApplication, map_extend, map_empty] at name
+    have nameY := (M.realize_uniformNameFormula s pairing unions powers separation collection carrier y hy).1 name
+    rw [realize_binaryApplication, map_extend, map_extend, map_empty] at renamed
+    have eq := (M.realize_uniformRenameFormula s pairing unions powers separation collection carrier f graph
+      σ ⟨y, nameY⟩ hσ hy).1 renamed
+    exact (congrArg Subtype.val eq).symm
+  · intro eq
+    subst y
+    refine ⟨σ.val, hσ, ?_⟩
+    apply (M.realize_exConditions s 3 _ (extend σ.val base) carrier rfl).2
+    refine ⟨p, ?_, ?_, ?_⟩
+    · exact (M.realize_orderedPairFormula pairing 2 1 0 _ hz hσ hp).2 rfl
+    · rw [realize_domainApplication, map_extend, map_empty]
+      exact (M.realize_uniformNameFormula s pairing unions powers separation collection carrier _ hy).2
+        (Name.rename s f σ).property
+    · rw [realize_binaryApplication, map_extend, map_extend, map_empty]
+      exact (M.realize_uniformRenameFormula s pairing unions powers separation collection carrier f graph
+        σ (Name.rename s f σ) hσ hy).2 rfl
+
+theorem realize_renamedEntryFormula
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0)
+    (separation : SeparationSchema M.sets) (collection : CollectionSchema M.sets)
+    (carrier : s.carrier ∈ M.sets) (f : P → P) (graph : s.graph s f ∈ M.sets)
+    (τ : Name s) (hτ : τ.val ∈ M.sets) (z : ZFSet.{u}) (hz : z ∈ M.sets) :
+    Realize M.sets renamedEntryFormula (extend z (extend τ.val (renameParameters s f))) ↔
+      z ∈ (Name.rename s f τ).val := by
+  let base := extend z (extend τ.val (renameParameters s f))
+  rw [renamedEntryFormula, realize_ex]
+  constructor
+  · rintro ⟨x, hx, rest⟩
+    obtain ⟨p, old, rest⟩ := (M.realize_exConditions s 3 _ (extend x base) carrier rfl).1 rest
+    have entry := (M.realize_pairMembershipFormula pairing 1 0 3
+      (extend (s.encode p) (extend x base)) hx (M.transitive carrier (s.encode_mem p)) hτ).1 old
+    let σ : Name s := ⟨x, Name.isName_of_pair_mem τ x p entry⟩
+    obtain ⟨y, hy, rest⟩ := (realize_ex M.sets _ _).1 rest
+    obtain ⟨q, shape, condition, name, renamed⟩ := (M.realize_exConditions s 5 _
+      (extend y (extend (s.encode p) (extend x base))) carrier rfl).1 rest
+    let e := extend (s.encode q) (extend y (extend (s.encode p) (extend x base)))
+    have raw := (M.realize_orderedPairFormula pairing 4 1 0 e hz hy
+      (M.transitive carrier (s.encode_mem q))).1 shape
+    have cond := (M.realize_pairMembershipFormula pairing 2 0 7 e
+      (M.transitive carrier (s.encode_mem p)) (M.transitive carrier (s.encode_mem q)) graph).1 condition
+    have pq := (s.pair_mem_graph s f p q).1 cond
+    rw [realize_domainApplication, map_extend, map_empty] at name
+    have nameY := (M.realize_uniformNameFormula s pairing unions powers separation collection carrier y hy).1 name
+    let ν : Name s := ⟨y, nameY⟩
+    rw [realize_binaryApplication, map_extend, map_extend, map_empty] at renamed
+    have eq := (M.realize_uniformRenameFormula s pairing unions powers separation collection carrier f graph σ ν hx hy).1 renamed
+    have member := (Name.entry_rename s f τ ν q).2 ⟨σ, p, entry, eq, pq⟩
+    change z = ZFSet.pair y (s.encode q) at raw
+    rw [raw]
+    exact member
+  · intro member
+    obtain ⟨ν, q, rfl⟩ := Name.entries_cover (Name.rename s f τ) member
+    obtain ⟨σ, p, entry, image, cond⟩ := (Name.entry_rename s f τ ν q).1 member
+    have hσ := (M.nameDomain s).children hτ entry
+    have hν := M.pair_left hz
+    refine ⟨σ.val, hσ, ?_⟩
+    apply (M.realize_exConditions s 3 _ (extend σ.val base) carrier rfl).2
+    refine ⟨p, ?_, ?_⟩
+    · exact (M.realize_pairMembershipFormula pairing 1 0 3 _ hσ
+        (M.transitive carrier (s.encode_mem p)) hτ).2 entry
+    · rw [realize_ex]
+      refine ⟨ν.val, hν, ?_⟩
+      apply (M.realize_exConditions s 5 _ (extend ν.val (extend (s.encode p) (extend σ.val base))) carrier rfl).2
+      let e := extend (s.encode q) (extend ν.val (extend (s.encode p) (extend σ.val base)))
+      refine ⟨q, ?_, ?_, ?_, ?_⟩
+      · exact (M.realize_orderedPairFormula pairing 4 1 0 e hz hν
+          (M.transitive carrier (s.encode_mem q))).2 rfl
+      · exact (M.realize_pairMembershipFormula pairing 2 0 7 e
+          (M.transitive carrier (s.encode_mem p)) (M.transitive carrier (s.encode_mem q)) graph).2
+          ((s.pair_mem_graph s f p q).2 cond)
+      · rw [realize_domainApplication, map_extend, map_empty]
+        exact (M.realize_uniformNameFormula s pairing unions powers separation collection carrier ν.val hν).2 ν.property
+      · rw [realize_binaryApplication, map_extend, map_extend, map_empty]
+        exact (M.realize_uniformRenameFormula s pairing unions powers separation collection carrier f graph σ ν hσ hν).2 image
+
+end PartitionPilot.Forcing.TransitiveGround
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/RepresentativeProductAgreement.lean

@@ -1,120 +1,120 @@
-import OAI.SetTheory.PartitionPrinciple.Geometry.InitialRepresentativeAgreement
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing
-
-universe u
-
-theorem TaskRepresentative.source_mem
-    {P r A R U Labels I i g a : ZFSet.{u}}
-    (represented : TaskRepresentative P r A R U Labels i g)
-    (source : ZFSet.pair i a ∈ literalTaskSourceGraph I P R U Labels) : a ∈ P := by
-  obtain ⟨a', ha, c, hc, base, hb, s, hs, F, hF, label, hl, equal, _⟩ := represented
-  have aEq : a = a' :=
-    ((literalTaskFieldGraph_entry_iff ha hc hb hs hF hl 0).1 (equal ▸ source)).2
-  exact aEq.symm ▸ ha
-
-theorem TaskTransportCode.representative_product_agreement
-    {P R U Labels A δ i j G m one r g h k I a : ZFSet.{u}}
-    (transport : TaskTransportCode P R U Labels A δ i j)
-    (action : PosetActionCode G P m one r A)
-    (hδ : δ ∈ G) (hg : g ∈ G) (hk : k ∈ G)
-    (product : ZFSet.pair (ZFSet.pair δ g) k ∈ m)
-    (first : TaskRepresentative P r A R U Labels i g)
-    (second : TaskRepresentative P r A R U Labels j h)
-    (source : ZFSet.pair i a ∈ literalTaskSourceGraph I P R U Labels) :
-    ActionAgreementBelow P r A k h a := by
-  obtain ⟨a', ha, c, hc, base, hb, s, hs, F, hF, label, hl,
-    c', _, base', _, s', _, F', _, old, new, target, _, baseEq, _⟩ := transport
-  have aEq : a = a' :=
-    ((literalTaskFieldGraph_entry_iff ha hc hb hs hF hl 0).1 (old ▸ source)).2
-  have oldRestriction := (old ▸ first).restriction
-  have newRestriction := (new ▸ second).restriction
-  have composed := oldRestriction.transport action hg hδ hk product target
-  rw [baseEq] at newRestriction
-  intro x hx y _ lower
-  exact (composed.base_action_iff action hx (aEq ▸ lower)).symm.trans
-    (newRestriction.base_action_iff action hx (aEq ▸ lower))
-
-namespace TransitiveGround
-
-open SetFormula
-variable (M : TransitiveGround.{u})
-
-theorem groundTaskRepresentatives_product_agreement
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    {P G r μ A Labels m inv one Reps δ i j g h k a : ZFSet.{u}}
-    (hP : P ∈ M.sets) (hG : G ∈ M.sets) (hA : A ∈ M.sets)
-    (group : GroupCode G m inv one) (action : PosetActionCode G P m one r A)
-    (meet : MeetOrderCode P r μ)
-    (reps : ZFSet.IsFunc (M.groundEligibleTasks P G r μ A Labels) G Reps)
-    (represents : ∀ i g, ZFSet.pair i g ∈ Reps →
-      TaskRepresentative P r A (M.groundRelations P P) (M.groundMeetFilters P r μ) Labels i g)
-    (task : ZFSet.pair (ZFSet.pair δ i) j ∈ M.groundTaskTransport P G r μ A Labels)
-    (source : ZFSet.pair i a ∈ literalTaskSourceGraph (M.groundEligibleTasks P G r μ A Labels)
-      P (M.groundRelations P P) (M.groundMeetFilters P r μ) Labels)
-    (first : ZFSet.pair i g ∈ Reps) (second : ZFSet.pair j h ∈ Reps)
-    (product : ZFSet.pair (ZFSet.pair δ g) k ∈ m) :
-    let d := M.groundEligibleTaskBatchInputs (Labels := Labels) group action meet
-    ActionAgreementBelow d.batchCarrier d.batchOrder
-      (M.groundEligibleBatchAction P G r μ A Labels) k h a := by
-  have transported := (triple_mem_taskTransportGraph G _ P _ _ Labels A δ i j).1 task
-  have hg := (ZFSet.pair_mem_prod.1 (reps.1 first)).2
-  have hh := (ZFSet.pair_mem_prod.1 (reps.1 second)).2
-  have hk := (ZFSet.pair_mem_prod.1 (group.mul_function.1 product)).2
-  have old := transported.2.2.2.representative_product_agreement action transported.1 hg hk
-    product (represents i g first) (represents j h second) source
-  exact M.groundEligibleBatchAction_agreement pairing unions powers separation hP hG hA
-    group action meet hk hh ((represents i g first).source_mem source) old
-
-theorem groundTaskRepresentatives_composed_entry
-    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
-    (unions : Realize M.sets SetFormula.union Fin.elim0)
-    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
-    {P G r μ A Labels m inv one Reps δ i j g h a x y z : ZFSet.{u}}
-    (hP : P ∈ M.sets) (hG : G ∈ M.sets) (hA : A ∈ M.sets)
-    (group : GroupCode G m inv one) (action : PosetActionCode G P m one r A)
-    (meet : MeetOrderCode P r μ)
-    (reps : ZFSet.IsFunc (M.groundEligibleTasks P G r μ A Labels) G Reps)
-    (represents : ∀ i g, ZFSet.pair i g ∈ Reps →
-      TaskRepresentative P r A (M.groundRelations P P) (M.groundMeetFilters P r μ) Labels i g)
-    (task : ZFSet.pair (ZFSet.pair δ i) j ∈ M.groundTaskTransport P G r μ A Labels)
-    (source : ZFSet.pair i a ∈ literalTaskSourceGraph (M.groundEligibleTasks P G r μ A Labels)
-      P (M.groundRelations P P) (M.groundMeetFilters P r μ) Labels)
-    (first : ZFSet.pair i g ∈ Reps) (second : ZFSet.pair j h ∈ Reps)
-    (hx : x ∈ (M.groundEligibleTaskBatchInputs (Labels := Labels) group action meet).batchCarrier)
-    (lower : ZFSet.pair x a ∈
-      (M.groundEligibleTaskBatchInputs (Labels := Labels) group action meet).batchOrder)
-    (firstAction : ZFSet.pair (ZFSet.pair g x) y ∈ M.groundEligibleBatchAction P G r μ A Labels)
-    (secondAction : ZFSet.pair (ZFSet.pair h x) z ∈ M.groundEligibleBatchAction P G r μ A Labels) :
-    ZFSet.pair (ZFSet.pair δ y) z ∈ M.groundEligibleBatchAction P G r μ A Labels := by
-  have transported := (triple_mem_taskTransportGraph G _ P _ _ Labels A δ i j).1 task
-  have hg := (ZFSet.pair_mem_prod.1 (reps.1 first)).2
-  have hh := (ZFSet.pair_mem_prod.1 (reps.1 second)).2
-  obtain ⟨k, product, _⟩ := group.mul_function.2 (ZFSet.pair δ g)
-    (ZFSet.pair_mem_prod.2 ⟨transported.1, hg⟩)
-  have hk := (ZFSet.pair_mem_prod.1 (group.mul_function.1 product)).2
-  have agree := M.groundTaskRepresentatives_product_agreement pairing unions powers separation
-    hP hG hA group action meet reps represents task source first second product
-  have full := M.groundEligibleBatchAction_code (Labels := Labels)
-    pairing unions powers separation hP hG hA group action meet
-  have hy := (ZFSet.pair_mem_prod.1 (full.function.1 firstAction)).2
-  obtain ⟨w, acted, _⟩ := full.function.2 (ZFSet.pair δ y)
-    (ZFSet.pair_mem_prod.2 ⟨transported.1, hy⟩)
-  have hw := (ZFSet.pair_mem_prod.1 (full.function.1 acted)).2
-  have composed := full.mul δ transported.1 g hg k hk x hx y hy w hw product firstAction acted
-  have equal := agree.entry_eq full hh hx lower composed secondAction
-  exact equal ▸ acted
-
-end TransitiveGround
-
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Geometry.InitialRepresentativeAgreement
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing
+
+universe u
+
+theorem TaskRepresentative.source_mem
+    {P r A R U Labels I i g a : ZFSet.{u}}
+    (represented : TaskRepresentative P r A R U Labels i g)
+    (source : ZFSet.pair i a ∈ literalTaskSourceGraph I P R U Labels) : a ∈ P := by
+  obtain ⟨a', ha, c, hc, base, hb, s, hs, F, hF, label, hl, equal, _⟩ := represented
+  have aEq : a = a' :=
+    ((literalTaskFieldGraph_entry_iff ha hc hb hs hF hl 0).1 (equal ▸ source)).2
+  exact aEq.symm ▸ ha
+
+theorem TaskTransportCode.representative_product_agreement
+    {P R U Labels A δ i j G m one r g h k I a : ZFSet.{u}}
+    (transport : TaskTransportCode P R U Labels A δ i j)
+    (action : PosetActionCode G P m one r A)
+    (hδ : δ ∈ G) (hg : g ∈ G) (hk : k ∈ G)
+    (product : ZFSet.pair (ZFSet.pair δ g) k ∈ m)
+    (first : TaskRepresentative P r A R U Labels i g)
+    (second : TaskRepresentative P r A R U Labels j h)
+    (source : ZFSet.pair i a ∈ literalTaskSourceGraph I P R U Labels) :
+    ActionAgreementBelow P r A k h a := by
+  obtain ⟨a', ha, c, hc, base, hb, s, hs, F, hF, label, hl,
+    c', _, base', _, s', _, F', _, old, new, target, _, baseEq, _⟩ := transport
+  have aEq : a = a' :=
+    ((literalTaskFieldGraph_entry_iff ha hc hb hs hF hl 0).1 (old ▸ source)).2
+  have oldRestriction := (old ▸ first).restriction
+  have newRestriction := (new ▸ second).restriction
+  have composed := oldRestriction.transport action hg hδ hk product target
+  rw [baseEq] at newRestriction
+  intro x hx y _ lower
+  exact (composed.base_action_iff action hx (aEq ▸ lower)).symm.trans
+    (newRestriction.base_action_iff action hx (aEq ▸ lower))
+
+namespace TransitiveGround
+
+open SetFormula
+variable (M : TransitiveGround.{u})
+
+theorem groundTaskRepresentatives_product_agreement
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    {P G r μ A Labels m inv one Reps δ i j g h k a : ZFSet.{u}}
+    (hP : P ∈ M.sets) (hG : G ∈ M.sets) (hA : A ∈ M.sets)
+    (group : GroupCode G m inv one) (action : PosetActionCode G P m one r A)
+    (meet : MeetOrderCode P r μ)
+    (reps : ZFSet.IsFunc (M.groundEligibleTasks P G r μ A Labels) G Reps)
+    (represents : ∀ i g, ZFSet.pair i g ∈ Reps →
+      TaskRepresentative P r A (M.groundRelations P P) (M.groundMeetFilters P r μ) Labels i g)
+    (task : ZFSet.pair (ZFSet.pair δ i) j ∈ M.groundTaskTransport P G r μ A Labels)
+    (source : ZFSet.pair i a ∈ literalTaskSourceGraph (M.groundEligibleTasks P G r μ A Labels)
+      P (M.groundRelations P P) (M.groundMeetFilters P r μ) Labels)
+    (first : ZFSet.pair i g ∈ Reps) (second : ZFSet.pair j h ∈ Reps)
+    (product : ZFSet.pair (ZFSet.pair δ g) k ∈ m) :
+    let d := M.groundEligibleTaskBatchInputs (Labels := Labels) group action meet
+    ActionAgreementBelow d.batchCarrier d.batchOrder
+      (M.groundEligibleBatchAction P G r μ A Labels) k h a := by
+  have transported := (triple_mem_taskTransportGraph G _ P _ _ Labels A δ i j).1 task
+  have hg := (ZFSet.pair_mem_prod.1 (reps.1 first)).2
+  have hh := (ZFSet.pair_mem_prod.1 (reps.1 second)).2
+  have hk := (ZFSet.pair_mem_prod.1 (group.mul_function.1 product)).2
+  have old := transported.2.2.2.representative_product_agreement action transported.1 hg hk
+    product (represents i g first) (represents j h second) source
+  exact M.groundEligibleBatchAction_agreement pairing unions powers separation hP hG hA
+    group action meet hk hh ((represents i g first).source_mem source) old
+
+theorem groundTaskRepresentatives_composed_entry
+    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
+    (unions : Realize M.sets SetFormula.union Fin.elim0)
+    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
+    {P G r μ A Labels m inv one Reps δ i j g h a x y z : ZFSet.{u}}
+    (hP : P ∈ M.sets) (hG : G ∈ M.sets) (hA : A ∈ M.sets)
+    (group : GroupCode G m inv one) (action : PosetActionCode G P m one r A)
+    (meet : MeetOrderCode P r μ)
+    (reps : ZFSet.IsFunc (M.groundEligibleTasks P G r μ A Labels) G Reps)
+    (represents : ∀ i g, ZFSet.pair i g ∈ Reps →
+      TaskRepresentative P r A (M.groundRelations P P) (M.groundMeetFilters P r μ) Labels i g)
+    (task : ZFSet.pair (ZFSet.pair δ i) j ∈ M.groundTaskTransport P G r μ A Labels)
+    (source : ZFSet.pair i a ∈ literalTaskSourceGraph (M.groundEligibleTasks P G r μ A Labels)
+      P (M.groundRelations P P) (M.groundMeetFilters P r μ) Labels)
+    (first : ZFSet.pair i g ∈ Reps) (second : ZFSet.pair j h ∈ Reps)
+    (hx : x ∈ (M.groundEligibleTaskBatchInputs (Labels := Labels) group action meet).batchCarrier)
+    (lower : ZFSet.pair x a ∈
+      (M.groundEligibleTaskBatchInputs (Labels := Labels) group action meet).batchOrder)
+    (firstAction : ZFSet.pair (ZFSet.pair g x) y ∈ M.groundEligibleBatchAction P G r μ A Labels)
+    (secondAction : ZFSet.pair (ZFSet.pair h x) z ∈ M.groundEligibleBatchAction P G r μ A Labels) :
+    ZFSet.pair (ZFSet.pair δ y) z ∈ M.groundEligibleBatchAction P G r μ A Labels := by
+  have transported := (triple_mem_taskTransportGraph G _ P _ _ Labels A δ i j).1 task
+  have hg := (ZFSet.pair_mem_prod.1 (reps.1 first)).2
+  have hh := (ZFSet.pair_mem_prod.1 (reps.1 second)).2
+  obtain ⟨k, product, _⟩ := group.mul_function.2 (ZFSet.pair δ g)
+    (ZFSet.pair_mem_prod.2 ⟨transported.1, hg⟩)
+  have hk := (ZFSet.pair_mem_prod.1 (group.mul_function.1 product)).2
+  have agree := M.groundTaskRepresentatives_product_agreement pairing unions powers separation
+    hP hG hA group action meet reps represents task source first second product
+  have full := M.groundEligibleBatchAction_code (Labels := Labels)
+    pairing unions powers separation hP hG hA group action meet
+  have hy := (ZFSet.pair_mem_prod.1 (full.function.1 firstAction)).2
+  obtain ⟨w, acted, _⟩ := full.function.2 (ZFSet.pair δ y)
+    (ZFSet.pair_mem_prod.2 ⟨transported.1, hy⟩)
+  have hw := (ZFSet.pair_mem_prod.1 (full.function.1 acted)).2
+  have composed := full.mul δ transported.1 g hg k hk x hx y hy w hw product firstAction acted
+  have equal := agree.entry_eq full hh hx lower composed secondAction
+  exact equal ▸ acted
+
+end TransitiveGround
+
+end PartitionPilot.Forcing
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/RootedSupportOwnerFunction.lean

@@ -1,59 +1,59 @@
-import OAI.SetTheory.PartitionPrinciple.Geometry.RootedSupportOrder
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Compression.RecursiveMaps.RootedGluing.Scheme
-
-universe u
-variable {V : Type u} (d : Scheme V)
-
-noncomputable def owner (x : d.Node) : V :=
-  Classical.choose (d.existsUnique_leastSupport x)
-
-theorem owner_least (x : d.Node) : d.LeastSupport (d.owner x) x :=
-  (Classical.choose_spec (d.existsUnique_leastSupport x)).1
-
-theorem owner_eq_iff (x : d.Node) (v : V) :
-    d.owner x = v ↔ d.LeastSupport v x := by
-  constructor
-  · intro eq
-    rw [← eq]
-    exact d.owner_least x
-  · exact d.leastSupport_unique (d.owner_least x)
-
-theorem owner_depth_mono {x y : d.Node} (lower : d.gluedOrder.le x y) :
-    d.depth (d.owner x) ≤ d.depth (d.owner y) :=
-  d.leastSupport_depth_mono (d.owner_least x) (d.owner_least y) lower
-
-theorem owner_eq_of_depth_eq {x y : d.Node} (lower : d.gluedOrder.le x y)
-    (same : d.depth (d.owner x) = d.depth (d.owner y)) : d.owner x = d.owner y :=
-  d.leastSupport_eq_of_depth_eq (d.owner_least x) (d.owner_least y) lower same
-
-theorem owner_root_iff (x : d.Node) : d.owner x = d.root ↔ d.Supports d.root x :=
-  (d.owner_eq_iff x d.root).trans (d.leastSupport_root_iff x)
-
-noncomputable def ownerCoordinate (x : d.Node) : d.Space (d.owner x) :=
-  Classical.choose (d.owner_least x).1
-
-theorem ownerCoordinate_entry (x : d.Node) :
-    (d.vertex (d.owner x)).toFun (d.ownerCoordinate x) = x :=
-  Classical.choose_spec (d.owner_least x).1
-
-theorem ownerCoordinate_unique (x : d.Node) (a : d.Space (d.owner x))
-    (entry : (d.vertex (d.owner x)).toFun a = x) : a = d.ownerCoordinate x :=
-  embedding_injective (d.vertex (d.owner x)).toMeetEmbedding
-    (entry.trans (d.ownerCoordinate_entry x).symm)
-
-theorem ownerCoordinate_fresh (x : d.Node) (nonroot : d.depth (d.owner x) ≠ 0) :
-    ¬ (d.order (d.owner x)).le (d.ownerCoordinate x) (d.childAnchor (d.owner x) nonroot) := by
-  apply (d.leastSupport_vertex_iff (d.owner x) nonroot (d.ownerCoordinate x)).mp
-  rw [d.ownerCoordinate_entry]
-  exact d.owner_least x
-
-end PartitionPilot.Compression.RecursiveMaps.RootedGluing.Scheme
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Geometry.RootedSupportOrder
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Compression.RecursiveMaps.RootedGluing.Scheme
+
+universe u
+variable {V : Type u} (d : Scheme V)
+
+noncomputable def owner (x : d.Node) : V :=
+  Classical.choose (d.existsUnique_leastSupport x)
+
+theorem owner_least (x : d.Node) : d.LeastSupport (d.owner x) x :=
+  (Classical.choose_spec (d.existsUnique_leastSupport x)).1
+
+theorem owner_eq_iff (x : d.Node) (v : V) :
+    d.owner x = v ↔ d.LeastSupport v x := by
+  constructor
+  · intro eq
+    rw [← eq]
+    exact d.owner_least x
+  · exact d.leastSupport_unique (d.owner_least x)
+
+theorem owner_depth_mono {x y : d.Node} (lower : d.gluedOrder.le x y) :
+    d.depth (d.owner x) ≤ d.depth (d.owner y) :=
+  d.leastSupport_depth_mono (d.owner_least x) (d.owner_least y) lower
+
+theorem owner_eq_of_depth_eq {x y : d.Node} (lower : d.gluedOrder.le x y)
+    (same : d.depth (d.owner x) = d.depth (d.owner y)) : d.owner x = d.owner y :=
+  d.leastSupport_eq_of_depth_eq (d.owner_least x) (d.owner_least y) lower same
+
+theorem owner_root_iff (x : d.Node) : d.owner x = d.root ↔ d.Supports d.root x :=
+  (d.owner_eq_iff x d.root).trans (d.leastSupport_root_iff x)
+
+noncomputable def ownerCoordinate (x : d.Node) : d.Space (d.owner x) :=
+  Classical.choose (d.owner_least x).1
+
+theorem ownerCoordinate_entry (x : d.Node) :
+    (d.vertex (d.owner x)).toFun (d.ownerCoordinate x) = x :=
+  Classical.choose_spec (d.owner_least x).1
+
+theorem ownerCoordinate_unique (x : d.Node) (a : d.Space (d.owner x))
+    (entry : (d.vertex (d.owner x)).toFun a = x) : a = d.ownerCoordinate x :=
+  embedding_injective (d.vertex (d.owner x)).toMeetEmbedding
+    (entry.trans (d.ownerCoordinate_entry x).symm)
+
+theorem ownerCoordinate_fresh (x : d.Node) (nonroot : d.depth (d.owner x) ≠ 0) :
+    ¬ (d.order (d.owner x)).le (d.ownerCoordinate x) (d.childAnchor (d.owner x) nonroot) := by
+  apply (d.leastSupport_vertex_iff (d.owner x) nonroot (d.ownerCoordinate x)).mp
+  rw [d.ownerCoordinate_entry]
+  exact d.owner_least x
+
+end PartitionPilot.Compression.RecursiveMaps.RootedGluing.Scheme
+
+end
+
+end OAI

lean/OAI/SetTheory/PartitionPrinciple/Definability/RowAssignmentCutGraphLaws.lean

@@ -1,87 +1,87 @@
-import OAI.SetTheory.PartitionPrinciple.Geometry.GroundRowAssignmentCuts
-
-namespace OAI
-
-section
-
-namespace PartitionPilot.Forcing
-universe u
-
-theorem rowAssignmentCutGraph_function (upper lower levels alpha : ZFSet.{u})
-    (flat : ∀ p ∈ upper, ∃ row A, p = ZFSet.pair row A)
-    (closed : ∀ row A, ZFSet.pair row A ∈ upper →
-      ZFSet.pair row (assignmentCut levels alpha A) ∈ lower) :
-    ZFSet.IsFunc upper lower (rowAssignmentCutGraph upper lower levels alpha) := by
-  refine ⟨fun _ h => ((mem_rowAssignmentCutGraph _ _ _ _ _).1 h).1, ?_⟩
-  intro p hp
-  obtain ⟨row, A, rfl⟩ := flat p hp
-  refine ⟨ZFSet.pair row (assignmentCut levels alpha A),
-    (pair_mem_rowAssignmentCutGraph _ _ _ _ _ _ _).2 ⟨hp, closed row A hp, rfl⟩, ?_⟩
-  intro q entry
-  exact ((pair_mem_rowAssignmentCutGraph _ _ _ _ _ _ _).1 entry).2.2
-
-theorem rowAssignmentCutGraph_compose
-    (upper middle lower outerLevels beta innerLevels alpha directLevels gamma : ZFSet.{u})
-    (middle_valid : ∀ row A, ZFSet.pair row A ∈ upper →
-      ZFSet.pair row (assignmentCut outerLevels beta A) ∈ middle)
-    (coherent : ∀ row A, ZFSet.pair row A ∈ upper →
-      assignmentCut innerLevels alpha (assignmentCut outerLevels beta A) =
-        assignmentCut directLevels gamma A) :
-    relationCompose upper middle lower
-      (rowAssignmentCutGraph upper middle outerLevels beta)
-      (rowAssignmentCutGraph middle lower innerLevels alpha) =
-        rowAssignmentCutGraph upper lower directLevels gamma := by
-  apply ZFSet.ext
-  intro z
-  constructor
-  · intro hz
-    obtain ⟨p, hp, q, _, w, hw, rfl, first, second⟩ := (mem_relationCompose _ _ _ _ _ z).1 hz
-    obtain ⟨_, row, A, equal⟩ := (mem_rowAssignmentCutGraph _ _ _ _ _).1 first
-    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
-    have value := ((pair_mem_rowAssignmentCutGraph _ _ _ _ _ _ _).1 second).2.2
-    rw [coherent row A hp] at value
-    exact (pair_mem_rowAssignmentCutGraph _ _ _ _ _ _ _).2 ⟨hp, hw, value⟩
-  · intro hz
-    obtain ⟨bound, row, A, rfl⟩ := (mem_rowAssignmentCutGraph _ _ _ _ z).1 hz
-    obtain ⟨hp, hw⟩ := ZFSet.pair_mem_prod.1 bound
-    have hm := middle_valid row A hp
-    exact (mem_relationCompose _ _ _ _ _ _).2
-      ⟨ZFSet.pair row A, hp, ZFSet.pair row (assignmentCut outerLevels beta A), hm,
-        ZFSet.pair row (assignmentCut directLevels gamma A), hw, rfl,
-        (pair_mem_rowAssignmentCutGraph _ _ _ _ _ _ _).2 ⟨hp, hm, rfl⟩,
-        (pair_mem_rowAssignmentCutGraph _ _ _ _ _ _ _).2
-          ⟨hm, hw, congrArg (ZFSet.pair row) (coherent row A hp).symm⟩⟩
-
-theorem rowAssignmentCutGraph_nested (upper middle lower levels alpha beta : ZFSet.{u})
-    (below : alpha ⊆ beta)
-    (middle_valid : ∀ row A, ZFSet.pair row A ∈ upper →
-      ZFSet.pair row (assignmentCut levels beta A) ∈ middle) :
-    relationCompose upper middle lower (rowAssignmentCutGraph upper middle levels beta)
-      (rowAssignmentCutGraph middle lower levels alpha) =
-        rowAssignmentCutGraph upper lower levels alpha :=
-  rowAssignmentCutGraph_compose upper middle lower levels beta levels alpha levels alpha
-    middle_valid (fun _ _ _ => assignmentCut_nested below)
-
-theorem rowAssignmentCutGraph_identity (carrier levels alpha : ZFSet.{u})
-    (flat : ∀ p ∈ carrier, ∃ row A, p = ZFSet.pair row A)
-    (fixed : ∀ row A, ZFSet.pair row A ∈ carrier → assignmentCut levels alpha A = A) :
-    rowAssignmentCutGraph carrier carrier levels alpha = identityFunctionGraph carrier := by
-  apply ZFSet.ext
-  intro z
-  constructor
-  · intro hz
-    obtain ⟨bound, row, A, rfl⟩ := (mem_rowAssignmentCutGraph _ _ _ _ z).1 hz
-    have hp := (ZFSet.pair_mem_prod.1 bound).1
-    rw [fixed row A hp]
-    exact (mem_identityFunctionGraph _ _).2 ⟨ZFSet.pair row A, hp, rfl⟩
-  · intro hz
-    obtain ⟨p, hp, rfl⟩ := (mem_identityFunctionGraph _ _).1 hz
-    obtain ⟨row, A, rfl⟩ := flat p hp
-    exact (pair_mem_rowAssignmentCutGraph _ _ _ _ _ _ _).2
-      ⟨hp, hp, congrArg (ZFSet.pair row) (fixed row A hp).symm⟩
-
-end PartitionPilot.Forcing
-
-end
-
-end OAI
+import OAI.SetTheory.PartitionPrinciple.Geometry.GroundRowAssignmentCuts
+
+namespace OAI
+
+section
+
+namespace PartitionPilot.Forcing
+universe u
+
+theorem rowAssignmentCutGraph_function (upper lower levels alpha : ZFSet.{u})
+    (flat : ∀ p ∈ upper, ∃ row A, p = ZFSet.pair row A)
+    (closed : ∀ row A, ZFSet.pair row A ∈ upper →
+      ZFSet.pair row (assignmentCut levels alpha A) ∈ lower) :
+    ZFSet.IsFunc upper lower (rowAssignmentCutGraph upper lower levels alpha) := by
+  refine ⟨fun _ h => ((mem_rowAssignmentCutGraph _ _ _ _ _).1 h).1, ?_⟩
+  intro p hp
+  obtain ⟨row, A, rfl⟩ := flat p hp
+  refine ⟨ZFSet.pair row (assignmentCut levels alpha A),
+    (pair_mem_rowAssignmentCutGraph _ _ _ _ _ _ _).2 ⟨hp, closed row A hp, rfl⟩, ?_⟩
+  intro q entry
+  exact ((pair_mem_rowAssignmentCutGraph _ _ _ _ _ _ _).1 entry).2.2
+
+theorem rowAssignmentCutGraph_compose
+    (upper middle lower outerLevels beta innerLevels alpha directLevels gamma : ZFSet.{u})
+    (middle_valid : ∀ row A, ZFSet.pair row A ∈ upper →
+      ZFSet.pair row (assignmentCut outerLevels beta A) ∈ middle)
+    (coherent : ∀ row A, ZFSet.pair row A ∈ upper →
+      assignmentCut innerLevels alpha (assignmentCut outerLevels beta A) =
+        assignmentCut directLevels gamma A) :
+    relationCompose upper middle lower
+      (rowAssignmentCutGraph upper middle outerLevels beta)
+      (rowAssignmentCutGraph middle lower innerLevels alpha) =
+        rowAssignmentCutGraph upper lower directLevels gamma := by
+  apply ZFSet.ext
+  intro z
+  constructor
+  · intro hz
+    obtain ⟨p, hp, q, _, w, hw, rfl, first, second⟩ := (mem_relationCompose _ _ _ _ _ z).1 hz
+    obtain ⟨_, row, A, equal⟩ := (mem_rowAssignmentCutGraph _ _ _ _ _).1 first
+    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal
+    have value := ((pair_mem_rowAssignmentCutGraph _ _ _ _ _ _ _).1 second).2.2
+    rw [coherent row A hp] at value
+    exact (pair_mem_rowAssignmentCutGraph _ _ _ _ _ _ _).2 ⟨hp, hw, value⟩
+  · intro hz
+    obtain ⟨bound, row, A, rfl⟩ := (mem_rowAssignmentCutGraph _ _ _ _ z).1 hz
+    obtain ⟨hp, hw⟩ := ZFSet.pair_mem_prod.1 bound
+    have hm := middle_valid row A hp
+    exact (mem_relationCompose _ _ _ _ _ _).2
+      ⟨ZFSet.pair row A, hp, ZFSet.pair row (assignmentCut outerLevels beta A), hm,
+        ZFSet.pair row (assignmentCut directLevels gamma A), hw, rfl,
+        (pair_mem_rowAssignmentCutGraph _ _ _ _ _ _ _).2 ⟨hp, hm, rfl⟩,
+        (pair_mem_rowAssignmentCutGraph _ _ _ _ _ _ _).2
+          ⟨hm, hw, congrArg (ZFSet.pair row) (coherent row A hp).symm⟩⟩
+
+theorem rowAssignmentCutGraph_nested (upper middle lower levels alpha beta : ZFSet.{u})
+    (below : alpha ⊆ beta)
+    (middle_valid : ∀ row A, ZFSet.pair row A ∈ upper →
+      ZFSet.pair row (assignmentCut levels beta A) ∈ middle) :
+    relationCompose upper middle lower (rowAssignmentCutGraph upper middle levels beta)
+      (rowAssignmentCutGraph middle lower levels alpha) =
+        rowAssignmentCutGraph upper lower levels alpha :=
+  rowAssignmentCutGraph_compose upper middle lower levels beta levels alpha levels alpha
+    middle_valid (fun _ _ _ => assignmentCut_nested below)
+
+theorem rowAssignmentCutGraph_identity (carrier levels alpha : ZFSet.{u})
+    (flat : ∀ p ∈ carrier, ∃ row A, p = ZFSet.pair row A)
+    (fixed : ∀ row A, ZFSet.pair row A ∈ carrier → assignmentCut levels alpha A = A) :
+    rowAssignmentCutGraph carrier carrier levels alpha = identityFunctionGraph carrier := by
+  apply ZFSet.ext
+  intro z
+  constructor
+  · intro hz
+    obtain ⟨bound, row, A, rfl⟩ := (mem_rowAssignmentCutGraph _ _ _ _ z).1 hz
+    have hp := (ZFSet.pair_mem_prod.1 bound).1
+    rw [fixed row A hp]
+    exact (mem_identityFunctionGraph _ _).2 ⟨ZFSet.pair row A, hp, rfl⟩
+  · intro hz
+    obtain ⟨p, hp, rfl⟩ := (mem_identityFunctionGraph _ _).1 hz
+    obtain ⟨row, A, rfl⟩ := flat p hp
+    exact (pair_mem_rowAssignmentCutGraph _ _ _ _ _ _ _).2
+      ⟨hp, hp, congrArg (ZFSet.pair row) (fixed row A hp).symm⟩
+
+end PartitionPilot.Forcing
+
+end
+
+end OAI