Download data/lean/OAI/NumberTheory/PowerFree/RegularBlocks.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 17.1 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/NumberTheory/PowerFree/RegularBlocks.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/NumberTheory/PowerFree/RegularBlocks.lean
-
curl -L -o RegularBlocks.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/NumberTheory/PowerFree/RegularBlocks.lean
17.1 kB
| import OAI.NumberTheory.PowerFree.PrimeBlocks | |
| namespace OAI | |
| open scoped BigOperators | |
| open Matrix | |
| open scoped BigOperators | |
| open scoped BigOperators | |
| namespace QuarticPowerFree | |
| open scoped BigOperators | |
| theorem independent_many_regular {r : β} {S : Type*} [Fintype S] | |
| {Ξ© : Fin r β Type*} [β i, Fintype (Ξ© i)] | |
| (w : β i, Ξ© i β β) (hw : β i a, 0 β€ w i a) | |
| (hsum : β i, β a, w i a = 1) | |
| (b : (β i, Ξ© i) β S β Fin r β β) | |
| (hb : β x z i, 0 β€ b x z i) (Ξ· ΞΎ : β) (hΞΎ : 0 < ΞΎ) | |
| (hmean : β z i x, (β a, w i a * b (Function.update x i a) z i) β€ Ξ·) : | |
| β x : β i, Ξ© i, | |
| ((Finset.univ.filter fun z : S => β i, b x z i β€ ΞΎ).card : β) β₯ | |
| (1 - (r : β)*Ξ·/ΞΎ) * Fintype.card S := by | |
| classical | |
| let W : (β i, Ξ© i) β β := fun x => β i, w i (x i) | |
| have hW : β x, 0 β€ W x := fun x => Finset.prod_nonneg fun i _ => hw i (x i) | |
| have hsumW : β x, W x = 1 := by | |
| change (β x : β i, Ξ© i, β i, w i (x i)) = 1 | |
| rw [β Fintype.prod_sum] | |
| simp only [hsum,Finset.prod_const_one] | |
| have hm (z : S) (i : Fin r) : β x, W x * b x z i β€ Ξ· := | |
| independent_average_le w hw hsum i (fun x => b x z i) Ξ· (hmean z i) | |
| have hbad (z : S) : | |
| (β x, W x * if β i, ΞΎ < b x z i then (1 : β) else 0) β€ (r : β)*Ξ·/ΞΎ := by | |
| calc | |
| _ β€ β x, W x * ((β i, b x z i)/ΞΎ) := | |
| Finset.sum_le_sum fun x _ => mul_le_mul_of_nonneg_left | |
| (bad_blocks_indicator_le (b x z) (hb x z) ΞΎ hΞΎ) (hW x) | |
| _ = (β i, β x, W x * b x z i)/ΞΎ := by | |
| simp_rw [β mul_div_assoc,Finset.mul_sum] | |
| rw [β Finset.sum_div,Finset.sum_comm] | |
| _ β€ (β _i : Fin r, Ξ·)/ΞΎ := div_le_div_of_nonneg_right | |
| (Finset.sum_le_sum fun i _ => hm z i) hΞΎ.le | |
| _ = (r : β)*Ξ·/ΞΎ := by simp | |
| obtain β¨x,hxβ© := exists_many_regular W hW hsumW | |
| (fun x z => β i, ΞΎ < b x z i) ((r : β)*Ξ·/ΞΎ) hbad | |
| refine β¨x,?_β© | |
| simpa only [not_exists,not_lt] using hx | |
| lemma adaptiveStates_precomp {K V Ο Ξ± Ξ² : Type*} [Field K] [AddCommGroup V] | |
| [Module K V] (W : β β Ο β Ξ± β Submodule K V) | |
| (next : β β Ο β Submodule K V β Ο) (f : Ξ² β Ξ±) | |
| (n i : β) (s : Ο) (a : Ξ²) : | |
| adaptiveStates (fun j t b => W j t (f b)) next n i s a = | |
| adaptiveStates W next n i s (f a) := by | |
| induction n generalizing i s with | |
| | zero => rfl | |
| | succ n ih => simp only [adaptiveStates,ih] | |
| noncomputable def selectedBlocks {r T : β} {P : Fin r β Finset β} | |
| {ell : Fin r β β} (a : β i, BlockSample (P i) (ell i) T) : Fin r β Finset β := | |
| fun i => blockSet (a i) | |
| lemma selectedBlocks_update {r T : β} {P : Fin r β Finset β} | |
| {ell : Fin r β β} (a : β i, BlockSample (P i) (ell i) T) | |
| (i : Fin r) (u : BlockSample (P i) (ell i) T) : | |
| selectedBlocks (Function.update a i u) = Function.update (selectedBlocks a) i (blockSet u) := by | |
| funext j | |
| by_cases h : j = i | |
| Β· subst j; simp [selectedBlocks] | |
| Β· simp [selectedBlocks,Function.update_of_ne h] | |
| theorem regular_adaptive_blocks {K V Ο S : Type*} | |
| [Field K] [AddCommGroup V] [Module K V] [Module.Finite K V] [Fintype S] | |
| {r : β} (P : Fin r β Finset β) (ell : Fin r β β) (T n : β) | |
| (W : S β β β Ο β (Fin r β Finset β) β Submodule K V) | |
| (next : S β β β Ο β Submodule K V β Ο) (start : S β Ο) | |
| (minor : S β Ο β β€) | |
| (hW : β z j s B i A A', A β A' β | |
| W z j s (Function.update B i A) β€ W z j s (Function.update B i A')) | |
| (X ΞΆ B Ξ· ΞΎ : β) (hX : 1 < X) (hΞΆ : 0 < ΞΆ) (hΞΎ : 0 < ΞΎ) | |
| (hp : β i p, p β P i β p.Prime) | |
| (hsmall : β i p, p β P i β X^ΞΆ β€ (p : β)) | |
| (hminor : β z A, (β i, A i β P i) β | |
| β t β adaptiveStates (W z) (next z) n 0 (start z) A, | |
| minor z t β 0 β§ |(minor z t : β)| β€ X^B) | |
| (hT : 0 < T) (hsize : β i, ell i+T < (P i).card) | |
| (hΞ· : β i, (((Module.finrank K V+1)^n : β) : β)/T + | |
| (β(B*(n+1:β))/ΞΆββ : β)/(((P i).card : β)-(ell i+T)) β€ Ξ·) : | |
| β A : Fin r β Finset β, | |
| (β i, A i β P i β§ ell i < (A i).card β§ (A i).card β€ ell i+T) β§ | |
| ((Finset.univ.filter fun z : S => β i, | |
| ((β p β A i, | |
| if (p : β€) β£ ((adaptiveStates (W z) (next z) n 0 (start z) A).map (minor z)).prod | |
| then (1 : β) else 0) / (A i).card) β€ ΞΎ).card : β) β₯ | |
| (1-(r : β)*Ξ·/ΞΎ)*Fintype.card S := by | |
| classical | |
| let Ξ© := fun i => BlockSample (P i) (ell i) T | |
| let w : β i, Ξ© i β β := fun i => blockWeight (P i) (ell i) T | |
| let M := fun z A => ((adaptiveStates (W z) (next z) n 0 (start z) A).map (minor z)).prod | |
| let b : (β i, Ξ© i) β S β Fin r β β := fun a z i => | |
| (β p β selectedBlocks a i, if (p : β€) β£ M z (selectedBlocks a) then (1 : β) else 0) / | |
| (selectedBlocks a i).card | |
| have hb : β a z i, 0 β€ b a z i := by | |
| intro a z i | |
| exact div_nonneg (Finset.sum_nonneg fun p _ => by split_ifs <;> positivity) | |
| (Nat.cast_nonneg _) | |
| have hmean : β z i a, (β u, w i u * b (Function.update a i u) z i) β€ Ξ· := by | |
| intro z i a | |
| let Aβ := selectedBlocks a | |
| let Wi := fun j s A => W z j s (Function.update Aβ i A) | |
| let bad : Finset β β Finset β := fun A => (P i).filter fun p : β => | |
| (p : β€) β£ M z (Function.update Aβ i A) | |
| have hm (A : Finset β) (hA : A β P i) : | |
| β t β adaptiveStates Wi (next z) n 0 (start z) A, | |
| minor z t β 0 β§ |(minor z t : β)| β€ X^B := by | |
| rw [adaptiveStates_precomp] | |
| apply hminor z | |
| intro j | |
| by_cases h : j = i | |
| Β· subst j; simpa using hA | |
| Β· simpa only [Function.update_of_ne h, Aβ, selectedBlocks] using (blockSet_spec (a j)).1 | |
| have hdel := adaptive_deletion_bound Wi (next z) | |
| (fun j s A A' hAA' => hW z j s Aβ i A A' hAA') (minor z) n (start z) | |
| (P i) (hp i) X ΞΆ B hX hΞΆ (hsmall i) hm (ell i) T hT (hsize i) | |
| dsimp only at hdel | |
| simp only [Wi, adaptiveStates_precomp] at hdel | |
| change ((β j β Finset.range T, badFraction (P i) (ell i+j+1) bad) / T) β€ _ at hdel | |
| have heq : (β u, w i u * b (Function.update a i u) z i) = | |
| (β j β Finset.range T, badFraction (P i) (ell i+j+1) bad) / T := by | |
| rw [β blockWeight_bad_average] | |
| apply Finset.sum_congr rfl | |
| intro u _ | |
| dsimp only [w,b] | |
| rw [selectedBlocks_update, Function.update_self] | |
| congr 2 | |
| apply Finset.sum_congr rfl | |
| intro p hpU | |
| have hpP := (blockSet_spec u).1 hpU | |
| simp only [bad,Finset.mem_filter,hpP,true_and,Aβ] | |
| rw [heq] | |
| exact hdel.trans (hΞ· i) | |
| obtain β¨a,haβ© := independent_many_regular w | |
| (fun i => blockWeight_nonneg (P i) (ell i) T) | |
| (fun i => blockWeight_sum (P i) (ell i) T hT (hsize i).le) | |
| b hb Ξ· ΞΎ hΞΎ hmean | |
| refine β¨selectedBlocks a,?_,haβ© | |
| intro i | |
| obtain β¨hsub,hcardβ© := blockSet_spec (a i) | |
| refine β¨hsub,?_,?_β© | |
| Β· change ell i < (blockSet (a i)).card | |
| rw [hcard]; omega | |
| Β· change (blockSet (a i)).card β€ ell i+T | |
| rw [hcard] | |
| have := (a i).1.isLt | |
| omega | |
| open MvPolynomial | |
| noncomputable def cumulativeBlockPrimes {r : β} (B : Fin r β Finset β) (i : β) : Finset β := | |
| (Finset.univ.filter fun j => j.val β€ i).biUnion B | |
| theorem cumulativeBlockPrimes_mono {r : β} {B C : Fin r β Finset β} | |
| (hBC : β j, B j β C j) (i : β) : | |
| cumulativeBlockPrimes B i β cumulativeBlockPrimes C i := by | |
| classical | |
| intro p hp | |
| obtain β¨j,hj,hpβ© := Finset.mem_biUnion.mp hp | |
| exact Finset.mem_biUnion.mpr β¨j,hj,hBC j hpβ© | |
| def pathDegreeBudget (n : β) (d : β β β) (A h e : β) : β β β | |
| | 0 => e | |
| | i+1 => patchDegreeBudget n A h (kernelDegreeBudget (d i) h (pathDegreeBudget n d A h e i)) | |
| noncomputable def physicalKernel {n r E : β} (G : KernelGeometry n) (d : β β β) | |
| (z : Fin n β β€) (i : β) (s : Ideal (MvPolynomial (Fin n) β) Γ IntegerPatch n) | |
| (B : Fin r β Finset β) : Submodule β (totalSpace (Ο := Fin n) (K := β) E) := | |
| stagedEvaluationSpace (evaluationCell G.points s.1 z (cumulativeBlockPrimes B i)) (d i) E | |
| noncomputable def physicalNext {n E : β} (G : KernelGeometry n) (d : β β β) | |
| (A h e : β) (z : Fin n β β€) (i : β) | |
| (s : Ideal (MvPolynomial (Fin n) β) Γ IntegerPatch n) | |
| (W : Submodule β (totalSpace (Ο := Fin n) (K := β) E)) : | |
| Ideal (MvPolynomial (Fin n) β) Γ IntegerPatch n := | |
| firstCoveringChild z s (kernelChildList G (d i) A h (pathDegreeBudget n d A h e i) s.1 W) | |
| def PhysicalState {n : β} (G : KernelGeometry n) (h e : β) (z : Fin n β β€) | |
| (s : Ideal (MvPolynomial (Fin n) β) Γ IntegerPatch n) : Prop := | |
| KernelParent h e s.1 β§ s.2.On s.1 β§ s.2.Bounded e G.height β§ PatchPieceCovers s z | |
| theorem physicalKernel_mono {n r E : β} (G : KernelGeometry n) (d : β β β) | |
| (z : Fin n β β€) (i : β) (s : Ideal (MvPolynomial (Fin n) β) Γ IntegerPatch n) | |
| {B C : Fin r β Finset β} (hBC : β j, B j β C j) : | |
| physicalKernel (E := E) G d z i s B β€ physicalKernel G d z i s C := | |
| stagedEvaluationSpace_mono (evaluationCell_antitone G.points s.1 z | |
| (cumulativeBlockPrimes_mono hBC i)) | |
| theorem physical_step {n r E : β} (G : KernelGeometry n) (d : β β β) | |
| (A h e : β) (z : Fin n β β€) (hz : z β G.points) (i : β) | |
| (s : Ideal (MvPolynomial (Fin n) β) Γ IntegerPatch n) | |
| (hs : PhysicalState G h (pathDegreeBudget n d A h e i) z s) | |
| (B : Fin r β Finset β) : | |
| let W := physicalKernel (E := E) G d z i s B | |
| let t := physicalNext G d A h e z i s W | |
| PhysicalState G h (pathDegreeBudget n d A h e (i+1)) z t β§ | |
| t β kernelChildList G (d i) A h (pathDegreeBudget n d A h e i) s.1 W β§ | |
| s.1 β€ t.1 β§ stagedKernelPolynomials (d i) E W β t.1 β§ | |
| affineDimension t.1 β€ affineDimension s.1 β§ | |
| (Β¬ stagedKernelPolynomials (d i) E W β s.1 β affineDimension t.1 < affineDimension s.1) := by | |
| classical | |
| dsimp only | |
| have hc := kernelChildList_spec G (d i) A h (pathDegreeBudget n d A h e i) s.1 | |
| (physicalKernel (E := E) G d z i s B) hs.1 | |
| have hzc : z β evaluationCell G.points s.1 z (cumulativeBlockPrimes B i) := by | |
| exact Finset.mem_filter.mpr β¨hz,hs.2.2.2.1,by simpβ© | |
| have hzF : β p β stagedKernelPolynomials (d i) E (physicalKernel G d z i s B), | |
| eval (fun l => (z l : β)) p = 0 := by | |
| rintro p β¨v,hv,rfl,_β© | |
| exact hv.2 z hzc | |
| have hsel := firstCoveringChild_spec z s _ (hc.2.2 z hz hs.2.2.2.1 hzF) | |
| have hg := hc.2.1 _ hsel.1 | |
| obtain β¨β¨hp,hle,hdim,hdeg,hOn,hBound,_β©,hF,hdim',hstrictβ© := hg | |
| exact β¨β¨β¨hp,hdim,hdegβ©,hOn,hBound,hsel.2β©,hsel.1,hle,hF,hdim',hstrictβ© | |
| theorem physical_path_good {n r E : β} (G : KernelGeometry n) (d : β β β) | |
| (A h e : β) (z : Fin n β β€) (hz : z β G.points) | |
| (B : Fin r β Finset β) (m i : β) | |
| (s : Ideal (MvPolynomial (Fin n) β) Γ IntegerPatch n) | |
| (hs : PhysicalState G h (pathDegreeBudget n d A h e i) z s) : | |
| β t β adaptiveStates (physicalKernel (E := E) G d z) (physicalNext G d A h e z) m i s B, | |
| β j, i β€ j β§ j β€ i+m β§ PhysicalState G h (pathDegreeBudget n d A h e j) z t := by | |
| induction m generalizing i s with | |
| | zero => | |
| intro t ht | |
| have ht : t = s := by simpa only [adaptiveStates,List.mem_singleton] using ht | |
| subst t | |
| exact β¨i,le_rfl,by omega,hsβ© | |
| | succ m ih => | |
| intro t ht | |
| rcases List.mem_cons.mp ht with hts | ht | |
| Β· subst t | |
| exact β¨i,le_rfl,by omega,hsβ© | |
| Β· have hstep := (physical_step (E := E) G d A h e z hz i s hs B).1 | |
| obtain β¨j,hij,hj,htjβ© := ih (i+1) _ hstep t ht | |
| exact β¨j,by omega,by omega,htjβ© | |
| theorem physical_rank_mono_stable {n r E : β} (G : KernelGeometry n) (d : β β β) | |
| (A h e : β) (z : Fin n β β€) (m i : β) | |
| (s : Ideal (MvPolynomial (Fin n) β) Γ IntegerPatch n) | |
| {B C : Fin r β Finset β} (hBC : β j, B j β C j) : | |
| adaptiveCode (physicalKernel (E := E) G d z) (physicalNext G d A h e z) m i s C β€ | |
| adaptiveCode (physicalKernel (E := E) G d z) (physicalNext G d A h e z) m i s B β§ | |
| (adaptiveCode (physicalKernel (E := E) G d z) (physicalNext G d A h e z) m i s C = | |
| adaptiveCode (physicalKernel (E := E) G d z) (physicalNext G d A h e z) m i s B β | |
| adaptiveStates (physicalKernel (E := E) G d z) (physicalNext G d A h e z) m i s C = | |
| adaptiveStates (physicalKernel (E := E) G d z) (physicalNext G d A h e z) m i s B) := by | |
| let := totalSpace_finite (n := n) (K := β) E | |
| exact adaptiveCode_mono_stable _ _ B C (fun i s => physicalKernel_mono G d z i s hBC) m i s | |
| open MvPolynomial | |
| open scoped BigOperators | |
| theorem physical_uniform_minor_height (n : β) (d : β β β) (A h e m E : β) : | |
| β C : β, 1 β€ C β§ β b : β, | |
| β (G : KernelGeometry n) (z : Fin n β β€), z β G.points β | |
| β (s : Ideal (MvPolynomial (Fin n) β) Γ IntegerPatch n), | |
| PhysicalState G h e z s β β (r : β) (B : Fin r β Finset β), | |
| β t β adaptiveStates (physicalKernel (E := E) G d z) (physicalNext G d A h e z) m 0 s B, | |
| eval z t.2.minor β 0 β§ |((eval z t.2.minor : β€) : β)| β€ C*G.height^b := by | |
| classical | |
| let D := (Finset.range (m+1)).sup (pathDegreeBudget n d A h e) | |
| obtain β¨C,hC,b,hbβ© := uniform_patch_minor_height n D | |
| refine β¨C,hC,b,?_β© | |
| intro G z hz s hs r B t ht | |
| obtain β¨j,_,hj,hjtβ© := physical_path_good (E := E) G d A h e z hz B m 0 s hs t ht | |
| have hD : pathDegreeBudget n d A h e j β€ D := | |
| Finset.le_sup (f := pathDegreeBudget n d A h e) (Finset.mem_range.mpr (by omega)) | |
| exact β¨hjt.2.2.2.2,hb t.2 G.height G.one_le_height (hjt.2.2.1.mono hD) z (G.bounded z hz)β© | |
| theorem physical_regular_blocks (n : β) (d : β β β) (A h e m E : β) : | |
| β C : β, 1 β€ C β§ β b : β, | |
| β (G : KernelGeometry n) | |
| (start : G.points β Ideal (MvPolynomial (Fin n) β) Γ IntegerPatch n), | |
| (β z, PhysicalState G h e z.val (start z)) β | |
| β (r : β) (P : Fin r β Finset β) (ell : Fin r β β) (T : β) | |
| (X ΞΆ w Ξ· ΞΎ : β), 1 < X β C β€ X β 0 β€ w β G.height β€ X^w β 0 < ΞΆ β 0 < ΞΎ β | |
| (β i p, p β P i β p.Prime) β | |
| (β i p, p β P i β X^ΞΆ β€ (p : β)) β | |
| 0 < T β (β i, ell i+T < (P i).card) β | |
| (β i, ((((E+n).choose n+1)^m : β) : β)/T + | |
| (β((w*b+1)*(m+1:β))/ΞΆββ : β)/(((P i).card : β)-(ell i+T)) β€ Ξ·) β | |
| β B : Fin r β Finset β, | |
| (β i, B i β P i β§ ell i < (B i).card β§ (B i).card β€ ell i+T) β§ | |
| ((Finset.univ.filter fun z : G.points => β i, | |
| ((β p β B i, | |
| if (p : β€) β£ ((adaptiveStates (physicalKernel (E := E) G d z.val) | |
| (physicalNext G d A h e z.val) m 0 (start z) B).map | |
| (fun t => eval z.val t.2.minor)).prod | |
| then (1 : β) else 0) / (B i).card) β€ ΞΎ).card : β) β₯ | |
| (1-(r : β)*Ξ·/ΞΎ)*G.points.card := by | |
| classical | |
| obtain β¨C,hC,b,hbβ© := physical_uniform_minor_height n d A h e m E | |
| refine β¨C,hC,b,?_β© | |
| intro G start hs r P ell T X ΞΆ w Ξ· ΞΎ hX hCX hw hheight hΞΆ hΞΎ hp hsmall hT hsize hΞ· | |
| let := totalSpace_finite (n := n) (K := β) E | |
| have hmono : β (z : G.points) j s (B : Fin r β Finset β) i U U', U β U' β | |
| physicalKernel (E := E) G d z.val j s (Function.update B i U) β€ | |
| physicalKernel G d z.val j s (Function.update B i U') := by | |
| intro z j s B i U U' hUU' | |
| apply physicalKernel_mono | |
| intro k | |
| by_cases hk : k = i | |
| Β· subst k; simpa using hUU' | |
| Β· simp only [Function.update_of_ne hk] | |
| exact Finset.Subset.refl _ | |
| have hminor : β (z : G.points) B, (β i, B i β P i) β | |
| β t β adaptiveStates (physicalKernel (E := E) G d z.val) | |
| (physicalNext G d A h e z.val) m 0 (start z) B, | |
| eval z.val t.2.minor β 0 β§ |((eval z.val t.2.minor : β€) : β)| β€ X^(w*b+1) := by | |
| intro z B _ t ht | |
| have ht' := hb G z.val z.property (start z) (hs z) r B t ht | |
| refine β¨ht'.1,ht'.2.trans ?_β© | |
| calc | |
| C*G.height^b β€ X*(X^w)^b := mul_le_mul hCX | |
| (pow_le_pow_leftβ (zero_le_one.trans G.one_le_height) hheight b) | |
| (pow_nonneg (zero_le_one.trans G.one_le_height) b) (zero_lt_one.trans hX).le | |
| _ = X^(w*b+1) := by | |
| rw [Real.rpow_add (zero_lt_one.trans hX), Real.rpow_one, | |
| Real.rpow_mul (zero_lt_one.trans hX).le,Real.rpow_natCast,mul_comm] | |
| have hΞ·' : β i, (((Module.finrank β (totalSpace (Ο := Fin n) (K := β) E)+1)^m : β) : β)/T + | |
| (β((w*b+1)*(m+1:β))/ΞΆββ : β)/(((P i).card : β)-(ell i+T)) β€ Ξ· := by | |
| simpa only [totalSpace_finrank] using hΞ· | |
| simpa only [Fintype.card_coe] using | |
| regular_adaptive_blocks P ell T m (fun z => physicalKernel (E := E) G d z.val) | |
| (fun z => physicalNext G d A h e z.val) start | |
| (fun z t => eval z.val t.2.minor) hmono X ΞΆ (w*b+1) Ξ· ΞΎ hX hΞΆ hΞΎ hp hsmall hminor | |
| hT hsize hΞ·' | |
| end QuarticPowerFree | |
| end OAI | |