| import OAI.Combinatorics.HalvingLines.RankCoordinates |
|
|
| namespace OAI |
|
|
| open Filter Topology |
|
|
| namespace PlanarHalving |
| namespace PlaneGraph |
|
|
| noncomputable def height (p q : Point) (x : ℝ) : ℝ := |
| p.2 + (x - p.1) * PlanarHalving.slope p q |
|
|
| @[simp] lemma height_left (p q : Point) : height p q p.1 = p.2 := by simp [height] |
| @[simp] lemma height_right (p q : Point) (hx : p.1 ≠ q.1) : height p q q.1 = q.2 := by |
| unfold height PlanarHalving.slope |
| have h : q.1 - p.1 ≠ 0 := sub_ne_zero.mpr hx.symm |
| field_simp |
| ring |
|
|
| lemma height_point_openSegment (p q : Point) {x : ℝ} (hl : p.1 < x) (hr : x < q.1) : |
| (x, height p q x) ∈ openSegment ℝ p q := by |
| rw [openSegment_eq_image] |
| have hd : 0 < q.1 - p.1 := sub_pos.mpr (hl.trans hr) |
| refine ⟨(x - p.1) / (q.1 - p.1), ⟨div_pos (sub_pos.mpr hl) hd, ?_⟩, ?_⟩ |
| · apply (div_lt_one hd).mpr |
| linarith |
| · ext <;> simp only [Prod.fst_add, Prod.snd_add, Prod.smul_fst, Prod.smul_snd, |
| smul_eq_mul, height, PlanarHalving.slope] |
| all_goals field_simp; ring |
|
|
| lemma height_continuous (p q : Point) : Continuous (height p q) := by |
| unfold height |
| fun_prop |
|
|
| lemma height_order {p q r s : Point} |
| (hd : Disjoint (openSegment ℝ p q) (openSegment ℝ r s)) |
| {x y : ℝ} (hxy : x < y) (hp : p.1 ≤ x) (hr : r.1 ≤ x) |
| (hq : y ≤ q.1) (hs : y ≤ s.1) |
| (hstart : height p q x < height r s x) : |
| height p q y ≤ height r s y := by |
| by_contra h |
| have hend : height r s y < height p q y := lt_of_not_ge h |
| let f : ℝ → ℝ := fun z => height p q z - height r s z |
| have hc : Continuous f := (height_continuous p q).sub (height_continuous r s) |
| have hfx : f x < 0 := sub_neg.mpr hstart |
| have hfy : 0 < f y := sub_pos.mpr hend |
| obtain ⟨z, hz, he⟩ := intermediate_value_Icc hxy.le hc.continuousOn ⟨hfx.le, hfy.le⟩ |
| have hxz : x < z := lt_of_le_of_ne hz.1 (by intro heq; subst z; exact ne_of_lt hfx he) |
| have hzy : z < y := lt_of_le_of_ne hz.2 (by intro heq; subst z; exact ne_of_gt hfy he) |
| have h₁ := height_point_openSegment p q (hp.trans_lt hxz) (hzy.trans_le hq) |
| have h₂ := height_point_openSegment r s (hr.trans_lt hxz) (hzy.trans_le hs) |
| have hv : height p q z = height r s z := sub_eq_zero.mp he |
| rw [← hv] at h₂ |
| exact Set.disjoint_left.mp hd h₁ h₂ |
|
|
| def Position {V : Type*} (P : V → Point) : Prop := |
| Function.Injective P ∧ ∀ i j l, i ≠ j → j ≠ l → i ≠ l → |
| orient (P i) (P j) (P l) ≠ 0 |
|
|
| variable {V : Type*} [Fintype V] {P : V → Point} |
|
|
| structure Drawing (P : V → Point) where |
| vertices : Finset V |
| edges : Finset (V × V) |
| right : ∀ e ∈ edges, (P e.1).1 < (P e.2).1 |
| ends : ∀ e ∈ edges, e.1 ∈ vertices ∧ e.2 ∈ vertices |
|
|
| def Drawing.NonCrossing (D : Drawing P) : Prop := |
| ∀ e ∈ D.edges, ∀ f ∈ D.edges, e ≠ f → |
| Disjoint (openSegment ℝ (P e.1) (P e.2)) (openSegment ℝ (P f.1) (P f.2)) |
|
|
| omit [Fintype V] in |
| lemma slope_eq_implies_eq (hP : Position P) {v u w : V} |
| (hu : (P v).1 < (P u).1) (hw : (P v).1 < (P w).1) |
| (hs : PlanarHalving.slope (P v) (P u) = PlanarHalving.slope (P v) (P w)) : u = w := by |
| by_contra hn |
| have hvu : v ≠ u := by intro h; subst u; exact (lt_irrefl _ hu) |
| have hvw : v ≠ w := by intro h; subst w; exact (lt_irrefl _ hw) |
| have hyu := height_right (P v) (P u) hu.ne |
| have hyw := height_right (P v) (P w) hw.ne |
| rw [height, hs] at hyu |
| rw [height] at hyw |
| apply hP.2 v u w hvu hn hvw |
| unfold orient |
| have hu' : (P u).2 - (P v).2 = ((P u).1 - (P v).1) * PlanarHalving.slope (P v) (P w) := by linarith |
| have hw' : (P w).2 - (P v).2 = ((P w).1 - (P v).1) * PlanarHalving.slope (P v) (P w) := by linarith |
| rw [hu', hw'] |
| ring |
|
|
| def IsGap (D : Drawing P) (g : V × V × V) : Prop := |
| (g.1, g.2.1) ∈ D.edges ∧ (g.1, g.2.2) ∈ D.edges ∧ |
| PlanarHalving.slope (P g.1) (P g.2.1) < PlanarHalving.slope (P g.1) (P g.2.2) ∧ |
| ∀ w, (g.1, w) ∈ D.edges → |
| PlanarHalving.slope (P g.1) (P g.2.1) < PlanarHalving.slope (P g.1) (P w) → |
| PlanarHalving.slope (P g.1) (P g.2.2) ≤ PlanarHalving.slope (P g.1) (P w) |
|
|
| noncomputable def Drawing.gaps (D : Drawing P) : Finset (V × V × V) := |
| by classical exact Finset.univ.filter (IsGap D) |
|
|
| lemma height_lt_height_iff (p u v : Point) {x : ℝ} (hx : p.1 < x) : |
| height p u x < height p v x ↔ PlanarHalving.slope p u < PlanarHalving.slope p v := by |
| simp only [height, add_lt_add_iff_left, mul_lt_mul_iff_right₀ (sub_pos.mpr hx)] |
|
|
| lemma height_le_height_iff (p u v : Point) {x : ℝ} (hx : p.1 < x) : |
| height p u x ≤ height p v x ↔ PlanarHalving.slope p u ≤ PlanarHalving.slope p v := by |
| simp only [height, add_le_add_iff_left, mul_le_mul_iff_right₀ (sub_pos.mpr hx)] |
|
|
| def InWedge (P : V → Point) (g : V × V × V) (q : V) : Prop := |
| (P g.1).1 < (P q).1 ∧ (P q).1 ≤ (P g.2.1).1 ∧ (P q).1 ≤ (P g.2.2).1 ∧ |
| height (P g.1) (P g.2.1) (P q).1 ≤ (P q).2 ∧ |
| (P q).2 ≤ height (P g.1) (P g.2.2) (P q).1 |
|
|
| def FirstVertex (P : V → Point) (s : Finset V) (g : V × V × V) (q : V) : Prop := |
| InWedge P g q ∧ ∀ r ∈ s, InWedge P g r → (P q).1 ≤ (P r).1 |
|
|
| omit [Fintype V] in |
| lemma IsGap.width_pos {D : Drawing P} {g : V × V × V} (hg : IsGap D g) |
| {x : ℝ} (hx : (P g.1).1 < x) : height (P g.1) (P g.2.1) x < height (P g.1) (P g.2.2) x := |
| (height_lt_height_iff _ _ _ hx).mpr hg.2.2.1 |
|
|
| omit [Fintype V] in |
| lemma IsGap.exists_inWedge {D : Drawing P} {g : V × V × V} (hg : IsGap D g) : |
| ∃ q ∈ D.vertices, InWedge P g q := by |
| have hl := D.right _ hg.1 |
| have hu := D.right _ hg.2.1 |
| by_cases h : (P g.2.1).1 ≤ (P g.2.2).1 |
| · refine ⟨g.2.1, (D.ends _ hg.1).2, hl, le_rfl, h, ?_, ?_⟩ |
| · rw [height_right _ _ hl.ne] |
| · simpa only [height_right _ _ hl.ne] using (hg.width_pos hl).le |
| · refine ⟨g.2.2, (D.ends _ hg.2.1).2, hu, (not_le.mp h).le, le_rfl, ?_, ?_⟩ |
| · simpa only [height_right _ _ hu.ne] using (hg.width_pos hu).le |
| · rw [height_right _ _ hu.ne] |
|
|
| omit [Fintype V] in |
| lemma IsGap.exists_firstVertex {D : Drawing P} {g : V × V × V} (hg : IsGap D g) : |
| ∃ q : ↥D.vertices, FirstVertex P D.vertices g q := by |
| classical |
| let W := D.vertices.filter (InWedge P g) |
| have he : W.Nonempty := by |
| obtain ⟨q, hqv, hq⟩ := hg.exists_inWedge |
| exact ⟨q, Finset.mem_filter.mpr ⟨hqv, hq⟩⟩ |
| obtain ⟨q, hq, hmin⟩ := W.exists_min_image (fun r => (P r).1) he |
| refine ⟨⟨q, (Finset.mem_filter.mp hq).1⟩, (Finset.mem_filter.mp hq).2, ?_⟩ |
| intro r hrv hr |
| exact hmin r (Finset.mem_filter.mpr ⟨hrv, hr⟩) |
|
|
| omit [Fintype V] in |
| lemma IsGap.separated_of_same_source (hP : Position P) {D : Drawing P} |
| {g h : V × V × V} (hg : IsGap D g) (hh : IsGap D h) |
| (hsrc : g.1 = h.1) (hne : g ≠ h) {x : ℝ} (hx : (P g.1).1 < x) : |
| height (P g.1) (P g.2.2) x ≤ height (P h.1) (P h.2.1) x ∨ |
| height (P h.1) (P h.2.2) x ≤ height (P g.1) (P g.2.1) x := by |
| have hhl : (h.1, h.2.1) ∈ D.edges := hh.1 |
| have hhu : (h.1, h.2.2) ∈ D.edges := hh.2.1 |
| have hgl : (g.1, g.2.1) ∈ D.edges := hg.1 |
| have hgu : (g.1, g.2.2) ∈ D.edges := hg.2.1 |
| rcases lt_trichotomy (PlanarHalving.slope (P g.1) (P g.2.1)) |
| (PlanarHalving.slope (P h.1) (P h.2.1)) with hl | he | hl |
| · left |
| rw [← hsrc] at hhl hl ⊢ |
| exact (height_le_height_iff _ _ _ hx).mpr (hg.2.2.2 _ hhl hl) |
| · have hlower : g.2.1 = h.2.1 := by |
| rw [← hsrc] at hhl he |
| exact slope_eq_implies_eq hP (D.right _ hgl) (D.right _ hhl) he |
| have hupper : g.2.2 = h.2.2 := by |
| have hab := hh.2.2.1 |
| have hba := hg.2.2.1 |
| rw [← hsrc] at hab hhu |
| rw [← hlower] at hab |
| have hb := hg.2.2.2 _ hhu hab |
| rw [hsrc] at hba hgu |
| rw [hlower] at hba |
| have ha := hh.2.2.2 _ hgu hba |
| rw [← hsrc] at ha |
| exact slope_eq_implies_eq hP (v := g.1) |
| (D.right (g.1, g.2.2) hg.2.1) (D.right (g.1, h.2.2) hhu) (le_antisymm hb ha) |
| exact (hne (Prod.ext hsrc (Prod.ext hlower hupper))).elim |
| · right |
| rw [hsrc] at hgl hl hx ⊢ |
| exact (height_le_height_iff _ _ _ hx).mpr (hh.2.2.2 _ hgl hl) |
|
|
| omit [Fintype V] in |
| lemma firstVertex_separated_of_source_lt {D : Drawing P} (hD : D.NonCrossing) |
| {g h : V × V × V} (hg : IsGap D g) (hh : IsGap D h) |
| {q : V} (hqg : FirstVertex P D.vertices g q) (hqh : FirstVertex P D.vertices h q) |
| (hsrc : (P g.1).1 < (P h.1).1) : |
| height (P g.1) (P g.2.2) (P q).1 ≤ height (P h.1) (P h.2.1) (P q).1 ∨ |
| height (P h.1) (P h.2.2) (P q).1 ≤ height (P g.1) (P g.2.1) (P q).1 := by |
| have hnot : ¬ (height (P g.1) (P g.2.1) (P h.1).1 ≤ (P h.1).2 ∧ |
| (P h.1).2 ≤ height (P g.1) (P g.2.2) (P h.1).1) := by |
| intro hi |
| have hw : InWedge P g h.1 := ⟨hsrc, hqh.1.1.le.trans hqg.1.2.1, |
| hqh.1.1.le.trans hqg.1.2.2.1, hi⟩ |
| exact (not_le_of_gt hqh.1.1) (hqg.2 _ (D.ends _ hh.1).1 hw) |
| have hneq : g.1 ≠ h.1 := by intro h; rw [h] at hsrc; exact lt_irrefl _ hsrc |
| rcases not_and_or.mp hnot with hlo | hup |
| · right |
| apply height_order (hD _ hh.2.1 _ hg.1 (by intro h; exact hneq (Prod.mk.inj h).1.symm)) |
| hqh.1.1 le_rfl hsrc.le hqh.1.2.2.1 hqg.1.2.1 |
| simpa only [height_left] using lt_of_not_ge hlo |
| · left |
| apply height_order (hD _ hg.2.1 _ hh.1 (by intro h; exact hneq (Prod.mk.inj h).1)) |
| hqh.1.1 hsrc.le le_rfl hqg.1.2.2.1 hqh.1.2.1 |
| simpa only [height_left] using lt_of_not_ge hup |
|
|
| omit [Fintype V] in |
| lemma FirstVertex.separated (hP : Position P) |
| (hx : Function.Injective (fun v => (P v).1)) {D : Drawing P} (hD : D.NonCrossing) |
| {g h : V × V × V} (hg : IsGap D g) (hh : IsGap D h) |
| {q : V} (hqg : FirstVertex P D.vertices g q) (hqh : FirstVertex P D.vertices h q) (hne : g ≠ h) : |
| height (P g.1) (P g.2.2) (P q).1 ≤ height (P h.1) (P h.2.1) (P q).1 ∨ |
| height (P h.1) (P h.2.2) (P q).1 ≤ height (P g.1) (P g.2.1) (P q).1 := by |
| rcases lt_trichotomy (P g.1).1 (P h.1).1 with hl | he | hl |
| · exact firstVertex_separated_of_source_lt hD hg hh hqg hqh hl |
| · exact hg.separated_of_same_source hP hh (hx he) hne hqg.1.1 |
| · exact (firstVertex_separated_of_source_lt hD hh hg hqh hqg hl).symm |
|
|
| noncomputable def Drawing.first (D : Drawing P) (g : ↥D.gaps) : ↥D.vertices := |
| by classical exact Classical.choose ((Finset.mem_filter.mp g.property).2.exists_firstVertex) |
|
|
| lemma Drawing.first_spec (D : Drawing P) (g : ↥D.gaps) : FirstVertex P D.vertices g.val (D.first g) := |
| by classical exact Classical.choose_spec ((Finset.mem_filter.mp g.property).2.exists_firstVertex) |
|
|
| noncomputable def Drawing.gapCharge (D : Drawing P) (g : ↥D.gaps) : ↥D.vertices × Bool := |
| by classical exact (D.first g, decide |
| (height (P g.val.1) (P g.val.2.1) (P (D.first g)).1 < (P (D.first g)).2)) |
|
|
| lemma Drawing.gapCharge_injective (hP : Position P) |
| (hx : Function.Injective (fun v => (P v).1)) (D : Drawing P) (hD : D.NonCrossing) : |
| Function.Injective D.gapCharge := by |
| classical |
| intro g h he |
| apply Subtype.ext |
| by_contra hne |
| have hq : D.first g = D.first h := congrArg Prod.fst he |
| have hb := congrArg Prod.snd he |
| change decide (height (P g.val.1) (P g.val.2.1) (P (D.first g)).1 < (P (D.first g)).2) = |
| decide (height (P h.val.1) (P h.val.2.1) (P (D.first h)).1 < (P (D.first h)).2) at hb |
| rw [← hq] at hb |
| have hg : IsGap D g.val := (Finset.mem_filter.mp g.property).2 |
| have hh : IsGap D h.val := (Finset.mem_filter.mp h.property).2 |
| have hfg := D.first_spec g |
| have hfh := D.first_spec h |
| rw [← hq] at hfh |
| have hgwidth := hg.width_pos hfg.1.1 |
| have hhwidth := hh.width_pos hfh.1.1 |
| rcases FirstVertex.separated hP hx hD hg hh hfg hfh hne with hsep | hsep |
| · have htrue : height (P g.val.1) (P g.val.2.1) (P (D.first g)).1 < (P (D.first g)).2 := |
| hgwidth.trans_le (hsep.trans hfh.1.2.2.2.1) |
| have hfalse : ¬ height (P h.val.1) (P h.val.2.1) (P (D.first g)).1 < (P (D.first g)).2 := by |
| linarith only [hsep, hfg.1.2.2.2.2] |
| simp [htrue, hfalse] at hb |
| · have htrue : height (P h.val.1) (P h.val.2.1) (P (D.first g)).1 < (P (D.first g)).2 := |
| hhwidth.trans_le (hsep.trans hfg.1.2.2.2.1) |
| have hfalse : ¬ height (P g.val.1) (P g.val.2.1) (P (D.first g)).1 < (P (D.first g)).2 := by |
| linarith only [hsep, hfh.1.2.2.2.2] |
| simp [htrue, hfalse] at hb |
|
|
| lemma Drawing.card_gaps_le (hP : Position P) |
| (hx : Function.Injective (fun v => (P v).1)) (D : Drawing P) (hD : D.NonCrossing) : |
| D.gaps.card ≤ 2 * D.vertices.card := by |
| have h := Fintype.card_le_of_injective D.gapCharge (D.gapCharge_injective hP hx hD) |
| simpa only [Fintype.card_coe, Fintype.card_prod, Fintype.card_bool, |
| Nat.mul_comm] using h |
|
|
| lemma Drawing.exists_next_gap (D : Drawing P) {v u : V} (he : (v,u) ∈ D.edges) |
| (hh : ∃ w, (v,w) ∈ D.edges ∧ PlanarHalving.slope (P v) (P u) < PlanarHalving.slope (P v) (P w)) : |
| ∃ w, IsGap D (v,u,w) := by |
| classical |
| let W := Finset.univ.filter (fun w => (v,w) ∈ D.edges ∧ |
| PlanarHalving.slope (P v) (P u) < PlanarHalving.slope (P v) (P w)) |
| have hw : W.Nonempty := by obtain ⟨w, hw⟩ := hh; exact ⟨w, by simpa [W] using hw⟩ |
| obtain ⟨w, hw, hmin⟩ := W.exists_min_image (fun w => PlanarHalving.slope (P v) (P w)) hw |
| have hp := (Finset.mem_filter.mp hw).2 |
| refine ⟨w, he, hp.1, hp.2, ?_⟩ |
| intro r hr hs |
| exact hmin r (Finset.mem_filter.mpr ⟨Finset.mem_univ _, hr, hs⟩) |
|
|
| noncomputable def Drawing.edgeCharge (D : Drawing P) (e : ↥D.edges) : ↥D.vertices ⊕ ↥D.gaps := by |
| classical |
| exact if h : ∃ w, IsGap D (e.val.1, e.val.2, w) then |
| Sum.inr ⟨(e.val.1, e.val.2, Classical.choose h), Finset.mem_filter.mpr |
| ⟨Finset.mem_univ _, Classical.choose_spec h⟩⟩ |
| else Sum.inl ⟨e.val.1, (D.ends _ e.property).1⟩ |
|
|
| lemma Drawing.edgeCharge_injective (hP : Position P) (D : Drawing P) : |
| Function.Injective D.edgeCharge := by |
| classical |
| intro e f he |
| dsimp only [Drawing.edgeCharge] at he |
| split_ifs at he with hg hh |
| · have heq := congrArg Subtype.val (Sum.inr.inj he) |
| apply Subtype.ext |
| exact Prod.ext (Prod.mk.inj heq).1 (Prod.mk.inj (Prod.mk.inj heq).2).1 |
| · rename_i hh |
| have hsrc : e.val.1 = f.val.1 := congrArg Subtype.val (Sum.inl.inj he) |
| have hemax : ¬ ∃ w, (e.val.1, w) ∈ D.edges ∧ |
| PlanarHalving.slope (P e.val.1) (P e.val.2) < PlanarHalving.slope (P e.val.1) (P w) := |
| fun h => hg (D.exists_next_gap e.property h) |
| have hfmax : ¬ ∃ w, (f.val.1, w) ∈ D.edges ∧ |
| PlanarHalving.slope (P f.val.1) (P f.val.2) < PlanarHalving.slope (P f.val.1) (P w) := |
| fun h => hh (D.exists_next_gap f.property h) |
| have hef : PlanarHalving.slope (P e.val.1) (P e.val.2) ≤ |
| PlanarHalving.slope (P f.val.1) (P f.val.2) := by |
| by_contra h |
| apply hfmax |
| refine ⟨e.val.2, ?_, ?_⟩ |
| · simpa only [← hsrc, Prod.mk.eta] using e.property |
| · simpa only [← hsrc] using lt_of_not_ge h |
| have hfe : PlanarHalving.slope (P f.val.1) (P f.val.2) ≤ |
| PlanarHalving.slope (P e.val.1) (P e.val.2) := by |
| by_contra h |
| apply hemax |
| refine ⟨f.val.2, ?_, ?_⟩ |
| · simpa only [hsrc, Prod.mk.eta] using f.property |
| · simpa only [hsrc] using lt_of_not_ge h |
| have hright := D.right f.val f.property |
| have heq := le_antisymm hef hfe |
| rw [← hsrc] at hright heq |
| have htarget := slope_eq_implies_eq hP (D.right e.val e.property) hright heq |
| exact Subtype.ext (Prod.ext hsrc htarget) |
|
|
| theorem Drawing.planar_bound (hP : Position P) |
| (hx : Function.Injective (fun v => (P v).1)) (D : Drawing P) (hD : D.NonCrossing) : |
| D.edges.card ≤ 3 * D.vertices.card := by |
| have hc := Fintype.card_le_of_injective D.edgeCharge (D.edgeCharge_injective hP) |
| have hcard : D.edges.card ≤ D.vertices.card + D.gaps.card := by |
| simpa only [Fintype.card_coe, Fintype.card_sum] using hc |
| have hg := D.card_gaps_le hP hx hD |
| omega |
|
|
| omit [Fintype V] in |
| lemma slope_eq_implies_eq_ne (hP : Position P) {v u w : V} |
| (hu : (P v).1 ≠ (P u).1) (hw : (P v).1 ≠ (P w).1) |
| (hs : PlanarHalving.slope (P v) (P u) = PlanarHalving.slope (P v) (P w)) : u = w := by |
| by_contra hn |
| have hvu : v ≠ u := fun h => hu (congrArg (fun i => (P i).1) h) |
| have hvw : v ≠ w := fun h => hw (congrArg (fun i => (P i).1) h) |
| have hyu := height_right (P v) (P u) hu |
| have hyw := height_right (P v) (P w) hw |
| rw [height, hs] at hyu |
| rw [height] at hyw |
| apply hP.2 v u w hvu hn hvw |
| unfold orient |
| have hu' : (P u).2 - (P v).2 = ((P u).1 - (P v).1) * PlanarHalving.slope (P v) (P w) := by linarith |
| have hw' : (P w).2 - (P v).2 = ((P w).1 - (P v).1) * PlanarHalving.slope (P v) (P w) := by linarith |
| rw [hu', hw'] |
| ring |
|
|
| lemma height_of_mem_openSegment {p q z : Point} (hx : p.1 ≠ q.1) |
| (hz : z ∈ openSegment ℝ p q) : z.1 ≠ p.1 ∧ z.2 = height p q z.1 := by |
| rw [openSegment_eq_image] at hz |
| obtain ⟨t, ht, rfl⟩ := hz |
| have hd : q.1 - p.1 ≠ 0 := sub_ne_zero.mpr hx.symm |
| simp only [Prod.fst_add, Prod.snd_add, Prod.smul_fst, Prod.smul_snd, smul_eq_mul] |
| constructor |
| · have hmul : t * (q.1 - p.1) ≠ 0 := mul_ne_zero ht.1.ne' hd |
| intro he |
| apply hmul |
| linarith |
| · unfold height PlanarHalving.slope |
| field_simp |
| ring |
|
|
| lemma openSegment_horizontal_bounds {p q z : Point} (hx : p.1 < q.1) |
| (hz : z ∈ openSegment ℝ p q) : p.1 < z.1 ∧ z.1 < q.1 := by |
| rw [openSegment_eq_image] at hz |
| obtain ⟨t, ht, rfl⟩ := hz |
| simp only [Prod.fst_add, Prod.smul_fst, smul_eq_mul] |
| constructor <;> nlinarith [mul_pos ht.1 (sub_pos.mpr hx), |
| mul_pos (sub_pos.mpr ht.2) (sub_pos.mpr hx)] |
|
|
| omit [Fintype V] in |
| lemma incident_disjoint (hP : Position P) (hx : Function.Injective (fun v => (P v).1)) |
| {v u w : V} (hvu : v ≠ u) (hvw : v ≠ w) (huw : u ≠ w) : |
| Disjoint (openSegment ℝ (P v) (P u)) (openSegment ℝ (P v) (P w)) := by |
| apply Set.disjoint_left.mpr |
| intro z hzu hzw |
| have hu := height_of_mem_openSegment (fun h => hvu (hx h)) hzu |
| have hw := height_of_mem_openSegment (fun h => hvw (hx h)) hzw |
| have he : PlanarHalving.slope (P v) (P u) = PlanarHalving.slope (P v) (P w) := by |
| apply mul_left_cancel₀ (sub_ne_zero.mpr hu.1) |
| dsimp only [height] at hu hw |
| linarith only [hu.2, hw.2] |
| exact huw (slope_eq_implies_eq_ne hP (fun h => hvu (hx h)) (fun h => hvw (hx h)) he) |
|
|
| def Crosses (P : V → Point) (e f : V × V) : Prop := |
| ¬ Disjoint (openSegment ℝ (P e.1) (P e.2)) (openSegment ℝ (P f.1) (P f.2)) |
|
|
| omit [Fintype V] in |
| lemma Drawing.crossing_endpoints (hP : Position P) |
| (hx : Function.Injective (fun v => (P v).1)) (D : Drawing P) |
| {e f : V × V} (he : e ∈ D.edges) (hf : f ∈ D.edges) (hne : e ≠ f) |
| (hc : Crosses P e f) : |
| e.1 ≠ e.2 ∧ f.1 ≠ f.2 ∧ e.1 ≠ f.1 ∧ e.1 ≠ f.2 ∧ e.2 ≠ f.1 ∧ e.2 ≠ f.2 := by |
| have hev : e.1 ≠ e.2 := by intro h; have := D.right _ he; rw [h] at this; exact lt_irrefl _ this |
| have hfv : f.1 ≠ f.2 := by intro h; have := D.right _ hf; rw [h] at this; exact lt_irrefl _ this |
| have h11 : e.1 ≠ f.1 := by |
| intro h |
| apply hc |
| rw [h] |
| exact incident_disjoint hP hx (by simpa only [← h] using hev) hfv |
| (fun h' => hne (Prod.ext h h')) |
| have h22 : e.2 ≠ f.2 := by |
| intro h |
| apply hc |
| rw [openSegment_symm ℝ (P e.1), openSegment_symm ℝ (P f.1), h] |
| exact incident_disjoint hP hx (by simpa only [← h] using hev.symm) hfv.symm |
| (fun h' => hne (Prod.ext h' h)) |
| obtain ⟨z, hze, hzf⟩ := Set.not_disjoint_iff.mp hc |
| have hxe := openSegment_horizontal_bounds (D.right _ he) hze |
| have hxf := openSegment_horizontal_bounds (D.right _ hf) hzf |
| refine ⟨hev, hfv, h11, ?_, ?_, h22⟩ |
| · intro h |
| rw [h] at hxe |
| exact lt_irrefl _ (hxe.1.trans hxf.2) |
| · intro h |
| rw [h] at hxe |
| exact lt_irrefl _ (hxf.1.trans hxe.2) |
|
|
| noncomputable def edgeIndex : (V × V) ≃ Fin (Fintype.card (V × V)) := Fintype.equivFin _ |
|
|
| noncomputable def Drawing.crossings (D : Drawing P) : Finset ((V × V) × (V × V)) := by |
| classical |
| exact (D.edges ×ˢ D.edges).filter (fun ef => edgeIndex ef.1 < edgeIndex ef.2 ∧ Crosses P ef.1 ef.2) |
|
|
| noncomputable def Drawing.uncross (D : Drawing P) : Drawing P := by |
| classical |
| exact ⟨D.vertices, D.edges \ D.crossings.image Prod.fst, |
| fun e he => D.right e (Finset.mem_sdiff.mp he).1, |
| fun e he => D.ends e (Finset.mem_sdiff.mp he).1⟩ |
|
|
| lemma Drawing.uncross_nonCrossing (D : Drawing P) : D.uncross.NonCrossing := by |
| classical |
| intro e he f hf hne |
| by_contra hc |
| have he' := Finset.mem_sdiff.mp he |
| have hf' := Finset.mem_sdiff.mp hf |
| have hi : edgeIndex e ≠ edgeIndex f := fun h => hne (edgeIndex.injective h) |
| rcases hi.lt_or_gt with hlt | hlt |
| · apply he'.2 |
| exact Finset.mem_image.mpr ⟨(e,f), Finset.mem_filter.mpr |
| ⟨Finset.mem_product.mpr ⟨he'.1, hf'.1⟩, hlt, hc⟩, rfl⟩ |
| · apply hf'.2 |
| exact Finset.mem_image.mpr ⟨(f,e), Finset.mem_filter.mpr |
| ⟨Finset.mem_product.mpr ⟨hf'.1, he'.1⟩, hlt, fun h => hc h.symm⟩, rfl⟩ |
|
|
| theorem Drawing.linear_crossing_bound (hP : Position P) |
| (hx : Function.Injective (fun v => (P v).1)) (D : Drawing P) : |
| D.edges.card ≤ 3 * D.vertices.card + D.crossings.card := by |
| classical |
| have hp := D.uncross.planar_bound hP hx D.uncross_nonCrossing |
| change (D.edges \ D.crossings.image Prod.fst).card ≤ 3 * D.vertices.card at hp |
| have hi : (D.edges ∩ D.crossings.image Prod.fst).card ≤ D.crossings.card := |
| (Finset.card_le_card Finset.inter_subset_right).trans (Finset.card_image_le) |
| have he := Finset.card_sdiff_add_card_inter D.edges (D.crossings.image Prod.fst) |
| omega |
|
|
| end PlaneGraph |
| end PlanarHalving |
|
|
| end OAI |
|
|
