| import Mathlib |
|
|
| namespace OAI |
|
|
| open Set MeasureTheory |
|
|
| namespace SparseClusters |
|
|
| variable {V : Type*} [Fintype V] [DecidableEq V] |
|
|
| noncomputable def component (G : SimpleGraph V) (x : V) : Finset V := by |
| classical |
| exact Finset.univ.filter (G.Reachable x) |
|
|
| @[simp] lemma mem_component (G : SimpleGraph V) (x y : V) : |
| y ∈ component G x ↔ G.Reachable x y := by simp [component] |
|
|
| omit [Fintype V] in |
| lemma walk_boundary {G : SimpleGraph V} {x y : V} (p : G.Walk x y) |
| (S : Finset V) (hx : x ∈ S) (hy : y ∉ S) : |
| ∃ a ∈ S, ∃ b, b ∉ S ∧ G.Adj a b ∧ b ∈ p.support := by |
| induction p with |
| | nil => exact (hy hx).elim |
| | @cons x z y hxz p ih => |
| by_cases hz : z ∈ S |
| · obtain ⟨a, ha, b, hb, hab, hbp⟩ := ih hz hy |
| exact ⟨a, ha, b, hb, hab, by simp [hbp]⟩ |
| · exact ⟨x, hx, z, hz, hxz, by simp⟩ |
|
|
| lemma walk_mem_component {G : SimpleGraph V} {x y : V} (p : G.Walk x y) |
| {z : V} (hz : z ∈ p.support) : z ∈ component G x := by |
| exact (mem_component _ _ _).mpr (p.takeUntil z hz).reachable |
|
|
| lemma closed_walk_witness (G : SimpleGraph V) (x : V) (m : ℕ) |
| (hm : m + 1 ≤ (component G x).card) : |
| ∃ p : G.Walk x x, p.length = 2*m ∧ p.support.toFinset.card = m+1 := by |
| classical |
| induction m with |
| | zero => exact ⟨.nil, rfl, by simp⟩ |
| | succ m ih => |
| obtain ⟨p, hp, hc⟩ := ih (by omega) |
| have hnot : ¬ component G x ⊆ p.support.toFinset := by |
| intro h |
| have hh := Finset.card_le_card h |
| omega |
| obtain ⟨y, hy, hyp⟩ := Finset.not_subset.mp hnot |
| obtain ⟨w⟩ := (mem_component G x y).mp hy |
| obtain ⟨a, ha, b, hb, hab, hbw⟩ := walk_boundary w p.support.toFinset |
| (by simp) hyp |
| have hap : a ∈ p.support := List.mem_toFinset.mp ha |
| let q := p.takeUntil a hap |
| let r := p.dropUntil a hap |
| let p' := q.append (.cons hab (.cons hab.symm r)) |
| have hpr : q.append r = p := p.take_spec hap |
| have hlen : q.length + r.length = p.length := by |
| simpa only [SimpleGraph.Walk.length_append] using congrArg SimpleGraph.Walk.length hpr |
| have hsup : p'.support.toFinset = insert b p.support.toFinset := by |
| ext z |
| have hpz : z ∈ p.support ↔ z ∈ q.support ∨ z ∈ r.support := by |
| rw [← hpr, SimpleGraph.Walk.mem_support_append_iff] |
| simp only [List.mem_toFinset, Finset.mem_insert, p', SimpleGraph.Walk.mem_support_append_iff, |
| SimpleGraph.Walk.support_cons, List.mem_cons, hpz] |
| have ha : a ∈ q.support := q.end_mem_support |
| grind |
| refine ⟨p', ?_, ?_⟩ |
| · simp only [p', SimpleGraph.Walk.length_append, SimpleGraph.Walk.length_cons] |
| omega |
| · rw [hsup, Finset.card_insert_of_notMem hb, hc] |
|
|
| lemma card_walks_le (G : SimpleGraph V) [DecidableRel G.Adj] (D : ℕ) |
| (hD : ∀ x, (Finset.univ.filter (G.Adj x)).card ≤ D) (n : ℕ) (x y : V) : |
| (G.finsetWalkLength n x y).card ≤ D ^ n := by |
| classical |
| induction n generalizing x y with |
| | zero => |
| by_cases h : x = y |
| · subst y; simp [SimpleGraph.finsetWalkLength] |
| · simp [SimpleGraph.finsetWalkLength, h] |
| | succ n ih => |
| rw [SimpleGraph.finsetWalkLength] |
| calc |
| _ ≤ ∑ z : G.neighborSet x, ((G.finsetWalkLength n z y).map |
| ⟨fun p => SimpleGraph.Walk.cons z.property p, fun p q h => by cases h; rfl⟩).card := |
| Finset.card_biUnion_le |
| _ ≤ ∑ _ : G.neighborSet x, D ^ n := by |
| apply Finset.sum_le_sum; intro z _ |
| simpa only [Finset.card_map] using ih z y |
| _ = (Finset.univ.filter (G.Adj x)).card * D ^ n := by |
| simp only [Finset.sum_const, nsmul_eq_mul] |
| congr 1 |
| simp [Fintype.card_subtype] |
| _ ≤ D ^ (n+1) := by rw [pow_succ]; exact Nat.mul_le_mul_right _ (hD x) |>.trans_eq (Nat.mul_comm _ _) |
| |
| end SparseClusters |
| |
| namespace SparseClusters |
| |
| variable {V : Type*} [Fintype V] [DecidableEq V] |
|
|
| omit [Fintype V] [DecidableEq V] in |
| lemma walk_all_bad {G : SimpleGraph V} (bad : Set V) |
| (hb : ∀ x y, G.Adj x y → x ∈ bad ∧ y ∈ bad) {x y : V} (p : G.Walk x y) |
| (hx : x ∈ bad) : ∀ z ∈ p.support, z ∈ bad := by |
| induction p with |
| | nil => simpa using hx |
| | @cons x w y hxw p ih => |
| intro z hz |
| rcases List.mem_cons.mp hz with rfl | hz |
| · exact hx |
| · exact ih (hb x w hxw).2 z hz |
|
|
| omit [Fintype V] [DecidableEq V] in |
| lemma walk_start_bad {G : SimpleGraph V} (bad : Set V) |
| (hb : ∀ x y, G.Adj x y → x ∈ bad ∧ y ∈ bad) {x y : V} (p : G.Walk x y) |
| (hp : 0 < p.length) : x ∈ bad := by |
| cases p with |
| | nil => simp at hp |
| | cons h p => exact (hb _ _ h).1 |
|
|
| lemma sparse_component_tail {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) |
| (G : SimpleGraph V) [DecidableRel G.Adj] (D : ℕ) |
| (hD : ∀ x, (Finset.univ.filter (G.Adj x)).card ≤ D) |
| (H : Ω → SimpleGraph V) (bad : Ω → Set V) (hHG : ∀ ω, H ω ≤ G) |
| (hbad : ∀ ω x y, (H ω).Adj x y → x ∈ bad ω ∧ y ∈ bad ω) |
| (ρ : ENNReal) (hρ : ρ ≤ 1) |
| (hsparse : ∀ S : Finset V, μ {ω | ∀ x ∈ S, x ∈ bad ω} ≤ ρ ^ S.card) |
| (x : V) (m : ℕ) (hm : 1 ≤ m) : |
| μ {ω | m+1 ≤ (component (H ω) x).card} ≤ ((D : ENNReal)^2 * ρ)^m := by |
| classical |
| let W := {p : G.Walk x x // p.length = 2*m} |
| let E (p : W) : Set Ω := if m+1 ≤ p.val.support.toFinset.card then |
| {ω | ∀ z ∈ p.val.support.toFinset, z ∈ bad ω} else ∅ |
| have hsub : {ω | m+1 ≤ (component (H ω) x).card} ⊆ ⋃ p : W, E p := by |
| intro ω hω |
| obtain ⟨p, hplen, hpcard⟩ := closed_walk_witness (H ω) x m hω |
| let q : W := ⟨p.mapLe (hHG ω), by simpa using hplen⟩ |
| apply Set.mem_iUnion.mpr |
| refine ⟨q, ?_⟩ |
| have hqc : q.val.support.toFinset.card = m+1 := by |
| simpa only [q, SimpleGraph.Walk.support_mapLe_eq_support] using hpcard |
| simp only [E, ite_eq_left hqc.ge, Set.mem_ofPred_eq] |
| intro z hz |
| have hz' : z ∈ p.support := by simpa only [q, SimpleGraph.Walk.support_mapLe_eq_support, List.mem_toFinset] using hz |
| exact walk_all_bad (bad ω) (hbad ω) p |
| (walk_start_bad (bad ω) (hbad ω) p (by omega)) z hz' |
| have hEp (p : W) : μ (E p) ≤ ρ ^ m := by |
| dsimp [E] |
| split_ifs with hp |
| · exact (hsparse p.val.support.toFinset).trans (pow_le_pow_of_le_one bot_le hρ (by omega)) |
| · simp |
| calc |
| _ ≤ μ (⋃ p : W, E p) := measure_mono hsub |
| _ ≤ ∑ p : W, μ (E p) := measure_iUnion_fintype_le μ E |
| _ ≤ ∑ _ : W, ρ ^ m := Finset.sum_le_sum fun p _ => hEp p |
| _ = (Fintype.card W : ENNReal) * ρ ^ m := by simp |
| _ ≤ ((D ^ (2*m) : ℕ) : ENNReal) * ρ ^ m := by |
| gcongr |
| change Fintype.card {p : G.Walk x x | p.length = 2*m} ≤ _ |
| rw [SimpleGraph.card_set_walk_length_eq] |
| exact card_walks_le G D hD (2*m) x x |
| _ = _ := by rw [Nat.cast_pow, pow_mul, mul_pow] |
|
|
| omit [DecidableEq V] in |
| lemma card_le_fiber_mul_image {W : Type*} [DecidableEq W] (φ : V → W) (B : ℕ) |
| (hB : ∀ w, (Finset.univ.filter fun x => φ x = w).card ≤ B) (S : Finset V) : |
| S.card ≤ (S.image φ).card * B := by |
| by_contra h |
| obtain ⟨w, hw, hcard⟩ := Finset.exists_lt_card_fiber_of_mul_lt_card_of_maps_to |
| (fun x hx => Finset.mem_image.mpr ⟨x, hx, rfl⟩) (Nat.lt_of_not_ge h) |
| have hsub : (S.filter fun x => φ x = w) ⊆ (Finset.univ.filter fun x => φ x = w) := |
| Finset.filter_subset_filter _ (Finset.subset_univ _) |
| exact (not_lt_of_ge ((Finset.card_le_card hsub).trans (hB w))) hcard |
|
|
| lemma sparse_box_component_tail {Ω W : Type*} [MeasurableSpace Ω] [DecidableEq W] |
| (μ : Measure Ω) (G : SimpleGraph V) [DecidableRel G.Adj] (D B : ℕ) |
| (hD : ∀ x, (Finset.univ.filter (G.Adj x)).card ≤ D) (hBpos : 0 < B) |
| (φ : V → W) (hB : ∀ w, (Finset.univ.filter fun x => φ x = w).card ≤ B) |
| (H : Ω → SimpleGraph V) (bad : Ω → Set W) (hHG : ∀ ω, H ω ≤ G) |
| (hbad : ∀ ω x y, (H ω).Adj x y → φ x ∈ bad ω ∧ φ y ∈ bad ω) |
| (ρ : ENNReal) (hρ : ρ ≤ 1) |
| (hsparse : ∀ S : Finset W, μ {ω | ∀ w ∈ S, w ∈ bad ω} ≤ ρ ^ S.card) |
| (x : V) (m : ℕ) (hm : 1 ≤ m) : |
| μ {ω | B*m+1 ≤ (component (H ω) x).card} ≤ ((D : ENNReal)^(2*B) * ρ)^m := by |
| classical |
| let Paths := {p : G.Walk x x // p.length = 2*(B*m)} |
| let E (p : Paths) : Set Ω := if B*m+1 ≤ p.val.support.toFinset.card then |
| {ω | ∀ w ∈ p.val.support.toFinset.image φ, w ∈ bad ω} else ∅ |
| have hsub : {ω | B*m+1 ≤ (component (H ω) x).card} ⊆ ⋃ p : Paths, E p := by |
| intro ω hω |
| obtain ⟨p, hplen, hpcard⟩ := closed_walk_witness (H ω) x (B*m) hω |
| let q : Paths := ⟨p.mapLe (hHG ω), by simpa using hplen⟩ |
| apply Set.mem_iUnion.mpr |
| refine ⟨q, ?_⟩ |
| have hqc : q.val.support.toFinset.card = B*m+1 := by |
| simpa only [q, SimpleGraph.Walk.support_mapLe_eq_support] using hpcard |
| simp only [E, ite_eq_left hqc.ge] |
| intro w hw |
| obtain ⟨z, hz, rfl⟩ := Finset.mem_image.mp hw |
| have hz' : z ∈ p.support := by |
| simpa only [q, SimpleGraph.Walk.support_mapLe_eq_support, List.mem_toFinset] using hz |
| exact walk_all_bad (φ ⁻¹' bad ω) (hbad ω) p |
| (walk_start_bad (φ ⁻¹' bad ω) (hbad ω) p (by nlinarith)) z hz' |
| have hEp (p : Paths) : μ (E p) ≤ ρ ^ m := by |
| dsimp [E] |
| split_ifs with hp |
| · have hfib := card_le_fiber_mul_image φ B hB p.val.support.toFinset |
| have hc : m ≤ (p.val.support.toFinset.image φ).card := by nlinarith |
| exact (hsparse _).trans (pow_le_pow_of_le_one bot_le hρ hc) |
| · simp |
| calc |
| _ ≤ μ (⋃ p : Paths, E p) := measure_mono hsub |
| _ ≤ ∑ p : Paths, μ (E p) := measure_iUnion_fintype_le μ E |
| _ ≤ ∑ _ : Paths, ρ ^ m := Finset.sum_le_sum fun p _ => hEp p |
| _ = (Fintype.card Paths : ENNReal) * ρ ^ m := by simp |
| _ ≤ ((D ^ (2*(B*m)) : ℕ) : ENNReal) * ρ ^ m := by |
| gcongr |
| change Fintype.card {p : G.Walk x x | p.length = 2*(B*m)} ≤ _ |
| rw [SimpleGraph.card_set_walk_length_eq] |
| exact card_walks_le G D hD (2*(B*m)) x x |
| _ = _ := by rw [Nat.cast_pow, ← mul_assoc, pow_mul, mul_pow] |
|
|
| end SparseClusters |
|
|
| namespace SparseClusters |
|
|
| lemma measurable_graph_statistic {Ω V X : Type*} [MeasurableSpace Ω] [Fintype V] |
| [MeasurableSpace X] (H : Ω → SimpleGraph V) |
| (hH : ∀ x y, MeasurableSet {ω | (H ω).Adj x y}) (F : SimpleGraph V → X) : |
| Measurable (fun ω => F (H ω)) := by |
| classical |
| have hfib (J : SimpleGraph V) : MeasurableSet {ω | H ω = J} := by |
| have he : {ω | H ω = J} = {ω | ∀ x y, (H ω).Adj x y ↔ J.Adj x y} := by |
| ext ω |
| exact ⟨fun h x y => by rw [h], fun h => SimpleGraph.ext (funext fun x => funext fun y => propext (h x y))⟩ |
| rw [he] |
| simp_rw [Set.ofPred_forall] |
| apply MeasurableSet.iInter; intro x |
| apply MeasurableSet.iInter; intro y |
| by_cases h : J.Adj x y |
| · simpa only [h, iff_true] using hH x y |
| · simpa only [h, iff_false, Set.compl_ofPred] using (hH x y).compl |
| intro S hS |
| have he : (fun ω => F (H ω)) ⁻¹' S = ⋃ J : SimpleGraph V, |
| if F J ∈ S then {ω | H ω = J} else ∅ := by |
| ext ω |
| simp only [Set.mem_preimage, Set.mem_iUnion] |
| constructor |
| · intro h; exact ⟨H ω, by simp [h]⟩ |
| · rintro ⟨J, h⟩ |
| split_ifs at h with hh |
| · have h' : H ω = J := h |
| simpa only [h'] using hh |
| · exact False.elim h |
| rw [he] |
| apply MeasurableSet.iUnion; intro J |
| split_ifs with hh |
| · exact hfib J |
| · exact MeasurableSet.empty |
| |
| lemma summable_box_moment (B k : ℕ) : |
| Summable (fun m : ℕ => ((B : ℝ) * (m+1))^k * (1/2 : ℝ)^m) := by |
| have hs := summable_pow_mul_geometric_of_norm_lt_one (R := ℝ) k |
| (show ‖(1/2 : ℝ)‖ < 1 by norm_num) |
| have hs' := ((summable_nat_add_iff 1).mpr hs).mul_left ((B : ℝ)^k * 2) |
| apply hs'.congr |
| intro m |
| simp only [Nat.cast_add, Nat.cast_one, pow_succ, mul_pow] |
| ring |
|
|
| noncomputable def boxMoment (B k : ℕ) : ℝ := |
| ∑' m : ℕ, ((B : ℝ) * (m+1))^k * (1/2 : ℝ)^m |
|
|
| lemma boxMoment_nonneg (B k : ℕ) : 0 ≤ boxMoment B k := |
| tsum_nonneg (fun m => by positivity) |
|
|
| lemma nat_moment_of_geometric_tail {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) |
| [IsProbabilityMeasure μ] (H : Ω → ℕ) (hH : Measurable H) (hpos : ∀ ω, 0 < H ω) |
| (B : ℕ) (hB : 0 < B) |
| (htail : ∀ m : ℕ, 1 ≤ m → μ {ω | B*m+1 ≤ H ω} ≤ (1/2 : ENNReal)^m) |
| (k : ℕ) : ∫⁻ ω, (H ω : ENNReal)^k ∂μ ≤ ENNReal.ofReal (boxMoment B k) := by |
| let F := fun ω => (H ω - 1) / B |
| have hF : Measurable F := (measurable_of_countable (fun n : ℕ => (n-1)/B)).comp hH |
| have hbound (ω) : H ω ≤ B * (F ω + 1) := by |
| have hh := Nat.mod_lt (H ω - 1) hB |
| have he := Nat.mod_add_div (H ω - 1) B |
| dsimp [F] |
| rw [Nat.mul_add, Nat.mul_one] |
| have hp := hpos ω |
| omega |
| have hprob (m : ℕ) : μ (F ⁻¹' {m}) ≤ (1/2 : ENNReal)^m := by |
| by_cases hm : m = 0 |
| · subst m; simpa using (prob_le_one (μ := μ) (s := F ⁻¹' {0})) |
| · apply le_trans (measure_mono (show F ⁻¹' {m} ⊆ {ω | B*m+1 ≤ H ω} from ?_)) |
| (htail m (Nat.one_le_iff_ne_zero.mpr hm)) |
| intro ω hω |
| change B*m+1 ≤ H ω |
| have hd : (H ω - 1) / B = m := hω |
| have hh := Nat.div_mul_le_self (H ω - 1) B |
| have hp := hpos ω |
| rw [hd, Nat.mul_comm] at hh |
| omega |
| calc |
| _ ≤ ∫⁻ ω, (((B : ENNReal) * (F ω+1))^k) ∂μ := by |
| apply lintegral_mono; intro ω |
| exact pow_le_pow_left' (by exact_mod_cast hbound ω) k |
| _ = ∫⁻ m : ℕ, (((B : ENNReal) * (m+1))^k) ∂(Measure.map F μ) := |
| (lintegral_map (μ := μ) (f := fun m : ℕ => ((B : ENNReal) * (m+1))^k) (measurable_of_countable _) hF).symm |
| _ = ∑' m : ℕ, (((B : ENNReal) * (m+1))^k) * μ (F ⁻¹' {m}) := by |
| rw [lintegral_countable'] |
| simp only [Measure.map_apply hF (measurableSet_singleton _)] |
| _ ≤ ∑' m : ℕ, (((B : ENNReal) * (m+1))^k) * (1/2 : ENNReal)^m := by |
| apply ENNReal.tsum_le_tsum; intro m |
| exact mul_le_mul_right (hprob m) _ |
| _ = ENNReal.ofReal (boxMoment B k) := by |
| rw [boxMoment, ENNReal.ofReal_tsum_of_nonneg (fun m => by positivity) (summable_box_moment B k)] |
| congr 1; ext m |
| rw [ENNReal.ofReal_mul (by positivity), ENNReal.ofReal_pow (by positivity), |
| ENNReal.ofReal_mul (by positivity), ENNReal.ofReal_pow (by positivity)] |
| simp [ENNReal.ofReal_add (by positivity : (0 : ℝ) ≤ m) (by norm_num : (0 : ℝ) ≤ 1)] |
|
|
| lemma nat_pow_measurable {Ω : Type*} [MeasurableSpace Ω] (H : Ω → ℕ) |
| (hH : Measurable H) (k : ℕ) : Measurable (fun ω => (H ω : ℝ)^k) := |
| (measurable_of_countable (fun n : ℕ => (n : ℝ)^k)).comp hH |
|
|
| lemma nat_pow_integrable_of_bound {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) |
| [IsFiniteMeasure μ] (H : Ω → ℕ) (hH : Measurable H) (N : ℕ) (hN : ∀ ω, H ω ≤ N) |
| (k : ℕ) : Integrable (fun ω => (H ω : ℝ)^k) μ := by |
| apply (integrable_const ((N : ℝ)^k)).mono' (nat_pow_measurable H hH k).aestronglyMeasurable |
| filter_upwards [] with ω |
| rw [Real.norm_eq_abs, abs_of_nonneg (by positivity)] |
| exact pow_le_pow_left₀ (by positivity) (by exact_mod_cast hN ω) k |
|
|
| lemma nat_real_moment_of_geometric_tail {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) |
| [IsProbabilityMeasure μ] (H : Ω → ℕ) (hH : Measurable H) (hpos : ∀ ω, 0 < H ω) |
| (B : ℕ) (hB : 0 < B) |
| (htail : ∀ m : ℕ, 1 ≤ m → μ {ω | B*m+1 ≤ H ω} ≤ (1/2 : ENNReal)^m) |
| (k : ℕ) : (∫ ω, (H ω : ℝ)^k ∂μ) ≤ boxMoment B k := by |
| have hh := nat_moment_of_geometric_tail μ H hH hpos B hB htail k |
| rw [integral_eq_lintegral_of_nonneg_ae (Filter.Eventually.of_forall fun ω => by positivity) |
| (nat_pow_measurable H hH k).aestronglyMeasurable] |
| have he (ω) : ENNReal.ofReal ((H ω : ℝ)^k) = (H ω : ENNReal)^k := by |
| rw [ENNReal.ofReal_pow (by positivity), ENNReal.ofReal_natCast] |
| simp_rw [he] |
| exact (ENNReal.toReal_mono ENNReal.ofReal_ne_top hh).trans_eq |
| (ENNReal.toReal_ofReal (boxMoment_nonneg B k)) |
|
|
| lemma maximum_nat_moment_bound {Ω V : Type*} [MeasurableSpace Ω] [Fintype V] |
| (μ : Measure Ω) [IsProbabilityMeasure μ] (H : V → Ω → ℕ) |
| (hH : ∀ x, Measurable (H x)) (N : ℕ) (hN : ∀ x ω, H x ω ≤ N) |
| (k : ℕ) (_hk : 0 < k) (C R : ℝ) (hR : 0 < R) |
| (hmoment : ∀ x, (∫ ω, (H x ω : ℝ)^k ∂μ) ≤ C) : |
| μ.real {ω | ∃ x, R < (H x ω : ℝ)} ≤ (Fintype.card V : ℝ) * C / R^k := by |
| have hRp : 0 < R^k := pow_pos hR k |
| have hsingle (x : V) : μ.real {ω | R < (H x ω : ℝ)} ≤ C / R^k := by |
| apply (le_div_iff₀ hRp).mpr |
| have hs : {ω | R < (H x ω : ℝ)} ⊆ {ω | R^k ≤ (H x ω : ℝ)^k} := by |
| intro ω hω |
| exact pow_le_pow_left₀ hR.le hω.le k |
| have hm := measureReal_mono (μ := μ) hs |
| have hh := mul_meas_ge_le_integral_of_nonneg |
| (μ := μ) (f := fun ω => (H x ω : ℝ)^k) |
| (Filter.Eventually.of_forall fun ω => by positivity) |
| (nat_pow_integrable_of_bound μ (H x) (hH x) N (hN x) k) (R^k) |
| nlinarith [hmoment x] |
| rw [show {ω | ∃ x, R < (H x ω : ℝ)} = ⋃ x, {ω | R < (H x ω : ℝ)} by ext; simp] |
| calc |
| _ ≤ ∑ x : V, μ.real {ω | R < (H x ω : ℝ)} := measureReal_iUnion_fintype_le _ |
| _ ≤ ∑ _ : V, C / R^k := Finset.sum_le_sum fun x _ => hsingle x |
| _ = _ := by simp [mul_div_assoc] |
|
|
| variable {V W : Type*} [Fintype V] [DecidableEq V] [Fintype W] [DecidableEq W] |
|
|
| omit [Fintype V] [DecidableEq V] [Fintype W] [DecidableEq W] in |
| lemma reachable_of_edge_reachable (H : SimpleGraph V) (K : SimpleGraph W) (φ : V → W) |
| (he : ∀ x y, H.Adj x y → K.Reachable (φ x) (φ y)) {x y : V} |
| (hxy : H.Reachable x y) : K.Reachable (φ x) (φ y) := by |
| obtain ⟨p⟩ := hxy |
| induction p with |
| | nil => exact SimpleGraph.Reachable.refl _ |
| | cons h p ih => exact (he _ _ h).trans ih |
|
|
| lemma component_card_le_cover (H : SimpleGraph V) (K : SimpleGraph W) |
| (φ : V → W) (B : ℕ) |
| (hB : ∀ w, (Finset.univ.filter fun x => φ x = w).card ≤ B) |
| (he : ∀ x y, H.Adj x y → K.Reachable (φ x) (φ y)) (x : V) : |
| (component H x).card ≤ B * (component K (φ x)).card := by |
| have hsub : (component H x).image φ ⊆ component K (φ x) := by |
| intro w hw |
| obtain ⟨y, hy, rfl⟩ := Finset.mem_image.mp hw |
| exact (mem_component _ _ _).mpr |
| (reachable_of_edge_reachable H K φ he ((mem_component _ _ _).mp hy)) |
| exact (card_le_fiber_mul_image φ B hB _).trans |
| ((Nat.mul_le_mul_right B (Finset.card_le_card hsub)).trans_eq (Nat.mul_comm _ _)) |
|
|
| noncomputable def badBoxGraph (K : SimpleGraph W) (bad : Set W) : SimpleGraph W where |
| Adj x y := K.Adj x y ∧ x ∈ bad ∧ y ∈ bad |
| symm := ⟨by intro x y h; exact ⟨h.1.symm, h.2.2, h.2.1⟩⟩ |
| loopless := ⟨fun x h => K.irrefl h.1⟩ |
|
|
| lemma sparse_cover_component_tail {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) |
| (K : SimpleGraph W) [DecidableRel K.Adj] (Db B : ℕ) |
| (hDb : ∀ w, (Finset.univ.filter (K.Adj w)).card ≤ Db) |
| (φ : V → W) (hB : ∀ w, (Finset.univ.filter fun x => φ x = w).card ≤ B) |
| (H : Ω → SimpleGraph V) (bad : Ω → Set W) |
| (hcover : ∀ ω x y, (H ω).Adj x y → φ x = φ y ∨ K.Adj (φ x) (φ y)) |
| (hbad : ∀ ω x y, (H ω).Adj x y → φ x ∈ bad ω ∧ φ y ∈ bad ω) |
| (ρ : ENNReal) (hρ : ρ ≤ 1) |
| (hsparse : ∀ S : Finset W, μ {ω | ∀ w ∈ S, w ∈ bad ω} ≤ ρ ^ S.card) |
| (x : V) (m : ℕ) (hm : 1 ≤ m) : |
| μ {ω | B*m+1 ≤ (component (H ω) x).card} ≤ ((Db : ENNReal)^2 * ρ)^m := by |
| have he (ω x y) (hxy : (H ω).Adj x y) : |
| (badBoxGraph K (bad ω)).Reachable (φ x) (φ y) := by |
| rcases hcover ω x y hxy with hh | hh |
| · simpa only [hh] using (SimpleGraph.Reachable.refl (φ y) : (badBoxGraph K (bad ω)).Reachable (φ y) (φ y)) |
| · exact SimpleGraph.Adj.reachable ⟨hh, hbad ω x y hxy⟩ |
| have hsub : {ω | B*m+1 ≤ (component (H ω) x).card} ⊆ |
| {ω | m+1 ≤ (component (badBoxGraph K (bad ω)) (φ x)).card} := by |
| intro ω hω |
| have hc := component_card_le_cover (H ω) (badBoxGraph K (bad ω)) φ B hB (he ω) x |
| change B*m+1 ≤ (component (H ω) x).card at hω |
| change m+1 ≤ _ |
| by_contra hh |
| have hle : (component (badBoxGraph K (bad ω)) (φ x)).card ≤ m := by omega |
| have hmul := Nat.mul_le_mul_left B hle |
| omega |
| apply (measure_mono hsub).trans |
| exact sparse_component_tail μ K Db hDb (fun ω => badBoxGraph K (bad ω)) bad |
| (fun ω x y h => h.1) (fun ω x y h => h.2) ρ hρ hsparse (φ x) m hm |
|
|
| end SparseClusters |
|
|
| end OAI |
|
|
