| 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 |
|
|
