| import OAI.SetTheory.PartitionPrinciple.Geometry.CompatibleCopies | |
| namespace OAI | |
| section | |
| namespace PartitionPilot.Compression.RecursiveMaps.CompatibleCopies.Data | |
| universe u v | |
| variable {A : Type u} {I : Type v} {P : MeetOrder A} (d : Data P I) | |
| def Node := Quotient d.setoid | |
| def point (i : I) (x : A) : d.Node := Quotient.mk d.setoid (i, x) | |
| def nodeLe : d.Node → d.Node → Prop := | |
| Quotient.lift₂ d.Le (fun _ _ _ _ ha hb => propext | |
| ⟨fun h => d.le_trans (d.related_le (d.related_symm ha)) (d.le_trans h (d.related_le hb)), | |
| fun h => d.le_trans (d.related_le ha) (d.le_trans h (d.related_le (d.related_symm hb)))⟩) | |
| theorem mk_le_mk (i j : I) (x y : A) : d.nodeLe (d.point i x) (d.point j y) ↔ d.Le (i, x) (j, y) := | |
| Iff.rfl | |
| theorem mk_eq_mk (i j : I) (x y : A) : d.point i x = d.point j y ↔ d.Related (i, x) (j, y) := | |
| ⟨fun h => Quotient.exact h, fun h => Quotient.sound h⟩ | |
| theorem node_refl (x : d.Node) : d.nodeLe x x := by | |
| induction x using Quotient.ind with | |
| | _ x => exact d.le_refl x | |
| theorem node_trans {x y z : d.Node} (hxy : d.nodeLe x y) (hyz : d.nodeLe y z) : d.nodeLe x z := by | |
| induction x, y, z using Quotient.inductionOn₃ with | |
| | _ x y z => exact d.le_trans hxy hyz | |
| theorem node_antisymm {x y : d.Node} (hxy : d.nodeLe x y) (hyx : d.nodeLe y x) : x = y := by | |
| induction x, y using Quotient.inductionOn₂ with | |
| | _ x y => exact Quotient.sound (d.le_antisymm_related hxy hyx) | |
| theorem vertex_le (i : I) (x y : A) : d.nodeLe (d.point i x) (d.point i y) ↔ P.le x y := | |
| d.same_vertex_le i x y | |
| theorem vertex_below (i j : I) (x y : A) : | |
| d.nodeLe (d.point i x) (d.point j y) ↔ P.le x (d.part i j y) := | |
| d.below_iff_part i j x y | |
| theorem cover (x : d.Node) : ∃ i y, d.point i y = x := by | |
| induction x using Quotient.ind with | |
| | _ x => exact ⟨x.1, x.2, rfl⟩ | |
| theorem vertex_ideal (i : I) (y : A) (x : d.Node) (lower : d.nodeLe x (d.point i y)) : | |
| ∃ z, d.point i z = x := by | |
| induction x using Quotient.ind with | |
| | _ x => | |
| have moved := d.move_to_upper_vertex lower | |
| exact ⟨(d.change x.1 i).toFun x.2, (Quotient.sound moved.1).symm⟩ | |
| def IsMeet (x y m : d.Node) : Prop := | |
| d.nodeLe m x ∧ d.nodeLe m y ∧ ∀ z, d.nodeLe z x → d.nodeLe z y → d.nodeLe z m | |
| theorem cross_meet_spec (i j : I) (x y : A) : | |
| d.IsMeet (d.point i x) (d.point j y) (d.point i (P.meet x (d.part i j y))) := by | |
| refine ⟨(d.vertex_le i _ _).mpr (P.meet_le_left _ _), | |
| (d.vertex_below i j _ _).mpr (P.meet_le_right _ _), ?_⟩ | |
| intro z hx hy | |
| rcases d.vertex_ideal i x z hx with ⟨a, rfl⟩ | |
| exact (d.vertex_le i _ _).mpr | |
| (P.le_meet ((d.vertex_le i _ _).mp hx) ((d.vertex_below i j _ _).mp hy)) | |
| theorem all_meets (x y : d.Node) : ∃ m, d.IsMeet x y m := by | |
| induction x, y using Quotient.inductionOn₂ with | |
| | _ x y => exact ⟨_, d.cross_meet_spec x.1 y.1 x.2 y.2⟩ | |
| noncomputable def order : MeetOrder d.Node where | |
| le := d.nodeLe | |
| meet x y := Classical.choose (d.all_meets x y) | |
| refl := d.node_refl | |
| trans := d.node_trans | |
| antisymm := d.node_antisymm | |
| meet_le_left x y := (Classical.choose_spec (d.all_meets x y)).1 | |
| meet_le_right x y := (Classical.choose_spec (d.all_meets x y)).2.1 | |
| le_meet hx hy := (Classical.choose_spec (d.all_meets _ _)).2.2 _ hx hy | |
| theorem meet_eq {x y m : d.Node} (h : d.IsMeet x y m) : d.order.meet x y = m := | |
| d.node_antisymm (h.2.2 _ (d.order.meet_le_left x y) (d.order.meet_le_right x y)) | |
| (d.order.le_meet h.1 h.2.1) | |
| theorem vertex_meet_spec (i : I) (x y : A) : | |
| d.IsMeet (d.point i x) (d.point i y) (d.point i (P.meet x y)) := by | |
| refine ⟨(d.vertex_le i _ _).mpr (P.meet_le_left _ _), | |
| (d.vertex_le i _ _).mpr (P.meet_le_right _ _), ?_⟩ | |
| intro z hx hy | |
| rcases d.vertex_ideal i x z hx with ⟨a, rfl⟩ | |
| exact (d.vertex_le i _ _).mpr | |
| (P.le_meet ((d.vertex_le i _ _).mp hx) ((d.vertex_le i _ _).mp hy)) | |
| noncomputable def vertex (i : I) : MeetEmbedding P d.order where | |
| toFun := d.point i | |
| le_iff := d.vertex_le i | |
| map_meet x y := (d.meet_eq (d.vertex_meet_spec i x y)).symm | |
| theorem vertex_injective (i : I) : Function.Injective (d.vertex i).toFun := | |
| fun _ _ h => embedding_injective (d.vertex i) h | |
| theorem exact_overlap (i j : I) (x y : A) : | |
| (d.vertex i).toFun x = (d.vertex j).toFun y ↔ | |
| P.le x (d.anchor i j) ∧ (d.change i j).toFun x = y := | |
| d.mk_eq_mk i j x y | |
| theorem cross_meet (i j : I) (x y : A) : | |
| d.order.meet ((d.vertex i).toFun x) ((d.vertex j).toFun y) = | |
| (d.vertex i).toFun (P.meet x (d.part i j y)) := | |
| d.meet_eq (d.cross_meet_spec i j x y) | |
| theorem part_respects (i : I) {x y : d.Label} (h : d.Related x y) : | |
| d.part i x.1 x.2 = d.part i y.1 y.2 := by | |
| apply P.antisymm | |
| · exact (d.below_iff_part i y.1 _ _).mp | |
| (d.le_trans (d.part_below i x.1 x.2) (d.related_le h)) | |
| · exact (d.below_iff_part i x.1 _ _).mp | |
| (d.le_trans (d.part_below i y.1 y.2) (d.related_le (d.related_symm h))) | |
| def projection (i : I) : d.Node → A := | |
| Quotient.lift (fun x => d.part i x.1 x.2) (fun _ _ h => d.part_respects i h) | |
| theorem greatest_part (i : I) (x : d.Node) (a : A) : | |
| d.order.le ((d.vertex i).toFun a) x ↔ P.le a (d.projection i x) := by | |
| induction x using Quotient.ind with | |
| | _ x => exact d.below_iff_part i x.1 a x.2 | |
| theorem projection_formula (i j : I) (x : A) : | |
| d.projection i ((d.vertex j).toFun x) = (d.change j i).toFun (P.meet x (d.anchor j i)) := rfl | |
| theorem vertex_principal (i : I) (x : d.Node) : | |
| d.order.le x ((d.vertex i).toFun d.top) ↔ ∃ a, (d.vertex i).toFun a = x := by | |
| constructor | |
| · exact d.vertex_ideal i d.top x | |
| · rintro ⟨a, rfl⟩ | |
| exact (d.vertex_le i _ _).mpr (d.greatest a) | |
| theorem bottom_preserved (i : I) (zero : A) (least : ∀ x, P.le zero x) : | |
| ∀ x, d.order.le ((d.vertex i).toFun zero) x := | |
| fun x => (d.greatest_part i x zero).mpr (least _) | |
| theorem comparison_in_vertex (x y : d.Node) (lower : d.order.le x y) : | |
| ∃ i a b, (d.vertex i).toFun a = x ∧ (d.vertex i).toFun b = y ∧ P.le a b := by | |
| rcases d.cover y with ⟨i, b, rfl⟩ | |
| rcases d.vertex_ideal i b x lower with ⟨a, rfl⟩ | |
| exact ⟨i, a, b, rfl, rfl, (d.vertex_le i _ _).mp lower⟩ | |
| end PartitionPilot.Compression.RecursiveMaps.CompatibleCopies.Data | |
| end | |
| end OAI | |