openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Geometry /GroundBatchHeightGraphs.lean
| import OAI.SetTheory.PartitionPrinciple.Definability.BatchAttachmentRealization | |
| namespace OAI | |
| open scoped ZFSet | |
| section | |
| namespace PartitionPilot.Forcing | |
| universe u | |
| namespace BoundedFormula | |
| open SetFormula | |
| def componentHeightEntryFormula {n} | |
| (w I Qs B Hs Cs E C D boundQs boundHs boundE : Fin n) : BoundedFormula n := | |
| let lift (i : Fin n) : Fin (n + 8) := i.succ.succ.succ.succ.succ.succ.succ.succ | |
| let body : BoundedFormula (n + 8) := | |
| .conj (pairOfPairsFormula (lift w) 7 3 1 0) | |
| (.conj (pairMembershipFormula 7 6 (lift Qs)) | |
| (.conj (pairMembershipFormula 7 5 (lift Hs)) | |
| (.conj (pairMembershipFormula 7 4 (lift E)) | |
| (.conj (pairMembershipFormula 7 1 (lift Cs)) | |
| (.conj (pairMembershipFormula 3 2 5) (pairMembershipFormula 2 0 4)))))) | |
| exMem I (exMem boundQs.succ (exMem boundHs.succ.succ | |
| (exMem boundE.succ.succ.succ (exMem 2 | |
| (exMem B.succ.succ.succ.succ.succ | |
| (exMem C.succ.succ.succ.succ.succ.succ | |
| (exMem D.succ.succ.succ.succ.succ.succ.succ body))))))) | |
| theorem truth_componentHeightEntryFormula {n} | |
| (w I Qs B Hs Cs E C D boundQs boundHs boundE : Fin n) (env : Fin n → ZFSet.{u}) : | |
| Truth (componentHeightEntryFormula w I Qs B Hs Cs E C D boundQs boundHs boundE) env ↔ | |
| ∃ i ∈ env I, ∃ Q ∈ env boundQs, ∃ g ∈ env boundHs, ∃ f ∈ env boundE, | |
| ∃ q ∈ Q, ∃ a ∈ env B, ∃ c ∈ env C, ∃ z ∈ env D, | |
| env w = ZFSet.pair (ZFSet.pair i q) (ZFSet.pair c z) ∧ | |
| ZFSet.pair i Q ∈ env Qs ∧ ZFSet.pair i g ∈ env Hs ∧ ZFSet.pair i f ∈ env E ∧ | |
| ZFSet.pair i c ∈ env Cs ∧ ZFSet.pair q a ∈ g ∧ ZFSet.pair a z ∈ f := by | |
| simp only [componentHeightEntryFormula, truth_exMem, Truth, | |
| truth_pairOfPairsFormula, truth_pairMembershipFormula] | |
| rfl | |
| def taggedHeightEntryFormula {n} (w P N H fresh : Fin n) : BoundedFormula n := | |
| exMem N (exMem H.succ | |
| (.conj (orderedTripleFormula w.succ.succ P.succ.succ 1 0) | |
| (pairMembershipFormula 1 0 fresh.succ.succ))) | |
| theorem truth_taggedHeightEntryFormula {n} (w P N H fresh : Fin n) | |
| (env : Fin n → ZFSet.{u}) : | |
| Truth (taggedHeightEntryFormula w P N H fresh) env ↔ | |
| ∃ x ∈ env N, ∃ h ∈ env H, | |
| env w = ZFSet.pair (ZFSet.pair (env P) x) h ∧ ZFSet.pair x h ∈ env fresh := by | |
| simp only [taggedHeightEntryFormula, truth_exMem, Truth, | |
| truth_orderedTripleFormula, truth_pairMembershipFormula] | |
| rfl | |
| end BoundedFormula | |
| namespace TransitiveGround | |
| open SetFormula | |
| variable (M : TransitiveGround.{u}) | |
| theorem componentHeightGraph_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 Qs B Hs Cs E C D : ZFSet.{u}} | |
| (hI : I ∈ M.sets) (hQs : Qs ∈ M.sets) (hB : B ∈ M.sets) (hHs : Hs ∈ M.sets) | |
| (hCs : Cs ∈ M.sets) (hE : E ∈ M.sets) (hC : C ∈ M.sets) (hD : D ∈ M.sets) : | |
| componentHeightGraph I Qs B Hs Cs E C D ∈ M.sets := by | |
| have qBound := M.union_mem unions (M.union_mem unions hQs) | |
| have hBound := M.union_mem unions (M.union_mem unions hHs) | |
| have eBound := M.union_mem unions (M.union_mem unions hE) | |
| let params := extend I (extend Qs (extend B (extend Hs (extend Cs (extend E | |
| (extend C (extend D (extend (⋃₀ ⋃₀ Qs) (extend (⋃₀ ⋃₀ Hs) | |
| (extend (⋃₀ ⋃₀ E) Fin.elim0)))))))))) | |
| have selected := M.bounded_separation_mem separation | |
| (BoundedFormula.componentHeightEntryFormula 0 1 2 3 4 5 6 7 8 9 10 11) params | |
| (Fin.cases hI (Fin.cases hQs (Fin.cases hB (Fin.cases hHs (Fin.cases hCs | |
| (Fin.cases hE (Fin.cases hC (Fin.cases hD (Fin.cases qBound | |
| (Fin.cases hBound (Fin.cases eBound (fun i => Fin.elim0 i)))))))))))) | |
| (M.prod_mem pairing unions powers separation | |
| (M.indexedAttachmentDomain_mem pairing unions powers separation hI hQs) | |
| (M.prod_mem pairing unions powers separation hC hD)) | |
| have equal : ZFSet.sep (fun z => BoundedFormula.Truth | |
| (BoundedFormula.componentHeightEntryFormula 0 1 2 3 4 5 6 7 8 9 10 11) (extend z params)) | |
| (ZFSet.prod (indexedAttachmentDomain I Qs) (ZFSet.prod C D)) = | |
| componentHeightGraph I Qs B Hs Cs E C D := by | |
| apply ZFSet.ext | |
| intro z | |
| rw [componentHeightGraph, ZFSet.mem_sep, ZFSet.mem_sep] | |
| exact and_congr Iff.rfl | |
| (BoundedFormula.truth_componentHeightEntryFormula 0 1 2 3 4 5 6 7 8 9 10 11 _) | |
| exact equal ▸ selected | |
| theorem taggedHeightGraph_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 N H old fresh : ZFSet.{u}} | |
| (hP : P ∈ M.sets) (hN : N ∈ M.sets) (hH : H ∈ M.sets) | |
| (hold : old ∈ M.sets) (hfresh : fresh ∈ M.sets) : | |
| taggedHeightGraph P N H old fresh ∈ M.sets := by | |
| let params := extend P (extend N (extend H (extend fresh Fin.elim0))) | |
| have selected := M.bounded_separation_mem separation | |
| (BoundedFormula.taggedHeightEntryFormula 0 1 2 3 4) params | |
| (Fin.cases hP (Fin.cases hN (Fin.cases hH (Fin.cases hfresh (fun i => Fin.elim0 i))))) | |
| (M.prod_mem pairing unions powers separation | |
| (M.taggedExtension_mem pairing unions powers separation hP hN) hH) | |
| have equal : ZFSet.sep (fun z => BoundedFormula.Truth | |
| (BoundedFormula.taggedHeightEntryFormula 0 1 2 3 4) (extend z params)) | |
| (ZFSet.prod (taggedExtension P N) H) = | |
| ZFSet.sep (fun w => ∃ x ∈ N, ∃ h ∈ H, | |
| w = ZFSet.pair (ZFSet.pair P x) h ∧ ZFSet.pair x h ∈ fresh) | |
| (ZFSet.prod (taggedExtension P N) H) := by | |
| apply ZFSet.ext | |
| intro z | |
| rw [ZFSet.mem_sep, ZFSet.mem_sep] | |
| exact and_congr Iff.rfl (BoundedFormula.truth_taggedHeightEntryFormula 0 1 2 3 4 _) | |
| exact M.binary_union_mem pairing unions hold (equal ▸ selected) | |
| end TransitiveGround | |
| end PartitionPilot.Forcing | |
| end | |
| end OAI | |