| import OAI.Probability.CriticalZ3.PlanarBoundary |
|
|
| namespace OAI |
|
|
| universe uAlpha uE uV |
|
|
| open _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory Classical Filter Topology Function |
|
|
| open scoped ENNReal BigOperators Matrix |
|
|
| /-! Exact greedy constants used in the shell trials and contour estimate. -/ |
| namespace GreedyPacking |
| open Classical |
|
|
| variable {α : Type uAlpha} |
|
|
| /-- Greedily deleting at most M conflicts loses at most M elements per choice. -/ |
| theorem exists_packing (t : Finset α) (R : α → α → Prop) |
| (hrefl : ∀ a ∈ t, R a a) (hsym : ∀ a ∈ t, ∀ b ∈ t, R a b → R b a) |
| (M : ℕ) (hM : ∀ a ∈ t, (t.filter (R a)).card ≤ M) : |
| ∃ s : Finset α, s ⊆ t ∧ (s : Set α).Pairwise (fun a b => ¬R a b) ∧ t.card ≤ M*s.card := by |
| classical |
| induction t using Finset.strongInduction with |
| | H t ih => |
| by_cases ht : t = ∅ |
| · subst t |
| exact ⟨∅,by simp,by simp,by simp⟩ |
| obtain ⟨a,ha⟩ := Finset.nonempty_iff_ne_empty.mpr ht |
| let u := t.filter (fun b => ¬R a b) |
| have hu : u ⊆ t := Finset.filter_subset _ _ |
| have hau : a ∉ u := by simp [u,hrefl a ha] |
| have hut : u ⊂ t := Finset.ssubset_iff_subset_ne.mpr ⟨hu,by intro h; exact hau (h.symm ▸ ha)⟩ |
| obtain ⟨s,hs,hpair,hcard⟩ := ih u hut |
| (fun b hb => hrefl b (hu hb)) |
| (fun b hb c hc h => hsym b (hu hb) c (hu hc) h) |
| (fun b hb => le_trans (Finset.card_le_card (Finset.filter_subset_filter _ hu)) (hM b (hu hb))) |
| refine ⟨insert a s,Finset.insert_subset ha (hs.trans hu),?_,?_⟩ |
| · simp only [Finset.coe_insert] |
| rw [Set.pairwise_insert] |
| refine ⟨hpair,?_⟩ |
| intro b hb _ |
| exact ⟨(Finset.mem_filter.mp (hs hb)).2, |
| fun h => (Finset.mem_filter.mp (hs hb)).2 (hsym b (hu (hs hb)) a ha h)⟩ |
| · have has : a ∉ s := fun h => hau (hs h) |
| rw [Finset.card_insert_of_notMem has] |
| have he : (t.filter (R a)).card+u.card = t.card := by |
| exact Finset.card_filter_add_card_filter_not (s := t) (R a) |
| have hm := hM a ha |
| nlinarith |
|
|
| /-- The prescribed K choices exist once there are K M candidates. -/ |
| theorem exists_packing_card (t : Finset α) (R : α → α → Prop) |
| (hrefl : ∀ a ∈ t, R a a) (hsym : ∀ a ∈ t, ∀ b ∈ t, R a b → R b a) |
| (M K : ℕ) (hM0 : 0 < M) (hM : ∀ a ∈ t, (t.filter (R a)).card ≤ M) |
| (ht : K*M ≤ t.card) : |
| ∃ s : Finset α, s ⊆ t ∧ s.card = K ∧ (s : Set α).Pairwise (fun a b => ¬R a b) := by |
| obtain ⟨s,hs,hpair,hcard⟩ := exists_packing t R hrefl hsym M hM |
| have hk : K ≤ s.card := by nlinarith |
| obtain ⟨u,hu,huc⟩ := Finset.exists_subset_card_eq hk |
| exact ⟨u,hu.trans hs,huc,hpair.mono hu⟩ |
|
|
| end GreedyPacking |
|
|
| namespace FiniteMatching |
| open Classical |
| variable {E : Type uE} {V : Type uV} [Fintype E] |
|
|
| noncomputable def incident (a b : E → V) (v : V) : Finset E := |
| Finset.univ.filter (fun e => a e = v ∨ b e = v) |
|
|
| def conflict (a b : E → V) (e f : E) : Prop := |
| a e = a f ∨ a e = b f ∨ b e = a f ∨ b e = b f |
|
|
| omit [Fintype E] in |
| theorem conflict_refl (a b : E → V) (e : E) : conflict a b e e := Or.inl rfl |
|
|
| omit [Fintype E] in |
| theorem conflict_symm (a b : E → V) {e f : E} : conflict a b e f → conflict a b f e := by |
| unfold conflict |
| aesop |
|
|
| theorem conflict_card (a b : E → V) |
| (hdeg : ∀ v, (incident a b v).card ≤ 4) (e : E) : |
| (Finset.univ.filter (conflict a b e)).card ≤ 7 := by |
| have heq : Finset.univ.filter (conflict a b e) = incident a b (a e) ∪ incident a b (b e) := by |
| ext f |
| simp only [Finset.mem_filter,Finset.mem_univ,true_and,Finset.mem_union,incident,conflict, |
| Finset.mem_filter,Finset.mem_univ,true_and] |
| aesop |
| rw [heq] |
| have hi : e ∈ incident a b (a e) ∩ incident a b (b e) := by simp [incident] |
| have hpos := Finset.card_pos.mpr ⟨e,hi⟩ |
| have he := Finset.card_union_add_card_inter (incident a b (a e)) (incident a b (b e)) |
| have ha := hdeg (a e) |
| have hb := hdeg (b e) |
| omega |
|
|
| theorem exists_matching (a b : E → V) (hdeg : ∀ v, (incident a b v).card ≤ 4) : |
| ∃ s : Finset E, (s : Set E).Pairwise (fun e f => ¬conflict a b e f) ∧ |
| Fintype.card E ≤ 7*s.card := by |
| obtain ⟨s,_,hp,hc⟩ := GreedyPacking.exists_packing Finset.univ (conflict a b) |
| (fun e _ => conflict_refl a b e) (fun _ _ _ _ => conflict_symm a b) |
| 7 (fun e _ => conflict_card a b hdeg e) |
| exact ⟨s,hp,by simpa only [Finset.card_univ] using hc⟩ |
|
|
| /- Choosing either endpoint of each edge of a matching gives distinct vertices. -/ |
| omit [Fintype E] in |
| theorem endpoint_injective (a b : E → V) (s : Finset E) |
| (hp : (s : Set E).Pairwise (fun e f => ¬conflict a b e f)) (choice : s → Bool) : |
| Function.Injective (fun e : s => if choice e then a e.val else b e.val) := by |
| intro e f hef |
| by_contra hne |
| have hn : e.val ≠ f.val := fun h => hne (Subtype.ext h) |
| have hc := hp e.property f.property hn |
| cases he : choice e <;> cases hf : choice f <;> simp only [he,hf,Bool.false_eq_true, |
| ite_false,ite_true] at hef |
| · exact hc (Or.inr (Or.inr (Or.inr hef))) |
| · exact hc (Or.inr (Or.inr (Or.inl hef))) |
| · exact hc (Or.inr (Or.inl hef)) |
| · exact hc (Or.inl hef) |
|
|
| end FiniteMatching |
|
|
| namespace PlanarBoundary |
| open Classical |
|
|
| def primalInside {X : Finset Point} (e : Boundary X) : Point := e.val.1 |
| def primalOutside {X : Finset Point} (e : Boundary X) : Point := e.val.1+outward e.val.2 |
|
|
| /-- Boundary edges incident to a fixed primal vertex have at most four possibilities. -/ |
| theorem boundary_degree (X : Finset Point) (v : Point) : |
| Fintype.card {e : Boundary X |
| let f : {e : Boundary X |
| fun e => e.val.val.2 |
| have hinj : Function.Injective f := by |
| intro e g he |
| have hd : e.val.val.2 = g.val.val.2 := he |
| have hc : e.val.val.1 = g.val.val.1 := by |
| by_cases hv : v ∈ X |
| · have hve : primalInside e.val = v := e.property.resolve_right |
| (by intro h; apply e.val.property.2; change primalOutside e.val ∈ X; rwa [h]) |
| have hvg : primalInside g.val = v := g.property.resolve_right |
| (by intro h; apply g.val.property.2; change primalOutside g.val ∈ X; rwa [h]) |
| exact hve.trans hvg.symm |
| · have hve : primalOutside e.val = v := e.property.resolve_left |
| (fun h => hv (h ▸ e.val.property.1)) |
| have hvg : primalOutside g.val = v := g.property.resolve_left |
| (fun h => hv (h ▸ g.val.property.1)) |
| have hh := hve.trans hvg.symm |
| change e.val.val.1+outward e.val.val.2 = g.val.val.1+outward g.val.val.2 at hh |
| rw [hd] at hh |
| exact add_right_cancel hh |
| exact Subtype.ext (Subtype.ext (Prod.ext hc hd)) |
| exact (Fintype.card_le_of_injective f hinj).trans_eq (Fintype.card_fin 4) |
|
|
| def Valid {n : ℕ} (c : Code n) : Prop := |
| ∃ X : Finset Point, ∃ e : Fin n → Boundary X, Function.Injective e ∧ |
| ∀ i, traceSide c i = (e i).val |
|
|
| def inner {n : ℕ} (c : Code n) (i : Fin n) : Point := (traceSide c i).1 |
| def outer {n : ℕ} (c : Code n) (i : Fin n) : Point := |
| (traceSide c i).1+outward (traceSide c i).2 |
|
|
| theorem code_degree {n : ℕ} (c : Code n) (hc : Valid c) (v : Point) : |
| (FiniteMatching.incident (inner c) (outer c) v).card ≤ 4 := by |
| obtain ⟨X,e,hinj,he⟩ := hc |
| let f : {i : Fin n |
| {e : Boundary X |
| ⟨e i.val,by simpa only [primalInside,primalOutside,inner,outer,he] using i.property⟩ |
| have hf : Function.Injective f := by |
| intro i j hij |
| apply Subtype.ext |
| exact hinj (congrArg Subtype.val hij) |
| have hh := (Fintype.card_le_of_injective f hf).trans (boundary_degree X v) |
| have heq : (FiniteMatching.incident (inner c) (outer c) v).card = |
| Fintype.card {i : Fin n |
| rw [Fintype.card_subtype] |
| apply congrArg Finset.card |
| ext i |
| simp only [FiniteMatching.incident, Finset.mem_filter, Finset.mem_univ, true_and] |
| rw [heq] |
| exact hh |
|
|
| theorem exists_code_matching {n : ℕ} (c : Code n) (hc : Valid c) : |
| ∃ s : Finset (Fin n), |
| (s : Set (Fin n)).Pairwise (fun i j => ¬FiniteMatching.conflict (inner c) (outer c) i j) ∧ |
| n ≤ 7*s.card := by |
| simpa only [Fintype.card_fin] using FiniteMatching.exists_matching _ _ (code_degree c hc) |
|
|
| end PlanarBoundary |
|
|
| end OAI |
|
|
