| import OAI.Geometry.LatticeCovering.Rounding |
|
|
| namespace OAI |
|
|
| section |
| section |
| noncomputable section |
| open scoped BigOperators |
| open Real |
| noncomputable section |
| open scoped BigOperators |
| open MeasureTheory ProbabilityTheory Set |
| noncomputable section |
| open scoped BigOperators |
| open MeasureTheory Set |
| noncomputable section |
| open Module Submodule MeasureTheory |
| open scoped BigOperators |
| noncomputable section |
| open Real Filter Topology |
|
|
| namespace SingleLatticeCovering.Folded |
| open Real Filter Topology Asymptotics |
|
|
| lemma eventually_rpow_ratio_bound {s t c : ℝ} (hst : s < t) (hc : 0 < c) : |
| ∀ᶠ b : ℝ in atTop, b^s ≤ c*b^t := by |
| have ht := tendsto_rpow_neg_atTop (sub_pos.mpr hst) |
| filter_upwards [ht.eventually (gt_mem_nhds hc), eventually_gt_atTop (0 : ℝ)] with b hb hb0 |
| have he : b^(-(t-s)) = b^s/b^t := by |
| rw [←Real.rpow_sub hb0] |
| congr 1 |
| ring |
| rw [he] at hb |
| exact (div_lt_iff₀ (Real.rpow_pos_of_pos hb0 t)).mp hb |>.le |
|
|
| lemma eventually_prime_power (k : ℝ) (hk : 0 < k) : |
| ∀ᶠ b : ℝ in atTop, ∀ p : ℝ, 0 < p → |
| b*logMean (heightR b)-4*b^(56/100 : ℝ) ≤ Real.log p → b^k ≤ p := by |
| filter_upwards [(logMean_tendsto.comp heightR_tendsto).eventually (eventually_ge_atTop (2 : ℝ)), |
| eventually_rpow_ratio_bound (by norm_num : (56/100 : ℝ) < 1) (by norm_num : (0 : ℝ) < 1/4), |
| eventually_logpow_bound (1 : ℝ) (by norm_num : (0 : ℝ) < 1) (inv_pos.mpr hk), |
| eventually_gt_atTop (1 : ℝ)] with b hμ hr hl hb1 |
| intro p hp hlp |
| have hb0 : 0 < b := by linarith |
| rw [Real.rpow_one] at hr |
| rw [Real.rpow_one, Real.rpow_one] at hl |
| have hbl : b ≤ Real.log p := by |
| dsimp only [Function.comp_apply] at hμ |
| nlinarith [mul_le_mul_of_nonneg_left hμ hb0.le] |
| have hkl : Real.log b*k ≤ b := by |
| calc |
| _ ≤ (k⁻¹*b)*k := mul_le_mul_of_nonneg_right hl hk.le |
| _ = b := by field_simp |
| rw [Real.rpow_def_of_pos hb0] |
| exact (Real.exp_le_exp.mpr (hkl.trans hbl)).trans_eq (Real.exp_log hp) |
|
|
| lemma grid_slack_of_fourth {b h p : ℝ} (hb : 2 ≤ b) (hh : 0 < h) |
| (hsq : h^2 ≤ b) (hp : b^4 ≤ p) : |
| b*h^2/p ≤ b^(-(2 : ℝ)) ∧ p⁻¹ ≤ 1/(2*h^2) := by |
| have hb0 : 0 < b := by linarith |
| have hp0 : 0 < p := lt_of_lt_of_le (by positivity) hp |
| have he : b^(-(2 : ℝ)) = 1/b^2 := by rw [Real.rpow_neg hb0.le, Real.rpow_two, one_div] |
| constructor |
| · rw [he, div_le_div_iff₀ hp0 (by positivity)] |
| nlinarith [mul_le_mul_of_nonneg_left hsq (show 0 ≤ b^3 by positivity)] |
| · rw [inv_eq_one_div, div_le_div_iff₀ hp0 (by positivity)] |
| nlinarith [sq_nonneg (b-2),sq_nonneg (b^2-2)] |
|
|
| lemma eventually_rounding_slack : ∀ᶠ b : ℝ in atTop, ∀ p : ℝ, 0 < p → |
| b*logMean (heightR b)-4*b^(56/100 : ℝ) ≤ Real.log p → |
| b*heightR b^2/p ≤ b^(-(1/20 : ℝ)) ∧ |
| b*heightR b^2/p ≤ (1/2 : ℝ)*b^(56/100 : ℝ) ∧ |
| p⁻¹ ≤ 1/(2*heightR b^2) := by |
| filter_upwards [eventually_prime_power (4 : ℝ) (by norm_num), eventually_height_square_le, |
| eventually_rpow_ratio_bound (by norm_num : (-2 : ℝ) < 56/100) (by norm_num : (0 : ℝ) < 1/2), |
| eventually_ge_atTop (2 : ℝ)] with b hp hs hr hb |
| intro p hp0 hlp |
| have hp4 : b^4 ≤ p := by |
| have ht := hp p hp0 hlp |
| change b^((4 : ℕ) : ℝ) ≤ p at ht |
| rwa [Real.rpow_natCast] at ht |
| have hg := grid_slack_of_fourth hb (heightR_pos (by linarith)) hs hp4 |
| exact ⟨hg.1.trans (Real.rpow_le_rpow_of_exponent_le (by linarith) (by norm_num)), hg.1.trans hr,hg.2⟩ |
|
|
|
|
| end SingleLatticeCovering.Folded |
|
|
|
|
| namespace SingleLatticeCovering.Folded |
| open Real Filter Topology MeasureTheory ConstructionA |
|
|
| lemma numerical_count_tail {b m : ℝ} (hb : 1 ≤ b) |
| (hm : 2*b^(70/100 : ℝ) ≤ m) : 4/m ≤ 2*b^(-(1/20 : ℝ)) := by |
| have hb0 : 0 < b := lt_of_lt_of_le (by norm_num) hb |
| have hp : 0 < b^(70/100 : ℝ) := Real.rpow_pos_of_pos hb0 _ |
| have hm0 : 0 < m := by linarith |
| calc |
| 4/m ≤ 4/(2*b^(70/100 : ℝ)) := div_le_div_of_nonneg_left (by norm_num) (by positivity) hm |
| _ = 2*b^(-(70/100 : ℝ)) := by rw [Real.rpow_neg hb0.le]; field_simp; ring |
| _ ≤ _ := mul_le_mul_of_nonneg_left (Real.rpow_le_rpow_of_exponent_le hb (by norm_num)) (by norm_num) |
|
|
|
|
|
|
|
|
| lemma eventually_grid_mass : ∀ᶠ b : ℕ in atTop, ∀ (p : ℕ) [NeZero p], 0 < p → |
| (b : ℝ)*logMean (height b)-4*(b : ℝ)^(56/100 : ℝ) ≤ Real.log p → |
| |gridMass (ι := Fin b) (height b) p Finset.univ-1| ≤ 7*(b : ℝ)^(-(1/20 : ℝ)) ∧ |
| |gridMass (height b) p (gridEligible (ι := Fin b) (height b) (logMean (height b)) |
| ((b : ℝ)^(56/100 : ℝ)) ((b : ℝ)^(70/100 : ℝ)) p)-1| ≤ 7*(b : ℝ)^(-(1/20 : ℝ)) := by |
| have hε : ∀ᶠ b : ℝ in atTop, b^(-(1/20 : ℝ)) ≤ 1/2 := |
| (tendsto_rpow_neg_atTop (by norm_num : (0 : ℝ) < 1/20)).eventually |
| (eventually_le_nhds (by norm_num : (0 : ℝ) < 1/2)) |
| filter_upwards [height_tendsto.eventually (eventually_ge_atTop (1 : ℝ)), |
| tendsto_natCast_atTop_atTop.eventually eventually_central_mean, |
| tendsto_natCast_atTop_atTop.eventually eventually_log_variance_tail, |
| tendsto_natCast_atTop_atTop.eventually eventually_rounding_slack, |
| tendsto_natCast_atTop_atTop.eventually hε, eventually_ge_atTop (2 : ℕ)] |
| with b hh hm hv hs he hb |
| intro p inst hp hlp |
| have hb0 : 0 < (b : ℝ) := by exact_mod_cast (show 0 < b by omega) |
| have hb1 : 1 ≤ (b : ℝ) := by exact_mod_cast (show 1 ≤ b by omega) |
| have hh0 : 0 < height b := by linarith |
| have hp0 : 0 < (p : ℝ) := by exact_mod_cast hp |
| let e := (b : ℝ)^(-(1/20 : ℝ)) |
| let c := (1/2 : ℝ)*(b : ℝ)^(56/100 : ℝ) |
| let r := (b : ℝ)^(70/100 : ℝ) |
| let E := gridEligible (ι := Fin b) (height b) (logMean (height b)) (2*c) r p |
| have he0 : 0 ≤ e := Real.rpow_nonneg hb0.le _ |
| have hc : 0 < c := mul_pos (by norm_num) (Real.rpow_pos_of_pos hb0 _) |
| have hslack := hs (p : ℝ) hp0 hlp |
| have hη : (b : ℝ)*height b^2*(p : ℝ)⁻¹ ≤ e := by simpa only [div_eq_mul_inv, height, heightR, e] using hslack.1 |
| have hηc : (b : ℝ)*height b^2*(p : ℝ)⁻¹ ≤ c := by simpa only [div_eq_mul_inv, height, heightR, c] using hslack.2.1 |
| have ha : 1-totalMass (height b)^b ≤ 2*e := by |
| apply (height_totalMass_power_loss hb).2.trans |
| exact mul_le_mul_of_nonneg_left (Real.rpow_le_rpow_of_exponent_le hb1 (by norm_num)) (by norm_num) |
| have hg : 1-3*e ≤ (cubeLaw (height b) : Measure (Fin b → ℝ)).real |
| (continuousGood (height b) c r) := by |
| have ht := continuous_good_mass (ι := Fin b) hh (by simpa using (show 0 < b by omega)) hc |
| (by simpa only [Fintype.card_fin, height, heightR, r] using hm) |
| have hct := numerical_count_tail hb1 hm |
| have ht' : 1-(b : ℝ)*((Real.log 2+height b^2/8)/2)^2/c^2 - |
| 4/((b : ℝ)*Real.exp (-(height b^2)/8)/(height b*Real.sqrt (2*Real.pi))) ≤ |
| (cubeLaw (height b) : Measure (Fin b → ℝ)).real (continuousGood (height b) c r) := by |
| simpa only [continuousGood, Fintype.card_fin] using ht |
| change (b : ℝ)*((Real.log 2+height b^2/8)/2)^2/c^2 ≤ e at hv |
| change 4/((b : ℝ)*Real.exp (-(height b^2)/8)/(height b*Real.sqrt (2*Real.pi))) ≤ 2*e at hct |
| linarith |
| have hout := grid_from_continuous (ι := Fin b) hh0 (show 0 ≤ 2*e by positivity) |
| (show 0 ≤ 3*e by positivity) p hp E (continuousGood (height b) c r) |
| (continuousGood_measurable hh0) |
| (fun t ht htc => round_into_eligible hh0 p hp |
| (by simpa only [Fintype.card_fin] using hηc) hslack.2.2 htc ht) |
| (by simpa only [Fintype.card_fin] using ha) hg |
| (by simpa only [Fintype.card_fin] using hη.trans he) |
| have htwo : 2*c = (b : ℝ)^(56/100 : ℝ) := by dsimp [c]; ring |
| simp only [Fintype.card_fin, E, htwo] at hout |
| exact ⟨hout.1.trans (by linarith), hout.2.trans (by linarith)⟩ |
| |
| |
| end SingleLatticeCovering.Folded |
| |
| |
| |
| |
| |
| noncomputable section |
| open scoped BigOperators |
| |
| namespace SingleLatticeCovering.Sampler |
| |
| universe u v |
| |
| section FiniteAverages |
| variable {α : Type u} {β : Type v} [Fintype α] [Fintype β] |
| |
| lemma expect_prod (f : α × β → ℝ) : |
| (𝔼 z, f z) = 𝔼 a, 𝔼 b, f (a, b) := by |
| simp only [Fintype.expect_eq_sum_div_card, Fintype.card_prod, Nat.cast_mul, |
| ← Finset.sum_div, Fintype.sum_prod_type, div_div] |
| rw [mul_comm] |
| |
| |
| def consEquiv (k : ℕ) (α : Type u) : (Fin (k + 1) → α) ≃ α × (Fin k → α) where |
| toFun w := (w 0, Fin.tail w) |
| invFun z := Fin.cons z.1 z.2 |
| left_inv w := Fin.cons_self_tail w |
| right_inv z := by simp |
| |
| lemma expect_cons (k : ℕ) (f : (Fin (k + 1) → α) → ℝ) : |
| (𝔼 w, f w) = 𝔼 a, 𝔼 w, f (Fin.cons a w) := by |
| calc |
| (𝔼 w, f w) = 𝔼 z : α × (Fin k → α), f (Fin.cons z.1 z.2) := |
| Fintype.expect_equiv (consEquiv k α) _ _ (fun w => by simp [consEquiv]) |
| _ = _ := expect_prod _ |
| |
| lemma expect_append (k j : ℕ) (f : (Fin (k+j) → α) → ℝ) : |
| (𝔼 w, f w) = 𝔼 u : Fin k → α, 𝔼 v : Fin j → α, f (Fin.append u v) := by |
| calc |
| (𝔼 w, f w) = 𝔼 z : (Fin k → α) × (Fin j → α), f (Fin.append z.1 z.2) := |
| (Fintype.expect_equiv (Fin.appendEquiv k j) _ _ (fun _ => rfl)).symm |
| _ = _ := expect_prod _ |
| |
| |
| lemma expect_mono {f g : α → ℝ} (h : ∀ a, f a ≤ g a) : |
| (𝔼 a, f a) ≤ 𝔼 a, g a := Finset.expect_le_expect (fun a _ => h a) |
| |
| lemma expect_nonneg {f : α → ℝ} (h : ∀ a, 0 ≤ f a) : 0 ≤ 𝔼 a, f a := |
| Finset.expect_nonneg (fun a _ => h a) |
| |
| end FiniteAverages |
| |
| section FiniteProbability |
| variable {α : Type u} {β : Type v} [Fintype α] [Fintype β] |
| |
| |
| def probability (p : α → Prop) : ℝ := by |
| classical |
| exact 𝔼 x, if p x then 1 else 0 |
| |
| lemma probability_nonneg (p : α → Prop) : 0 ≤ probability p := by |
| classical |
| exact expect_nonneg (fun _ => by split_ifs <;> norm_num) |
| |
| lemma probability_le_one [Nonempty α] (p : α → Prop) : probability p ≤ 1 := by |
| classical |
| exact Finset.expect_le Finset.univ_nonempty (fun _ _ => by split_ifs <;> norm_num) |
| |
| lemma probability_mono {p q : α → Prop} (h : ∀ x, p x → q x) : |
| probability p ≤ probability q := by |
| classical |
| apply expect_mono |
| intro x |
| by_cases hp : p x |
| · simp [hp, h x hp] |
| · by_cases hq : q x <;> simp [hp, hq] |
| |
| lemma probability_union_le (p q : α → Prop) : |
| probability (fun x => p x ∨ q x) ≤ probability p + probability q := by |
| classical |
| unfold probability |
| rw [← Finset.expect_add_distrib] |
| apply expect_mono |
| intro x |
| by_cases hp : p x <;> by_cases hq : q x <;> simp [hp, hq] |
| |
| lemma probability_false : probability (fun _ : α => False) = 0 := by |
| simp [probability] |
| |
| lemma probability_true [Nonempty α] : probability (fun _ : α => True) = 1 := by |
| simp [probability] |
| |
| lemma probability_compl [Nonempty α] (p : α → Prop) : |
| probability (fun x => ¬ p x) = 1 - probability p := by |
| classical |
| unfold probability |
| rw [← Fintype.expect_const (ι := α) (1 : ℝ), ← Finset.expect_sub_distrib] |
| apply Finset.expect_congr rfl |
| intro x _ |
| by_cases h : p x <;> simp [h] |
| |
| lemma probability_prod (p : α × β → Prop) : |
| probability p = 𝔼 a, probability (fun b => p (a,b)) := expect_prod _ |
| |
| lemma probability_fst [Nonempty β] (p : α → Prop) : |
| probability (fun x : α × β => p x.1) = probability p := by |
| rw [probability_prod] |
| classical |
| unfold probability |
| apply Finset.expect_congr rfl |
| intro x _ |
| by_cases h : p x <;> simp [h] |
| |
| lemma probability_cons (k : ℕ) (p : (Fin (k+1) → α) → Prop) : |
| probability p = 𝔼 a, probability (fun w : Fin k → α => p (Fin.cons a w)) := by |
| classical |
| exact expect_cons k _ |
| |
| lemma probability_cons_tail (k : ℕ) (p : (Fin (k+1) → α) → Prop) : |
| probability p = 𝔼 w : Fin k → α, probability (fun a => p (Fin.cons a w)) := by |
| classical |
| rw [probability_cons] |
| unfold probability |
| rw [Finset.expect_comm] |
| |
| lemma probability_append (k j : ℕ) (p : (Fin (k+j) → α) → Prop) : |
| probability p = probability (fun z : (Fin k → α) × (Fin j → α) => p (Fin.append z.1 z.2)) := by |
| classical |
| unfold probability |
| exact (Fintype.expect_equiv (Fin.appendEquiv k j) _ _ (fun _ => rfl)).symm |
| |
| |
| lemma probability_snd [Nonempty α] (p : β → Prop) : |
| probability (fun x : α × β => p x.2) = probability p := by |
| rw [probability_prod] |
| exact Fintype.expect_const (ι := α) (probability p) |
| |
| |
| lemma probability_gt_le {f : α → ℝ} (hf : ∀ x, 0 ≤ f x) {t : ℝ} (ht : 0 < t) : |
| probability (fun x => t < f x) ≤ (𝔼 x, f x) / t := by |
| classical |
| rw [le_div_iff₀ ht] |
| unfold probability |
| rw [Finset.expect_mul] |
| apply expect_mono |
| intro x |
| by_cases h : t < f x |
| · simpa [h] using h.le |
| · simpa [h] using hf x |
| |
| lemma probability_le_of_pointwise [Nonempty α] {p : α → Prop} [DecidablePred p] {f : α → ℝ} {a : ℝ} |
| (h : ∀ x, (if p x then (1 : ℝ) else 0) ≤ f x) (hf : (𝔼 x, f x) ≤ a) : |
| probability p ≤ a := by |
| classical |
| unfold probability |
| apply (expect_mono (g := f) ?_).trans hf |
| intro x |
| by_cases hp : p x <;> simpa [hp] using h x |
| |
| end FiniteProbability |
| |
| section GroupAverages |
| variable {G : Type u} [AddCommGroup G] [Fintype G] |
| |
| lemma expect_sub_right (f : G → ℝ) (a : G) : |
| (𝔼 x, f (x - a)) = 𝔼 x, f x := |
| Fintype.expect_equiv (Equiv.subRight a) _ _ (fun _ => rfl) |
| |
| lemma expect_sub_left (f : G → ℝ) (a : G) : |
| (𝔼 x, f (a - x)) = 𝔼 x, f x := |
| Fintype.expect_equiv (Equiv.subLeft a) _ _ (fun _ => rfl) |
| |
| lemma expect_correlation (f g : G → ℝ) : |
| (𝔼 w, 𝔼 x, f x * g (x - w)) = (𝔼 x, f x) * 𝔼 x, g x := by |
| rw [Finset.expect_comm] |
| simp_rw [← Finset.mul_expect, expect_sub_left, ← Finset.expect_mul] |
| |
| |
| def step (w : G) (f : G → ℝ) (x : G) : ℝ := (f x + f (x - w)) / 2 |
| |
| lemma step_nonneg {G : Type u} [AddCommGroup G] [Fintype G] (w : G) {f : G → ℝ} (hf : ∀ x, 0 ≤ f x) (x : G) : |
| 0 ≤ step w f x := by exact div_nonneg (add_nonneg (hf x) (hf _)) (by norm_num) |
| |
| lemma step_mean (w : G) (f : G → ℝ) : (𝔼 x, step w f x) = 𝔼 x, f x := by |
| simp only [step, ← Finset.expect_div, Finset.expect_add_distrib, expect_sub_right] |
| ring |
| |
| |
| |
| lemma step_second_moment (f : G → ℝ) : |
| (𝔼 w, 𝔼 x, (step w f x) ^ 2) = |
| ((𝔼 x, (f x) ^ 2) + (𝔼 x, f x) ^ 2) / 2 := by |
| have h (w x : G) : (step w f x) ^ 2 = |
| ((f x) ^ 2 + (f (x-w)) ^ 2 + 2 * (f x * f (x-w))) / 4 := by |
| unfold step |
| ring |
| have hs (w : G) : (𝔼 x, (f (x-w))^2) = 𝔼 x, (f x)^2 := |
| expect_sub_right (fun x => (f x)^2) w |
| simp_rw [h, ← Finset.expect_div, Finset.expect_add_distrib, |
| ← Finset.mul_expect, hs, Fintype.expect_const] |
| rw [expect_correlation] |
| ring |
| |
| |
| def binaryAverage : {k : ℕ} → (Fin k → G) → (G → ℝ) → G → ℝ |
| | 0, _, f => f |
| | _ + 1, w, f => step (w 0) (binaryAverage (Fin.tail w) f) |
| |
| @[simp] lemma binaryAverage_zero {G : Type u} [AddCommGroup G] [Fintype G] (w : Fin 0 → G) (f : G → ℝ) : |
| binaryAverage w f = f := rfl |
| |
| @[simp] lemma binaryAverage_cons {G : Type u} [AddCommGroup G] [Fintype G] {k : ℕ} (a : G) (w : Fin k → G) (f : G → ℝ) : |
| binaryAverage (Fin.cons a w) f = step a (binaryAverage w f) := rfl |
| |
| lemma binaryAverage_mean {k : ℕ} (w : Fin k → G) (f : G → ℝ) : |
| (𝔼 x, binaryAverage w f x) = 𝔼 x, f x := by |
| induction k with |
| | zero => rfl |
| | succ k ih => |
| change (𝔼 x, step (w 0) (binaryAverage (Fin.tail w) f) x) = _ |
| rw [step_mean, ih] |
| |
| lemma binaryAverage_nonneg {k : ℕ} (w : Fin k → G) {f : G → ℝ} |
| (hf : ∀ x, 0 ≤ f x) (x : G) : 0 ≤ binaryAverage w f x := by |
| induction k generalizing x with |
| | zero => exact hf x |
| | succ k ih => exact step_nonneg _ (fun x => ih (Fin.tail w) x) x |
| |
| lemma binaryAverage_sub_const {G : Type u} [AddCommGroup G] [Fintype G] {k : ℕ} (w : Fin k → G) (f : G → ℝ) (c : ℝ) (x : G) : |
| binaryAverage w (fun y => f y - c) x = binaryAverage w f x - c := by |
| induction k generalizing x with |
| | zero => rfl |
| | succ k ih => |
| change ((binaryAverage (Fin.tail w) (fun y => f y-c) x + |
| binaryAverage (Fin.tail w) (fun y => f y-c) (x-w 0)) / 2) = _ |
| rw [ih, ih] |
| change _ = (binaryAverage (Fin.tail w) f x + binaryAverage (Fin.tail w) f (x-w 0)) / 2-c |
| ring |
| |
| |
| |
| lemma binaryAverage_centered_second_moment (k : ℕ) (f : G → ℝ) |
| (hf : (𝔼 x, f x) = 0) : |
| (𝔼 w : Fin k → G, 𝔼 x, (binaryAverage w f x)^2) = |
| (𝔼 x, (f x)^2) / (2 : ℝ)^k := by |
| induction k with |
| | zero => simp |
| | succ k ih => |
| rw [expect_cons, Finset.expect_comm] |
| simp_rw [binaryAverage_cons, step_second_moment, binaryAverage_mean, hf, |
| zero_pow (by decide : 2 ≠ 0), add_zero, ← Finset.expect_div] |
| rw [ih, pow_succ] |
| ring |
| |
| lemma binaryAverage_variance (k : ℕ) (f : G → ℝ) : |
| (𝔼 w : Fin k → G, 𝔼 x, (binaryAverage w f x - (𝔼 y, f y))^2) = |
| (𝔼 x, (f x - (𝔼 y, f y))^2) / (2 : ℝ)^k := by |
| simpa only [binaryAverage_sub_const] using |
| binaryAverage_centered_second_moment k (fun x => f x - (𝔼 y, f y)) (by |
| rw [Finset.expect_sub_distrib, Fintype.expect_const, sub_self]) |
| |
| |
| lemma variance_eq (f : G → ℝ) : |
| (𝔼 x, (f x - (𝔼 y, f y))^2) = (𝔼 x, (f x)^2) - (𝔼 x, f x)^2 := by |
| have h (x : G) : (f x - (𝔼 y, f y))^2 = |
| (f x)^2 - 2 * (𝔼 y, f y) * f x + (𝔼 y, f y)^2 := by ring |
| simp_rw [h, Finset.expect_add_distrib, Finset.expect_sub_distrib, |
| ← Finset.mul_expect, Fintype.expect_const] |
| ring |
| |
| lemma lower_tail_le_variance {G : Type u} [AddCommGroup G] [Fintype G] (f : G → ℝ) {δ : ℝ} (hδ : 0 < δ) |
| (hμ : 0 < 𝔼 x, f x) : |
| probability (fun x => f x < (1-δ) * (𝔼 y, f y)) ≤ |
| (𝔼 x, (f x - (𝔼 y, f y))^2) / (δ * (𝔼 x, f x))^2 := by |
| have ht : 0 < δ * (𝔼 y, f y) := mul_pos hδ hμ |
| apply (probability_mono (q := fun x => (δ*(𝔼 y, f y))^2 < |
| (f x - (𝔼 y, f y))^2) ?_).trans |
| (probability_gt_le (fun x => sq_nonneg _) (sq_pos_of_pos ht)) |
| intro x hx |
| nlinarith |
| |
| |
| lemma expected_bad_fraction_le (k : ℕ) (f : G → ℝ) {δ : ℝ} (hδ : 0 < δ) |
| (hμ : 0 < 𝔼 x, f x) : |
| (𝔼 w : Fin k → G, |
| probability (fun x => binaryAverage w f x < (1-δ) * (𝔼 y, f y))) ≤ |
| (𝔼 x, (f x - (𝔼 y, f y))^2) / ((2 : ℝ)^k * (δ * (𝔼 x, f x))^2) := by |
| have h (w : Fin k → G) := lower_tail_le_variance (binaryAverage w f) hδ |
| (by simpa only [binaryAverage_mean] using hμ) |
| simp only [binaryAverage_mean] at h |
| have he := expect_mono h |
| rw [← Finset.expect_div, binaryAverage_variance, div_div] at he |
| exact he |
| |
| |
| def subsetShift {k : ℕ} (w : Fin k → G) (e : Fin k → Bool) : G := |
| ∑ i, if e i then w i else 0 |
| |
| lemma subsetShift_cons {G : Type u} [AddCommGroup G] [Fintype G] {k : ℕ} (w : Fin (k+1) → G) (b : Bool) (e : Fin k → Bool) : |
| subsetShift w (Fin.cons b e) = (if b then w 0 else 0) + subsetShift (Fin.tail w) e := by |
| simp [subsetShift, Fin.sum_univ_succ, Fin.tail] |
| |
| lemma subsetShift_append {G : Type u} [AddCommGroup G] [Fintype G] {k j : ℕ} (u : Fin k → G) (v : Fin j → G) |
| (a : Fin k → Bool) (b : Fin j → Bool) : |
| subsetShift (Fin.append u v) (Fin.append a b) = subsetShift u a + subsetShift v b := by |
| simp [subsetShift, Fin.sum_univ_add] |
| |
| |
| lemma expect_bool (f : Bool → ℝ) : (𝔼 b, f b) = (f false + f true)/2 := by |
| rw [Fintype.expect_eq_sum_div_card, Fintype.sum_bool] |
| simp [add_comm] |
| |
| |
| |
| lemma binaryAverage_eq_expect {k : ℕ} (w : Fin k → G) (f : G → ℝ) (x : G) : |
| binaryAverage w f x = 𝔼 e : Fin k → Bool, f (x-subsetShift w e) := by |
| induction k generalizing x with |
| | zero => simp [subsetShift] |
| | succ k ih => |
| rw [expect_cons, expect_bool] |
| simp only [subsetShift_cons, Bool.false_eq_true, ↓reduceIte, zero_add, |
| sub_add_eq_sub_sub] |
| rw [← ih (Fin.tail w) x, ← ih (Fin.tail w) (x-w 0)] |
| rfl |
| |
| lemma binaryAverage_eq_sum {k : ℕ} (w : Fin k → G) (f : G → ℝ) (x : G) : |
| binaryAverage w f x = (∑ e : Fin k → Bool, f (x-subsetShift w e)) / (2 : ℝ)^k := by |
| rw [binaryAverage_eq_expect, Fintype.expect_eq_sum_div_card] |
| simp |
| |
| |
| |
| lemma binaryAverage_append {k j : ℕ} (u : Fin k → G) (v : Fin j → G) (f : G → ℝ) (x : G) : |
| binaryAverage (Fin.append u v) f x = binaryAverage v (binaryAverage u f) x := by |
| rw [binaryAverage_eq_expect, expect_append, Finset.expect_comm] |
| simp_rw [subsetShift_append, binaryAverage_eq_expect] |
| apply Finset.expect_congr rfl |
| intro b _ |
| apply Finset.expect_congr rfl |
| intro a _ |
| congr 1 |
| abel |
| |
| |
| lemma binaryAverage_mono {G : Type u} [AddCommGroup G] [Fintype G] {k : ℕ} (w : Fin k → G) {f g : G → ℝ} |
| (h : ∀ x, f x ≤ g x) (x : G) : binaryAverage w f x ≤ binaryAverage w g x := by |
| induction k generalizing x with |
| | zero => exact h x |
| | succ k ih => |
| change (binaryAverage (Fin.tail w) f x + binaryAverage (Fin.tail w) f (x-w 0))/2 ≤ |
| (binaryAverage (Fin.tail w) g x + binaryAverage (Fin.tail w) g (x-w 0))/2 |
| exact div_le_div_of_nonneg_right (add_le_add (ih _ x) (ih _ (x-w 0))) (by norm_num) |
| |
| lemma binaryAverage_mul_const {G : Type u} [AddCommGroup G] [Fintype G] {k : ℕ} (w : Fin k → G) (f : G → ℝ) (c : ℝ) (x : G) : |
| binaryAverage w (fun y => c * f y) x = c * binaryAverage w f x := by |
| induction k generalizing x with |
| | zero => rfl |
| | succ k ih => |
| change (binaryAverage (Fin.tail w) (fun y => c*f y) x + |
| binaryAverage (Fin.tail w) (fun y => c*f y) (x-w 0))/2 = _ |
| rw [ih, ih] |
| change _ = c * ((binaryAverage (Fin.tail w) f x + binaryAverage (Fin.tail w) f (x-w 0))/2) |
| ring |
| |
| |
| |
| def binarySum {k : ℕ} (w : Fin k → G) (f : G → ℝ) (x : G) : ℝ := |
| (2 : ℝ)^k * binaryAverage w f x |
| |
| @[simp] lemma binarySum_zero {G : Type u} [AddCommGroup G] [Fintype G] (w : Fin 0 → G) (f : G → ℝ) (x : G) : |
| binarySum w f x = f x := by simp [binarySum] |
| |
| @[simp] lemma binarySum_cons {G : Type u} [AddCommGroup G] [Fintype G] {k : ℕ} (a : G) (w : Fin k → G) (f : G → ℝ) (x : G) : |
| binarySum (Fin.cons a w) f x = binarySum w f x + binarySum w f (x-a) := by |
| simp only [binarySum, binaryAverage_cons, step, pow_succ] |
| ring |
| |
| |
| def potential (θ : ℝ) (f : G → ℝ) : ℝ := 𝔼 x, Real.exp (-θ * f x) |
| |
| lemma potential_pos (θ : ℝ) (f : G → ℝ) : 0 < potential θ f := |
| Finset.expect_pos (fun _ _ => Real.exp_pos _) Finset.univ_nonempty |
| |
| |
| lemma potential_square (θ : ℝ) (f : G → ℝ) : |
| (𝔼 w, potential θ (fun x => f x + f (x-w))) = (potential θ f)^2 := by |
| unfold potential |
| simp_rw [mul_add, Real.exp_add] |
| rw [expect_correlation (fun x => Real.exp (-θ * f x)) (fun x => Real.exp (-θ * f x)), pow_two] |
| |
| lemma potential_step_failure (θ ε : ℝ) (f : G → ℝ) : |
| probability (fun w => Real.exp ε * (potential θ f)^2 < |
| potential θ (fun x => f x + f (x-w))) ≤ Real.exp (-ε) := by |
| have hp := potential_pos θ f |
| have ht : 0 < Real.exp ε * (potential θ f)^2 := mul_pos (Real.exp_pos _) (sq_pos_of_pos hp) |
| have h := probability_gt_le |
| (fun w => (potential_pos θ (fun x => f x + f (x-w))).le) ht |
| rw [potential_square] at h |
| convert h using 1 |
| rw [Real.exp_neg] |
| field_simp |
| |
| |
| |
| lemma potential_iteration_failure (θ ε a : ℝ) (f : G → ℝ) |
| (h₀ : potential θ f ≤ Real.exp a) (k : ℕ) : |
| probability (fun w : Fin k → G => |
| Real.exp ((2 : ℝ)^k * a + ((2 : ℝ)^k - 1) * ε) < |
| potential θ (binarySum w f)) ≤ (k : ℝ) * Real.exp (-ε) := by |
| induction k with |
| | zero => |
| have h : (fun w : Fin 0 → G => |
| Real.exp ((2 : ℝ)^0 * a + ((2 : ℝ)^0 - 1)*ε) < |
| potential θ (binarySum w f)) = (fun _ => False) := by |
| funext w |
| simp only [pow_zero, one_mul, sub_self, zero_mul, add_zero] |
| simp only [show binarySum w f = f by funext x; simp] |
| exact propext (iff_false_intro (not_lt_of_ge h₀)) |
| rw [h, probability_false] |
| simp |
| | succ k ih => |
| let T : ℝ := Real.exp ((2 : ℝ)^k * a + ((2 : ℝ)^k-1)*ε) |
| have hT : 0 < T := Real.exp_pos _ |
| have hnext : Real.exp ((2 : ℝ)^(k+1)*a + ((2 : ℝ)^(k+1)-1)*ε) = |
| Real.exp ε * T^2 := by |
| dsimp [T] |
| rw [← Real.exp_nat_mul, ← Real.exp_add] |
| congr 1 |
| rw [pow_succ] |
| ring |
| rw [probability_cons_tail] |
| have hcond (w : Fin k → G) : |
| probability (fun z => |
| Real.exp ((2 : ℝ)^(k+1)*a+((2 : ℝ)^(k+1)-1)*ε) < |
| potential θ (binarySum (Fin.cons z w) f)) ≤ |
| (if T < potential θ (binarySum w f) then 1 else 0) + Real.exp (-ε) := by |
| by_cases hw : T < potential θ (binarySum w f) |
| · simp only [hw, ↓reduceIte] |
| exact (probability_le_one _).trans (by linarith [Real.exp_pos (-ε)]) |
| · have hle : potential θ (binarySum w f) ≤ T := le_of_not_gt hw |
| simp only [hw, ↓reduceIte, zero_add] |
| apply (probability_mono (q := fun z => Real.exp ε * (potential θ (binarySum w f))^2 < |
| potential θ (fun x => binarySum w f x + binarySum w f (x-z))) ?_).trans |
| (potential_step_failure θ ε (binarySum w f)) |
| intro z hz |
| rw [hnext] at hz |
| have hs : (potential θ (binarySum w f))^2 ≤ T^2 := |
| pow_le_pow_left₀ (potential_pos θ _).le hle 2 |
| have hb : binarySum (Fin.cons z w) f = |
| fun x => binarySum w f x + binarySum w f (x-z) := by |
| funext x |
| exact binarySum_cons z w f x |
| rw [hb] at hz |
| exact lt_of_le_of_lt (mul_le_mul_of_nonneg_left hs (Real.exp_pos _).le) hz |
| have he := expect_mono hcond |
| rw [Finset.expect_add_distrib, Fintype.expect_const] at he |
| change _ ≤ probability (fun w : Fin k → G => T < potential θ (binarySum w f)) + |
| Real.exp (-ε) at he |
| dsimp [T] at he |
| push_cast |
| linarith |
| |
| |
| lemma exp_le_card_mul_potential (θ : ℝ) (f : G → ℝ) (x : G) : |
| Real.exp (-θ * f x) ≤ (Fintype.card G : ℝ) * potential θ f := by |
| classical |
| rw [potential, Fintype.expect_eq_sum_div_card] |
| have hc : (Fintype.card G : ℝ) ≠ 0 := by positivity |
| rw [mul_div_cancel₀ _ hc] |
| exact Finset.single_le_sum (f := fun y => Real.exp (-θ*f y)) |
| (fun y _ => (Real.exp_pos _).le) (Finset.mem_univ x) |
| |
| lemma potential_bound_pointwise (θ a : ℝ) (f : G → ℝ) |
| (h : potential θ f ≤ Real.exp a) (x : G) : |
| -θ * f x ≤ Real.log (Fintype.card G) + a := by |
| have hc : (0 : ℝ) < Fintype.card G := by positivity |
| have he := (exp_le_card_mul_potential θ f x).trans (mul_le_mul_of_nonneg_left h hc.le) |
| have heq : (Fintype.card G : ℝ) * Real.exp a = |
| Real.exp (Real.log (Fintype.card G) + a) := by rw [Real.exp_add, Real.exp_log hc] |
| rw [heq] at he |
| exact Real.exp_le_exp.mp he |
| |
| lemma potential_bound_binaryAverage {k : ℕ} (w : Fin k → G) (f : G → ℝ) |
| {θ δ : ℝ} (hθ : 0 < θ) (hδ : 0 ≤ δ) |
| (h : potential θ (binarySum w f) ≤ |
| Real.exp ((2 : ℝ)^k * (-θ+1) + ((2 : ℝ)^k-1)*(θ*δ))) (x : G) : |
| 1-δ-1/θ-Real.log (Fintype.card G)/(θ*(2 : ℝ)^k) ≤ binaryAverage w f x := by |
| have hh := potential_bound_pointwise θ _ _ h x |
| unfold binarySum at hh |
| have hp : (0 : ℝ) < 2^k := by positivity |
| have he : θ*(2 : ℝ)^k*(1-δ-1/θ-Real.log (Fintype.card G)/(θ*(2 : ℝ)^k)) = |
| θ*(2 : ℝ)^k-θ*(2 : ℝ)^k*δ-(2 : ℝ)^k-Real.log (Fintype.card G) := by |
| field_simp |
| |
| apply le_of_mul_le_mul_left (a := θ*(2 : ℝ)^k) _ (mul_pos hθ hp) |
| rw [he] |
| nlinarith [mul_nonneg hθ.le hδ] |
| |
| |
| |
| lemma indicator_initial_potential {p : G → Prop} [DecidablePred p] {θ : ℝ} |
| (hθ : 0 ≤ θ) (hp : probability (fun x => ¬p x) ≤ Real.exp (-2*θ)) : |
| potential θ (fun x => if p x then 1 else 0) ≤ Real.exp (-θ+1) := by |
| classical |
| have hi (x : G) : Real.exp (-θ*(if p x then 1 else 0)) = |
| (if ¬p x then 1 else 0) + (if p x then 1 else 0) * Real.exp (-θ) := by |
| by_cases h : p x <;> simp [h] |
| have he : potential θ (fun x => if p x then 1 else 0) = |
| probability (fun x => ¬p x) + probability p * Real.exp (-θ) := by |
| unfold potential probability |
| simp_rw [hi, Finset.expect_add_distrib, ← Finset.expect_mul] |
| congr 1 |
| · apply Finset.expect_congr rfl |
| intro x _ |
| by_cases h : p x <;> simp [h] |
| · congr 1 |
| apply Finset.expect_congr rfl |
| intro x _ |
| by_cases h : p x <;> simp [h] |
| rw [he] |
| calc |
| probability (fun x => ¬p x) + probability p * Real.exp (-θ) ≤ |
| Real.exp (-2*θ) + Real.exp (-θ) := |
| add_le_add hp (by nlinarith [probability_le_one p, Real.exp_pos (-θ)]) |
| _ ≤ 2 * Real.exp (-θ) := by |
| have : Real.exp (-2*θ) ≤ Real.exp (-θ) := Real.exp_le_exp.mpr (by linarith) |
| linarith |
| _ ≤ Real.exp 1 * Real.exp (-θ) := by |
| have htwo : (2 : ℝ) ≤ Real.exp 1 := by linarith [Real.add_one_le_exp (1 : ℝ)] |
| exact mul_le_mul_of_nonneg_right htwo (Real.exp_pos _).le |
| _ = _ := by rw [← Real.exp_add]; congr 1; ring |
| |
| |
| lemma second_stage_failure {p : G → Prop} [DecidablePred p] {θ δ : ℝ} |
| (hθ : 0 < θ) (hδ : 0 ≤ δ) |
| (hp : probability (fun x => ¬p x) ≤ Real.exp (-2*θ)) (k : ℕ) : |
| probability (fun w : Fin k → G => ∃ x, |
| binaryAverage w (fun y => if p y then 1 else 0) x < |
| 1-δ-1/θ-Real.log (Fintype.card G)/(θ*(2 : ℝ)^k)) ≤ |
| (k : ℝ) * Real.exp (-(θ*δ)) := by |
| apply (probability_mono (q := fun w : Fin k → G => |
| Real.exp ((2 : ℝ)^k*(-θ+1)+((2 : ℝ)^k-1)*(θ*δ)) < |
| potential θ (binarySum w (fun y => if p y then 1 else 0))) ?_).trans |
| (potential_iteration_failure θ (θ*δ) (-θ+1) _ (indicator_initial_potential hθ.le hp) k) |
| intro w hw |
| by_contra h |
| obtain ⟨x, hx⟩ := hw |
| exact not_lt_of_ge (potential_bound_binaryAverage w _ hθ hδ (le_of_not_gt h) x) hx |
| |
| |
| |
| lemma two_stage_failure (f : G → ℝ) (hf : ∀ x, 0 ≤ f x) {δ θ : ℝ} |
| (hδ : 0 < δ) (hδ₁ : δ < 1) (hθ : 0 < θ) (hμ : 0 < 𝔼 x, f x) (k j : ℕ) : |
| probability (fun z : (Fin k → G) × (Fin j → G) => ∃ x, |
| binaryAverage z.2 (binaryAverage z.1 f) x < |
| (1-δ)*(𝔼 y, f y)*(1-δ-1/θ-Real.log (Fintype.card G)/(θ*(2 : ℝ)^j))) ≤ |
| ((𝔼 x, (f x-(𝔼 y, f y))^2) / |
| ((2 : ℝ)^k*(δ*(𝔼 y, f y))^2)) / Real.exp (-2*θ) + |
| (j : ℝ)*Real.exp (-(θ*δ)) := by |
| classical |
| let μ : ℝ := 𝔼 x, f x |
| let β (u : Fin k → G) : ℝ := probability (fun x => binaryAverage u f x < (1-δ)*μ) |
| let L : ℝ := 1-δ-1/θ-Real.log (Fintype.card G)/(θ*(2 : ℝ)^j) |
| have ht : 0 < (1-δ)*μ := mul_pos (sub_pos.mpr hδ₁) hμ |
| have hfirst : probability (fun u => Real.exp (-2*θ) < β u) ≤ |
| ((𝔼 x, (f x-μ)^2) / ((2 : ℝ)^k*(δ*μ)^2)) / Real.exp (-2*θ) := by |
| have hb := probability_gt_le (f := β) (fun u => probability_nonneg _) (Real.exp_pos (-2*θ)) |
| have hc := expected_bad_fraction_le k f hδ hμ |
| exact hb.trans (div_le_div_of_nonneg_right hc (Real.exp_pos _).le) |
| rw [probability_prod] |
| have hcond (u : Fin k → G) : |
| probability (fun v : Fin j → G => ∃ x, binaryAverage v (binaryAverage u f) x < |
| (1-δ)*μ*L) ≤ |
| (if Real.exp (-2*θ) < β u then 1 else 0) + (j : ℝ)*Real.exp (-(θ*δ)) := by |
| by_cases hu : Real.exp (-2*θ) < β u |
| · simp only [hu, ↓reduceIte] |
| exact (probability_le_one _).trans (by |
| have : 0 ≤ (j : ℝ)*Real.exp (-(θ*δ)) := by positivity |
| linarith) |
| · simp only [hu, ↓reduceIte, zero_add] |
| let p : G → Prop := fun x => (1-δ)*μ ≤ binaryAverage u f x |
| have hp : probability (fun x => ¬p x) ≤ Real.exp (-2*θ) := by |
| simpa only [p, not_le] using (le_of_not_gt hu) |
| have hpoint (x : G) : (1-δ)*μ*(if p x then 1 else 0) ≤ binaryAverage u f x := by |
| by_cases hx : p x |
| · rw [ite_eq_left hx, mul_one] |
| exact hx |
| · simpa [hx] using binaryAverage_nonneg u hf x |
| have hsample (v : Fin j → G) (x : G) : |
| (1-δ)*μ*binaryAverage v (fun y => if p y then 1 else 0) x ≤ |
| binaryAverage v (binaryAverage u f) x := by |
| simpa only [binaryAverage_mul_const] using binaryAverage_mono v hpoint x |
| apply (probability_mono (q := fun v : Fin j → G => ∃ x, |
| binaryAverage v (fun y => if p y then 1 else 0) x < L) ?_).trans |
| (second_stage_failure hθ hδ.le hp j) |
| rintro v ⟨x, hx⟩ |
| refine ⟨x, ?_⟩ |
| by_contra hn |
| have hh := mul_le_mul_of_nonneg_left (le_of_not_gt hn) ht.le |
| exact not_lt_of_ge (hh.trans (hsample v x)) hx |
| have he := expect_mono hcond |
| rw [Finset.expect_add_distrib, Fintype.expect_const] at he |
| have hs : (𝔼 u : Fin k → G, if Real.exp (-2*θ) < β u then (1 : ℝ) else 0) = |
| probability (fun u => Real.exp (-2*θ) < β u) := by |
| unfold probability |
| apply Finset.expect_congr rfl |
| intro u _ |
| by_cases hu : Real.exp (-2*θ) < β u <;> simp |
| rw [hs] at he |
| exact he.trans (add_le_add hfirst le_rfl) |
| |
| |
| |
| lemma two_stage_failure_three_delta (f : G → ℝ) (hf : ∀ x, 0 ≤ f x) {δ θ : ℝ} |
| (hδ : 0 < δ) (hδ₁ : δ < 1) (hθ : 0 < θ) (hμ : 0 < 𝔼 x, f x) (k j : ℕ) |
| (hsmall : 1/θ+Real.log (Fintype.card G)/(θ*(2 : ℝ)^j) ≤ δ) : |
| probability (fun z : (Fin k → G) × (Fin j → G) => ∃ x, |
| binaryAverage z.2 (binaryAverage z.1 f) x < (1-3*δ)*(𝔼 y, f y)) ≤ |
| ((𝔼 x, (f x-(𝔼 y, f y))^2) / |
| ((2 : ℝ)^k*(δ*(𝔼 y, f y))^2)) / Real.exp (-2*θ) + |
| (j : ℝ)*Real.exp (-(θ*δ)) := by |
| have ht : 0 ≤ (1-δ)*(𝔼 y, f y) := mul_nonneg (by linarith) hμ.le |
| have hl : (1-3*δ)*(𝔼 y, f y) ≤ |
| (1-δ)*(𝔼 y, f y)*(1-δ-1/θ-Real.log (Fintype.card G)/(θ*(2 : ℝ)^j)) := by |
| calc |
| _ ≤ (1-δ)*(𝔼 y, f y)*(1-2*δ) := by |
| nlinarith [mul_nonneg (sq_nonneg δ) hμ.le] |
| _ ≤ _ := mul_le_mul_of_nonneg_left (by linarith) ht |
| exact (probability_mono (fun z hz => by |
| obtain ⟨x, hx⟩ := hz |
| exact ⟨x, hx.trans_le hl⟩)).trans (two_stage_failure f hf hδ hδ₁ hθ hμ k j) |
| |
| |
| lemma sampler_explicit_parameters (f : G → ℝ) (hf : ∀ x, 0 ≤ f x) {δ θ : ℝ} |
| (hδ : 0 < δ) (hδ₁ : δ < 1) (hθ : 0 < θ) (hμ : 0 < 𝔼 x, f x) (k j : ℕ) |
| (hsmall : 1/θ+Real.log (Fintype.card G)/(θ*(2 : ℝ)^j) ≤ δ) : |
| probability (fun w : Fin (k+j) → G => ∃ x, |
| (∑ e : Fin (k+j) → Bool, f (x-subsetShift w e)) / (2 : ℝ)^(k+j) < |
| (1-3*δ)*(𝔼 y, f y)) ≤ |
| ((𝔼 x, (f x-(𝔼 y, f y))^2) / |
| ((2 : ℝ)^k*(δ*(𝔼 y, f y))^2)) / Real.exp (-2*θ) + |
| (j : ℝ)*Real.exp (-(θ*δ)) := by |
| simp_rw [← binaryAverage_eq_sum] |
| rw [probability_append] |
| simp_rw [binaryAverage_append] |
| exact two_stage_failure_three_delta f hf hδ hδ₁ hθ hμ k j hsmall |
| |
| end GroupAverages |
| end SingleLatticeCovering.Sampler |
| |
| |
| |
| |
| noncomputable section |
| open Filter Topology Asymptotics |
| |
| |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| |
| end OAI |
| |
