math / data /lean /OAI /Combinatorics /HalvingLines /PlaneGraph.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
21.5 kB
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