Download data/lean/OAI/NumberTheory/PowerFree/PrimePools.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 15.9 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/NumberTheory/PowerFree/PrimePools.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/NumberTheory/PowerFree/PrimePools.lean
-
curl -L -o PrimePools.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/NumberTheory/PowerFree/PrimePools.lean
15.9 kB
| import OAI.NumberTheory.PowerFree.WeightedRelations | |
| namespace OAI | |
| open scoped BigOperators | |
| open Matrix | |
| open scoped BigOperators | |
| open scoped BigOperators | |
| namespace QuarticPowerFree | |
| section | |
| open MvPolynomial | |
| open scoped BigOperators | |
| attribute [local instance] Classical.propDecidable | |
| open scoped Classical | |
| noncomputable def physicalPathProduct {n r E : β} (G : KernelGeometry n) (d : β β β) | |
| (A h e m : β) (start : G.points β Ideal (MvPolynomial (Fin n) β) Γ IntegerPatch n) | |
| (B : Fin r β Finset β) (z : G.points) : β€ := | |
| ((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 | |
| theorem physical_minor_dvd_pathProduct {n r E : β} (G : KernelGeometry n) (d : β β β) | |
| (A h e m : β) (start : G.points β Ideal (MvPolynomial (Fin n) β) Γ IntegerPatch n) | |
| (B : Fin r β Finset β) (z : G.points) (i : β) (hi : i β€ m) : | |
| eval z.val (physicalStateAt (E := E) G d A h e start B i z).2.minor β£ | |
| physicalPathProduct (E := E) G d A h e m start B z := by | |
| apply List.dvd_prod | |
| apply List.mem_map.mpr | |
| exact β¨physicalStateAt (E := E) G d A h e start B i z, | |
| adaptiveStateAt_mem_states _ _ m i 0 _ B hi,rflβ© | |
| def PhysicalRegular {n r E : β} (G : KernelGeometry n) (d : β β β) | |
| (A h e m : β) (start : G.points β Ideal (MvPolynomial (Fin n) β) Γ IntegerPatch n) | |
| (B : Fin r β Finset β) (ΞΎ : β) (z : G.points) : Prop := | |
| β j, ((β p β B j, if (p : β€) β£ physicalPathProduct (E := E) G d A h e m start B z | |
| then (1 : β) else 0) / (B j).card) β€ ΞΎ | |
| theorem filter_card_le_of_fraction {Ξ± : Type*} (S : Finset Ξ±) (P : Ξ± β Prop) | |
| [DecidablePred P] (ΞΎ : β) | |
| (h : (β p β S, if P p then (1 : β) else 0) / S.card β€ ΞΎ) : | |
| ((S.filter P).card : β) β€ ΞΎ*S.card := by | |
| by_cases hs : S.card = 0 | |
| Β· have he := Finset.card_eq_zero.mp hs | |
| subst S | |
| simp | |
| have hp : (0 : β) < S.card := by exact_mod_cast (Nat.pos_of_ne_zero hs) | |
| rw [Finset.sum_boole] at h | |
| exact (div_le_iffβ hp).mp h | |
| theorem PhysicalRegular.bad_minor {n r E : β} (G : KernelGeometry n) (d : β β β) | |
| (A h e m : β) (start : G.points β Ideal (MvPolynomial (Fin n) β) Γ IntegerPatch n) | |
| (B : Fin r β Finset β) (ΞΎ : β) (z : G.points) | |
| (hz : PhysicalRegular (E := E) G d A h e m start B ΞΎ z) (i : β) (hi : i β€ m) (j : Fin r) : | |
| (((B j).filter fun p : β => (p:β€) β£ eval z.val | |
| (physicalStateAt (E := E) G d A h e start B i z).2.minor).card : β) β€ ΞΎ*(B j).card := by | |
| have hsub : ((B j).filter fun p : β => (p:β€) β£ eval z.val | |
| (physicalStateAt (E := E) G d A h e start B i z).2.minor) β | |
| ((B j).filter fun p : β => (p:β€) β£ physicalPathProduct (E := E) G d A h e m start B z) := by | |
| intro p hp | |
| obtain β¨hp,hdβ© := Finset.mem_filter.mp hp | |
| exact Finset.mem_filter.mpr β¨hp,hd.trans (physical_minor_dvd_pathProduct G d A h e m start B z i hi)β© | |
| calc | |
| _ β€ (((B j).filter fun p : β => | |
| (p:β€) β£ physicalPathProduct (E := E) G d A h e m start B z).card : β) := by | |
| exact_mod_cast Finset.card_le_card hsub | |
| _ β€ _ := filter_card_le_of_fraction _ _ ΞΎ (hz j) | |
| theorem cumulative_good_prime_product {r : β} (B : Fin r β Finset β) | |
| (hdisj : β a b, a β b β Disjoint (B a) (B b)) (i : β) (v : β€) | |
| (X ΞΆ ΞΎ : β) (hX : 1 β€ X) (hΞΆ : 0 β€ ΞΆ) | |
| (hlo : β j p, p β B j β X^ΞΆ β€ (p:β)) | |
| (hbad : β j, (((B j).filter fun p : β => (p:β€) β£ v).card : β) β€ ΞΎ*(B j).card) : | |
| X^((1-ΞΎ)*ΞΆ*β j β Finset.univ.filter (fun j : Fin r => j.val β€ i), ((B j).card : β)) β€ | |
| β p β (cumulativeBlockPrimes B i).filter (fun p : β => Β¬ (p:β€) β£ v), (p:β) := by | |
| classical | |
| let J := Finset.univ.filter (fun j : Fin r => j.val β€ i) | |
| let Q := (cumulativeBlockPrimes B i).filter (fun p : β => Β¬ (p:β€) β£ v) | |
| have hg (j : Fin r) : (1-ΞΎ)*(B j).card β€ | |
| (((B j).filter fun p : β => Β¬ (p:β€) β£ v).card : β) := by | |
| have hc := Finset.card_filter_add_card_filter_not (s := B j) (fun p : β => (p:β€) β£ v) | |
| have hcr : (((B j).filter fun p : β => (p:β€) β£ v).card : β) + | |
| (((B j).filter fun p : β => Β¬ (p:β€) β£ v).card : β) = (B j).card := by exact_mod_cast hc | |
| nlinarith [hbad j] | |
| have heq : Q = J.biUnion (fun j => (B j).filter fun p : β => Β¬ (p:β€) β£ v) := by | |
| ext p | |
| simp only [Q,J,cumulativeBlockPrimes,Finset.mem_filter,Finset.mem_biUnion] | |
| constructor | |
| Β· rintro β¨β¨j,hj,hpβ©,hgβ© | |
| exact β¨j,hj,hp,hgβ© | |
| Β· rintro β¨j,hj,hp,hgβ© | |
| exact β¨β¨j,hj,hpβ©,hgβ© | |
| have hpair : (J : Set (Fin r)).PairwiseDisjoint | |
| (fun j => (B j).filter fun p : β => Β¬ (p:β€) β£ v) := by | |
| intro a _ b _ hab | |
| exact (hdisj a b hab).mono (Finset.filter_subset _ _) (Finset.filter_subset _ _) | |
| have hcard : (1-ΞΎ)*(β j β J, ((B j).card : β)) β€ (Q.card : β) := by | |
| rw [heq,Finset.card_biUnion hpair,Nat.cast_sum,Finset.mul_sum] | |
| exact Finset.sum_le_sum (fun j _ => hg j) | |
| calc | |
| _ β€ X^(ΞΆ*(Q.card : β)) := by | |
| apply Real.rpow_le_rpow_of_exponent_le hX | |
| nlinarith | |
| _ = (X^ΞΆ)^Q.card := Real.rpow_mul_natCast (zero_le_one.trans hX) ΞΆ Q.card | |
| _ = β _p β Q, X^ΞΆ := by simp | |
| _ β€ _ := by | |
| apply Finset.prod_le_prodβ | |
| Β· intro p _; exact Real.rpow_nonneg (zero_le_one.trans hX) _ | |
| Β· intro p hp | |
| obtain β¨j,_,hpjβ© := Finset.mem_biUnion.mp (Finset.mem_filter.mp hp).1 | |
| exact hlo j p hpj | |
| end | |
| section | |
| open MvPolynomial | |
| open scoped BigOperators | |
| attribute [local instance] Classical.propDecidable | |
| open scoped Classical | |
| noncomputable def firstStop (r : β) (P : β β Prop) : β := | |
| Nat.find (show β i, i = r β¨ P i from β¨r,Or.inl rflβ©) | |
| theorem firstStop_le (r : β) (P : β β Prop) : firstStop r P β€ r := | |
| Nat.find_min' _ (Or.inl rfl) | |
| theorem firstStop_spec (r : β) (P : β β Prop) : firstStop r P = r β¨ P (firstStop r P) := | |
| Nat.find_spec (show β i, i = r β¨ P i from β¨r,Or.inl rflβ©) | |
| theorem firstStop_not_before (r : β) (P : β β Prop) {i : β} (hi : i < firstStop r P) : Β¬ P i := | |
| fun hp => Nat.find_min _ hi (Or.inr hp) | |
| theorem dimension_until_firstStop (r : β) (dim : β β β) (Ex : β β Prop) | |
| (hzero : dim 0 β€ r) (hmono : β i < r, dim (i+1) β€ dim i) | |
| (hstep : β i < r, Β¬ Ex i β dim i = r-i β dim (i+1) < dim i) : | |
| β i β€ firstStop r (fun i => Ex i β¨ dim i = 0), dim i β€ r-i := by | |
| intro i | |
| induction i with | |
| | zero => intro _; simpa using hzero | |
| | succ i ih => | |
| intro hi | |
| have his : i < firstStop r (fun i => Ex i β¨ dim i = 0) := by omega | |
| have hir : i < r := lt_of_lt_of_le his (firstStop_le _ _) | |
| have hd := ih his.le | |
| have hstop := firstStop_not_before r (fun i => Ex i β¨ dim i = 0) his | |
| by_cases he : dim i = r-i | |
| Β· have hs := hstep i hir (fun h => hstop (Or.inl h)) he | |
| omega | |
| Β· have hm := hmono i hir | |
| omega | |
| theorem firstStop_terminal (r : β) (dim : β β β) (Ex : β β Prop) | |
| (hzero : dim 0 β€ r) (hmono : β i < r, dim (i+1) β€ dim i) | |
| (hstep : β i < r, Β¬ Ex i β dim i = r-i β dim (i+1) < dim i) : | |
| let t := firstStop r (fun i => Ex i β¨ dim i = 0) | |
| Ex t β¨ dim t = 0 := by | |
| dsimp only | |
| rcases firstStop_spec r (fun i => Ex i β¨ dim i = 0) with he | hp | |
| Β· right | |
| have hd := dimension_until_firstStop r dim Ex hzero hmono hstep | |
| (firstStop r (fun i => Ex i β¨ dim i = 0)) le_rfl | |
| rw [he,Nat.sub_self] at hd | |
| rw [he] | |
| exact Nat.eq_zero_of_le_zero hd | |
| Β· exact hp | |
| theorem physical_fiber_le_points {n r E : β} (G : KernelGeometry n) (d : β β β) | |
| (A h e : β) (start : G.points β Ideal (MvPolynomial (Fin n) β) Γ IntegerPatch n) | |
| (hs : β z, PhysicalState G h e z.val (start z)) (B : Fin r β Finset β) | |
| (i : β) (z : G.points) (S : Finset G.points) : | |
| (S.filter fun w => physicalNode (E := E) G d A h e start B i w = | |
| physicalNode (E := E) G d A h e start B i z).card β€ | |
| (G.points.filter (PointOn (physicalStateAt (E := E) G d A h e start B i z).1)).card := by | |
| classical | |
| let F := S.filter fun w => physicalNode (E := E) G d A h e start B i w = | |
| physicalNode (E := E) G d A h e start B i z | |
| have hsub : F.image (fun w : G.points => w.val) β | |
| G.points.filter (PointOn (physicalStateAt (E := E) G d A h e start B i z).1) := by | |
| intro x hx | |
| rcases Finset.mem_image.mp hx with β¨w,hw,hwxβ© | |
| rw [β hwx] | |
| have hn := (Finset.mem_filter.mp hw).2 | |
| have he := congrArg Prod.fst hn | |
| change physicalStateAt (E := E) G d A h e start B i w = | |
| physicalStateAt (E := E) G d A h e start B i z at he | |
| have hp := (physicalStateAt_good (E := E) G d A h e start hs B i w).2.2.2.1 | |
| rw [he] at hp | |
| exact Finset.mem_filter.mpr β¨w.property,hpβ© | |
| calc | |
| _ = (F.image (fun w : G.points => w.val)).card := | |
| (Finset.card_image_of_injective F Subtype.val_injective).symm | |
| _ β€ _ := Finset.card_le_card hsub | |
| theorem physical_dimension_mono {n r E : β} (G : KernelGeometry n) (d : β β β) | |
| (A h e : β) (start : G.points β Ideal (MvPolynomial (Fin n) β) Γ IntegerPatch n) | |
| (hs : β z, PhysicalState G h e z.val (start z)) (B : Fin r β Finset β) | |
| (i : β) (z : G.points) : | |
| affineDimension (physicalStateAt (E := E) G d A h e start B (i+1) z).1 β€ | |
| affineDimension (physicalStateAt (E := E) G d A h e start B i z).1 := by | |
| rw [physicalStateAt_succ] | |
| exact (physical_step (E := E) G d A h e z.val z.property i _ | |
| (physicalStateAt_good (E := E) G d A h e start hs B i z) B).2.2.2.2.1 | |
| end | |
| section | |
| open MvPolynomial | |
| open scoped BigOperators | |
| attribute [local instance] Classical.propDecidable | |
| open scoped Classical | |
| theorem physical_stopped_count {n r E : β} (G : KernelGeometry n) (d : β β β) | |
| (A h e : β) (start : G.points β Ideal (MvPolynomial (Fin n) β) Γ IntegerPatch n) | |
| (hs : β z, PhysicalState G h e z.val (start z)) (B : Fin r β Finset β) | |
| (S : Finset G.points) (M b : Fin r β β) | |
| (L : List (Ideal (MvPolynomial (Fin n) β) Γ IntegerPatch n)) (T : β) | |
| (Ex : Ideal (MvPolynomial (Fin n) β) β Prop) | |
| (hstart : β z β S, start z β L) (hT : 1 β€ T) | |
| (hroot : β z β S, affineDimension (start z).1 β€ r) | |
| (hM : β i, 1 β€ M i) (hprime : β i, β p β B i, p.Prime) | |
| (hupper : β i, β p β B i, p β€ M i) | |
| (hbad : β i : Fin r, β z β S, | |
| ((B i).filter fun p : β => (p:β€) β£ eval z.val | |
| (physicalStateAt (E := E) G d A h e start B i.val z).2.minor).card β€ b i) | |
| (hcut : β i < r, β z β S, | |
| Β¬ Ex (physicalStateAt (E := E) G d A h e start B i z).1 β | |
| affineDimension (physicalStateAt (E := E) G d A h e start B i z).1 = r-i β | |
| affineDimension (physicalStateAt (E := E) G d A h e start B (i+1) z).1 < | |
| affineDimension (physicalStateAt (E := E) G d A h e start B i z).1) | |
| (hex : β i β€ r, β z β S, | |
| Ex (physicalStateAt (E := E) G d A h e start B i z).1 β | |
| (G.points.filter (PointOn (physicalStateAt (E := E) G d A h e start B i z).1)).card β€ T) : | |
| S.card β€ (β i β Finset.range (r+1), L.length * β j β Finset.range i, | |
| if hj : j < r then physicalBranchAllowance n d A h e B M b | |
| (fun k => r-k.val) β¨j,hjβ© else 1) * T := by | |
| classical | |
| let dim := fun z i => affineDimension (physicalStateAt (E := E) G d A h e start B i z).1 | |
| let ex := fun z i => Ex (physicalStateAt (E := E) G d A h e start B i z).1 | |
| let stop := fun z => firstStop r (fun i => ex z i β¨ dim z i = 0) | |
| have hm (z) (i) (_hi : i < r) : dim z (i+1) β€ dim z i := | |
| physical_dimension_mono G d A h e start hs B i z | |
| have hz (z) (hz : z β S) : dim z 0 β€ r := hroot z hz | |
| have hc (z) (hz : z β S) (i) (hi : i < r) : | |
| Β¬ ex z i β dim z i = r-i β dim z (i+1) < dim z i := hcut i hi z hz | |
| have hd (z) (hz' : z β S) := dimension_until_firstStop r (dim z) (ex z) (hz z hz') (hm z) (hc z hz') | |
| have ht (z) (hz' : z β S) := firstStop_terminal r (dim z) (ex z) (hz z hz') (hm z) (hc z hz') | |
| apply physical_forest_count G d A h e start hs B S stop M b (fun k => r-k.val) L T | |
| hstart (fun _ _ => firstStop_le _ _) hM hprime hupper | |
| Β· intro i z hz hi | |
| exact hd z hz i.val hi.le | |
| Β· intro i z hz _ | |
| exact hbad i z hz | |
| Β· intro i hi z hz hzi | |
| have hsub : (S.filter fun w => stop w = i β§ physicalNode (E := E) G d A h e start B i w = | |
| physicalNode (E := E) G d A h e start B i z) β | |
| S.filter (fun w => physicalNode (E := E) G d A h e start B i w = | |
| physicalNode (E := E) G d A h e start B i z) := by | |
| intro w hw | |
| obtain β¨hw,_,hnβ© := Finset.mem_filter.mp hw | |
| exact Finset.mem_filter.mpr β¨hw,hnβ© | |
| apply (Finset.card_le_card hsub).trans | |
| have hterm : ex z i β¨ dim z i = 0 := by | |
| have hh := ht z hz | |
| change ex z (stop z) β¨ dim z (stop z) = 0 at hh | |
| simpa only [hzi] using hh | |
| rcases hterm with he | he | |
| Β· exact (physical_fiber_le_points G d A h e start hs B i z S).trans (hex i hi z hz he) | |
| Β· exact (physical_zeroDim_fiber G d A h e start hs B i z S he).trans hT | |
| end | |
| theorem finite_prime_pool (N M : β) (hM : M β 0) : | |
| β P : Finset β, P.card = N β§ β p β P, p.Prime β§ M < p β§ p β€ 2^N*M := by | |
| induction N with | |
| | zero => exact β¨β ,by simp,by simpβ© | |
| | succ N ih => | |
| obtain β¨P,hcard,hPβ© := ih | |
| obtain β¨p,hp,hlo,hhiβ© := Nat.exists_prime_lt_and_le_two_mul (2^N*M) | |
| (Nat.mul_ne_zero (by positivity) hM) | |
| have hnot : p β P := fun h => (not_lt_of_ge (hP p h).2.2) hlo | |
| refine β¨insert p P,by simp [hnot,hcard],?_β© | |
| intro q hq | |
| rcases Finset.mem_insert.mp hq with rfl | hq | |
| Β· refine β¨hp,?_,?_β© | |
| Β· exact (Nat.le_mul_of_pos_left M (by positivity : 0 < 2^N)).trans_lt hlo | |
| Β· simpa only [pow_succ, Nat.mul_comm, Nat.mul_left_comm, Nat.mul_assoc] using hhi | |
| Β· obtain β¨hqprime,hqlo,hqhiβ© := hP q hq | |
| refine β¨hqprime,hqlo,hqhi.trans ?_β© | |
| exact Nat.mul_le_mul_right M (Nat.pow_le_pow_right (by decide) (Nat.le_succ N)) | |
| theorem disjoint_prime_pools (r t : β) (x : β) (hx : 1 β€ x) : | |
| β P : Fin r β Finset β, | |
| (β i, (P i).card = t) β§ | |
| (β i j, i β j β Disjoint (P i) (P j)) β§ | |
| β i p, p β P i β p.Prime β§ x β€ (p : β) β§ (p : β) β€ 2^(r*t+1)*x := by | |
| classical | |
| obtain β¨Q,hcard,hQβ© := finite_prime_pool (r*t) βxββ | |
| (Nat.ne_of_gt (Nat.ceil_pos.mpr (zero_lt_one.trans_le hx))) | |
| let e : (Fin r Γ Fin t) β Q := Fintype.equivOfCardEq (by simp [hcard]) | |
| let P : Fin r β Finset β := fun i => Finset.univ.image (fun j => (e (i,j)).val) | |
| have hinj (i : Fin r) : Function.Injective (fun j => (e (i,j)).val) := by | |
| intro j k he | |
| exact (Prod.mk.inj (e.injective (Subtype.ext he))).2 | |
| refine β¨P,?_,?_,?_β© | |
| Β· intro i | |
| simp only [P,Finset.card_image_of_injective _ (hinj i),Finset.card_univ,Fintype.card_fin] | |
| Β· intro i j hij | |
| apply Finset.disjoint_left.mpr | |
| intro p hpi hpj | |
| obtain β¨a,_,haβ© := Finset.mem_image.mp hpi | |
| obtain β¨b,_,hbβ© := Finset.mem_image.mp hpj | |
| exact hij (Prod.mk.inj (e.injective (Subtype.ext (ha.trans hb.symm)))).1 | |
| Β· intro i p hp | |
| obtain β¨j,_,rflβ© := Finset.mem_image.mp hp | |
| obtain β¨hprime,hlo,hhiβ© := hQ _ (e (i,j)).property | |
| refine β¨hprime,(Nat.le_ceil x).trans (by exact_mod_cast hlo.le),?_β© | |
| have hc : (βxββ : β) β€ 2*x := (Nat.ceil_lt_add_one (zero_le_one.trans hx)).le.trans (by linarith) | |
| calc | |
| ((e (i,j)).val : β) β€ (2 : β)^(r*t)*(βxββ : β) := by exact_mod_cast hhi | |
| _ β€ 2^(r*t)*(2*x) := mul_le_mul_of_nonneg_left hc (by positivity) | |
| _ = 2^(r*t+1)*x := by rw [pow_succ]; ring | |
| end QuarticPowerFree | |
| end OAI | |