| import OAI.NumberTheory.PowerFree.DegreeBudgets |
|
|
| namespace OAI |
|
|
| universe u |
|
|
| open scoped BigOperators |
| open Matrix |
| open scoped BigOperators |
| namespace QuarticPowerFree |
|
|
| section |
| open MvPolynomial |
| open scoped BigOperators |
| |
| theorem exists_mv_interpolate {ι σ K : Type*} [Fintype ι] [Field K] |
| (z : ι → σ → K) (hz : Function.Injective z) (v : ι → K) : |
| ∃ p : MvPolynomial σ K, ∀ i, eval (z i) p = v i := by |
| classical |
| have hsep : ∀ i j : ι, i ≠ j → ∃ a, z i a ≠ z j a := by |
| intro i j hij |
| by_contra! h |
| exact hij (hz (funext h)) |
| let L : ι → ι → MvPolynomial σ K := fun i j => |
| if hij : i = j then 1 else |
| let a := (hsep i j hij).choose |
| C ((z i a - z j a)⁻¹) * (X a - C (z j a)) |
| have hLi : ∀ i j, eval (z i) (L i j) = 1 := by |
| intro i j |
| by_cases h : i = j |
| · simp [L, h] |
| · simp only [L, h, ↓reduceDIte, map_mul, eval_C, map_sub, eval_X] |
| exact inv_mul_cancel₀ (sub_ne_zero.mpr (hsep i j h).choose_spec) |
| have hLj : ∀ i j, i ≠ j → eval (z j) (L i j) = 0 := by |
| intro i j h |
| simp [L, h] |
| refine ⟨∑ i, C (v i) * ∏ j, L i j, ?_⟩ |
| intro a |
| rw [map_sum, Finset.sum_eq_single a] |
| · simp [hLi] |
| · intro i _ hia |
| rw [map_mul, eval_C, map_prod] |
| have hp : (∏ j, eval (z a) (L i j)) = 0 := |
| Finset.prod_eq_zero (Finset.mem_univ a) (hLj i a hia) |
| rw [hp, mul_zero] |
| · simp |
|
|
| theorem card_points_le_hilbert_constant {n : ℕ} {K ι : Type*} [Field K] [Fintype ι] |
| (I : Ideal (MvPolynomial (Fin n) K)) (z : ι → Fin n → K) |
| (hz : Function.Injective z) (hroot : ∀ i p, p ∈ I → eval (z i) p = 0) |
| (P : Polynomial ℚ) (hdeg : P.natDegree = 0) |
| (hP : ∀ᶠ T : ℕ in Filter.atTop, |
| (Module.finrank K ((totalSpace T).map (Ideal.Quotient.mkₐ K I).toLinearMap) : ℚ) = P.eval (T : ℚ)) : |
| (Fintype.card ι : ℚ) ≤ P.coeff 0 := by |
| classical |
| choose p hp using fun i : ι => exists_mv_interpolate z hz (Pi.single i 1) |
| obtain ⟨N,hN⟩ := Filter.eventually_atTop.mp hP |
| let T := max N (Finset.univ.sup (fun i => (p i).totalDegree)) |
| have hpd : ∀ i, p i ∈ totalSpace T := by |
| intro i |
| apply mem_totalSpace.mpr |
| exact (Finset.le_sup (f := fun j => (p j).totalDegree) (Finset.mem_univ i)).trans (le_max_right _ _) |
| let W := (totalSpace T).map (Ideal.Quotient.mkₐ K I).toLinearMap |
| let L : (ι → K) →ₗ[K] W := |
| { toFun := fun x => ⟨Ideal.Quotient.mk I (∑ i, x i • p i), |
| ⟨∑ i, x i • p i, Submodule.sum_mem _ (fun i _ => Submodule.smul_mem _ _ (hpd i)), rfl⟩⟩ |
| map_add' := by |
| intro x y |
| apply Subtype.ext |
| change Ideal.Quotient.mk I (∑ i, (x i+y i) • p i) = |
| Ideal.Quotient.mk I (∑ i, x i • p i) + Ideal.Quotient.mk I (∑ i, y i • p i) |
| simp only [add_smul, Finset.sum_add_distrib, map_add] |
| map_smul' := by |
| intro c x |
| apply Subtype.ext |
| change Ideal.Quotient.mk I (∑ i, (c*x i) • p i) = |
| c • Ideal.Quotient.mk I (∑ i, x i • p i) |
| have hs : (∑ i, (c*x i) • p i) = c • (∑ i, x i • p i) := by |
| rw [Finset.smul_sum] |
| simp only [smul_smul] |
| rw [hs] |
| exact (Ideal.Quotient.mkₐ K I).toLinearMap.map_smul c _ } |
| have hev (x : ι → K) (i : ι) : eval (z i) (∑ j, x j • p j) = x i := by |
| change (aeval (z i)).toLinearMap (∑ j, x j • p j) = x i |
| have he (j : ι) : (aeval (z i)).toLinearMap (p j) = (if j=i then (1 : K) else 0) := by |
| change eval (z i) (p j) = _ |
| simpa [Pi.single_apply, eq_comm] using hp j i |
| simp only [map_sum, LinearMap.map_smul, he, smul_eq_mul] |
| simp |
| have hL : Function.Injective L := by |
| intro x y hxy |
| have hm : (∑ i, x i • p i) - (∑ i, y i • p i) ∈ I := |
| Ideal.Quotient.eq.mp (congrArg Subtype.val hxy) |
| funext i |
| have he := hroot i _ hm |
| rw [map_sub, hev, hev, sub_eq_zero] at he |
| exact he |
| let := totalSpace_finite (n := n) (K := K) T |
| have hc : Fintype.card ι ≤ Module.finrank K W := by |
| simpa only [Module.finrank_fintype_fun_eq_card] using LinearMap.finrank_le_finrank_of_injective hL |
| have he := hN T (le_max_left _ _) |
| rw [Polynomial.eq_C_of_natDegree_eq_zero hdeg, Polynomial.eval_C] at he |
| exact (Nat.cast_le.mpr hc).trans_eq he |
|
|
| end |
| section |
| open MvPolynomial |
| attribute [local instance] Classical.propDecidable |
|
|
| theorem affineDimension_independent_coordinates {n : ℕ} {K : Type*} [Field K] |
| (I : Ideal (MvPolynomial (Fin n) K)) (hI : I ≠ ⊤) : |
| ∃ j : Fin (affineDimension I) → Fin n, |
| Function.Injective j ∧ |
| AlgebraicIndependent K (fun a => Ideal.Quotient.mk I (X (j a))) := by |
| obtain ⟨P,j,hj,hi,_,N,hN⟩ := coordinate_hilbert_degree_independent I hI |
| have he : P = coordinateHilbert I := by |
| apply polynomial_eq_of_eventually_nat_eval_eq |
| filter_upwards [Filter.eventually_atTop.mpr ⟨N,hN⟩,coordinateHilbert_eventually I] with T hp hq |
| exact hp.symm.trans hq |
| subst P |
| exact ⟨j,hj,hi⟩ |
| |
| theorem determined_bounded_patch {n D : ℕ} {ι K : Type*} |
| [Fintype ι] [Field K] [CharZero K] |
| (I : Ideal (MvPolynomial (Fin n) K)) [I.IsPrime] |
| (hD : affineDegree I ≤ D) (z : ι → Fin n → ℤ) |
| (hdet : DeterminedInDegree I z D) |
| (hzI : ∀ p ∈ I, ∀ i, eval (fun l => (z i l : K)) p = 0) |
| (H : ℝ) (hH : 1 ≤ H) (hz : ∀ i l, |(z i l : ℝ)| ≤ H) : |
| ∃ J : Set (Fin n), Nat.card J = affineDimension I ∧ |
| ∃ G : ↥(Jᶜ) → MvPolynomial (Fin n) ℤ, |
| (∀ i, (G i).totalDegree ≤ D) ∧ |
| (∀ i m, |(((G i).coeff m : ℤ) : ℝ)| ≤ integralKernelHeight ((D+n).choose n) (H^D)) ∧ |
| (∀ i, MvPolynomial.map (Int.castRingHom K) (G i) ∈ I) ∧ |
| Matrix.det (fun i l : ↥(Jᶜ) => pderiv l.val (MvPolynomial.map (Int.castRingHom K) (G i))) ∉ I := by |
| obtain ⟨j,_,hj⟩ := affineDimension_independent_coordinates I (Ideal.IsPrime.ne_top inferInstance) |
| obtain hc | hp := bounded_patch_or_cut I (coordinateHilbert I) le_rfl |
| (coordinateHilbert_eventually I) hD j hj z hzI H hH hz |
| · obtain ⟨G,hG,_,hvan,hnot⟩ := hc |
| have hd : (MvPolynomial.map (Int.castRingHom K) G).totalDegree ≤ D := by |
| simpa only [totalDegree, support_map_of_injective G (f := Int.castRingHom K) (Int.cast_injective (α := K))] using hG |
| have hv : ∀ i, eval (fun l => (z i l : K)) (MvPolynomial.map (Int.castRingHom K) G) = 0 := by |
| intro i |
| have he := map_eval (Int.castRingHom K) (z i) G |
| rw [hvan i, map_zero] at he |
| exact he.symm |
| exact (hnot ((hdet _ hd).mp hv)).elim |
| · exact hp |
| |
| theorem point_on_minimal_component {n : ℕ} {K : Type*} [Field K] |
| (J : Ideal (MvPolynomial (Fin n) K)) (z : Fin n → K) |
| (hz : ∀ p ∈ J, eval z p = 0) : |
| ∃ Q ∈ J.minimalPrimes, ∀ p ∈ Q, eval z p = 0 := by |
| let P := RingHom.ker (eval z) |
| have hP : P.IsPrime := RingHom.ker_isPrime _ |
| obtain ⟨Q,hQ,hQP⟩ := Ideal.exists_minimalPrimes_le (show J ≤ P from hz) |
| exact ⟨Q,hQ,fun p hp => hQP hp⟩ |
| |
| theorem proper_cut_components {n h : ℕ} {K : Type u} [Field K] |
| (I : Ideal (MvPolynomial (Fin n) K)) [I.IsPrime] |
| (p : MvPolynomial (Fin n) K) (hp : p ∉ I) |
| (hd : affineDimension I = h+1) : |
| ∃ Q : Finset (Ideal (MvPolynomial (Fin n) K)), |
| (∀ J ∈ Q, J.IsPrime ∧ affineDimension J = h) ∧ |
| (∑ J ∈ Q, affineDegree J) ≤ (p.totalDegree : ℚ) * affineDegree I ∧ |
| (Q.card : ℚ) ≤ (p.totalDegree : ℚ) * affineDegree I ∧ |
| (∀ z : Fin n → K, (∀ F ∈ I, eval z F = 0) → eval z p = 0 → |
| ∃ J ∈ Q, ∀ F ∈ J, eval z F = 0) := by |
| classical |
| let J := I ⊔ Ideal.span {p} |
| let Q := (Ideal.finite_minimalPrimes_of_isNoetherianRing (MvPolynomial (Fin n) K) J).toFinset |
| have hQ : ∀ q : Q, q.val ∈ J.minimalPrimes := fun q => by |
| exact (Set.Finite.mem_toFinset _).mp q.property |
| refine ⟨Q,?_,?_,?_,?_⟩ |
| · intro q hq |
| have hm := hQ ⟨q,hq⟩ |
| have := hm.isPrime |
| exact ⟨hm.isPrime,proper_cut_component_dimension I q p hp hm hd⟩ |
| · simpa only [Finset.univ_eq_attach, Finset.sum_attach] using proper_cut_sum_affineDegree_le I p hp hd (fun q : Q => q.val) hQ Subtype.val_injective |
| · simpa using proper_cut_component_card_le I p hp hd (fun q : Q => q.val) hQ Subtype.val_injective |
| · intro z hI hz |
| have hvan : ∀ F ∈ J, eval z F = 0 := by |
| change J ≤ RingHom.ker (eval z) |
| apply sup_le hI |
| exact Ideal.span_le.mpr (Set.singleton_subset_iff.mpr hz) |
| obtain ⟨q,hq,hzq⟩ := point_on_minimal_component J z hvan |
| exact ⟨q,(Set.Finite.mem_toFinset _).mpr hq,hzq⟩ |
| |
| end |
| open MvPolynomial |
| |
| theorem zeroDim_isMaximal {n : ℕ} {K : Type u} [Field K] |
| (I : Ideal (MvPolynomial (Fin n) K)) [I.IsPrime] |
| (hd : affineDimension I = 0) : I.IsMaximal := by |
| have ht := hilbert_natDegree_eq_trdeg I (coordinateHilbert I) (coordinateHilbert_eventually I) |
| change (affineDimension I : Cardinal) = _ at ht |
| rw [hd, Nat.cast_zero] at ht |
| let : Algebra.IsAlgebraic K (MvPolynomial (Fin n) K ⧸ I) := trdeg_eq_zero_iff.mp ht.symm |
| exact Ideal.Quotient.maximal_of_isField I (isField_of_isIntegral_of_isField' (R := K) |
| (S := MvPolynomial (Fin n) K ⧸ I) (Field.toIsField K)) |
| |
| theorem zeroDim_eq_point {n : ℕ} {K : Type u} [Field K] |
| (I : Ideal (MvPolynomial (Fin n) K)) [I.IsPrime] |
| (hd : affineDimension I = 0) (z : Fin n → K) |
| (hz : ∀ p ∈ I, eval z p = 0) : I = RingHom.ker (eval z) := by |
| apply (zeroDim_isMaximal I hd).eq_of_le (RingHom.ker_isPrime _).ne_top |
| exact hz |
| |
| theorem zeroDim_determined {n D : ℕ} {ι K : Type*} [Nonempty ι] [Field K] |
| (I : Ideal (MvPolynomial (Fin n) K)) [I.IsPrime] |
| (hd : affineDimension I = 0) (z : ι → Fin n → ℤ) |
| (hz : ∀ p ∈ I, ∀ i, eval (fun l => (z i l : K)) p = 0) : DeterminedInDegree I z D := by |
| intro p _ |
| constructor |
| · intro hp |
| obtain ⟨i⟩ := ‹Nonempty ι› |
| rw [zeroDim_eq_point I hd (fun l => (z i l : K)) (fun q hq => hz q hq i)] |
| exact hp i |
| · exact hz p |
| |
| open MvPolynomial |
| open scoped BigOperators |
| attribute [local instance] Classical.propDecidable |
| |
| structure IntegerPatch (n : ℕ) where |
| free : Set (Fin n) |
| equations : ↥(freeᶜ) → MvPolynomial (Fin n) ℤ |
| |
| noncomputable def IntegerPatch.minor {n : ℕ} (P : IntegerPatch n) : MvPolynomial (Fin n) ℤ := |
| Matrix.det (fun i j : ↥(P.freeᶜ) => pderiv j.val (P.equations i)) |
| |
| def IntegerPatch.On {n : ℕ} {K : Type*} [Field K] |
| (P : IntegerPatch n) (I : Ideal (MvPolynomial (Fin n) K)) : Prop := |
| Nat.card P.free = affineDimension I ∧ |
| (∀ i, MvPolynomial.map (Int.castRingHom K) (P.equations i) ∈ I) ∧ |
| MvPolynomial.map (Int.castRingHom K) P.minor ∉ I |
| |
| def IntegerPatch.Bounded {n : ℕ} (P : IntegerPatch n) (D : ℕ) (H : ℝ) : Prop := |
| ∃ d ≤ D, (∀ i, (P.equations i).totalDegree ≤ d) ∧ |
| ∀ i m, |(((P.equations i).coeff m : ℤ) : ℝ)| ≤ |
| integralKernelHeight ((d+n).choose n) (H^d) |
| |
| def PointOn {n : ℕ} {K : Type*} [Field K] |
| (I : Ideal (MvPolynomial (Fin n) K)) (z : Fin n → ℤ) : Prop := |
| ∀ p ∈ I, eval (fun l => (z l : K)) p = 0 |
| |
| theorem IntegerPatch.Bounded.mono {n D E : ℕ} {P : IntegerPatch n} {H : ℝ} |
| (h : P.Bounded D H) (hDE : D ≤ E) : P.Bounded E H := by |
| obtain ⟨d,hd,hdeg,hheight⟩ := h |
| exact ⟨d,hd.trans hDE,hdeg,hheight⟩ |
| |
| theorem map_integer_minor {n : ℕ} {K : Type*} [Field K] (P : IntegerPatch n) : |
| MvPolynomial.map (Int.castRingHom K) P.minor = |
| Matrix.det (fun i j : ↥(P.freeᶜ) => pderiv j.val |
| (MvPolynomial.map (Int.castRingHom K) (P.equations i))) := by |
| let M : Matrix ↥(P.freeᶜ) ↥(P.freeᶜ) (MvPolynomial (Fin n) ℤ) := |
| fun i j => pderiv j.val (P.equations i) |
| have he := (MvPolynomial.map (Int.castRingHom K)).map_det M |
| calc |
| MvPolynomial.map (Int.castRingHom K) P.minor = |
| Matrix.det (fun i j => MvPolynomial.map (Int.castRingHom K) (M i j)) := he |
| _ = _ := by congr 1; funext i j; exact pderiv_map.symm |
| |
| theorem determined_integer_patch {n D : ℕ} {ι K : Type*} |
| [Fintype ι] [Field K] [CharZero K] |
| (I : Ideal (MvPolynomial (Fin n) K)) [I.IsPrime] |
| (hD : affineDegree I ≤ D) (z : ι → Fin n → ℤ) |
| (hdet : DeterminedInDegree I z D) |
| (hzI : ∀ i, PointOn I (z i)) |
| (H : ℝ) (hH : 1 ≤ H) (hz : ∀ i l, |(z i l : ℝ)| ≤ H) : |
| ∃ P : IntegerPatch n, P.On I ∧ P.Bounded D H := by |
| obtain ⟨J,hJ,G,hdeg,hheight,hGI,hminor⟩ := determined_bounded_patch I hD z hdet |
| (fun p hp i => hzI i p hp) H hH hz |
| let P : IntegerPatch n := ⟨J,G⟩ |
| refine ⟨P,⟨hJ,hGI,?_⟩,D,le_rfl,hdeg,hheight⟩ |
| simpa only [map_integer_minor] using hminor |
| |
| theorem IntegerPatch.minor_degree_le {n D : ℕ} {P : IntegerPatch n} {H : ℝ} |
| (h : P.Bounded D H) : P.minor.totalDegree ≤ n * D := by |
| obtain ⟨d,hd,hdeg,_⟩ := h |
| apply (jacobian_minor_degree P.equations Subtype.val d hdeg).trans |
| apply Nat.mul_le_mul |
| · simpa only [Fintype.card_fin] using Fintype.card_subtype_le (fun x : Fin n => x ∈ P.freeᶜ) |
| · exact (Nat.sub_le _ _).trans hd |
| |
| theorem bounded_cut_components {n h e D : ℕ} {K : Type u} [Field K] |
| (I : Ideal (MvPolynomial (Fin n) K)) [I.IsPrime] |
| (he : affineDegree I ≤ e) (p : MvPolynomial (Fin n) K) |
| (hp : p ∉ I) (hpD : p.totalDegree ≤ D) (hd : affineDimension I = h+1) : |
| ∃ Q : Finset (Ideal (MvPolynomial (Fin n) K)), |
| Q.card ≤ D*e ∧ |
| (∀ J ∈ Q, J.IsPrime ∧ I ≤ J ∧ affineDimension J = h ∧ affineDegree J ≤ D*e) ∧ |
| (∀ z : Fin n → K, (∀ F ∈ I, eval z F = 0) → eval z p = 0 → |
| ∃ J ∈ Q, ∀ F ∈ J, eval z F = 0) := by |
| classical |
| let J := I ⊔ Ideal.span {p} |
| let Q := (Ideal.finite_minimalPrimes_of_isNoetherianRing (MvPolynomial (Fin n) K) J).toFinset |
| have hQ : ∀ q : Q, q.val ∈ J.minimalPrimes := fun q => |
| (Set.Finite.mem_toFinset _).mp q.property |
| have hsum : ∑ q ∈ Q, affineDegree q ≤ (D*e : ℕ) := by |
| calc |
| ∑ q ∈ Q, affineDegree q ≤ (p.totalDegree : ℚ) * affineDegree I := by |
| simpa only [Finset.univ_eq_attach, Finset.sum_attach] using |
| proper_cut_sum_affineDegree_le I p hp hd (fun q : Q => q.val) hQ Subtype.val_injective |
| _ ≤ (D : ℚ) * e := mul_le_mul (by exact_mod_cast hpD) he |
| ((one_le_affineDegree I Ideal.IsPrime.ne_top').trans' zero_le_one) (Nat.cast_nonneg _) |
| _ = (D*e : ℕ) := by norm_cast |
| have hnonneg : ∀ q ∈ Q, (0 : ℚ) ≤ affineDegree q := fun q hq => |
| zero_le_one.trans (one_le_affineDegree q (hQ ⟨q,hq⟩).isPrime.ne_top) |
| refine ⟨Q,?_,?_,?_⟩ |
| · have hc : (Q.card : ℚ) ≤ ∑ q ∈ Q, affineDegree q := by |
| calc |
| (Q.card : ℚ) = ∑ _q ∈ Q, (1 : ℚ) := by simp |
| _ ≤ _ := Finset.sum_le_sum fun q hq => one_le_affineDegree q (hQ ⟨q,hq⟩).isPrime.ne_top |
| exact_mod_cast hc.trans hsum |
| · intro q hq |
| have hm := hQ ⟨q,hq⟩ |
| let := hm.isPrime |
| refine ⟨hm.isPrime,?_,proper_cut_component_dimension I q p hp hm hd,?_⟩ |
| · exact le_sup_left.trans hm.1.2 |
| · simpa only [Nat.cast_mul] using (Finset.single_le_sum hnonneg hq).trans hsum |
| · intro z hz hpz |
| obtain ⟨q,hq,hzq⟩ := point_on_minimal_component J z (show J ≤ RingHom.ker (eval z) from |
| sup_le hz (Ideal.span_le.mpr (Set.singleton_subset_iff.mpr hpz))) |
| exact ⟨q,(Set.Finite.mem_toFinset _).mpr hq,hzq⟩ |
| |
| end QuarticPowerFree |
| |
| end OAI |
| |
