| import OAI.Geometry.PinnedDistances.GlobalPotentials |
|
|
| namespace OAI |
|
|
| universe u1 u2 u3 u4 u5 u6 u7 u8 u9 |
|
|
| section |
| noncomputable section |
| open NumberField |
| open scoped BigOperators |
| noncomputable section |
| open MeasureTheory |
| open scoped Topology |
| noncomputable section |
| open MeasureTheory |
| open scoped Topology ENNReal |
| noncomputable section |
| open MeasureTheory NumberField |
| open scoped BigOperators |
| noncomputable section |
| open scoped BigOperators |
| open MeasureTheory |
| noncomputable section |
| open Filter |
| open scoped Topology |
| noncomputable section |
| open scoped BigOperators |
| noncomputable section |
| open Filter |
| open scoped Topology |
| noncomputable section |
| open MeasureTheory |
| open scoped BigOperators |
| noncomputable section |
|
|
| namespace WeakPinned.Cuts |
| open scoped BigOperators |
| |
| def tent (δ u : ℝ) : ℝ := max 0 (min (u-δ) (1-δ-u)) |
| lemma tent_nonneg (δ u : ℝ) : 0≤tent δ u := le_max_left _ _ |
| lemma tent_symm (δ u : ℝ) : tent δ (1-u)=tent δ u := by |
| unfold tent |
| rw [show 1-u-δ=1-δ-u by ring,show 1-δ-(1-u)=u-δ by ring,min_comm] |
| lemma tent_zero_left {δ u : ℝ} (hu : u≤δ) : tent δ u=0 := by |
| unfold tent |
| exact max_eq_left ((min_le_left _ _).trans (sub_nonpos.mpr hu)) |
| lemma tent_zero_right {δ u : ℝ} (hu : 1-δ≤u) : tent δ u=0 := by |
| rw [← tent_symm] |
| exact tent_zero_left (by linarith) |
| lemma tent_le_one {δ u : ℝ} (hδ : 0≤δ) (hu : u≤1) : tent δ u≤1 := by |
| exact max_le (by norm_num) ((min_le_left _ _).trans (by linarith)) |
| lemma tent_lipschitz (δ u v : ℝ) : |tent δ u-tent δ v|≤|u-v| := by |
| have hm := abs_max_sub_max_le_max (0:ℝ) (min (u-δ) (1-δ-u)) 0 (min (v-δ) (1-δ-v)) |
| have hn := abs_min_sub_min_le_max (u-δ) (1-δ-u) (v-δ) (1-δ-v) |
| have he : 1-δ-u-(1-δ-v)=-(u-v) := by ring |
| have hf : u-δ-(v-δ)=u-v := by ring |
| simp only [he,hf,abs_neg,max_self] at hn |
| exact hm.trans (max_le (by simp [abs_nonneg]) hn) |
| lemma tent_positive {δ u : ℝ} (hu : 0<tent δ u) : δ<u ∧ u<1-δ := by |
| have h : 0 < min (u-δ) (1-δ-u) := (lt_max_iff.mp hu).resolve_left (lt_irrefl _) |
| have := lt_min_iff.mp h |
| constructor < |
| lemma tent_lower {δ u : ℝ} (hu : 2*δ≤u) (hu' : u≤1-2*δ) : δ≤tent δ u := by |
| exact le_max_iff.mpr (Or.inr (le_min (by linarith) (by linarith))) |
| |
| def cutError (δ p a : ℝ) : ℝ := |tent δ p-tent δ a|+tent δ a*|p-a| |
| lemma cutError_nonneg (δ p a : ℝ) : 0≤cutError δ p a := |
| add_nonneg (abs_nonneg _) (mul_nonneg (tent_nonneg _ _) (abs_nonneg _)) |
| lemma cutError_symm (δ p a : ℝ) : cutError δ (1-p) (1-a)=cutError δ p a := by |
| simp only [cutError,tent_symm,show 1-p-(1-a)=-(p-a) by ring,abs_neg] |
| lemma cutError_le {δ p a : ℝ} (hδ : 0≤δ) (ha : a≤1) : cutError δ p a≤2*|p-a| := by |
| have := tent_lipschitz δ p a |
| have := mul_le_mul_of_nonneg_right (tent_le_one hδ ha) (abs_nonneg (p-a)) |
| unfold cutError |
| linarith |
| lemma cutError_young {δ p a ε : ℝ} (hδ : 0≤δ) (ha : a≤1) (hε : 0<ε) : |
| cutError δ p a≤ε+(p-a)^2/ε := by |
| apply (cutError_le hδ ha).trans |
| apply (mul_le_mul_iff_left₀ hε).mp |
| have he : (ε+(p-a)^2/ε)*ε=ε^2+(p-a)^2 := by field_simp |
| rw [he] |
| nlinarith [sq_nonneg (|p-a|-ε),sq_abs (p-a)] |
| |
| /-- Tiny uniform cells have nonzero balanced-cut weight only if their sampled |
| mass is separated from zero. The variance quadratic then pays the cut error. -/ |
| lemma cutError_tiny {δ p a : ℝ} (hδ : 0<δ) (ha : a<δ/2) (hp : p≤1) : |
| cutError δ p a≤(4/δ^2)*(p-a)^2 ∧ cutError δ p a≤(4/δ^2)*(p^2/2) := by |
| have hz : tent δ a=0 := tent_zero_left (by linarith) |
| rw [cutError,hz,sub_zero,abs_of_nonneg (tent_nonneg _ _),zero_mul,add_zero] |
| by_cases hh : tent δ p=0 |
| · rw [hh]; constructor <;> positivity |
| · have ht : 0<tent δ p := lt_of_le_of_ne (tent_nonneg _ _) (Ne.symm hh) |
| have hpd := (tent_positive ht).1 |
| have ht1 := tent_le_one hδ.le hp |
| have hd2 : 0<δ^2 := sq_pos_of_pos hδ |
| constructor |
| · apply ht1.trans |
| apply (mul_le_mul_iff_left₀ hd2).mp |
| have he : ((4/δ^2)*(p-a)^2)*δ^2=4*(p-a)^2 := by field_simp |
| rw [he] |
| nlinarith [sq_nonneg (p-a-δ/2),mul_nonneg (by linarith : 0≤p-a-δ/2) hδ.le] |
| · apply ht1.trans |
| apply (mul_le_mul_iff_left₀ hd2).mp |
| have he : ((4/δ^2)*(p^2/2))*δ^2=2*p^2 := by field_simp; ring |
| rw [he] |
| nlinarith [sq_nonneg (p-δ),mul_nonneg (by linarith : 0≤p-δ) hδ.le] |
| end WeakPinned.Cuts |
| |
| namespace WeakPinned.Variance |
| open scoped BigOperators |
| open Cuts |
| variable {P : Type u1} {I : Type u2} [Fintype P] [Fintype I] [DecidableEq P] |
| |
| noncomputable def familyCutError (w : I → ℝ) (B : I → Finset P) (δ : ℝ) (C : Finset P) : ℝ := |
| ∑ i, w i*cutError δ (cellProb (B i) C) (cellProb Finset.univ C) |
| |
| lemma familyCutError_bound (w : I → ℝ) (B : I → Finset P) (T δ ε : ℝ) |
| (hw : ∀ i, 0≤w i) (hW : (∑ i, w i)≤1) (hδ : 0<δ) (hε : 0<ε) |
| (hk : ∀ i, 2/((B i).card:ℝ)≤δ) (C : Finset P) |
| (hlarge : δ/2≤cellProb Finset.univ C → T<C.card) |
| (hpair : δ/2≤cellProb Finset.univ C → 1≤(8/δ^2)*pairCell Finset.univ C) : |
| familyCutError w B δ C≤(8*ε/δ^2)*pairCell Finset.univ C+ |
| (1/ε+4/δ^2)*varianceCell w B T C := by |
| have hv : 0≤varianceCell w B T C := varianceCell_nonneg w B T hw C |
| by_cases ha : δ/2≤cellProb Finset.univ C |
| · have he := Finset.sum_le_sum (s:=Finset.univ) (fun i _ => |
| mul_le_mul_of_nonneg_left (cutError_young (p:=cellProb (B i) C) hδ.le (cellProb_le_one (Finset.univ : Finset P) C) hε) (hw i)) |
| change familyCutError w B δ C≤_ at he |
| simp only [mul_add,Finset.sum_add_distrib,← Finset.sum_mul,← mul_div_assoc,← Finset.sum_div] at he |
| have hvf : varianceCell w B T C=∑ i, w i*(cellProb (B i) C-cellProb Finset.univ C)^2 := by |
| simp only [varianceCell,ite_eq_left (hlarge ha)] |
| rw [← hvf] at he |
| have he2 : (∑ i, w i)*ε≤ε := by nlinarith |
| have he3 : ε≤(8*ε/δ^2)*pairCell Finset.univ C := by |
| have hh := mul_le_mul_of_nonneg_left (hpair ha) hε.le |
| calc |
| ε = ε*1 := by ring |
| _ ≤ ε*((8/δ^2)*pairCell Finset.univ C) := hh |
| _ = _ := by ring |
| have hx : 0≤(4/δ^2)*varianceCell w B T C := mul_nonneg (by positivity) hv |
| have hh : varianceCell w B T C/ε=(1/ε)*varianceCell w B T C := by ring |
| rw [hh] at he |
| nlinarith |
| · have hat : cellProb Finset.univ C<δ/2 := lt_of_not_ge ha |
| have hb : familyCutError w B δ C≤(4/δ^2)*varianceCell w B T C := by |
| unfold familyCutError varianceCell |
| split_ifs with hl |
| · rw [Finset.mul_sum] |
| apply Finset.sum_le_sum |
| intro i _ |
| have hh := (cutError_tiny hδ hat (cellProb_le_one (B i) C)).1 |
| have hm := mul_le_mul_of_nonneg_left hh (hw i) |
| convert hm using 1; ring |
| · simp only [Finset.mul_sum] |
| apply Finset.sum_le_sum |
| intro i _ |
| by_cases hpk : 2/((B i).card:ℝ)≤cellProb (B i) C |
| · rw [ite_eq_left hpk] |
| have hh := (cutError_tiny hδ hat (cellProb_le_one (B i) C)).2 |
| have hm := mul_le_mul_of_nonneg_left hh (hw i) |
| convert hm using 1; ring |
| · rw [ite_eq_right hpk] |
| have hp : cellProb (B i) C≤δ := (le_of_lt (lt_of_not_ge hpk)).trans (hk i) |
| simp only [cutError,tent_zero_left hp,tent_zero_left (show cellProb Finset.univ C≤δ by linarith), |
| sub_self,abs_zero,zero_mul,add_zero,mul_zero] |
| norm_num |
| have hx : 0≤(8*ε/δ^2)*pairCell Finset.univ C := mul_nonneg (by positivity) (pairCell_nonneg _ _) |
| have hy : 0≤(1/ε)*varianceCell w B T C := mul_nonneg (by positivity) hv |
| nlinarith |
| end WeakPinned.Variance |
| |
| namespace WeakPinned.Variance |
| open scoped BigOperators |
| variable {P : Type u3} {I : Type u4} [Fintype P] [Fintype I] [DecidableEq P] |
| |
| lemma balanced_cell_size (δ : ℝ) (hδ : 0<δ) (hn : 4≤δ*(Fintype.card P:ℝ)) |
| (C : Finset P) (ha : δ/2≤cellProb Finset.univ C) : 2≤C.card := by |
| have hn0 : (0:ℝ)<Fintype.card P := by |
| by_contra! h |
| have := mul_nonpos_of_nonneg_of_nonpos hδ.le h |
| linarith |
| simp only [cellProb,Finset.univ_inter,Finset.card_univ] at ha |
| have hh := (le_div_iff₀ hn0).mp ha |
| exact_mod_cast (show (2:ℝ)≤C.card by nlinarith) |
| |
| lemma balanced_cell_pair (δ : ℝ) (hδ : 0<δ) (hn : 4≤δ*(Fintype.card P:ℝ)) |
| (C : Finset P) (ha : δ/2≤cellProb Finset.univ C) : |
| 1≤(8/δ^2)*pairCell Finset.univ C := by |
| have hpair := (uniform_pair_comparison C (balanced_cell_size δ hδ hn C ha)).1 |
| have han := cellProb_nonneg (Finset.univ : Finset P) C |
| have hh : δ^2≤8*pairCell Finset.univ C := by nlinarith |
| have he : (8/δ^2)*pairCell Finset.univ C=(8*pairCell Finset.univ C)/δ^2 := by ring |
| rw [he] |
| exact (le_div_iff₀ (sq_pos_of_pos hδ)).mpr (by simpa using hh) |
| |
| /-- Integrated approximation to balanced tree cuts, quantitatively, with no |
| selection of a realizing grid and no hidden count of occurrence multiplicities. -/ |
| lemma weighted_cut_approximation (m : Finset P → ℝ) (hm : ∀ C, 0 ≤ m C) |
| (w : I → ℝ) (B : I → Finset P) (T δ ε : ℝ) |
| (hw : ∀ i, 0≤w i) (hW : (∑ i, w i)≤1) (hδ : 0<δ) (hε : 0<ε) |
| (hn : 4≤δ*(Fintype.card P:ℝ)) (hT : T<δ*(Fintype.card P:ℝ)/2) |
| (hk : ∀ i, 2/((B i).card:ℝ)≤δ) : |
| weightedIntegral m (familyCutError w B δ)≤ |
| (8*ε/δ^2)*weightedIntegral m (pairCell Finset.univ)+ |
| (1/ε+4/δ^2)*weightedIntegral m (varianceCell w B T) := by |
| have hn0 : (0:ℝ)<Fintype.card P := by |
| by_contra! h |
| have := mul_nonpos_of_nonneg_of_nonpos hδ.le h |
| linarith |
| have hpoint (C : Finset P) := familyCutError_bound w B T δ ε hw hW hδ hε hk C |
| (fun ha => by |
| simp only [cellProb,Finset.univ_inter,Finset.card_univ] at ha |
| have hh := (le_div_iff₀ hn0).mp ha |
| linarith) (balanced_cell_pair δ hδ hn C) |
| have hh := Finset.sum_le_sum (s:=Finset.univ) (fun C _ => |
| mul_le_mul_of_nonneg_left (hpoint C) (hm C)) |
| change weightedIntegral m (familyCutError w B δ)≤_ at hh |
| convert hh using 1 |
| simp only [weightedIntegral,mul_add,Finset.sum_add_distrib,Finset.mul_sum] |
| congr 1 <;> apply Finset.sum_congr rfl <;> intro C _ <;> ring |
| |
| end WeakPinned.Variance |
| |
| namespace WeakPinned |
| open Filter |
| open scoped Topology |
| |
| /-- A Young estimate for every fixed positive ε implies the required little-o |
| cut approximation. D is the actual (positive) overlap normalization. -/ |
| lemma cut_approximation_rate (E V W D : ℕ → ℝ) (δ K : ℝ) (hδ : 0<δ) (hK : 0<K) |
| (hE : ∀ j, 0≤E j) (hD : ∀ j, 0<D j) |
| (hW : ∀ᶠ j in atTop, W j≤K*D j) |
| (hV : Tendsto (fun j => V j/D j) atTop (𝓝 0)) |
| (hb : ∀ ε : ℝ, 0<ε → ∀ᶠ j in atTop, |
| E j≤(8*ε/δ^2)*W j+(1/ε+4/δ^2)*V j) : |
| Tendsto (fun j => E j/D j) atTop (𝓝 0) := by |
| apply Metric.tendsto_atTop.mpr |
| intro ζ hζ |
| let ε : ℝ := ζ*δ^2/(32*K) |
| have hε : 0<ε := by dsimp [ε]; positivity |
| have heq : (8*ε/δ^2)*K=ζ/4 := by dsimp [ε]; field_simp; ring |
| have hc : 0<1/ε+4/δ^2 := by positivity |
| have hh : ∀ᶠ j in atTop, |(1/ε+4/δ^2)*(V j/D j)|<ζ/2 := by |
| have hh0 : Tendsto (fun j => (1/ε+4/δ^2)*(V j/D j)) atTop (𝓝 0) := by |
| simpa only [mul_zero] using hV.const_mul (1/ε+4/δ^2) |
| exact (hh0.eventually (Metric.ball_mem_nhds (0:ℝ) (half_pos hζ))).mono |
| (fun j hj => by simpa only [Metric.mem_ball,Real.dist_eq,sub_zero] using hj) |
| have hh' : ∀ᶠ j in atTop, |E j/D j-0|<ζ := by |
| filter_upwards [hb ε hε,hW,hh] with j hj hjw hjv |
| have hn := div_nonneg (hE j) (hD j).le |
| rw [sub_zero,abs_of_nonneg hn] |
| have hp := mul_le_mul_of_nonneg_left hjw (show 0≤8*ε/δ^2 by positivity) |
| have hle : E j/D j≤(8*ε/δ^2)*K+(1/ε+4/δ^2)*(V j/D j) := by |
| apply (div_le_iff₀ (hD j)).mpr |
| have he : ((8*ε/δ^2)*K+(1/ε+4/δ^2)*(V j/D j))*D j = |
| (8*ε/δ^2)*(K*D j)+(1/ε+4/δ^2)*V j := by field_simp [ne_of_gt (hD j)] |
| rw [he] |
| linarith |
| rw [heq] at hle |
| have := (le_abs_self _).trans_lt hjv |
| linarith |
| obtain ⟨N,hN⟩ := eventually_atTop.mp hh' |
| exact ⟨N,fun j hj => by simpa only [Real.dist_eq] using hN j hj⟩ |
| end WeakPinned |
| |
| namespace WeakPinned |
| open Filter Variance Global |
| open scoped Topology BigOperators |
| variable {P : ℕ → Type u5} {I : ℕ → Type u6} [∀ j, Fintype (P j)] [∀ j, Fintype (I j)] [∀ j, DecidableEq (P j)] |
| |
| lemma variance_to_cut_rate (m : ∀ j, Finset (P j) → ℝ) (hm : ∀ j C, 0 ≤ m j C) |
| (w : ∀ j, I j → ℝ) (B : ∀ j, I j → Finset (P j)) (D : ℕ → ℝ) (γ c δ : ℝ) |
| (hD : ∀ j, 0<D j) (hδ : 0<δ) (hγ : 0<γ) (hc : 0<c) |
| (hn : Tendsto (fun j => (Fintype.card (P j):ℝ)) atTop atTop) |
| (hw : ∀ j i, 0≤w j i) (hW : ∀ j, (∑ i, w j i)≤1) |
| (hsize : ∀ j i, (Fintype.card (P j):ℝ)^γ≤((B j i).card:ℝ)) |
| (hWD : ∀ j, weightedIntegral (m j) (pairCell Finset.univ)≤D j) |
| (hV : Tendsto (fun j => weightedIntegral (m j) |
| (varianceCell (w j) (B j) ((Fintype.card (P j):ℝ)^(1-c)))/D j) atTop (𝓝 0)) : |
| Tendsto (fun j => weightedIntegral (m j) (familyCutError (w j) (B j) δ)/D j) atTop (𝓝 0) := by |
| let n := fun j => (Fintype.card (P j):ℝ) |
| have hnγ : Tendsto (fun j => n j^γ) atTop atTop := (tendsto_rpow_atTop hγ).comp hn |
| have hnc : Tendsto (fun j => n j^(-c)) atTop (𝓝 0) := (tendsto_rpow_neg_atTop hc).comp hn |
| apply cut_approximation_rate _ _ (fun j => weightedIntegral (m j) (pairCell Finset.univ)) D δ 1 hδ (by norm_num) |
| (fun j => Finset.sum_nonneg (fun C _ => mul_nonneg (hm j C) |
| (Finset.sum_nonneg (fun i _ => mul_nonneg (hw j i) (Cuts.cutError_nonneg _ _ _))))) hD |
| (Eventually.of_forall (fun j => by simpa using hWD j)) hV |
| intro ε hε |
| filter_upwards [hn.eventually (eventually_gt_atTop (4/δ)), |
| hnγ.eventually (eventually_ge_atTop (2/δ)), hnc.eventually (gt_mem_nhds (half_pos hδ))] with j hj hjγ hjc |
| have hn0 : 0<n j := (by positivity : 0<4/δ).trans hj |
| have hnj : 4≤δ*n j := by |
| have hh := (div_lt_iff₀ hδ).mp hj |
| nlinarith |
| have hT : n j^(1-c)<δ*n j/2 := by |
| rw [sub_eq_add_neg,Real.rpow_add hn0,Real.rpow_one] |
| nlinarith |
| have hk (i) : 2/((B j i).card:ℝ)≤δ := by |
| have hbs : 0<((B j i).card:ℝ) := (Real.rpow_pos_of_pos hn0 γ).trans_le (hsize j i) |
| apply (div_le_iff₀ hbs).mpr |
| have hh := (div_le_iff₀ hδ).mp (hjγ.trans (hsize j i)) |
| nlinarith |
| exact weighted_cut_approximation (m j) (hm j) (w j) (B j) (n j^(1-c)) δ ε |
| (hw j) (hW j) hδ hε hnj hT hk |
| |
| end WeakPinned |
| |
| namespace WeakPinned |
| open Filter Variance Global |
| open scoped Topology BigOperators |
| variable {V : ℕ → Type u7} {I : ℕ → Type u8} {K : ℕ → Type u9} [∀ j, Fintype (V j)] [∀ j, Fintype (I j)] [∀ j, DecidableEq (V j)] |
| [∀ j, Field (K j)] [∀ j, NumberField (K j)] |
| variable (G : ∀ j, Core.Fibers (V j) (I j)) (θ γ c : ℝ) (η : ℕ → ℝ) |
| (Z₁ Z₂ : ∀ j, V j → K j) (h₁ : ∀ j, Function.Injective (Z₁ j)) (h₂ : ∀ j, Function.Injective (Z₂ j)) |
| |
| /-- Cut approximation for both sampling families, normalized by W₂+A+1 |
| and hence by W in the unbounded regime. -/ |
| theorem sampling_cut_approximation_rates (δ : ℝ) (hδ : 0<δ) (hθ : 0<θ) |
| (hγ : 0<γ) (hγ1 : γ<1) (hc : 0<c) (hcγ : c<γ) |
| (hn : Tendsto (fun j => (Fintype.card (V j):ℝ)) atTop atTop) |
| (hη : Tendsto η atTop (𝓝 0)) (hη0 : ∀ j, 0≤η j) (hηb : ∀ j, η j≤θ/2) |
| (hG : ∀ j, PreparedGraph (V j) (I j) (G j) θ γ c (η j)) |
| (t : ∀ j, I j → K j) (ht : ∀ j e y, y ∈ (G j).targets e → |
| (Z₁ j ((G j).source e)-Z₁ j y)*(Z₂ j ((G j).source e)-Z₂ j y)=t j e) : |
| Tendsto (fun j => weightedIntegral (totalMass (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)) |
| (familyCutError (G j).fiberWeight (G j).targets δ)/ |
| (overlapScale (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)+potentialScale (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)+1)) atTop (𝓝 0) ∧ |
| Tendsto (fun j => weightedIntegral (totalMass (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)) |
| (familyCutError ((G j).retainedWeight ((Fintype.card (V j):ℝ)^γ)) |
| ((G j).retainedSet ((Fintype.card (V j):ℝ)^γ)) δ)/ |
| (overlapScale (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)+potentialScale (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)+1)) atTop (𝓝 0) := by |
| have hv := sampling_variance_rates G θ γ c η Z₁ Z₂ h₁ h₂ hθ hγ hγ1 hcγ hn hη hη0 hηb hG t ht |
| let m := fun j => totalMass (Z₁ j) (Z₂ j) (h₁ j) (h₂ j) |
| let D := fun j => overlapScale (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)+potentialScale (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)+1 |
| have hD (j) : 0<D j := by dsimp [D]; linarith [overlapScale_nonneg (Z₁ j) (Z₂ j) (h₁ j) (h₂ j),potentialScale_nonneg (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)] |
| have hWD (j) : weightedIntegral (m j) (pairCell Finset.univ)≤D j := by |
| change overlapScale (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)≤_ |
| dsimp [D] |
| linarith [potentialScale_nonneg (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)] |
| have hpos (j) : 0<(G j).edgeCount := (hG j).edgeCount_pos (by linarith [hηb j]) |
| constructor |
| · exact variance_to_cut_rate m (fun j => totalMass_nonneg _ _ _ _) |
| (fun j => (G j).fiberWeight) (fun j => (G j).targets) D γ c δ hD hδ hγ hc hn |
| (fun j => (G j).fiberWeight_nonneg) (fun j => ((G j).sum_fiberWeight (hpos j)).le) |
| (fun j i => ((hG j).fiber i).le) hWD hv.1 |
| · apply variance_to_cut_rate m (fun j => totalMass_nonneg _ _ _ _) |
| (fun j => (G j).retainedWeight ((Fintype.card (V j):ℝ)^γ)) |
| (fun j => (G j).retainedSet ((Fintype.card (V j):ℝ)^γ)) D γ c δ hD hδ hγ hc hn |
| (fun j => (G j).retainedWeight_nonneg _) (fun j => (G j).sum_retainedWeight _ (hpos j)) _ hWD hv.2 |
| intro j y |
| apply (G j).retainedSet_size |
| have hn1 : (1:ℝ)≤Fintype.card (V j) := by exact_mod_cast (by have := (hG j).card_ge; omega : 1≤Fintype.card (V j)) |
| simpa only [Real.rpow_one] using Real.rpow_le_rpow_of_exponent_le hn1 hγ1.le |
| end WeakPinned |
| |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| |
| end OAI |
| |
