openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Transfinite /AmalgamationCoinitiality.lean
| import OAI.SetTheory.PartitionPrinciple.Forcing.ChronologicalTransport | |
| namespace OAI | |
| section | |
| namespace PartitionPilot.Compression.RecursiveMaps.PrincipalAmalgamation.Input | |
| open Attachment Chronological | |
| universe u | |
| variable {A B Stage : Type u} [LinearOrder Stage] | |
| {P : MeetOrder A} {Q : MeetOrder B} (g : Input P Q) | |
| def birth (oldBirth : A → Stage) (s : Stage) : g.Node → Stage | |
| | .inl a => oldBirth a | |
| | .inr _ => s | |
| theorem birth_le (oldBirth : A → Stage) (s : Stage) (old : ∀ a, oldBirth a < s) : | |
| ∀ x, g.birth oldBirth s x ≤ s := by | |
| intro x | |
| cases x with | |
| | inl a => exact le_of_lt (old a) | |
| | inr _ => exact le_refl s | |
| theorem old_meet_preserved (oldBirth : A → Stage) (s : Stage) | |
| (old : ∀ a, oldBirth a < s) (previous : OldMeet (P := P) oldBirth) : | |
| OldMeet (P := g.order) (g.birth oldBirth s) := by | |
| intro x y earlier notLower | |
| cases x with | |
| | inl a => | |
| cases y with | |
| | inl b => | |
| have eq : g.order.meet (.inl a) (.inl b) = Sum.inl (P.meet a b) := | |
| (g.left.map_meet a b).symm | |
| rw [eq] | |
| exact previous a b earlier notLower | |
| | inr y => exact False.elim (lt_asymm earlier (old a)) | |
| | inr x => | |
| cases y with | |
| | inl a => | |
| rw [g.new_shadow_meet] | |
| exact old _ | |
| | inr y => exact False.elim (lt_irrefl s earlier) | |
| noncomputable def earlier_layer {Space : Stage → Type u} | |
| {order : ∀ t, MeetOrder (Space t)} (oldBirth : A → Stage) (s t : Stage) | |
| (earlier : t < s) (layer : GrowthLayer Space order P oldBirth t) : | |
| GrowthLayer Space order g.order (g.birth oldBirth s) t := by | |
| apply layer.transport g.left (fun _ => rfl) | |
| intro x hx | |
| cases x with | |
| | inl a => exact ⟨a, rfl⟩ | |
| | inr x => | |
| change s = t at hx | |
| exact False.elim (lt_irrefl s (hx ▸ earlier)) | |
| noncomputable def incoming_layer (Space : Stage → Type u) | |
| (order : ∀ t, MeetOrder (Space t)) (oldBirth : A → Stage) (s : Stage) | |
| (old : ∀ a, oldBirth a < s) (I : Type u) [Countable I] | |
| (index : I → Stage) (earlier : ∀ i, index i < s) | |
| (copy : ∀ i, MeetEmbedding (order (index i)) Q) | |
| (cover : ∀ b, ∃ i y, (copy i).toFun y = b) : | |
| GrowthLayer Space order g.order (g.birth oldBirth s) s := by | |
| apply GrowthLayer.copies I inferInstance index earlier (fun i => compose (copy i) g.right) | |
| intro x hx | |
| cases x with | |
| | inl a => | |
| change oldBirth a = s at hx | |
| exact False.elim (lt_irrefl s (hx ▸ old a)) | |
| | inr b => | |
| rcases cover b.val with ⟨i, y, eq⟩ | |
| exact ⟨i, y, (congrArg g.right.toFun eq).trans (g.represent_new b.val b.property)⟩ | |
| theorem profile_persists (c e K : A) (F : A → Prop) (inhabited : ∃ f, F f) | |
| (profile : Profile P c e K F) (separated : ¬ P.le e K) : | |
| ProfileOver g.left c e K F := | |
| attachment_preserves_profile g.data g.component_meets c e K F inhabited profile separated | |
| end PartitionPilot.Compression.RecursiveMaps.PrincipalAmalgamation.Input | |
| namespace PartitionPilot.Compression.RecursiveMaps.PrincipalAmalgamation | |
| open Chronological | |
| universe u | |
| noncomputable def binary_incoming_layer {A T Stage : Type u} [LinearOrder Stage] | |
| {P : MeetOrder A} {R : MeetOrder T} (tile : Input R R) (g : Input P tile.order) | |
| (Space : Stage → Type u) (order : ∀ t, MeetOrder (Space t)) | |
| (oldBirth : A → Stage) (s t : Stage) (old : ∀ a, oldBirth a < s) (earlier : t < s) | |
| (template : MeetIso (order t) R) : | |
| GrowthLayer Space order g.order (g.birth oldBirth s) s := by | |
| apply g.incoming_layer Space order oldBirth s old (ULift.{u} Bool) (fun _ => t) (fun _ => earlier) | |
| (fun i => compose template.toMeetEmbedding (BinaryTiles.vertex R tile i.down)) | |
| intro x | |
| rcases BinaryTiles.vertex_cover R tile x with ⟨i, y, eq⟩ | |
| refine ⟨⟨i⟩, template.inverse y, ?_⟩ | |
| change (BinaryTiles.vertex R tile i).toFun (template.toFun (template.inverse y)) = x | |
| rw [template.right_inverse] | |
| exact eq | |
| end PartitionPilot.Compression.RecursiveMaps.PrincipalAmalgamation | |
| end | |
| end OAI | |