Download data/lean/OAI/NumberTheory/PowerFree/PrimeBlocks.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 13.4 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/NumberTheory/PowerFree/PrimeBlocks.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/NumberTheory/PowerFree/PrimeBlocks.lean
-
curl -L -o PrimeBlocks.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/NumberTheory/PowerFree/PrimeBlocks.lean
13.4 kB
| import OAI.NumberTheory.PowerFree.AdaptiveRanks | |
| namespace OAI | |
| open scoped BigOperators | |
| open Matrix | |
| open scoped BigOperators | |
| open scoped BigOperators | |
| namespace QuarticPowerFree | |
| theorem product_distinct_prime_divisors_le (a : β€) (ha : a β 0) | |
| (P : Finset β) (hp : β p β P, p.Prime) | |
| (hd : β p β P, (p : β€) β£ a) : | |
| (β p β P, (p : β)) β€ |(a : β)| := by | |
| have hn : a.natAbs β 0 := (Int.natAbs_pos.mpr ha).ne' | |
| have hs : P β a.natAbs.primeFactors := by | |
| intro p h | |
| exact Nat.mem_primeFactors.mpr β¨hp p h, | |
| by simpa using Int.natAbs_dvd_natAbs.mpr (hd p h), hnβ© | |
| have hh := Nat.le_of_dvd (Int.natAbs_pos.mpr ha) | |
| ((Finset.prod_dvd_prod_of_subset P a.natAbs.primeFactors id hs).trans | |
| (Nat.prod_primeFactors_dvd a.natAbs)) | |
| have he : (a.natAbs : β) = |(a : β)| := by | |
| rw [β Int.cast_natCast, Int.natCast_natAbs, Int.cast_abs] | |
| rw [β he, β Nat.cast_prod] | |
| exact_mod_cast hh | |
| theorem card_large_prime_divisors_le (a : β€) (ha : a β 0) | |
| (P : Finset β) (hp : β p β P, p.Prime) (hd : β p β P, (p : β€) β£ a) | |
| (X ΞΆ B : β) (hX : 1 < X) (hΞΆ : 0 < ΞΆ) | |
| (hsmall : β p β P, X ^ ΞΆ β€ (p : β)) (hlarge : |(a : β)| β€ X ^ B) : | |
| (P.card : β) β€ B / ΞΆ := by | |
| have hx : 0 β€ X := (zero_lt_one.trans hX).le | |
| have h : X ^ (ΞΆ * (P.card : β)) β€ X ^ B := by | |
| rw [Real.rpow_mul hx, Real.rpow_natCast] | |
| calc | |
| (X ^ ΞΆ) ^ P.card = β _p β P, X ^ ΞΆ := (Finset.prod_const _).symm | |
| _ β€ β p β P, (p : β) := Finset.prod_le_prodβ | |
| (fun _ _ => (Real.rpow_pos_of_pos (zero_lt_one.trans hX) ΞΆ).le) hsmall | |
| _ β€ |(a : β)| := product_distinct_prime_divisors_le a ha P hp hd | |
| _ β€ X ^ B := hlarge | |
| rw [le_div_iffβ hΞΆ] | |
| simpa [mul_comm] using (Real.rpow_le_rpow_left_iff hX).mp h | |
| theorem card_large_prime_divisors_le_floor (a : β€) (ha : a β 0) | |
| (P : Finset β) (hp : β p β P, p.Prime) (hd : β p β P, (p : β€) β£ a) | |
| (X ΞΆ B : β) (hX : 1 < X) (hΞΆ : 0 < ΞΆ) | |
| (hsmall : β p β P, X ^ ΞΆ β€ (p : β)) (hlarge : |(a : β)| β€ X ^ B) : | |
| P.card β€ βB / ΞΆββ := | |
| Nat.le_floor (card_large_prime_divisors_le a ha P hp hd X ΞΆ B hX hΞΆ hsmall hlarge) | |
| open scoped BigOperators | |
| def cellKernel {K V ΞΉ : Type*} [Field K] [AddCommGroup V] [Module K V] | |
| (ev : ΞΉ β V ββ[K] K) (S : Set ΞΉ) : Submodule K V := | |
| β¨ i β S, LinearMap.ker (ev i) | |
| theorem cellKernel_mono {K V ΞΉ : Type*} [Field K] [AddCommGroup V] [Module K V] | |
| (ev : ΞΉ β V ββ[K] K) {S T : Set ΞΉ} (h : S β T) : | |
| cellKernel ev T β€ cellKernel ev S := by | |
| intro v hv | |
| simp only [cellKernel, Submodule.mem_iInf, LinearMap.mem_ker] at hv β’ | |
| exact fun i hi => hv i (h hi) | |
| theorem adaptiveStates_length {K V Ο Ξ± : Type*} [Field K] [AddCommGroup V] [Module K V] | |
| (W : β β Ο β Ξ± β Submodule K V) (next : β β Ο β Submodule K V β Ο) | |
| (n i : β) (s : Ο) (a : Ξ±) : (adaptiveStates W next n i s a).length = n+1 := by | |
| induction n generalizing i s with | |
| | zero => rfl | |
| | succ n ih => simp only [adaptiveStates, List.length_cons, ih] | |
| theorem list_minor_product_bound {Ο : Type*} (l : List Ο) (minor : Ο β β€) | |
| (X B : β) (hX : 0 < X) | |
| (hminor : β s β l, minor s β 0 β§ |(minor s : β)| β€ X^B) : | |
| (l.map minor).prod β 0 β§ |(((l.map minor).prod : β€) : β)| β€ X^(B*(l.length : β)) := by | |
| induction l with | |
| | nil => simp | |
| | cons x l ih => | |
| have hx := hminor x (by simp) | |
| have ht := ih (fun s hs => hminor s (by simp [hs])) | |
| constructor | |
| Β· simpa only [List.map_cons, List.prod_cons] using mul_ne_zero hx.1 ht.1 | |
| Β· simp only [List.map_cons, List.prod_cons, Int.cast_mul, abs_mul, | |
| List.length_cons, Nat.cast_add, Nat.cast_one, mul_add, mul_one, | |
| Real.rpow_add hX] | |
| exact (mul_le_mul hx.2 ht.2 (abs_nonneg _) (Real.rpow_nonneg hX.le _)).trans_eq (mul_comm _ _) | |
| theorem adaptive_deletion_bound {K V Ο : Type*} [Field K] [AddCommGroup V] | |
| [Module K V] [Module.Finite K V] | |
| (W : β β Ο β Finset β β Submodule K V) | |
| (next : β β Ο β Submodule K V β Ο) | |
| (hW : β i s A B, A β B β W i s A β€ W i s B) | |
| (minor : Ο β β€) (n : β) (s : Ο) | |
| (P : Finset β) (hp : β p β P, p.Prime) | |
| (X ΞΆ B : β) (hX : 1 < X) (hΞΆ : 0 < ΞΆ) | |
| (hsmall : β p β P, X^ΞΆ β€ (p : β)) | |
| (hminor : β A β P, β t β adaptiveStates W next n 0 s A, | |
| minor t β 0 β§ |(minor t : β)| β€ X^B) | |
| (ell T : β) (hT : 0 < T) (hsize : ell+T < P.card) : | |
| let bad := fun A => P.filter fun p : β => | |
| (p : β€) β£ ((adaptiveStates W next n 0 s A).map minor).prod | |
| (β j β Finset.range T, badFraction P (ell+j+1) bad) / (T : β) β€ | |
| (((Module.finrank K V+1)^n : β) : β) / T + | |
| (β(B*(n+1:β))/ΞΆββ : β) / ((P.card : β) - (ell+T)) := by | |
| classical | |
| intro bad | |
| let R := fun A => adaptiveCode W next n 0 s A | |
| apply deletion_average_bound P ell T hT hsize R bad | |
| ((Module.finrank K V+1)^n) β(B*(n+1:β))/ΞΆββ | |
| Β· intro A _ | |
| exact (adaptiveCode_lt W next n 0 s A).le | |
| Β· intro A _ q _ | |
| exact (adaptiveCode_mono_stable W next (A.erase q) A | |
| (fun i s => hW i s _ _ (Finset.erase_subset _ _)) n 0 s).1 | |
| Β· intro A _ q _ he | |
| have hs := (adaptiveCode_mono_stable W next (A.erase q) A | |
| (fun i s => hW i s _ _ (Finset.erase_subset _ _)) n 0 s).2 he | |
| dsimp [bad] | |
| rw [hs] | |
| Β· intro A hAP | |
| let l := adaptiveStates W next n 0 s A | |
| have hb := list_minor_product_bound l minor X B (zero_lt_one.trans hX) (hminor A hAP) | |
| have hl : l.length = n+1 := adaptiveStates_length W next n 0 s A | |
| have hin : P β© bad A = bad A := Finset.inter_eq_right.mpr (Finset.filter_subset _ _) | |
| rw [hin] | |
| apply card_large_prime_divisors_le_floor _ hb.1 _ | |
| (fun p h => hp p (Finset.mem_filter.mp h).1) | |
| (fun _ h => (Finset.mem_filter.mp h).2) X ΞΆ (B*(n+1:β)) hX hΞΆ | |
| (fun p h => hsmall p (Finset.mem_filter.mp h).1) | |
| simpa only [hl] using hb.2 | |
| open scoped BigOperators | |
| def BlockSample (P : Finset β) (ell T : β) := | |
| Ξ£ j : Fin T, (P.powersetCard (ell+j.val+1)) | |
| noncomputable instance (P : Finset β) (ell T : β) : Fintype (BlockSample P ell T) := | |
| inferInstanceAs (Fintype (Ξ£ j : Fin T, (P.powersetCard (ell+j.val+1)))) | |
| noncomputable def blockWeight (P : Finset β) (ell T : β) | |
| (a : BlockSample P ell T) : β := | |
| ((T : β) * ((P.powersetCard (ell+a.1.val+1)).card : β))β»ΒΉ | |
| def blockSet {P : Finset β} {ell T : β} (a : BlockSample P ell T) : Finset β := | |
| a.2.val | |
| theorem blockSet_spec {P : Finset β} {ell T : β} (a : BlockSample P ell T) : | |
| blockSet a β P β§ (blockSet a).card = ell+a.1.val+1 := | |
| Finset.mem_powersetCard.mp a.2.property | |
| theorem blockWeight_nonneg (P : Finset β) (ell T : β) | |
| (a : BlockSample P ell T) : 0 β€ blockWeight P ell T a := by | |
| unfold blockWeight | |
| positivity | |
| theorem blockWeight_sum (P : Finset β) (ell T : β) | |
| (hT : 0 < T) (hsize : ell+T β€ P.card) : | |
| β a : BlockSample P ell T, blockWeight P ell T a = 1 := by | |
| classical | |
| change (β a : Ξ£ j : Fin T, (P.powersetCard (ell+j.val+1)), | |
| ((T : β) * ((P.powersetCard (ell+a.1.val+1)).card : β))β»ΒΉ) = 1 | |
| rw [Fintype.sum_sigma] | |
| have he (j : Fin T) : | |
| (β _a : (P.powersetCard (ell+j.val+1)), | |
| ((T : β) * ((P.powersetCard (ell+j.val+1)).card : β))β»ΒΉ) = (T : β)β»ΒΉ := by | |
| have hc : 0 < (P.powersetCard (ell+j.val+1)).card := | |
| Finset.card_pos.mpr (Finset.powersetCard_nonempty.mpr (by omega)) | |
| simp only [Finset.sum_const, Finset.card_univ, Fintype.card_coe, nsmul_eq_mul] | |
| field_simp | |
| simp only [he,Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul] | |
| exact mul_inv_cancelβ (Nat.cast_ne_zero.mpr hT.ne') | |
| theorem blockWeight_bad_average (P : Finset β) (ell T : β) | |
| (bad : Finset β β Finset β) : | |
| (β a : BlockSample P ell T, blockWeight P ell T a * | |
| ((β q β blockSet a, if q β bad (blockSet a) then (1 : β) else 0) / | |
| (blockSet a).card)) = | |
| (β j β Finset.range T, badFraction P (ell+j+1) bad) / T := by | |
| classical | |
| change (β a : Ξ£ j : Fin T, (P.powersetCard (ell+j.val+1)), | |
| ((T : β) * ((P.powersetCard (ell+a.1.val+1)).card : β))β»ΒΉ * | |
| ((β q β a.2.val, if q β bad a.2.val then (1 : β) else 0) / a.2.val.card)) = _ | |
| rw [Fintype.sum_sigma, β Fin.sum_univ_eq_sum_range, Finset.sum_div] | |
| apply Finset.sum_congr rfl | |
| intro j _ | |
| simp only [badFraction] | |
| rw [Finset.sum_coe_sort (P.powersetCard (ell+j.val+1)) | |
| (fun S : Finset β => ((T : β) * ((P.powersetCard (ell+j.val+1)).card : β))β»ΒΉ * | |
| ((β q β S, if q β bad S then (1 : β) else 0) / S.card)), | |
| Finset.sum_div, Finset.sum_div] | |
| apply Finset.sum_congr rfl | |
| intro a ha | |
| rw [(Finset.mem_powersetCard.mp ha).2] | |
| simp only [div_eq_mul_inv, _root_.mul_inv_rev] | |
| ring | |
| theorem independent_average_le {ΞΉ : Type*} [Fintype ΞΉ] [DecidableEq ΞΉ] | |
| {Ξ© : ΞΉ β Type*} [β i, Fintype (Ξ© i)] | |
| (w : β i, Ξ© i β β) (hw : β i a, 0 β€ w i a) | |
| (hsum : β i, β a, w i a = 1) (i : ΞΉ) | |
| (F : (β j, Ξ© j) β β) (C : β) | |
| (hF : β x, (β a, w i a * F (Function.update x i a)) β€ C) : | |
| (β x, (β j, w j (x j)) * F x) β€ C := by | |
| classical | |
| let E := Equiv.piSplitAt i Ξ© | |
| let W : (β j : {j // j β i}, Ξ© j) β β := fun x => β j : {j // j β i}, w j.val (x j) | |
| have hs : β x, W x = 1 := by | |
| rw [show (β x, W x) = β x : (β j : {j // j β i}, Ξ© j), β j : {j // j β i}, w j.val (x j) from rfl, β Fintype.prod_sum] | |
| simp only [hsum, Finset.prod_const_one] | |
| have hwE (x : β j, Ξ© j) : (β j, w j (x j)) = w i (x i) * W (E x).2 := by | |
| rw [β Finset.mul_prod_erase Finset.univ (fun j => w j (x j)) (Finset.mem_univ i)] | |
| congr 1 | |
| exact Finset.prod_subtype (p := fun j => j β i) (Finset.univ.erase i) (by simp) (fun j => w j (x j)) | |
| have hE (x : (β j : {j // j β i}, Ξ© j)) (a b : Ξ© i) : | |
| Function.update (E.symm (a,x)) i b = E.symm (b,x) := by | |
| funext j | |
| by_cases h : j = i | |
| Β· subst j; simp [E, Equiv.piSplitAt] | |
| Β· simp [E, Equiv.piSplitAt, h] | |
| have hEq : (β x, (β j, w j (x j)) * F x) = | |
| β x, W x * (β a, w i a * F (E.symm (a,x))) := by | |
| rw [Fintype.sum_equiv E _ (fun z => w i z.1 * W z.2 * F (E.symm z))] | |
| Β· rw [Fintype.sum_prod_type, Finset.sum_comm] | |
| apply Finset.sum_congr rfl | |
| intro x _ | |
| rw [Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro a _ | |
| ring | |
| Β· intro x | |
| rw [hwE, E.symm_apply_apply] | |
| rfl | |
| rw [hEq] | |
| have hFin (x : β j : {j // j β i}, Ξ© j) : | |
| (β a, w i a * F (E.symm (a,x))) β€ C := by | |
| by_cases h : Nonempty (Ξ© i) | |
| Β· obtain β¨aβ© := h | |
| simpa only [hE] using hF (E.symm (a,x)) | |
| Β· have := not_nonempty_iff.mp h | |
| have hz := hsum i | |
| simp at hz | |
| calc | |
| _ β€ β x, W x * C := Finset.sum_le_sum fun x _ => | |
| mul_le_mul_of_nonneg_left (hFin x) (Finset.prod_nonneg fun j _ => hw j.val (x j)) | |
| _ = C := by rw [β Finset.sum_mul, hs, one_mul] | |
| theorem exists_many_regular {Ξ© ΞΉ : Type*} [Fintype Ξ©] [Fintype ΞΉ] | |
| (w : Ξ© β β) (hw : β a, 0 β€ w a) (hsum : β a, w a = 1) | |
| (bad : Ξ© β ΞΉ β Prop) [DecidableRel bad] | |
| (Ξ· : β) (hbad : β z, (β a, w a * if bad a z then (1 : β) else 0) β€ Ξ·) : | |
| β a : Ξ©, ((Finset.univ.filter fun z => Β¬ bad a z).card : β) β₯ | |
| (1-Ξ·) * Fintype.card ΞΉ := by | |
| classical | |
| have havg : (β a, w a * ((Finset.univ.filter fun z => bad a z).card : β)) β€ | |
| Ξ· * Fintype.card ΞΉ := by | |
| simp_rw [β Finset.sum_boole, Finset.mul_sum] | |
| rw [Finset.sum_comm] | |
| exact (Finset.sum_le_sum fun z _ => hbad z).trans_eq (by simp; ring) | |
| have hex : β a : Ξ©, ((Finset.univ.filter fun z => bad a z).card : β) β€ Ξ· * Fintype.card ΞΉ := by | |
| by_contra h | |
| push Not at h | |
| have hp : β a, 0 < w a := by | |
| by_contra h0 | |
| push Not at h0 | |
| have hz : β a, w a = 0 := fun a => le_antisymm (h0 a) (hw a) | |
| simp [hz] at hsum | |
| obtain β¨a,haβ© := hp | |
| have hlt : (β b, w b * (Ξ· * Fintype.card ΞΉ)) < | |
| β b, w b * ((Finset.univ.filter fun z => bad b z).card : β) := by | |
| apply Finset.sum_lt_sum | |
| Β· intro b _ | |
| exact mul_le_mul_of_nonneg_left (h b).le (hw b) | |
| Β· exact β¨a,Finset.mem_univ _,mul_lt_mul_of_pos_left (h a) haβ© | |
| rw [β Finset.sum_mul,hsum,one_mul] at hlt | |
| linarith | |
| obtain β¨a,haβ© := hex | |
| refine β¨a,?_β© | |
| have hc : (Finset.univ.filter fun z => bad a z).card + | |
| (Finset.univ.filter fun z => Β¬ bad a z).card = Fintype.card ΞΉ := by | |
| simpa using Finset.card_filter_add_card_filter_not (s := Finset.univ) (fun z => bad a z) | |
| have hcr : ((Finset.univ.filter fun z => bad a z).card : β) + | |
| ((Finset.univ.filter fun z => Β¬ bad a z).card : β) = Fintype.card ΞΉ := by exact_mod_cast hc | |
| linarith | |
| theorem bad_blocks_indicator_le {r : β} (b : Fin r β β) (hb : β i, 0 β€ b i) | |
| (ΞΎ : β) (hΞΎ : 0 < ΞΎ) : | |
| (if β i, ΞΎ < b i then (1 : β) else 0) β€ (β i, b i) / ΞΎ := by | |
| classical | |
| split_ifs with h | |
| Β· obtain β¨i,hiβ© := h | |
| rw [le_div_iffβ hΞΎ, one_mul] | |
| exact hi.le.trans (Finset.single_le_sum (fun j _ => hb j) (Finset.mem_univ i)) | |
| Β· exact div_nonneg (Finset.sum_nonneg fun i _ => hb i) hΞΎ.le | |
| end QuarticPowerFree | |
| end OAI | |