| import OAI.Combinatorics.ListHadwiger.Separability |
|
|
| namespace OAI |
|
|
| namespace LinearListHadwiger.Sampling |
| open Fractional FixedDecomposition |
| variable {V Ω : Type} [Fintype V] [DecidableEq V] [Fintype Ω] |
|
|
| lemma expectation_inter_card {V Ω : Type} [Fintype V] [DecidableEq V] [Fintype Ω] {μ : Ω → ℝ} (W : Ω → Finset V) (U : Finset V) : |
| expectation μ (fun ω => ((W ω ∩ U).card : ℝ)) = |
| ∑ v ∈ U, probability μ (fun ω => v ∈ W ω) := by |
| classical |
| have hc (ω : Ω) : ((W ω ∩ U).card : ℝ) = ∑ v ∈ U, if v ∈ W ω then 1 else 0 := by |
| rw [← Finset.sum_filter] |
| simp [Finset.filter_mem_eq_inter,Finset.inter_comm] |
| simp only [expectation,hc,Finset.mul_sum,probability] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro v hv |
| apply Finset.sum_congr rfl |
| intro ω _ |
| split_ifs <;> simp |
|
|
| lemma expectation_inter_card_le {μ : Ω → ℝ} (W : Ω → Finset V) {p : ℝ} |
| (hp : ∀ v, probability μ (fun ω => v ∈ W ω) ≤ p) (U : Finset V) : |
| expectation μ (fun ω => ((W ω ∩ U).card : ℝ)) ≤ (U.card : ℝ)*p := by |
| rw [expectation_inter_card] |
| calc |
| _ ≤ ∑ _v ∈ U, p := Finset.sum_le_sum (fun v _ => hp v) |
| _ = _ := by simp |
|
|
| theorem fixed_region {G : SimpleGraph V} {S : Finset V} {k : ℕ} |
| {μ : Ω → ℝ} (hμ : ∀ ω, 0 ≤ μ ω) (hμsum : ∑ ω, μ ω = 1) |
| (W : Ω → Finset V) (hWS : ∀ ω, W ω ⊆ S) |
| {r p ε : ℝ} (hr : 0 < r) (hp : 0 ≤ p) (hε : 0 ≤ ε) |
| (hsurv : ∀ v, probability μ (fun ω => v ∈ W ω) ≤ p) |
| (hsparse : (2*k : ℕ)*p ≤ r/1000) |
| (htailCard : ∀ U : Finset V, probability μ (fun ω => r/200 ≤ |
| |((W ω ∩ U).card : ℝ) - expectation μ (fun z => ((W z ∩ U).card : ℝ))|) ≤ ε) |
| (htailFrac : ∀ U : Finset V, probability μ (fun ω => r/20 ≤ |
| |number (G.induce (↑(W ω ∩ U) : Set V)) - |
| expectation μ (fun z => number (G.induce (↑(W z ∩ U) : Set V)))|) ≤ ε) |
| (hsmall : ((S.card+1 : ℕ)^2 : ℝ)*ε < 1) |
| (hfail : ∀ ω, 0 < μ ω → r/2 < number (G.induce (↑(W ω) : Set V))) : |
| ∃ H ⊆ S, KConnectedOn G H k ∧ |
| r/4 < expectation μ (fun ω => number (G.induce (↑(W ω ∩ H) : Set V))) := by |
| classical |
| by_contra hn |
| push Not at hn |
| obtain ⟨d,hd⟩ := exists_bounded_tree (G := G) (k := k) S |
| let Idx := Fin d.leaves.length ⊕ Fin d.separators.length |
| let cardBad (U : Finset V) (ω : Ω) : Prop := r/200 ≤ |
| |((W ω ∩ U).card : ℝ)-expectation μ (fun z => ((W z ∩ U).card : ℝ))| |
| let fracBad (U : Finset V) (ω : Ω) : Prop := r/20 ≤ |
| |number (G.induce (↑(W ω ∩ U) : Set V))- |
| expectation μ (fun z => number (G.induce (↑(W z ∩ U) : Set V)))| |
| let bad : Idx → Ω → Prop := fun i => match i with |
| | .inl l => if (d.leaves.get l).card ≤ 2*k then cardBad (d.leaves.get l) |
| else fracBad (d.leaves.get l) |
| | .inr z => cardBad (d.separators.get z) |
| have hbad (i : Idx) : probability μ (bad i) ≤ ε := by |
| cases i with |
| | inl l => |
| dsimp [bad] |
| split_ifs |
| · exact htailCard _ |
| · exact htailFrac _ |
| | inr z => exact htailCard _ |
| have hcard : Fintype.card Idx ≤ (S.card+1)^2 := by |
| simpa [Idx] using hd.trans (budget_le_square k S.card) |
| have hcardR : (Fintype.card Idx : ℝ) ≤ ((S.card+1 : ℕ)^2 : ℝ) := by exact_mod_cast hcard |
| have hbadall : probability μ (fun ω => ∃ i, bad i ω) < 1 := by |
| calc |
| _ ≤ ∑ i, probability μ (bad i) := probability_union_le hμ bad |
| _ ≤ ∑ _ : Idx, ε := Finset.sum_le_sum (fun i _ => hbad i) |
| _ = (Fintype.card Idx : ℝ)*ε := by simp |
| _ ≤ ((S.card+1 : ℕ)^2 : ℝ)*ε := mul_le_mul_of_nonneg_right hcardR hε |
| _ < 1 := hsmall |
| obtain ⟨ω,hω,havoid⟩ := exists_positive_avoiding hμ hμsum hbadall |
| have hsmallset (U : Finset V) (hU : U.card ≤ 2*k) (hgood : ¬cardBad U ω) : |
| ((W ω ∩ U).card : ℝ) < r/100 := by |
| have he := expectation_inter_card_le W hsurv U |
| have hUr : (U.card : ℝ) ≤ (2*k : ℕ) := by exact_mod_cast hU |
| have hmean : expectation μ (fun z => ((W z ∩ U).card : ℝ)) ≤ r/1000 := |
| he.trans ((mul_le_mul_of_nonneg_right hUr hp).trans hsparse) |
| have hdev := (abs_lt.mp (lt_of_not_ge hgood)).2 |
| linarith |
| have hsep : ∀ Z ∈ d.separators, ((W ω ∩ Z).card : ℝ) ≤ r/100 := by |
| intro Z hZ |
| obtain ⟨z,hz⟩ := List.mem_iff_get.mp hZ |
| apply (hsmallset Z (by have := d.separator_small hZ; omega) ?_).le |
| have hh : ¬bad (.inr z) ω := fun h => havoid ⟨.inr z,h⟩ |
| simpa only [bad,hz] using hh |
| have hleaf : ∀ L ∈ d.leaves, number (G.induce (↑(W ω ∩ L) : Set V)) ≤ 3*r/10 := by |
| intro L hL |
| obtain ⟨l,hl⟩ := List.mem_iff_get.mp hL |
| have hh : ¬bad (.inl l) ω := fun h => havoid ⟨.inl l,h⟩ |
| by_cases hs : L.card ≤ 2*k |
| · have hc : ¬cardBad L ω := by simpa only [bad,hl,ite_eq_left hs] using hh |
| have hc' := hsmallset L hs hc |
| have hn : number (G.induce (↑(W ω ∩ L) : Set V)) ≤ ((W ω ∩ L).card : ℝ) := by |
| simpa [Finset.filter_mem_eq_inter, Finset.inter_comm] using |
| number_le_card (G.induce (↑(W ω ∩ L) : Set V)) |
| linarith |
| · have hf : ¬fracBad L ω := by simpa only [bad,hl,ite_eq_right hs] using hh |
| have hconn := (d.leaf_stop hL).resolve_left hs |
| have hmean := hn L (d.leaf_subset hL) hconn |
| have hdev := (abs_lt.mp (lt_of_not_ge hf)).2 |
| linarith |
| have hnow := fractional_le_leaves_add_separator d (hWS ω) |
| (by positivity : (0 : ℝ) ≤ 3*r/10) (by positivity : (0 : ℝ) ≤ r/100) hleaf hsep |
| have hf := hfail ω hω |
| linarith |
| |
| end LinearListHadwiger.Sampling |
| |
| namespace LinearListHadwiger.PairedSources |
| open SimpleGraph PathPacking |
| variable {V I : Type} [Fintype V] [Fintype I] [DecidableEq V] [DecidableEq I] |
| |
| def graph (G : SimpleGraph V) (s : I → Bool → V) (U : Set V) : SimpleGraph (I ⊕ V) where |
| Adj x y := match x,y with |
| | .inl _, .inl _ => False |
| | .inl i, .inr v => v ∈ U ∧ (∀ j b, v ≠ s j b) ∧ ∃ b, G.Adj (s i b) v |
| | .inr v, .inl i => v ∈ U ∧ (∀ j b, v ≠ s j b) ∧ ∃ b, G.Adj (s i b) v |
| | .inr v, .inr w => v ∈ U ∧ w ∈ U ∧ (∀ j b, v ≠ s j b) ∧ |
| (∀ j b, w ≠ s j b) ∧ G.Adj v w |
| symm := ⟨by |
| intro x y h |
| cases x <;> cases y |
| · exact h.elim |
| · exact h |
| · exact h |
| · exact ⟨h.2.1,h.1,h.2.2.2.1,h.2.2.1,h.2.2.2.2.symm⟩⟩ |
| loopless := ⟨by |
| intro x h |
| cases x |
| · exact h |
| · exact h.2.2.2.2.ne rfl⟩ |
| |
| variable {G : SimpleGraph V} {s : I → Bool → V} {U : Set V} |
| |
| noncomputable def routeHom (i : I) (b : Bool) {v : V} |
| (p : G.Path (s i b) v) |
| (hU : ∀ w ∈ p.val.support, w ∈ U) |
| (hsource : ∀ w ∈ p.val.support, ∀ j c, w = s j c → w = s i b) : |
| G.induce {w | w ∈ p.val.support} →g graph G s U where |
| toFun w := if w.val = s i b then .inl i else .inr w.val |
| map_rel' := by |
| intro x y hxy |
| change G.Adj x.val y.val at hxy |
| dsimp |
| split_ifs with hx hy hy |
| · exact (hxy.ne (hx.trans hy.symm)).elim |
| · exact ⟨hU _ y.property,fun j c he => hy (hsource _ y.property j c he), |
| b,by simpa only [hx] using hxy⟩ |
| · exact ⟨hU _ x.property,fun j c he => hx (hsource _ x.property j c he), |
| b,by simpa only [hy] using hxy.symm⟩ |
| · exact ⟨hU _ x.property,hU _ y.property, |
| fun j c he => hx (hsource _ x.property j c he), |
| fun j c he => hy (hsource _ y.property j c he),hxy⟩ |
|
|
| lemma lift_regular {V I : Type} [Fintype V] [Fintype I] [DecidableEq V] [DecidableEq I] {G : SimpleGraph V} {s : I → Bool → V} {U : Set V} {x y : I ⊕ V} (q : (graph G s U).Walk x y) |
| (h : ∀ i, Sum.inl i ∉ q.support) {u v : V} |
| (hx : x = .inr u) (hy : y = .inr v) : |
| ∃ p : G.Walk u v, ∀ w ∈ p.support, Sum.inr w ∈ q.support := by |
| induction q generalizing u with |
| | nil => |
| have huv : u = v := Sum.inr.inj (hx.symm.trans hy) |
| subst v |
| refine ⟨Walk.nil,?_⟩ |
| intro w hw |
| have : w = u := by simpa using hw |
| subst w |
| simp [hx] |
| | @cons x z y e q ih => |
| have hq : ∀ i, Sum.inl i ∉ q.support := fun i hi => h i (by simp [hi]) |
| cases z with |
| | inl j => exact (hq j q.start_mem_support).elim |
| | inr z => |
| obtain ⟨p,hp⟩ := ih hq rfl hy |
| have he : G.Adj u z := by |
| rw [hx] at e |
| exact e.2.2.2.2 |
| refine ⟨Walk.cons he p,?_⟩ |
| intro w hw |
| simp only [Walk.support_cons,List.mem_cons] at hw ⊢ |
| rcases hw with rfl | hw |
| · exact Or.inl hx.symm |
| · exact Or.inr (hp w hw) |
|
|
| structure Packing (G : SimpleGraph V) (s : I → Bool → V) (D : Finset V) |
| (U : Set V) where |
| choose : I → Bool |
| target : I → ↥D |
| route : ∀ i, G.Path (s i (choose i)) (target i).val |
| disjoint : ∀ i j, i ≠ j → Disjoint {v | v ∈ (route i).val.support} |
| {v | v ∈ (route j).val.support} |
| source_only : ∀ i v, v ∈ (route i).val.support → |
| (∃ j b, v = s j b) → v = s i (choose i) |
| target_only : ∀ i v, v ∈ (route i).val.support → v ∈ D → v = (target i).val |
| inside : ∀ i v, v ∈ (route i).val.support → v ∈ U |
|
|
| lemma mapped_route {V I : Type} [Fintype V] [Fintype I] [DecidableEq V] [DecidableEq I] {G : SimpleGraph V} {s : I → Bool → V} {U : Set V} (i : I) (b : Bool) {v : V} |
| (p : G.Path (s i b) v) |
| (hU : ∀ w ∈ p.val.support, w ∈ U) |
| (hsource : ∀ w ∈ p.val.support, ∀ j c, w = s j c → w = s i b) |
| (hv : v ≠ s i b) : |
| ∃ q : (graph G s U).Walk (.inl i) (.inr v), |
| (∀ j, Sum.inl j ∈ q.support → j = i) ∧ |
| (∀ w, Sum.inr w ∈ q.support → w ∈ p.val.support) := by |
| classical |
| let f := routeHom i b p hU hsource |
| let q0 := (p.val.induce {w | w ∈ p.val.support} (fun _ => id)).map f |
| have hs : Sum.inl i = f ⟨s i b,p.val.start_mem_support⟩ := by simp [f,routeHom] |
| have ht : Sum.inr v = f ⟨v,p.val.end_mem_support⟩ := by simp [f,routeHom,hv] |
| refine ⟨q0.copy hs.symm ht.symm,?_,?_⟩ |
| · intro j hj |
| simp only [Walk.support_copy,q0,Walk.support_map] at hj |
| obtain ⟨w,_,hw⟩ := List.mem_map.mp hj |
| by_cases h : w.val = s i b |
| · have he : Sum.inl i = (Sum.inl j : I ⊕ V) := by |
| simpa [f,routeHom,h] using hw |
| exact (Sum.inl.inj he).symm |
| · have he : Sum.inr w.val = (Sum.inl j : I ⊕ V) := by |
| simp [f,routeHom,h] at hw |
| cases he |
| · intro w hw |
| simp only [Walk.support_copy,q0,Walk.support_map] at hw |
| obtain ⟨z,_,hz⟩ := List.mem_map.mp hw |
| by_cases h : z.val = s i b |
| · have he : Sum.inl i = (Sum.inr w : I ⊕ V) := by |
| simp [f,routeHom,h] at hz |
| cases he |
| · have he : Sum.inr z.val = (Sum.inr w : I ⊕ V) := by |
| simpa [f,routeHom,h] using hz |
| exact (Sum.inr.inj he) ▸ z.property |
|
|
| def Valid (s : I → Bool → V) (U : Set V) : I ⊕ V → Prop |
| | .inl _ => True |
| | .inr v => v ∈ U ∧ ∀ j b, v ≠ s j b |
|
|
| lemma ordinary_valid_on_walk {V I : Type} [Fintype V] [Fintype I] [DecidableEq V] [DecidableEq I] {G : SimpleGraph V} {s : I → Bool → V} {U : Set V} {x y : I ⊕ V} (q : (graph G s U).Walk x y) |
| (hx : Valid s U x) : |
| ∀ v, Sum.inr v ∈ q.support → v ∈ U ∧ ∀ j b, v ≠ s j b := by |
| induction q with |
| | @nil x => |
| intro v hv |
| have hh : Sum.inr v = x := by simpa using hv |
| simpa only [← hh,Valid] using hx |
| | @cons x z y e q ih => |
| have hz : Valid s U z := by |
| cases z with |
| | inl _ => trivial |
| | inr z => |
| cases x with |
| | inl _ => exact ⟨e.1,e.2.1⟩ |
| | inr _ => exact ⟨e.2.1,e.2.2.2.1⟩ |
| intro v hv |
| simp only [Walk.support_cons,List.mem_cons] at hv |
| rcases hv with hv | hv |
| · simpa only [← hv,Valid] using hx |
| · exact ih hz v hv |
|
|
| lemma lift_source_path {i : I} {v : V} |
| (q : (graph G s U).Path (.inl i) (.inr v)) |
| (hsource : ∀ j, Sum.inl j ∈ q.val.support → j = i) : |
| ∃ b : Bool, ∃ p : G.Path (s i b) v, |
| ∀ w ∈ p.val.support, w = s i b ∨ |
| (Sum.inr w ∈ q.val.support ∧ w ∈ U ∧ ∀ j c, w ≠ s j c) := by |
| obtain ⟨q,hq⟩ := q |
| cases q with |
| | @cons _ z _ e q => |
| cases z with |
| | inl j => exact e.elim |
| | inr z => |
| obtain ⟨hzU,hzs,b,he⟩ := e |
| have havoid : ∀ j, Sum.inl j ∉ q.support := by |
| intro j hj |
| have hji := hsource j (List.mem_cons_of_mem _ hj) |
| subst j |
| exact ((Walk.cons_isPath_iff _ _).mp hq).2 hj |
| obtain ⟨p,hp⟩ := lift_regular q havoid rfl rfl |
| let p0 := Walk.cons he p |
| refine ⟨b,p0.toPath,?_⟩ |
| intro w hw |
| have hww := p0.support_toPath_subset_support hw |
| simp only [p0,Walk.support_cons,List.mem_cons] at hww |
| rcases hww with hww | hww |
| · exact Or.inl hww |
| · have hqmem : Sum.inr w ∈ (Walk.cons (show (graph G s U).Adj (.inl i) (.inr z) from |
| ⟨hzU,hzs,b,he⟩) q).support := by simp [hp w hww] |
| exact Or.inr ⟨hqmem,ordinary_valid_on_walk |
| (Walk.cons (show (graph G s U).Adj (.inl i) (.inr z) from |
| ⟨hzU,hzs,b,he⟩) q) (show Valid s U (.inl i) from trivial) w hqmem⟩ |
|
|
| theorem combine {D : Finset V} (target : I → Bool → ↥D) |
| (route : ∀ i b, G.Path (s i b) (target i b).val) |
| (hgroups : ∀ i b j c, s i b = s j c → i = j) |
| (hD : ∀ v ∈ D, ∀ i b, v ≠ s i b) |
| (hU : ∀ i b v, v ∈ (route i b).val.support → v ∈ U) |
| (hS : ∀ i b v, v ∈ (route i b).val.support → |
| ∀ j c, v = s j c → v = s i b) |
| (hcon : ∀ v, (Finset.univ.filter (fun ib : I × Bool => |
| v ∈ (route ib.1 ib.2).val.support)).card ≤ 2) : |
| Nonempty (Packing G s D U) := by |
| classical |
| let Q := graph G s U |
| let A : Finset (I ⊕ V) := Finset.univ.map ⟨Sum.inl,Sum.inl_injective⟩ |
| let B : Finset (I ⊕ V) := D.map ⟨Sum.inr,Sum.inr_injective⟩ |
| have hq (ib : I × Bool) := mapped_route ib.1 ib.2 (route ib.1 ib.2) |
| (hU ib.1 ib.2) (hS ib.1 ib.2) |
| (hD _ (target ib.1 ib.2).property ib.1 ib.2) |
| choose q hqL hqR using hq |
| have hconQ (x : I ⊕ V) : |
| (Finset.univ.filter (fun ib : I × Bool => x ∈ (q ib).support)).card ≤ 2 := by |
| cases x with |
| | inl i => |
| have hsub : (Finset.univ.filter (fun ib : I × Bool => Sum.inl i ∈ (q ib).support)) ⊆ |
| ({i} ×ˢ (Finset.univ : Finset Bool)) := by |
| intro ib hib |
| have he : ib.1 = i := (hqL ib i (Finset.mem_filter.mp hib).2).symm |
| exact Finset.mem_product.mpr ⟨Finset.mem_singleton.mpr he,Finset.mem_univ _⟩ |
| simpa using Finset.card_le_card hsub |
| | inr v => |
| apply (Finset.card_le_card ?_).trans (hcon v) |
| intro ib hib |
| exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,hqR ib v (Finset.mem_filter.mp hib).2⟩ |
| have hAC : A.card = Fintype.card I := by simp [A] |
| have hPI : 2*A.card ≤ Fintype.card (I × Bool) := by simp [hAC,Fintype.card_prod]; omega |
| have hpack : Nonempty (FullPacking Q A B) := by |
| apply fullPacking_of_no_small_separator |
| intro X hX |
| obtain ⟨ib,hi⟩ := exists_region_avoiding (fun ib => {x | x ∈ (q ib).support}) |
| X 2 A.card (by omega) hPI hX (fun x _ => hconQ x) |
| exact ⟨Sum.inl ib.1,by simp [A],Sum.inr (target ib.1 ib.2).val, |
| by simp [B,(target ib.1 ib.2).property],q ib,hi⟩ |
| obtain ⟨P⟩ := hpack |
| let a (i : I) : ↥A := ⟨.inl i,by simp [A]⟩ |
| have ha : Function.Injective a := by |
| intro i j hij |
| exact Sum.inl.inj (congrArg Subtype.val hij) |
| have hd (i : I) : ∃ d : ↥D, (P.target (a i)).val = Sum.inr d.val := by |
| obtain ⟨v,hv,hve⟩ := Finset.mem_map.mp (P.target (a i)).property |
| exact ⟨⟨v,hv⟩,hve.symm⟩ |
| choose dest hdest using hd |
| let qp (i : I) : Q.Path (.inl i) (.inr (dest i).val) := |
| ⟨(P.route (a i)).val.copy rfl (hdest i),by |
| simpa only [Walk.isPath_copy] using (P.route (a i)).property⟩ |
| have hqps (i j : I) (h : Sum.inl j ∈ (qp i).val.support) : j = i := by |
| have hh := P.source_only (a i) (Sum.inl j) (by simpa [qp] using h) (by simp [A]) |
| exact Sum.inl.inj hh |
| have hlift (i : I) := lift_source_path (qp i) (hqps i) |
| choose b p hp using hlift |
| refine ⟨⟨b,dest,p,?_,?_,?_,?_⟩⟩ |
| · intro i j hij |
| apply Set.disjoint_left.mpr |
| intro w hwi hwj |
| rcases hp i w hwi with hi | hi <;> rcases hp j w hwj with hj | hj |
| · exact hij (hgroups i (b i) j (b j) (hi.symm.trans hj)) |
| · exact hj.2.2 i (b i) hi |
| · exact hi.2.2 j (b j) hj |
| · exact Set.disjoint_left.mp (P.disjoint (a i) (a j) (fun h => hij (ha h))) |
| (by simpa [qp] using hi.1) (by simpa [qp] using hj.1) |
| · intro i v hv ⟨j,c,hvS⟩ |
| rcases hp i v hv with h | h |
| · exact h |
| · exact (h.2.2 j c hvS).elim |
| · intro i v hv hvD |
| rcases hp i v hv with h | h |
| · exact (hD v hvD i (b i) h).elim |
| · have hh := P.target_only (a i) (Sum.inr v) (by simpa [qp] using h.1) |
| (by simp [B,hvD]) |
| rw [hdest i] at hh |
| exact Sum.inr.inj hh |
| · intro i v hv |
| rcases hp i v hv with h | h |
| · simpa only [h] using hU i (b i) _ (route i (b i)).val.start_mem_support |
| · exact h.2.1 |
|
|
| end LinearListHadwiger.PairedSources |
|
|
| end OAI |
|
|
