openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Transfinite /AttachmentCoinitiality.lean
| import OAI.SetTheory.PartitionPrinciple.Geometry.RationalHeightDescent | |
| namespace OAI | |
| section | |
| namespace PartitionPilot.Compression.RecursiveMaps.Chronological | |
| open Attachment | |
| universe u | |
| variable {O I Stage : Type u} [LinearOrder Stage] {P : MeetOrder O} | |
| (b : Templates.{u,u,u} P I) | |
| theorem attachment_bridge (birth : O ⊕ b.Fresh → Stage) (s : Stage) | |
| (old : ∀ a, birth (.inl a) < s) (x y : b.Fresh) (different : x.1 ≠ y.1) : | |
| OldBridge (P := b.extension) birth s (.inr x) (.inr y) := by | |
| classical | |
| by_cases xy : b.extension.le (.inr x) (.inr y) | |
| · exact Or.inr (Or.inl ⟨.inl (b.shadow y), old _, | |
| (b.cross_le_iff x y different).mp xy, P.refl _⟩) | |
| · by_cases yx : b.extension.le (.inr y) (.inr x) | |
| · exact Or.inr (Or.inr ⟨.inl (b.shadow x), old _, | |
| (b.cross_le_iff y x different.symm).mp yx, P.refl _⟩) | |
| · apply Or.inl | |
| rw [b.cross_meet_eq x y different xy yx] | |
| exact old _ | |
| theorem attachment_essential_component (birth : O ⊕ b.Fresh → Stage) (s : Stage) | |
| (old : ∀ a, birth (.inl a) < s) (fresh : ∀ x : b.Fresh, birth (.inr x) = s) | |
| (F : MeetFilter b.extension) (x y : b.Fresh) | |
| (hx : Essential birth F (.inr x)) (hy : Essential birth F (.inr y)) : x.1 = y.1 := by | |
| by_contra different | |
| exact essentials_no_bridge birth F s (.inr x) (.inr y) hx hy (fresh x) (fresh y) | |
| (attachment_bridge b birth s old x y different) | |
| theorem attachment_old_meet (birth : O ⊕ b.Fresh → Stage) (s : Stage) | |
| (old : ∀ a, birth (.inl a) < s) (fresh : ∀ x : b.Fresh, birth (.inr x) = s) | |
| (previous : OldMeet (P := P) (fun a => birth (.inl a))) : | |
| OldMeet (P := b.extension) birth := by | |
| intro x y earlier notLower | |
| cases x with | |
| | inl a => | |
| cases y with | |
| | inl c => | |
| have eq := (b.oldEmbedding.map_meet a c).symm | |
| change b.extension.meet (.inl a) (.inl c) = .inl (P.meet a c) at eq | |
| rw [eq] | |
| exact previous a c earlier notLower | |
| | inr y => | |
| rw [fresh] at earlier | |
| exact False.elim (lt_asymm earlier (old a)) | |
| | inr x => | |
| cases y with | |
| | inl a => | |
| rw [b.shadow_meet_eq x a notLower, fresh] | |
| exact old _ | |
| | inr y => | |
| rw [fresh, fresh] at earlier | |
| exact False.elim (lt_irrefl _ earlier) | |
| def birthFresh (birth : O ⊕ b.Fresh → Stage) (s : Stage) | |
| (old : ∀ a, birth (.inl a) < s) (x : {x // birth x = s}) : b.Fresh := by | |
| rcases x with ⟨x, hx⟩ | |
| cases x with | |
| | inl a => | |
| have impossible := old a | |
| rw [hx] at impossible | |
| exact False.elim (lt_irrefl _ impossible) | |
| | inr x => exact x | |
| theorem birthFresh_eq (birth : O ⊕ b.Fresh → Stage) (s : Stage) | |
| (old : ∀ a, birth (.inl a) < s) (x : {x // birth x = s}) : | |
| Sum.inr (birthFresh b birth s old x) = x.val := by | |
| rcases x with ⟨x, hx⟩ | |
| cases x with | |
| | inl a => | |
| have impossible := old a | |
| rw [hx] at impossible | |
| exact False.elim (lt_irrefl _ impossible) | |
| | inr x => rfl | |
| noncomputable def attachmentLayer (Space : Stage → Type u) (order : ∀ s, MeetOrder (Space s)) | |
| (birth : O ⊕ b.Fresh → Stage) (s : Stage) (old : ∀ a, birth (.inl a) < s) | |
| (index : I → Stage) (earlier : ∀ i, index i < s) | |
| (template : ∀ i, MeetIso (order (index i)) (b.order i)) : | |
| GrowthLayer Space order b.extension birth s := by | |
| apply GrowthLayer.separated I index earlier | |
| (fun i => compose (template i).toMeetEmbedding (b.templateEmbedding i)) | |
| (fun x => (birthFresh b birth s old x).1) | |
| · intro x | |
| let z := birthFresh b birth s old x | |
| refine ⟨(template z.1).inverse z.2.val, ?_⟩ | |
| change b.represent z.1 ((template z.1).toFun ((template z.1).inverse z.2.val)) = x.val | |
| rw [(template z.1).right_inverse, b.represent_new z.1 z.2.val z.2.property] | |
| exact birthFresh_eq b birth s old x | |
| · intro x y different | |
| have bridge := attachment_bridge b birth s old | |
| (birthFresh b birth s old x) (birthFresh b birth s old y) different | |
| rw [birthFresh_eq, birthFresh_eq] at bridge | |
| exact bridge | |
| def finiteLayer {A : Type u} {P : MeetOrder A} (Space : Stage → Type u) | |
| (order : ∀ s, MeetOrder (Space s)) (birth : A → Stage) (s : Stage) | |
| (finite : Set.Finite {x | birth x = s}) : GrowthLayer Space order P birth s := | |
| .countablePoints finite.countable | |
| end PartitionPilot.Compression.RecursiveMaps.Chronological | |
| end | |
| end OAI | |