Download data/lean/OAI/Geometry/LatticeCovering/Bits.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 38.5 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/LatticeCovering/Bits.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/LatticeCovering/Bits.lean
-
curl -L -o Bits.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/LatticeCovering/Bits.lean
38.5 kB
| 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 | |