openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Transfinite /CoinitialityPreservation.lean
| import OAI.SetTheory.PartitionPrinciple.Geometry.FinalProfilePersistence | |
| namespace OAI | |
| section | |
| namespace PartitionPilot.Compression.RecursiveMaps.Chronological | |
| universe u v w | |
| theorem all_filters_of_countable {A : Type u} [Countable A] (P : MeetOrder A) : | |
| AllFiltersCountable P := fun F => | |
| countableBelow_of_countable F F.mem (Set.to_countable _) (fun _ h => h) | |
| theorem all_filters_of_countable_cover {A : Type u} {I : Type v} [Countable I] | |
| {P : MeetOrder A} (Space : I → Type w) (orders : ∀ i, MeetOrder (Space i)) | |
| (copy : ∀ i, MeetEmbedding (orders i) P) | |
| (cover : ∀ x, ∃ i y, (copy i).toFun y = x) | |
| (small : ∀ i, AllFiltersCountable (orders i)) : AllFiltersCountable P := by | |
| intro F | |
| apply countableBelow_union F F.mem (fun i x => F.mem x ∧ ∃ y, (copy i).toFun y = x) | |
| · intro x positive | |
| rcases cover x with ⟨i, y, eq⟩ | |
| exact ⟨i, positive, y, eq⟩ | |
| · intro i | |
| exact countableBelow_copy (copy i) F (small i) | |
| theorem all_filters_of_surjective {A : Type u} {B : Type v} | |
| {P : MeetOrder A} {Q : MeetOrder B} (e : MeetEmbedding P Q) | |
| (onto : Function.Surjective e.toFun) (small : AllFiltersCountable P) : AllFiltersCountable Q := by | |
| intro F | |
| exact countableBelow_mono F (countableBelow_copy e F small) (fun x hx => ⟨hx, onto x⟩) | |
| def twoLayerBirth {O : Type u} {N : Type v} : O ⊕ N → ULift.{max u v} Nat | |
| | .inl _ => ⟨0⟩ | |
| | .inr _ => ⟨1⟩ | |
| theorem all_filters_of_separated_sum {O N I : Type u} {P : MeetOrder O} | |
| (Q : MeetOrder (O ⊕ N)) (old : MeetEmbedding P Q) | |
| (old_eq : ∀ x, old.toFun x = .inl x) | |
| (Space : I → Type u) (orders : ∀ i, MeetOrder (Space i)) | |
| (copy : ∀ i, MeetEmbedding (orders i) Q) (component : N → I) | |
| (cover : ∀ x, ∃ y, (copy (component x)).toFun y = .inr x) | |
| (separated : ∀ x y, component x ≠ component y → | |
| OldBridge (P := Q) twoLayerBirth ⟨1⟩ (.inr x) (.inr y)) | |
| (oldSmall : AllFiltersCountable P) (copySmall : ∀ i, AllFiltersCountable (orders i)) : | |
| AllFiltersCountable Q := by | |
| classical | |
| let : WellFoundedLT (ULift.{u} Nat) := InvImage.wf ULift.down Nat.lt_wfRel.wf | |
| intro F | |
| have fresh : CountableBelow F | |
| (fun x => Essential twoLayerBirth F x ∧ ∃ y, Sum.inr y = x) := by | |
| by_cases inhabited : ∃ x : N, Essential twoLayerBirth F (.inr x) | |
| · rcases inhabited with ⟨x, hx⟩ | |
| apply countableBelow_mono F (countableBelow_copy (copy (component x)) F (copySmall _)) | |
| rintro y ⟨hy, z, rfl⟩ | |
| have same : component z = component x := by | |
| by_contra different | |
| exact essentials_no_bridge twoLayerBirth F ⟨1⟩ (.inr z) (.inr x) hy hx rfl rfl | |
| (separated z x different) | |
| have covered := cover z | |
| rw [same] at covered | |
| exact ⟨hy.1, covered⟩ | |
| · exact countableBelow_empty F _ (by | |
| rintro x ⟨hx, y, rfl⟩ | |
| exact inhabited ⟨y, hx⟩) | |
| apply countable_basis_of_layers twoLayerBirth F (Set.to_countable _) | |
| rintro ⟨s⟩ | |
| cases s with | |
| | zero => | |
| apply countableBelow_mono F (countableBelow_copy old F oldSmall) | |
| rintro x ⟨hx, born⟩ | |
| cases x with | |
| | inl x => exact ⟨hx.1, x, old_eq x⟩ | |
| | inr x => exact False.elim (Nat.one_ne_zero (congrArg ULift.down born)) | |
| | succ s => | |
| apply countableBelow_mono F fresh | |
| rintro x ⟨hx, born⟩ | |
| cases x with | |
| | inl x => exact False.elim (Nat.noConfusion (congrArg ULift.down born)) | |
| | inr x => exact ⟨hx, x, rfl⟩ | |
| end PartitionPilot.Compression.RecursiveMaps.Chronological | |
| end | |
| end OAI | |