| import OAI.Geometry.LatticeCovering.SamplingBounds |
|
|
| 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 |
| noncomputable section |
| open scoped BigOperators |
| noncomputable section |
| open Filter Topology Asymptotics |
| noncomputable section |
| open scoped BigOperators |
| open Classical |
|
|
| namespace SingleLatticeCovering.Bits |
| universe u v w |
| variable {I : Type u} {J : Type v} {G : Type w} [Fintype I] [Fintype J] |
| [AddCommGroup G] [Fintype G] |
|
|
|
|
| def groupShift (w : I → G) (e : I → Bool) : G := ∑ i, if e i then w i else 0 |
|
|
| def fairAverage (w : I → G) (f : G → ℝ) (x : G) : ℝ := |
| (∑ e, f (x-groupShift w e))/(2 : ℝ)^(Fintype.card I) |
|
|
| def biasedAverage (q : I → ℝ) (w : I → G) (f : G → ℝ) (x : G) : ℝ := |
| integral q (fun e => f (x-groupShift w e)) |
|
|
| lemma groupShift_reindex {I : Type u} {J : Type v} {G : Type w} [Fintype I] [Fintype J] [AddCommGroup G] [Fintype G] (E : I ≃ J) (w : J → G) (e : J → Bool) : |
| groupShift (fun i => w (E i)) (fun i => e (E i)) = groupShift w e := |
| Fintype.sum_equiv E _ _ (fun _ => rfl) |
|
|
| lemma fairAverage_reindex {I : Type u} {J : Type v} {G : Type w} [Fintype I] [Fintype J] [AddCommGroup G] [Fintype G] (E : I ≃ J) (w : J → G) (f : G → ℝ) (x : G) : |
| fairAverage (fun i => w (E i)) f x = fairAverage w f x := by |
| classical |
| unfold fairAverage |
| rw [Fintype.card_congr E] |
| congr 1 |
| let D := Equiv.piCongrLeft (fun _ : J => Bool) E |
| apply Fintype.sum_equiv D |
| intro e |
| congr 2 |
| unfold groupShift |
| apply Fintype.sum_equiv E |
| intro i |
| simp [D] |
|
|
| lemma filled_groupShift {I : Type u} {G : Type w} [Fintype I] [AddCommGroup G] [Fintype G] (q : I → ℝ) (s : I → Bool) (a : Selected s → Bool) (w : I → G) : |
| groupShift w (filled q s a) = |
| groupShift (fun j : Selected s => w j) a + |
| ∑ j : Frozen s, if likelyBit (q j) then w j else 0 := by |
| classical |
| unfold groupShift |
| rw [← Fintype.sum_subtype_add_sum_subtype (fun i => s i=true)] |
| congr 1 <;> apply Finset.sum_congr rfl <;> intro j hj <;> |
| simp [filled, cubeSplit, Equiv.piEquivPiSubtypeProd, j.property] |
|
|
| lemma conditional_shift_average (q : I → ℝ) (s : I → Bool) (w : I → G) (f : G → ℝ) (x : G) : |
| (∑ e, conditionalMass q s e*f (x-groupShift w e)) = |
| fairAverage (fun j : Selected s => w j) f |
| (x-∑ j : Frozen s, if likelyBit (q j) then w j else 0) := by |
| rw [conditional_integral_eq_subcube] |
| unfold fairAverage |
| congr 1 |
| apply Finset.sum_congr (by ext; simp) |
| intro a _ |
| rw [filled_groupShift] |
| congr 1 |
| abel |
|
|
|
|
| lemma sampler_finite_index {b : ℝ} (f : G → ℝ) (A δ : ℝ) (hthreshold : |
| ∀ s : ℕ, b^(69/100 : ℝ) ≤ (s : ℝ) → (s : ℝ) ≤ b → |
| SingleLatticeCovering.Sampler.probability (fun w : Fin s → G => ∃ x, |
| (∑ e : Fin s → Bool, f (x-SingleLatticeCovering.Sampler.subsetShift w e))/(2 : ℝ)^s < A) ≤ δ) |
| (hs : b^(69/100 : ℝ) ≤ (Fintype.card I : ℝ)) (hsb : (Fintype.card I : ℝ) ≤ b) : |
| SingleLatticeCovering.Sampler.probability (fun w : I → G => ∃ x, fairAverage w f x < A) ≤ δ := by |
| classical |
| let E : Fin (Fintype.card I) ≃ I := (Fintype.equivFin I).symm |
| let D := Equiv.piCongrLeft (fun _ : I => G) E |
| have he : SingleLatticeCovering.Sampler.probability (fun w : I → G => ∃ x, fairAverage w f x < A) = |
| SingleLatticeCovering.Sampler.probability (fun w : Fin (Fintype.card I) → G => ∃ x, |
| (∑ e : Fin (Fintype.card I) → Bool, |
| f (x-SingleLatticeCovering.Sampler.subsetShift w e))/(2 : ℝ)^(Fintype.card I) < A) := by |
| unfold SingleLatticeCovering.Sampler.probability |
| apply (Fintype.expect_equiv D _ _ _).symm |
| intro w |
| have ha (x : G) : fairAverage (D w) f x = |
| (∑ e : Fin (Fintype.card I) → Bool, |
| f (x-SingleLatticeCovering.Sampler.subsetShift w e))/(2 : ℝ)^(Fintype.card I) := by |
| rw [← fairAverage_reindex E] |
| simp only [D, fairAverage, groupShift, SingleLatticeCovering.Sampler.subsetShift] |
| simp only [Fintype.card_fin] |
| congr 1 |
| apply Finset.sum_congr (by ext; simp) |
| intro e he |
| congr 2 |
| apply Finset.sum_congr (by ext; simp) |
| intro i hi |
| simp |
| congr 1 |
| apply propext |
| constructor <;> rintro ⟨x, hx⟩ <;> refine ⟨x, ?_⟩ |
| · rw [ha] |
| convert hx using 2 |
| · rw [ha] at hx |
| convert hx using 2 |
| rw [he] |
| exact hthreshold _ hs hsb |
|
|
|
|
|
|
| def componentGood (b A : ℝ) (f : G → ℝ) (w : I → G) (s : I → Bool) : Prop := |
| b^(69/100 : ℝ) ≤ (Fintype.card (Selected s) : ℝ) ∧ |
| ∀ x, A ≤ fairAverage (fun j : Selected s => w j) f x |
|
|
| def badMixture (b A : ℝ) (q : I → ℝ) (f : G → ℝ) (w : I → G) : ℝ := |
| integral (fun i => fairRate (q i)) (fun s => if componentGood b A f w s then 0 else 1) |
|
|
| lemma badMixture_nonneg {I : Type u} {G : Type w} [Fintype I] [AddCommGroup G] [Fintype G] (b A : ℝ) {q : I → ℝ} |
| (hq : ∀ i, 0 ≤ q i) (hq1 : ∀ i, q i ≤ 1) (f : G → ℝ) (w : I → G) : |
| 0 ≤ badMixture b A q f w := by |
| unfold badMixture integral |
| exact Finset.sum_nonneg (fun s _ => mul_nonneg |
| (productMass_nonneg (fun i => fairRate_nonneg (hq i) (hq1 i)) |
| (fun i => fairRate_le_one (q i)) s) (by dsimp; split_ifs <;> norm_num)) |
|
|
| lemma badMixture_le_one {I : Type u} {G : Type w} [Fintype I] [AddCommGroup G] [Fintype G] (b A : ℝ) {q : I → ℝ} |
| (hq : ∀ i, 0 ≤ q i) (hq1 : ∀ i, q i ≤ 1) (f : G → ℝ) (w : I → G) : |
| badMixture b A q f w ≤ 1 := by |
| conv_rhs => rw [← integral_const (fun i => fairRate (q i)) 1] |
| apply integral_mono (fun i => fairRate_nonneg (hq i) (hq1 i)) |
| (fun i => fairRate_le_one (q i)) |
| intro s |
| split_ifs <;> norm_num |
|
|
| lemma component_failure_mean_le {b A δ : ℝ} (f : G → ℝ) (hδ : 0 ≤ δ) |
| (hthreshold : ∀ s : ℕ, b^(69/100 : ℝ) ≤ (s : ℝ) → (s : ℝ) ≤ b → |
| SingleLatticeCovering.Sampler.probability (fun w : Fin s → G => ∃ x, |
| (∑ e : Fin s → Bool, f (x-SingleLatticeCovering.Sampler.subsetShift w e))/(2 : ℝ)^s < A) ≤ δ) |
| (hb : (Fintype.card I : ℝ) ≤ b) (s : I → Bool) : |
| (𝔼 w : I → G, if componentGood b A f w s then (0 : ℝ) else 1) ≤ |
| (if count s < b^(69/100 : ℝ) then 1 else 0)+δ := by |
| classical |
| by_cases hs : b^(69/100 : ℝ) ≤ (Fintype.card (Selected s) : ℝ) |
| · have hcard : (Fintype.card (Selected s) : ℝ) ≤ b := |
| (Nat.cast_le.mpr (Fintype.card_subtype_le _)).trans hb |
| have hfail := sampler_finite_index (I := Selected s) f A δ hthreshold hs hcard |
| have he (w : I → G) : (if componentGood b A f w s then (0 : ℝ) else 1) = |
| if ∃ x, fairAverage (fun j : Selected s => w j) f x < A then 1 else 0 := by |
| have hg : componentGood b A f w s ↔ |
| ¬∃ x, fairAverage (fun j : Selected s => w j) f x < A := by |
| simp only [componentGood, hs, true_and, not_exists, not_lt] |
| simp only [hg, ite_not] |
| simp_rw [he] |
| have hs' : ¬ count s < b^(69/100 : ℝ) := by rw [count_eq_card_selected]; exact not_lt_of_ge hs |
| simp only [hs', ↓reduceIte, zero_add] |
| calc |
| _ = 𝔼 v : Selected s → G, if ∃ x, fairAverage v f x < A then (1 : ℝ) else 0 := |
| expect_restrict s (fun v => if ∃ x, fairAverage v f x < A then (1 : ℝ) else 0) |
| _ ≤ δ := by |
| unfold SingleLatticeCovering.Sampler.probability at hfail |
| convert hfail using 1 |
| congr 1 |
| · ext v; simp |
| · congr! 10 |
| · have hs' : count s < b^(69/100 : ℝ) := by rw [count_eq_card_selected]; exact lt_of_not_ge hs |
| simp only [componentGood, hs, false_and, ↓reduceIte, hs', Fintype.expect_const] |
| linarith |
| |
| |
| |
| theorem expected_badMixture_le {b A δ : ℝ} {q : I → ℝ} |
| (hq : ∀ i, 0 ≤ q i) (hq1 : ∀ i, q i ≤ 1) (f : G → ℝ) (hδ : 0 ≤ δ) |
| (hthreshold : ∀ s : ℕ, b^(69/100 : ℝ) ≤ (s : ℝ) → (s : ℝ) ≤ b → |
| SingleLatticeCovering.Sampler.probability (fun w : Fin s → G => ∃ x, |
| (∑ e : Fin s → Bool, f (x-SingleLatticeCovering.Sampler.subsetShift w e))/(2 : ℝ)^s < A) ≤ δ) |
| (hb : (Fintype.card I : ℝ) ≤ b) |
| (hmean : 0 < meanCount (fun i => fairRate (q i))) |
| (ht : b^(69/100 : ℝ) ≤ meanCount (fun i => fairRate (q i))/2) : |
| (𝔼 w : I → G, badMixture b A q f w) ≤ 4/meanCount (fun i => fairRate (q i))+δ := by |
| classical |
| have hex : (𝔼 w : I → G, badMixture b A q f w) = |
| integral (fun i => fairRate (q i)) (fun s => |
| 𝔼 w : I → G, if componentGood b A f w s then (0 : ℝ) else 1) := by |
| unfold badMixture integral |
| rw [Finset.expect_sum_comm] |
| apply Finset.sum_congr rfl |
| intro s _ |
| exact (Finset.mul_expect _ _ _).symm |
| rw [hex] |
| calc |
| _ ≤ integral (fun i => fairRate (q i)) (fun s => |
| (if count s < b^(69/100 : ℝ) then 1 else 0)+δ) := |
| integral_mono (fun i => fairRate_nonneg (hq i) (hq1 i)) |
| (fun i => fairRate_le_one (q i)) (component_failure_mean_le f hδ hthreshold hb) |
| _ = integral (fun i => fairRate (q i)) (fun s => |
| if count s < b^(69/100 : ℝ) then 1 else 0)+δ := by rw [integral_add, integral_const] |
| _ ≤ _ := add_le_add_left (few_selected_probability |
| (fun i => fairRate_nonneg (hq i) (hq1 i)) (fun i => fairRate_le_one (q i)) hmean ht) δ |
| |
| |
| |
| theorem biasedAverage_of_badMixture_le {b A ε : ℝ} {q : I → ℝ} |
| (hq : ∀ i, 0 ≤ q i) (hq1 : ∀ i, q i ≤ 1) (f : G → ℝ) (hf : ∀ x, 0 ≤ f x) |
| (hA : 0 ≤ A) (w : I → G) (hw : badMixture b A q f w ≤ ε) (x : G) : |
| (1-ε)*A ≤ biasedAverage q w f x := by |
| have h := mixture_lower_bound hq hq1 (componentGood b A f w) |
| (fun e => f (x-groupShift w e)) (fun e => hf _) A hA (by |
| intro s hs |
| rw [conditional_shift_average] |
| exact hs.2 _) |
| exact (mul_le_mul_of_nonneg_right (sub_le_sub_left hw 1) hA).trans h |
| |
| end SingleLatticeCovering.Bits |
| |
| |
| |
| |
| |
| noncomputable section |
| |
| open scoped BigOperators |
| open Classical |
| namespace SingleLatticeCovering.WeightedSelection |
| universe u v |
| variable {Z : Type u} {W : Type v} [Fintype Z] [Fintype W] [Nonempty W] |
| |
| |
| def mass (F : Z → ℝ) (E : Finset Z) : ℝ := 𝔼 z, if z ∈ E then F z else 0 |
| |
| def loss (F : Z → ℝ) (E : Finset Z) (q : W → Z → ℝ) (w : W) : ℝ := |
| 𝔼 z, if z ∈ E then F z*q w z else 0 |
| |
| lemma mean_loss_le {Z : Type u} {W : Type v} [Fintype Z] [Fintype W] [Nonempty W] (F : Z → ℝ) (E : Finset Z) (q : W → Z → ℝ) (δ : ℝ) |
| (hF : ∀ z, 0 ≤ F z) (hqavg : ∀ z ∈ E, (𝔼 w, q w z) ≤ δ) : |
| (𝔼 w, loss F E q w) ≤ δ*mass F E := by |
| unfold loss mass |
| rw [Finset.expect_comm, Finset.mul_expect] |
| apply Finset.expect_le_expect |
| intro z _ |
| by_cases hz : z ∈ E |
| · simp only [hz, ↓reduceIte, ← Finset.mul_expect] |
| exact (mul_le_mul_of_nonneg_left (hqavg z hz) (hF z)).trans_eq (mul_comm _ _) |
| · simp only [hz, ↓reduceIte, Finset.expect_const_zero, mul_zero, le_refl] |
| |
| |
| |
| theorem choose_usable (F : Z → ℝ) (E : Finset Z) (q : W → Z → ℝ) (δ ε : ℝ) |
| (hF : ∀ z, 0 ≤ F z) (hq : ∀ w z, 0 ≤ q w z) |
| (hqavg : ∀ z ∈ E, (𝔼 w, q w z) ≤ δ) (hε : 0 < ε) : |
| ∃ w : W, ∃ U : Finset Z, U ⊆ E ∧ |
| (∀ z ∈ U, q w z ≤ ε) ∧ |
| mass F (E \ U) ≤ δ*mass F E/ε ∧ |
| mass F E - δ*mass F E/ε ≤ mass F U ∧ mass F U ≤ mass F E := by |
| classical |
| have havg := mean_loss_le F E q δ hF hqavg |
| obtain ⟨w,_,hw⟩ := Finset.exists_le_of_expect_le (s := Finset.univ) |
| Finset.univ_nonempty havg |
| let U := E.filter (fun z => q w z ≤ ε) |
| have hsub : U ⊆ E := Finset.filter_subset _ _ |
| have hgood : ∀ z ∈ U, q w z ≤ ε := fun _ h => (Finset.mem_filter.mp h).2 |
| have hdisc : ε*mass F (E \ U) ≤ loss F E q w := by |
| rw [mass, Finset.mul_expect, loss] |
| apply Finset.expect_le_expect |
| intro z _ |
| by_cases hz : z ∈ E \ U |
| · obtain ⟨hzE,hzU⟩ := Finset.mem_sdiff.mp hz |
| have hbad : ε < q w z := lt_of_not_ge (fun h => hzU (Finset.mem_filter.mpr ⟨hzE,h⟩)) |
| simp only [hz, hzE, ↓reduceIte] |
| nlinarith [mul_le_mul_of_nonneg_left hbad.le (hF z)] |
| · simp only [hz, ↓reduceIte, mul_zero] |
| split_ifs <;> first | exact mul_nonneg (hF z) (hq w z) | rfl |
| have hsplit : mass F (E \ U)+mass F U=mass F E := by |
| unfold mass |
| rw [← Finset.expect_add_distrib] |
| apply Finset.expect_congr rfl |
| intro z _ |
| by_cases hzU : z ∈ U |
| · have hzE := hsub hzU |
| simp only [hzU, hzE, Finset.mem_sdiff, not_true_eq_false, and_false, |
| ↓reduceIte, zero_add] |
| · by_cases hzE : z ∈ E <;> simp [hzU, hzE] |
| have hdisc' : mass F (E \ U) ≤ δ*mass F E/ε := (le_div_iff₀ hε).mpr (by linarith [hdisc.trans hw]) |
| have hdisc0 : 0 ≤ mass F (E \ U) := Finset.expect_nonneg (fun z _ => by |
| split_ifs <;> first | exact hF z | rfl) |
| exact ⟨w,U,hsub,hgood,hdisc',by linarith,by linarith⟩ |
|
|
| end SingleLatticeCovering.WeightedSelection |
|
|
| namespace SingleLatticeCovering.Bits |
| universe u v w |
| open Filter |
| open scoped Topology |
|
|
|
|
| def alpha : ℝ := (1+Real.exp 1)⁻¹ |
| lemma alpha_pos : 0 < alpha := inv_pos.mpr (by positivity) |
| lemma alpha_le_half : alpha ≤ 1/2 := by |
| unfold alpha |
| have he : 1 ≤ Real.exp 1 := Real.one_le_exp (by norm_num) |
| rw [← one_div] |
| apply (div_le_iff₀ (by positivity)).mpr |
| linarith |
|
|
| lemma eventually_mixture_parameters : ∀ᶠ b : ℝ in atTop, |
| 1 < b ∧ b^(69/100 : ℝ) ≤ alpha*b^(70/100 : ℝ) ∧ 3*b^(-1/10 : ℝ) ≤ 1 := by |
| have hr := SingleLatticeCovering.Sampler.Numeric.tendsto_rpow_ratio |
| (show (69/100 : ℝ) < 70/100 by norm_num) |
| have hp := tendsto_rpow_neg_atTop (show (0 : ℝ) < 1/10 by norm_num) |
| filter_upwards [eventually_gt_atTop (1 : ℝ), |
| (tendsto_order.1 hr).2 alpha alpha_pos, |
| (tendsto_order.1 hp).2 (1/3) (by norm_num)] with b hb hr hp |
| refine ⟨hb, ?_, by linarith⟩ |
| have hb0 : 0 < b := zero_lt_one.trans hb |
| exact (div_le_iff₀ (Real.rpow_pos_of_pos hb0 _)).mp hr.le |
|
|
| variable {I : Type u} {Z : Type v} {G : Type w} |
| [Fintype I] [Fintype Z] [AddCommGroup G] [Fintype G] |
|
|
| lemma expected_badMixture_uniform_le {b A : ℝ} (hb : 1 ≤ b) (f : G → ℝ) |
| (hthreshold : ∀ s : ℕ, b^(69/100 : ℝ) ≤ (s : ℝ) → (s : ℝ) ≤ b → |
| SingleLatticeCovering.Sampler.probability (fun w : Fin s → G => ∃ x, |
| (∑ e : Fin s → Bool, f (x-SingleLatticeCovering.Sampler.subsetShift w e))/(2 : ℝ)^s < A) ≤ b^(-1/2 : ℝ)) |
| (hcard : (Fintype.card I : ℝ) ≤ b) {q : I → ℝ} |
| (hq : ∀ i, 0 ≤ q i) (hq1 : ∀ i, q i ≤ 1) |
| (hmean : 2*alpha*b^(70/100 : ℝ) ≤ meanCount (fun i => fairRate (q i))) |
| (ht : b^(69/100 : ℝ) ≤ alpha*b^(70/100 : ℝ)) : |
| (𝔼 w : I → G, badMixture b A q f w) ≤ (2/alpha+1)*b^(-1/2 : ℝ) := by |
| have hb0 : 0 < b := zero_lt_one.trans_le hb |
| have hm0 : 0 < 2*alpha*b^(70/100 : ℝ) := mul_pos (mul_pos (by norm_num) alpha_pos) (Real.rpow_pos_of_pos hb0 _) |
| have hm : 0 < meanCount (fun i => fairRate (q i)) := hm0.trans_le hmean |
| have hbound := expected_badMixture_le hq hq1 f (Real.rpow_nonneg hb0.le _) |
| hthreshold hcard hm (by nlinarith) |
| have hrec : 4/meanCount (fun i => fairRate (q i)) ≤ |
| (2/alpha)*b^(-1/2 : ℝ) := by |
| calc |
| _ ≤ 4/(2*alpha*b^(70/100 : ℝ)) := div_le_div_of_nonneg_left (by norm_num) hm0 hmean |
| _ = (2/alpha)*b^(-70/100 : ℝ) := by |
| rw [show (-70/100 : ℝ) = -(70/100 : ℝ) by ring, 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)) (div_nonneg (by norm_num) alpha_pos.le) |
| nlinarith |
|
|
|
|
|
|
|
|
|
|
| theorem usable_anchor_selection : |
| ∃ B : ℝ, 1 < B ∧ ∀ b : ℝ, B ≤ b → |
| (Fintype.card I : ℝ) ≤ b → Real.log (Fintype.card G) ≤ b^4 → |
| ∀ f : G → ℝ, (∀ x, 0 ≤ f x) → (∀ x, f x ≤ Real.exp (b^(65/100 : ℝ))) → |
| (1/2 ≤ 𝔼 x, f x) → (𝔼 x, f x) ≤ 2 → |
| ∀ (F : Z → ℝ) (E : Finset Z) (q : Z → I → ℝ), (∀ z, 0 ≤ F z) → |
| (∀ z i, 0 ≤ q z i) → (∀ z i, q z i ≤ 1) → |
| (∀ z ∈ E, 2*alpha*b^(70/100 : ℝ) ≤ meanCount (fun i => fairRate (q z i))) → |
| ∃ w : I → G, ∃ U : Finset Z, U ⊆ E ∧ |
| (∀ z ∈ U, ∀ x, (1-b^(-1/20 : ℝ))*(1-3*b^(-1/10 : ℝ))*(𝔼 y, f y) ≤ |
| biasedAverage (q z) w f x) ∧ |
| SingleLatticeCovering.WeightedSelection.mass F (E \ U) ≤ |
| (2/alpha+1)*b^(-9/20 : ℝ)*SingleLatticeCovering.WeightedSelection.mass F E ∧ |
| SingleLatticeCovering.WeightedSelection.mass F E - |
| (2/alpha+1)*b^(-9/20 : ℝ)*SingleLatticeCovering.WeightedSelection.mass F E ≤ |
| SingleLatticeCovering.WeightedSelection.mass F U ∧ |
| SingleLatticeCovering.WeightedSelection.mass F U ≤ SingleLatticeCovering.WeightedSelection.mass F E := by |
| classical |
| obtain ⟨B₀,hB₀,hS⟩ := SingleLatticeCovering.Sampler.uniform_boolean_sampling.{w} |
| obtain ⟨B₁,hB₁⟩ := eventually_atTop.mp eventually_mixture_parameters |
| refine ⟨max B₀ B₁, hB₀.trans_le (le_max_left _ _), ?_⟩ |
| intro b hb hcard hG f hf hfcap hflo hfhi F E q hF hq hq1 hmean |
| obtain ⟨hb1,ht,hδ⟩ := hB₁ b ((le_max_right _ _).trans hb) |
| have hb0 : 0 < b := zero_lt_one.trans hb1 |
| let A : ℝ := (1-3*b^(-1/10 : ℝ))*(𝔼 y, f y) |
| have hA : 0 ≤ A := mul_nonneg (by linarith) (by linarith) |
| have hsam : ∀ s : ℕ, b^(69/100 : ℝ) ≤ (s : ℝ) → (s : ℝ) ≤ b → |
| SingleLatticeCovering.Sampler.probability (fun w : Fin s → G => ∃ x, |
| (∑ e : Fin s → Bool, f (x-SingleLatticeCovering.Sampler.subsetShift w e))/(2 : ℝ)^s < A) ≤ b^(-1/2 : ℝ) := by |
| intro s hs hsb |
| exact (hS b ((le_max_left _ _).trans hb) G hG f hf hfcap hflo hfhi s hs hsb).2 |
| have hbad : ∀ z ∈ E, (𝔼 w : I → G, badMixture b A (q z) f w) ≤ |
| (2/alpha+1)*b^(-1/2 : ℝ) := fun z hz => |
| expected_badMixture_uniform_le hb1.le f hsam hcard (hq z) (hq1 z) (hmean z hz) ht |
| obtain ⟨w,U,hUE,hU,hdisc,hmass,hmass'⟩ := |
| SingleLatticeCovering.WeightedSelection.choose_usable F E |
| (fun w z => badMixture b A (q z) f w) |
| ((2/alpha+1)*b^(-1/2 : ℝ)) (b^(-1/20 : ℝ)) hF |
| (fun w z => badMixture_nonneg b A (hq z) (hq1 z) f w) hbad (Real.rpow_pos_of_pos hb0 _) |
| have hid : (2/alpha+1)*b^(-1/2 : ℝ)*SingleLatticeCovering.WeightedSelection.mass F E / |
| b^(-1/20 : ℝ) = (2/alpha+1)*b^(-9/20 : ℝ)*SingleLatticeCovering.WeightedSelection.mass F E := by |
| rw [div_eq_mul_inv, ← Real.rpow_neg hb0.le] |
| have he : b^(-1/2 : ℝ)*b^((1/20 : ℝ))=b^(-9/20 : ℝ) := by |
| rw [← Real.rpow_add hb0]; norm_num |
| calc |
| _ = (2/alpha+1)*(b^(-1/2 : ℝ)*b^(1/20 : ℝ))*SingleLatticeCovering.WeightedSelection.mass F E := by |
| norm_num; ring |
| _ = _ := by rw [he] |
| refine ⟨w,U,hUE,?_,hid ▸ hdisc,hid ▸ hmass,hmass'⟩ |
| intro z hz x |
| have h := biasedAverage_of_badMixture_le (hq z) (hq1 z) f hf hA w (hU z hz) x |
| simpa only [A, mul_assoc] using h |
|
|
| end SingleLatticeCovering.Bits |
|
|
|
|
| namespace SingleLatticeCovering.Bits |
| universe u v w |
| open Filter |
| open scoped Topology |
| theorem usable_anchor_selection_uniform : |
| ∃ B : ℝ, 1 < B ∧ ∀ b : ℝ, B ≤ b → |
| ∀ (I : Type u) [Fintype I] (Z : Type v) [Fintype Z] |
| (G : Type w) [AddCommGroup G] [Fintype G], |
| (Fintype.card I : ℝ) ≤ b → Real.log (Fintype.card G) ≤ b^4 → |
| ∀ f : G → ℝ, (∀ x, 0 ≤ f x) → (∀ x, f x ≤ Real.exp (b^(65/100 : ℝ))) → |
| (1/2 ≤ 𝔼 x, f x) → (𝔼 x, f x) ≤ 2 → |
| ∀ (F : Z → ℝ) (E : Finset Z) (q : Z → I → ℝ), (∀ z, 0 ≤ F z) → |
| (∀ z i, 0 ≤ q z i) → (∀ z i, q z i ≤ 1) → |
| (∀ z ∈ E, 2*alpha*b^(70/100 : ℝ) ≤ meanCount (fun i => fairRate (q z i))) → |
| ∃ w : I → G, ∃ U : Finset Z, U ⊆ E ∧ |
| (∀ z ∈ U, ∀ x, (1-b^(-1/20 : ℝ))*(1-3*b^(-1/10 : ℝ))*(𝔼 y, f y) ≤ |
| biasedAverage (q z) w f x) ∧ |
| SingleLatticeCovering.WeightedSelection.mass F (E \ U) ≤ |
| (2/alpha+1)*b^(-9/20 : ℝ)*SingleLatticeCovering.WeightedSelection.mass F E ∧ |
| SingleLatticeCovering.WeightedSelection.mass F E - |
| (2/alpha+1)*b^(-9/20 : ℝ)*SingleLatticeCovering.WeightedSelection.mass F E ≤ |
| SingleLatticeCovering.WeightedSelection.mass F U ∧ |
| SingleLatticeCovering.WeightedSelection.mass F U ≤ SingleLatticeCovering.WeightedSelection.mass F E := by |
| classical |
| obtain ⟨B₀,hB₀,hS⟩ := SingleLatticeCovering.Sampler.uniform_boolean_sampling.{w} |
| obtain ⟨B₁,hB₁⟩ := eventually_atTop.mp eventually_mixture_parameters |
| refine ⟨max B₀ B₁, hB₀.trans_le (le_max_left _ _), ?_⟩ |
| intro b hb I _ Z _ G _ _ hcard hG f hf hfcap hflo hfhi F E q hF hq hq1 hmean |
| obtain ⟨hb1,ht,hδ⟩ := hB₁ b ((le_max_right _ _).trans hb) |
| have hb0 : 0 < b := zero_lt_one.trans hb1 |
| let A : ℝ := (1-3*b^(-1/10 : ℝ))*(𝔼 y, f y) |
| have hA : 0 ≤ A := mul_nonneg (by linarith) (by linarith) |
| have hsam : ∀ s : ℕ, b^(69/100 : ℝ) ≤ (s : ℝ) → (s : ℝ) ≤ b → |
| SingleLatticeCovering.Sampler.probability (fun w : Fin s → G => ∃ x, |
| (∑ e : Fin s → Bool, f (x-SingleLatticeCovering.Sampler.subsetShift w e))/(2 : ℝ)^s < A) ≤ b^(-1/2 : ℝ) := by |
| intro s hs hsb |
| exact (hS b ((le_max_left _ _).trans hb) G hG f hf hfcap hflo hfhi s hs hsb).2 |
| have hbad : ∀ z ∈ E, (𝔼 w : I → G, badMixture b A (q z) f w) ≤ |
| (2/alpha+1)*b^(-1/2 : ℝ) := fun z hz => |
| expected_badMixture_uniform_le hb1.le f hsam hcard (hq z) (hq1 z) (hmean z hz) ht |
| obtain ⟨w,U,hUE,hU,hdisc,hmass,hmass'⟩ := |
| SingleLatticeCovering.WeightedSelection.choose_usable F E |
| (fun w z => badMixture b A (q z) f w) |
| ((2/alpha+1)*b^(-1/2 : ℝ)) (b^(-1/20 : ℝ)) hF |
| (fun w z => badMixture_nonneg b A (hq z) (hq1 z) f w) hbad (Real.rpow_pos_of_pos hb0 _) |
| have hid : (2/alpha+1)*b^(-1/2 : ℝ)*SingleLatticeCovering.WeightedSelection.mass F E / |
| b^(-1/20 : ℝ) = (2/alpha+1)*b^(-9/20 : ℝ)*SingleLatticeCovering.WeightedSelection.mass F E := by |
| rw [div_eq_mul_inv, ← Real.rpow_neg hb0.le] |
| have he : b^(-1/2 : ℝ)*b^((1/20 : ℝ))=b^(-9/20 : ℝ) := by |
| rw [← Real.rpow_add hb0]; norm_num |
| calc |
| _ = (2/alpha+1)*(b^(-1/2 : ℝ)*b^(1/20 : ℝ))*SingleLatticeCovering.WeightedSelection.mass F E := by |
| norm_num; ring |
| _ = _ := by rw [he] |
| refine ⟨w,U,hUE,?_,hid ▸ hdisc,hid ▸ hmass,hmass'⟩ |
| intro z hz x |
| have h := biasedAverage_of_badMixture_le (hq z) (hq1 z) f hf hA w (hU z hz) x |
| simpa only [A, mul_assoc] using h |
|
|
| end SingleLatticeCovering.Bits |
|
|
|
|
|
|
|
|
|
|
| noncomputable section |
| open scoped BigOperators |
| open Classical |
|
|
| namespace SingleLatticeCovering.Blocks |
| local instance : (p : Prop) → Decidable p := Classical.propDecidable |
|
|
| universe u v |
| variable {K : Type u} {V : Type v} [Field K] [Fintype K] |
| [AddCommGroup V] [Module K V] [Fintype V] |
|
|
| abbrev Direction (V : Type v) [Zero V] := {v : V // v ≠ 0} |
|
|
|
|
| def lineSum (f : V → ℝ) (v x : V) : ℝ := ∑ a : K, f (x-a • v) |
|
|
|
|
| def lineMax (f : V → ℝ) (v x : V) : ℝ := |
| Finset.univ.sup' Finset.univ_nonempty (fun a : K => f (x-a • v)) |
| |
| lemma lineMax_nonneg {K : Type u} {V : Type v} [Field K] [Fintype K] [AddCommGroup V] [Module K V] [Fintype V] {f : V → ℝ} (hf : ∀ x, 0 ≤ f x) (v x : V) : |
| 0 ≤ lineMax (K := K) f v x := |
| (hf (x-(0 : K) • v)).trans (Finset.le_sup' (fun a : K => f (x-a • v)) (Finset.mem_univ (0 : K))) |
|
|
| lemma lineMax_le {K : Type u} {V : Type v} [Field K] [Fintype K] [AddCommGroup V] [Module K V] [Fintype V] {f : V → ℝ} {c : ℝ} (hf : ∀ x, f x ≤ c) (v x : V) : |
| lineMax (K := K) f v x ≤ c := Finset.sup'_le _ _ (fun _ _ => hf _) |
| |
| lemma lineMax_le_sum {K : Type u} {V : Type v} [Field K] [Fintype K] [AddCommGroup V] [Module K V] [Fintype V] {f : V → ℝ} (hf : ∀ x, 0 ≤ f x) (v x : V) : |
| lineMax (K := K) f v x ≤ lineSum (K := K) f v x := by |
| apply Finset.sup'_le |
| intro a ha |
| exact Finset.single_le_sum (f := fun b : K => f (x-b • v)) (fun b _ => hf _) ha |
|
|
| lemma mean_lineSum (f : V → ℝ) (v : V) : |
| (𝔼 x, lineSum (K := K) f v x) = (Fintype.card K : ℝ) * (𝔼 x, f x) := by |
| unfold lineSum |
| rw [Finset.expect_sum_comm] |
| have ht (a : K) : (𝔼 x, f (x-a • v)) = 𝔼 x, f x := |
| Fintype.expect_equiv (Equiv.subRight (a • v)) _ _ (fun _ => rfl) |
| simp only [ht, Finset.sum_const, Finset.card_univ, nsmul_eq_mul] |
|
|
|
|
| def collision (U : Finset V) (v z : V) : Prop := |
| ∃ w ∈ U, w ≠ z ∧ ∃ a : K, a • v = w-z |
|
|
| lemma collision_of_two {K : Type u} {V : Type v} [Field K] [Fintype K] [AddCommGroup V] [Module K V] [Fintype V] {U : Finset V} {v x : V} (hv : v ≠ 0) |
| {a b : K} (hab : a ≠ b) (hb : x-b • v ∈ U) : |
| collision (K := K) U v (x-a • v) := by |
| refine ⟨x-b • v,hb, ?_, a-b, ?_⟩ |
| · intro heq |
| have heq' : b • v = a • v := by exact (sub_right_inj.mp heq) |
| exact hab ((smul_left_injective K hv heq').symm) |
| · rw [sub_smul] |
| abel |
|
|
|
|
|
|
| lemma line_loss_le_collision {U : Finset V} {f : V → ℝ} |
| (hf : ∀ x, 0 ≤ f x) (hsupp : ∀ x, x ∉ U → f x = 0) |
| (v : Direction V) (x : V) : |
| lineSum (K := K) f v x - lineMax (K := K) f v x ≤ |
| ∑ a : K, if collision (K := K) U v (x-a • (v : V)) then f (x-a • (v : V)) else 0 := by |
| classical |
| by_cases hall : ∀ a : K, x-a • (v : V) ∈ U → collision (K := K) U v (x-a • (v : V)) |
| · have heq : (∑ a : K, if collision (K := K) U v (x-a • (v : V)) then f (x-a • (v : V)) else 0) = |
| lineSum (K := K) f v x := by |
| apply Finset.sum_congr rfl |
| intro a _ |
| by_cases ha : x-a • (v : V) ∈ U |
| · simp only [hall a ha, ↓reduceIte] |
| · simp only [hsupp _ ha, ite_self] |
| rw [heq] |
| exact sub_le_self _ (lineMax_nonneg hf _ _) |
| · push Not at hall |
| obtain ⟨a,ha,hac⟩ := hall |
| have hzero (b : K) (hb : b ≠ a) : f (x-b • (v : V)) = 0 := by |
| apply hsupp |
| intro hu |
| exact hac (collision_of_two v.property (Ne.symm hb) hu) |
| have hsum : lineSum (K := K) f v x = f (x-a • (v : V)) := by |
| rw [lineSum, Finset.sum_eq_single a] |
| · intro b _ hb |
| exact hzero b hb |
| · simp |
| have hmax : f (x-a • (v : V)) ≤ lineMax (K := K) f v x := |
| Finset.le_sup' (fun a : K => f (x-a • (v : V))) (Finset.mem_univ a) |
| apply le_trans (b := 0) |
| · rw [hsum] |
| exact sub_nonpos.mpr hmax |
| · exact Finset.sum_nonneg (fun b _ => by split_ifs <;> simp only [hf, le_refl]) |
| |
| |
| lemma direction_point_prob (z : V) : |
| (𝔼 v : Direction V, if (v : V)=z then (1 : ℝ) else 0) ≤ |
| 1 / (Fintype.card (Direction V) : ℝ) := by |
| classical |
| by_cases hz : z=0 |
| · subst z |
| have he (v : Direction V) : (if (v : V)=0 then (1 : ℝ) else 0) = 0 := ite_eq_right v.property |
| simp only [he, Finset.expect_const_zero] |
| positivity |
| · have heq (v : Direction V) : (v : V)=z ↔ v=⟨z,hz⟩ := ⟨fun h => Subtype.ext h, fun h => congrArg Subtype.val h⟩ |
| simp only [heq, Fintype.expect_eq_sum_div_card, Finset.sum_ite_eq', Finset.mem_univ, |
| ↓reduceIte, le_refl] |
|
|
| lemma collision_indicator_le {K : Type u} {V : Type v} [Field K] [Fintype K] [AddCommGroup V] [Module K V] [Fintype V] (U : Finset V) (v : Direction V) (z : V) : |
| (if collision (K := K) U v z then (1 : ℝ) else 0) ≤ |
| ∑ w ∈ U, ∑ a : Direction K, |
| if (v : V)=(a : K)⁻¹ • (w-z) then (1 : ℝ) else 0 := by |
| classical |
| by_cases hc : collision (K := K) U v z |
| · obtain ⟨w,hw,hwz,a,ha⟩ := hc |
| have ha0 : a ≠ 0 := by |
| intro h; rw [h,zero_smul] at ha |
| exact hwz (sub_eq_zero.mp ha.symm) |
| have hv : (v : V)=a⁻¹ • (w-z) := by rw [← ha, inv_smul_smul₀ ha0] |
| calc |
| _ = 1 := ite_eq_left ⟨w,hw,hwz,a,ha⟩ |
| _ ≤ ∑ b : Direction K, if (v : V)=(b : K)⁻¹ • (w-z) then (1 : ℝ) else 0 := by |
| apply le_trans (b := if (v : V)=a⁻¹ • (w-z) then (1 : ℝ) else 0) |
| · simp only [hv, ↓reduceIte, le_refl] |
| · exact Finset.single_le_sum (f := fun b : Direction K => |
| if (v : V)=(b : K)⁻¹ • (w-z) then (1 : ℝ) else 0) |
| (fun _ _ => by split_ifs <;> norm_num) (Finset.mem_univ ⟨a,ha0⟩) |
| _ ≤ _ := Finset.single_le_sum (f := fun w => ∑ a : Direction K, |
| if (v : V)=(a : K)⁻¹ • (w-z) then (1 : ℝ) else 0) |
| (fun w _ => Finset.sum_nonneg (fun _ _ => by split_ifs <;> norm_num)) hw |
| · simp only [hc, ↓reduceIte] |
| exact Finset.sum_nonneg (fun w _ => Finset.sum_nonneg (fun _ _ => by split_ifs <;> norm_num)) |
|
|
|
|
|
|
| lemma collision_probability_le (U : Finset V) (z : V) : |
| (𝔼 v : Direction V, if collision (K := K) U v z then (1 : ℝ) else 0) ≤ |
| (U.card : ℝ)*(Fintype.card (Direction K) : ℝ)/(Fintype.card (Direction V) : ℝ) := by |
| classical |
| calc |
| _ ≤ 𝔼 v : Direction V, ∑ w ∈ U, ∑ a : Direction K, |
| if (v : V)=(a : K)⁻¹ • (w-z) then (1 : ℝ) else 0 := |
| Finset.expect_le_expect (fun v _ => collision_indicator_le U v z) |
| _ = ∑ w ∈ U, ∑ a : Direction K, 𝔼 v : Direction V, |
| if (v : V)=(a : K)⁻¹ • (w-z) then (1 : ℝ) else 0 := by |
| rw [Finset.expect_sum_comm] |
| apply Finset.sum_congr rfl |
| intro w hw |
| exact Finset.expect_sum_comm _ _ _ |
| _ ≤ ∑ w ∈ U, ∑ a : Direction K, 1/(Fintype.card (Direction V) : ℝ) := |
| Finset.sum_le_sum (fun w _ => Finset.sum_le_sum (fun a _ => direction_point_prob _)) |
| _ = _ := by simp only [Finset.sum_const, nsmul_eq_mul, Finset.card_univ]; ring |
|
|
| lemma mean_line_loss_le {U : Finset V} {f : V → ℝ} |
| (hf : ∀ x, 0 ≤ f x) (hsupp : ∀ x, x ∉ U → f x = 0) |
| (v : Direction V) : |
| (Fintype.card K : ℝ)*(𝔼 x, f x) - (𝔼 x, lineMax (K := K) f v x) ≤ |
| (Fintype.card K : ℝ)*(𝔼 z, if collision (K := K) U v z then f z else 0) := by |
| have h := Finset.expect_le_expect (s := Finset.univ) |
| (fun x : V => fun _ => line_loss_le_collision (K := K) hf hsupp v x) |
| rw [Finset.expect_sub_distrib, mean_lineSum] at h |
| change (Fintype.card K : ℝ)*(𝔼 x, f x) - (𝔼 x, lineMax (K := K) f v x) ≤ |
| (𝔼 x, lineSum (K := K) (fun z => if collision (K := K) U v z then f z else 0) v x) at h |
| rwa [mean_lineSum] at h |
|
|
|
|
|
|
| lemma mean_direction_loss_le {U : Finset V} {f : V → ℝ} |
| (hf : ∀ x, 0 ≤ f x) (hsupp : ∀ x, x ∉ U → f x = 0) : |
| (𝔼 v : Direction V, |
| ((Fintype.card K : ℝ)*(𝔼 x, f x) - (𝔼 x, lineMax (K := K) f v x))) ≤ |
| ((U.card : ℝ)*(Fintype.card (Direction K) : ℝ)/(Fintype.card (Direction V) : ℝ)) * |
| ((Fintype.card K : ℝ)*(𝔼 x, f x)) := by |
| classical |
| let e : ℝ := (U.card : ℝ)*(Fintype.card (Direction K) : ℝ)/(Fintype.card (Direction V) : ℝ) |
| calc |
| (𝔼 v : Direction V, ((Fintype.card K : ℝ)*(𝔼 x, f x) - |
| (𝔼 x, lineMax (K := K) f (v : V) x))) ≤ 𝔼 v : Direction V, |
| (Fintype.card K : ℝ)*(𝔼 z, if collision (K := K) U v z then f z else 0) := |
| Finset.expect_le_expect (fun v _ => mean_line_loss_le (K := K) hf hsupp v) |
| _ = (Fintype.card K : ℝ) * (𝔼 z, f z * (𝔼 v : Direction V, |
| if collision (K := K) U v z then (1 : ℝ) else 0)) := by |
| rw [← Finset.mul_expect, Finset.expect_comm] |
| congr 1 |
| apply Finset.expect_congr rfl |
| intro z _ |
| rw [Finset.mul_expect] |
| apply Finset.expect_congr rfl |
| intro v _ |
| split_ifs <;> simp |
| _ ≤ (Fintype.card K : ℝ) * (𝔼 z, f z * e) := by |
| apply mul_le_mul_of_nonneg_left _ (Nat.cast_nonneg _) |
| exact Finset.expect_le_expect (fun z _ => mul_le_mul_of_nonneg_left |
| (collision_probability_le U z) (hf z)) |
| _ = ((U.card : ℝ)*(Fintype.card (Direction K) : ℝ)/(Fintype.card (Direction V) : ℝ)) * |
| ((Fintype.card K : ℝ)*(𝔼 x, f x)) := by rw [← Finset.expect_mul]; dsimp [e]; ring |
|
|
|
|
|
|
|
|
| theorem exists_sparse_line [Nontrivial V] {U : Finset V} {f : V → ℝ} |
| (hf : ∀ x, 0 ≤ f x) (hsupp : ∀ x, x ∉ U → f x = 0) : |
| ∃ v : Direction V, |
| (1-(U.card : ℝ)*(Fintype.card (Direction K) : ℝ)/(Fintype.card (Direction V) : ℝ)) * |
| ((Fintype.card K : ℝ)*(𝔼 x, f x)) ≤ (𝔼 x, lineMax (K := K) f v x) ∧ |
| (𝔼 x, lineMax (K := K) f v x) ≤ (Fintype.card K : ℝ)*(𝔼 x, f x) := by |
| obtain ⟨v,hv⟩ := exists_ne (0 : V) |
| let : Nonempty (Direction V) := ⟨⟨v,hv⟩⟩ |
| obtain ⟨v,_,hv⟩ := Finset.exists_le_of_expect_le Finset.univ_nonempty |
| (mean_direction_loss_le (K := K) hf hsupp) |
| refine ⟨v, by linarith, ?_⟩ |
| rw [← mean_lineSum (K := K) f v] |
| exact Finset.expect_le_expect (fun x _ => lineMax_le_sum hf _ _) |
|
|
| lemma card_direction (W : Type*) [Zero W] [Fintype W] : |
| Fintype.card (Direction W) = Fintype.card W - 1 := by |
| classical |
| simpa only [Direction, Fintype.card_unique] using Fintype.card_subtype_compl (fun w : W => w=0) |
|
|
| lemma collision_factor_le_twice {K : Type u} {V : Type v} [Field K] [Fintype K] [AddCommGroup V] [Module K V] [Fintype V] [Nontrivial V] (U : Finset V) : |
| (U.card : ℝ)*(Fintype.card (Direction K) : ℝ)/(Fintype.card (Direction V) : ℝ) ≤ |
| 2*(Fintype.card K : ℝ)*((U.card : ℝ)/(Fintype.card V : ℝ)) := by |
| have hV : 2 ≤ Fintype.card V := Fintype.one_lt_card |
| have hK : 1 ≤ Fintype.card K := Fintype.card_pos |
| rw [card_direction K, card_direction V, Nat.cast_sub hK, Nat.cast_sub (by omega : 1 ≤ Fintype.card V)] |
| norm_num only [Nat.cast_one] |
| have hV' : (2 : ℝ) ≤ Fintype.card V := Nat.cast_le.mpr hV |
| have hK' : (1 : ℝ) ≤ Fintype.card K := by exact_mod_cast hK |
| have hc : (0 : ℝ) ≤ U.card := Nat.cast_nonneg _ |
| apply (div_le_iff₀ (by linarith : (0 : ℝ) < (Fintype.card V : ℝ)-1)).mpr |
| have hVp : (0 : ℝ) < Fintype.card V := by linarith |
| field_simp |
| nlinarith [mul_nonneg hc (by linarith : 0 ≤ (Fintype.card K : ℝ)), |
| mul_nonneg hc (by nlinarith : 0 ≤ (Fintype.card K : ℝ)*((Fintype.card V : ℝ)-2))] |
|
|
|
|
| def usableMass (U : Finset V) (F : V → ℝ) : ℝ := |
| 𝔼 z, if z ∈ U then F z else 0 |
|
|
|
|
|
|
| def sparseWeight (U : Finset V) (F : V → ℝ) (z : V) : ℝ := |
| if z ∈ U then F z / (Fintype.card K : ℝ) else 0 |
|
|
| lemma mean_sparseWeight {K : Type u} {V : Type v} [Field K] [Fintype K] [AddCommGroup V] [Module K V] [Fintype V] (U : Finset V) (F : V → ℝ) : |
| (Fintype.card K : ℝ)*(𝔼 z, sparseWeight (K := K) U F z) = usableMass U F := by |
| have hp : (Fintype.card K : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr Fintype.card_ne_zero |
| rw [Finset.mul_expect] |
| apply Finset.expect_congr rfl |
| intro z _ |
| simp only [sparseWeight] |
| split_ifs <;> field_simp ; simp |
|
|
| lemma usable_density_le {V : Type v} [AddCommGroup V] [Fintype V] {U : Finset V} {F : V → ℝ} {a : ℝ} (ha : 0 < a) |
| (hF : ∀ z ∈ U, a ≤ F z) : |
| (U.card : ℝ)/(Fintype.card V : ℝ) ≤ usableMass U F / a := by |
| have hm : (𝔼 z, if z ∈ U then (1 : ℝ) else 0) = (U.card : ℝ)/(Fintype.card V : ℝ) := by |
| simp [Fintype.expect_eq_sum_div_card] |
| rw [← hm, le_div_iff₀ ha, Finset.expect_mul] |
| apply Finset.expect_le_expect |
| intro z _ |
| by_cases hz : z ∈ U |
| · simp only [hz, ↓reduceIte, one_mul] |
| exact hF z hz |
| · simp only [hz, ↓reduceIte, zero_mul, le_refl] |
|
|
|
|
|
|
|
|
| theorem gaussian_window_sparse_line [Nontrivial V] (U : Finset V) (F : V → ℝ) |
| (hF0 : ∀ z, 0 ≤ F z) (t r : ℝ) |
| (hFl : ∀ z ∈ U, Real.exp (t-r) ≤ F z) |
| (hFu : ∀ z ∈ U, F z ≤ Real.exp (t+r)) |
| (hpl : Real.exp (t-4*r) ≤ (Fintype.card K : ℝ)) |
| (hpu : (Fintype.card K : ℝ) ≤ Real.exp (t-3*r)) |
| (hM : usableMass U F ≤ 2) : |
| ∃ v : Direction V, |
| usableMass U F - 4*usableMass U F*Real.exp (-2*r) ≤ |
| (𝔼 x, lineMax (K := K) (sparseWeight (K := K) U F) v x) ∧ |
| (𝔼 x, lineMax (K := K) (sparseWeight (K := K) U F) v x) ≤ usableMass U F ∧ |
| ∀ x, 0 ≤ lineMax (K := K) (sparseWeight (K := K) U F) v x ∧ |
| lineMax (K := K) (sparseWeight (K := K) U F) v x ≤ Real.exp (5*r) := by |
| classical |
| have hp : (0 : ℝ) < Fintype.card K := Nat.cast_pos.mpr Fintype.card_pos |
| have hweight0 (z : V) : 0 ≤ sparseWeight (K := K) U F z := by |
| unfold sparseWeight |
| split_ifs |
| · exact div_nonneg (hF0 z) hp.le |
| · rfl |
| have hweightsupp (z : V) (hz : z ∉ U) : sparseWeight (K := K) U F z = 0 := by |
| simp only [sparseWeight, hz, ↓reduceIte] |
| have hM0 : 0 ≤ usableMass U F := Finset.expect_nonneg (fun z _ => by |
| split_ifs <;> simp only [hF0, le_refl]) |
| have hratio : (Fintype.card K : ℝ)/Real.exp (t-r) ≤ Real.exp (-2*r) := by |
| rw [div_le_iff₀ (Real.exp_pos _), ← Real.exp_add] |
| convert hpu using 1 ; congr 1 ; ring |
| have hsmall : (U.card : ℝ)*(Fintype.card (Direction K) : ℝ)/(Fintype.card (Direction V) : ℝ) ≤ |
| 4*Real.exp (-2*r) := by |
| calc |
| _ ≤ 2*(Fintype.card K : ℝ)*((U.card : ℝ)/(Fintype.card V : ℝ)) := collision_factor_le_twice U |
| _ ≤ 2*(Fintype.card K : ℝ)*(usableMass U F / Real.exp (t-r)) := |
| mul_le_mul_of_nonneg_left (usable_density_le (Real.exp_pos _) hFl) (by positivity) |
| _ = 2*usableMass U F*((Fintype.card K : ℝ)/Real.exp (t-r)) := by ring |
| _ ≤ 2*usableMass U F*Real.exp (-2*r) := mul_le_mul_of_nonneg_left hratio (by positivity) |
| _ ≤ 4*Real.exp (-2*r) := by nlinarith [Real.exp_pos (-2*r)] |
| obtain ⟨v,hv,hvu⟩ := exists_sparse_line (K := K) hweight0 hweightsupp |
| rw [mean_sparseWeight] at hv hvu |
| refine ⟨v, ?_, hvu, ?_⟩ |
| · have h := mul_le_mul_of_nonneg_right hsmall hM0 |
| nlinarith |
| · intro x |
| refine ⟨lineMax_nonneg hweight0 _ _, lineMax_le (fun z => ?_) _ _⟩ |
| unfold sparseWeight |
| split_ifs with hz |
| · calc |
| F z / (Fintype.card K : ℝ) ≤ Real.exp (t+r) / (Fintype.card K : ℝ) := |
| div_le_div_of_nonneg_right (hFu z hz) hp.le |
| _ ≤ Real.exp (t+r) / Real.exp (t-4*r) := |
| div_le_div_of_nonneg_left (Real.exp_pos _).le (Real.exp_pos _) hpl |
| _ = Real.exp (5*r) := by rw [← Real.exp_sub]; congr 1; ring |
| · exact (Real.exp_pos _).le |
|
|
| end SingleLatticeCovering.Blocks |
|
|
|
|
|
|
|
|
|
|
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
|
|
| end OAI |
|
|
