Download data/lean/OAI/NumberTheory/PowerFree/GenericCuts.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 18.7 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/NumberTheory/PowerFree/GenericCuts.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/NumberTheory/PowerFree/GenericCuts.lean
-
curl -L -o GenericCuts.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/NumberTheory/PowerFree/GenericCuts.lean
18.7 kB
| import OAI.NumberTheory.PowerFree.IntegralKernels | |
| namespace OAI | |
| universe u | |
| open scoped BigOperators | |
| open Matrix | |
| open scoped BigOperators | |
| namespace QuarticPowerFree | |
| section | |
| open MvPolynomial | |
| attribute [local instance] Classical.propDecidable | |
| noncomputable def genericPoint {n : β} {K : Type*} [Field K] | |
| (I : Ideal (MvPolynomial (Fin n) K)) [I.IsPrime] : | |
| Fin n β FractionRing (MvPolynomial (Fin n) K β§Έ I) := | |
| fun i => algebraMap _ _ (Ideal.Quotient.mk I (X i)) | |
| theorem aeval_genericPoint {n : β} {K : Type*} [Field K] | |
| (I : Ideal (MvPolynomial (Fin n) K)) [I.IsPrime] : | |
| aeval (genericPoint I) = | |
| (IsScalarTower.toAlgHom K (MvPolynomial (Fin n) K β§Έ I) | |
| (FractionRing (MvPolynomial (Fin n) K β§Έ I))).comp (Ideal.Quotient.mkβ K I) := by | |
| ext i | |
| simp only [aeval_X, AlgHom.comp_apply] | |
| rfl | |
| theorem aeval_genericPoint_eq_zero_iff {n : β} {K : Type*} [Field K] | |
| (I : Ideal (MvPolynomial (Fin n) K)) [I.IsPrime] | |
| (p : MvPolynomial (Fin n) K) : | |
| aeval (genericPoint I) p = 0 β p β I := by | |
| rw [aeval_genericPoint] | |
| change algebraMap (MvPolynomial (Fin n) K β§Έ I) | |
| (FractionRing (MvPolynomial (Fin n) K β§Έ I)) (Ideal.Quotient.mk I p) = 0 β _ | |
| rw [map_eq_zero_iff _ (IsFractionRing.injective _ _), Ideal.Quotient.eq_zero_iff_mem] | |
| theorem aeval_jacobian_det {Ο Ξ² K F : Type*} [Fintype Ξ²] [DecidableEq Ξ²] | |
| [CommRing K] [CommRing F] [Algebra K F] | |
| (z : Ο β F) (v : Ξ² β Ο) (G : Ξ² β MvPolynomial Ο K) : | |
| aeval z (Matrix.det (fun i j => pderiv (v j) (G i))) = | |
| Matrix.det (fun i j => aeval z (pderiv (v j) (G i))) := by | |
| exact (aeval z).toRingHom.map_det (fun i j => pderiv (v j) (G i)) | |
| theorem bounded_patch_or_cut {n h D : β} {ΞΉ K : Type*} | |
| [Fintype ΞΉ] [Field K] [CharZero K] | |
| (I : Ideal (MvPolynomial (Fin n) K)) [I.IsPrime] | |
| (P : Polynomial β) (hP : P.natDegree β€ h) | |
| (hT : βαΆ T : β in Filter.atTop, | |
| (Module.finrank K ((totalSpace T).map (Ideal.Quotient.mkβ K I).toLinearMap) : β) = P.eval (T : β)) | |
| (hD : (h.factorial : β) * P.coeff h β€ D) | |
| (j : Fin h β Fin n) | |
| (hj : AlgebraicIndependent K (fun a => Ideal.Quotient.mk I (X (j a)))) | |
| (z : ΞΉ β Fin n β β€) (hzI : β p β I, β i, eval (fun l => (z i l : K)) p = 0) | |
| (H : β) (hH : 1 β€ H) (hz : β i l, |(z i l : β)| β€ H) : | |
| (β G : MvPolynomial (Fin n) β€, | |
| G.totalDegree β€ D β§ | |
| (β m, |((G.coeff m : β€) : β)| β€ integralKernelHeight ((D+n).choose n) (H^D)) β§ | |
| (β i, eval (z i) G = 0) β§ MvPolynomial.map (Int.castRingHom K) G β I) β¨ | |
| (β J : Set (Fin n), Nat.card J = h β§ | |
| β 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 | |
| classical | |
| obtain β¨G,hGdeg,hGheight,hGvan,hGspanβ© := | |
| exists_bounded_degree_vanishing_polynomials (F := K) z H hH hz D | |
| simp only [Fintype.card_fin] at hGheight | |
| by_cases hGI : β a, MvPolynomial.map (Int.castRingHom K) (G a) β I | |
| Β· right | |
| obtain β¨J,hJ,Pβ,hPdeg,hPI,hPdetβ© := bounded_generic_jacobian I P hP hT hD j hj | |
| have hspan (i : β₯(JαΆ)) : Pβ i β Submodule.span K | |
| (Set.range (fun a => MvPolynomial.map (Int.castRingHom K) (G a))) := | |
| hGspan (Pβ i) (hPdeg i) (hzI (Pβ i) (hPI i)) | |
| have hdet : Matrix.det (fun i l : β₯(JαΆ) => | |
| aeval (genericPoint I) (pderiv l.val (Pβ i))) β 0 := by | |
| rw [β aeval_jacobian_det] | |
| exact mt (aeval_genericPoint_eq_zero_iff I _).mp hPdet | |
| obtain β¨a,_,haβ© := exists_nonsingular_jacobian_of_span | |
| (genericPoint I) (fun l : β₯(JαΆ) => l.val) | |
| (fun a => MvPolynomial.map (Int.castRingHom K) (G a)) Pβ hspan hdet | |
| refine β¨J,hJ,(fun i => G (a i)),(fun i => hGdeg (a i)), | |
| (fun i => hGheight (a i)),(fun i => hGI (a i)),?_β© | |
| intro hm | |
| apply ha | |
| rw [β aeval_jacobian_det] | |
| exact (aeval_genericPoint_eq_zero_iff I _).mpr hm | |
| Β· left | |
| obtain β¨a,haβ© := not_forall.mp hGI | |
| exact β¨G a,hGdeg a,hGheight a,hGvan a,haβ© | |
| end | |
| open MvPolynomial | |
| lemma monomial_exponent_le_order {Ο : Type*} (m : Ο ββ β) (i : Ο) : | |
| m i β€ monomialOrder m := by | |
| classical | |
| by_cases hi : i β m.support | |
| Β· exact Finset.single_le_sum (fun _ _ => Nat.zero_le _) hi | |
| Β· simp only [Finsupp.notMem_support_iff.mp hi, Nat.zero_le] | |
| theorem eval_abs_le_height_degree {Ο : Type*} [Fintype Ο] | |
| (p : MvPolynomial Ο β€) (D : β) (hp : p.totalDegree β€ D) | |
| (C H : β) (hC : 0 β€ C) (hH : 1 β€ H) | |
| (hc : β m, |((p.coeff m : β€) : β)| β€ C) | |
| (z : Ο β β€) (hz : β i, |(z i : β)| β€ H) : | |
| |((eval z p : β€) : β)| β€ | |
| ((D + Fintype.card Ο).choose (Fintype.card Ο) : β) * C * H^D := by | |
| classical | |
| have hs : p.support β monomialsUpTo Ο D := by | |
| intro m hm | |
| exact mem_monomialsUpTo.mpr ((le_totalDegree hm).trans hp) | |
| have hcard : p.support.card β€ (D + Fintype.card Ο).choose (Fintype.card Ο) := by | |
| rw [β card_monomialsUpTo] | |
| exact Finset.card_le_card hs | |
| have hm (m : Ο ββ β) (hm : m β p.support) : | |
| |((p.coeff m * m.prod (fun i e => z i ^ e) : β€) : β)| β€ C * H^D := by | |
| rw [Int.cast_mul, abs_mul] | |
| exact mul_le_mul (hc m) | |
| (monomial_eval_abs_le z m H hH hz D ((le_totalDegree hm).trans hp)) | |
| (abs_nonneg _) hC | |
| rw [MvPolynomial.eval_eq, Int.cast_sum] | |
| calc | |
| |β m β p.support, ((p.coeff m * β i β m.support, z i ^ m i : β€) : β)| β€ | |
| β m β p.support, |((p.coeff m * β i β m.support, z i ^ m i : β€) : β)| := | |
| Finset.abs_sum_le_sum_abs _ _ | |
| _ β€ β _m β p.support, C * H^D := Finset.sum_le_sum hm | |
| _ = (p.support.card : β) * C * H^D := by simp [mul_assoc] | |
| _ β€ ((D + Fintype.card Ο).choose (Fintype.card Ο) : β) * C * H^D := by | |
| gcongr | |
| theorem pderiv_coeff_abs_le {Ο : Type*} (p : MvPolynomial Ο β€) | |
| (D : β) (hp : p.totalDegree β€ D) (C : β) (hC : 0 β€ C) | |
| (hc : β m, |((p.coeff m : β€) : β)| β€ C) (i : Ο) (m : Ο ββ β) : | |
| |(((pderiv i p).coeff m : β€) : β)| β€ (D : β) * C := by | |
| classical | |
| rw [coeff_pderiv] | |
| by_cases hn : p.coeff (m + Finsupp.single i 1) = 0 | |
| Β· simp only [hn, zero_mul, Int.cast_zero, abs_zero] | |
| positivity | |
| Β· have hd : monomialOrder (m + Finsupp.single i 1) β€ D := | |
| (le_totalDegree (mem_support_iff.mpr hn)).trans hp | |
| have hex := (monomial_exponent_le_order (m + Finsupp.single i 1) i).trans hd | |
| simp only [Finsupp.add_apply, Finsupp.single_eq_same] at hex | |
| rw [Int.cast_mul, abs_mul, Int.cast_add, Int.cast_natCast, Int.cast_one, | |
| abs_of_nonneg (by positivity : (0:β) β€ (m i : β) + 1)] | |
| calc | |
| _ β€ C * (D : β) := mul_le_mul (hc _) (by exact_mod_cast hex) (by positivity) hC | |
| _ = _ := mul_comm _ _ | |
| theorem pderiv_degree_le_sub_one {Ο R : Type*} [CommSemiring R] | |
| (p : MvPolynomial Ο R) (D : β) (hp : p.totalDegree β€ D) (i : Ο) : | |
| (pderiv i p).totalDegree β€ D-1 := by | |
| by_cases he : pderiv i p = 0 | |
| Β· simp [he] | |
| Β· have hd := pderiv_totalDegree_lt i p he | |
| omega | |
| theorem jacobian_minor_degree {Ο Ξ² R : Type*} [Fintype Ξ²] [DecidableEq Ξ²] | |
| [CommRing R] (G : Ξ² β MvPolynomial Ο R) (v : Ξ² β Ο) | |
| (D : β) (hG : β i, (G i).totalDegree β€ D) : | |
| (Matrix.det (fun i j => pderiv (v j) (G i))).totalDegree β€ | |
| Fintype.card Ξ² * (D-1) := by | |
| classical | |
| let M : Matrix Ξ² Ξ² (MvPolynomial Ο R) := fun i j => pderiv (v j) (G i) | |
| change M.det.totalDegree β€ _ | |
| rw [Matrix.det_apply] | |
| apply (totalDegree_finsetSum _ _).trans | |
| apply Finset.sup_le | |
| intro e _ | |
| apply (totalDegree_smul_le _ _).trans | |
| apply (totalDegree_finsetProd _ _).trans | |
| calc | |
| β i : Ξ², (pderiv (v i) (G (e i))).totalDegree β€ β _i : Ξ², (D-1) := | |
| Finset.sum_le_sum (fun i _ => pderiv_degree_le_sub_one _ D (hG _) _) | |
| _ = Fintype.card Ξ² * (D-1) := by simp | |
| theorem eval_jacobian_minor_abs_le {Ο Ξ² : Type*} | |
| [Fintype Ο] [Fintype Ξ²] [DecidableEq Ξ²] | |
| (G : Ξ² β MvPolynomial Ο β€) (v : Ξ² β Ο) | |
| (D : β) (hG : β i, (G i).totalDegree β€ D) | |
| (C H : β) (hC : 0 β€ C) (hH : 1 β€ H) | |
| (hc : β i m, |(((G i).coeff m : β€) : β)| β€ C) | |
| (z : Ο β β€) (hz : β i, |(z i : β)| β€ H) : | |
| |((eval z (Matrix.det (fun i j => pderiv (v j) (G i))) : β€) : β)| β€ | |
| (Fintype.card Ξ²).factorial * | |
| (((D + Fintype.card Ο).choose (Fintype.card Ο) : β) * ((D : β)*C) * H^D)^Fintype.card Ξ² := by | |
| let M : Matrix Ξ² Ξ² (MvPolynomial Ο β€) := fun i j => pderiv (v j) (G i) | |
| change |((eval z M.det : β€) : β)| β€ _ | |
| rw [(eval z).map_det M] | |
| apply det_abs_le_uniform | |
| intro i j | |
| apply eval_abs_le_height_degree _ D | |
| ((pderiv_degree_le_sub_one _ D (hG i) _).trans (Nat.sub_le _ _)) | |
| ((D : β)*C) H (mul_nonneg (Nat.cast_nonneg _) hC) hH | |
| (pderiv_coeff_abs_le _ D (hG i) C hC (hc i) (v j)) z hz | |
| theorem coordinate_transcendence_basis {n : β} {K : Type u} [Field K] | |
| (I : Ideal (MvPolynomial (Fin n) K)) [I.IsPrime] : | |
| β m : β, β j : Fin m β Fin n, | |
| AlgebraicIndependent K (fun a => Ideal.Quotient.mk I (MvPolynomial.X (j a))) β§ | |
| Algebra.trdeg K (MvPolynomial (Fin n) K β§Έ I) = m := by | |
| classical | |
| let A := MvPolynomial (Fin n) K β§Έ I | |
| let x : Fin n β A := fun i => Ideal.Quotient.mk I (MvPolynomial.X i) | |
| have hx : MvPolynomial.aeval x = Ideal.Quotient.mkβ K I := by | |
| apply MvPolynomial.algHom_ext | |
| intro i | |
| simp only [MvPolynomial.aeval_X] | |
| rfl | |
| have hg : Algebra.adjoin K (Set.range x) = β€ := by | |
| rw [Algebra.adjoin_range_eq_range_aeval, hx] | |
| exact (AlgHom.range_eq_top _).mpr Ideal.Quotient.mk_surjective | |
| have : Algebra.IsAlgebraic (Algebra.adjoin K (Set.range x)) A := by | |
| rw [hg] | |
| constructor | |
| intro a | |
| exact isAlgebraic_algebraMap (R := (β€ : Subalgebra K A)) β¨a, trivialβ© | |
| obtain β¨t, ht, htbβ© := exists_isTranscendenceBasis_subset (R := K) (A := A) (Set.range x) | |
| have htfin : t.Finite := (Set.finite_range x).subset ht | |
| let : Fintype t := htfin.fintype | |
| let e : Fin (Fintype.card t) β t := (Fintype.equivFin t).symm | |
| choose j hj using fun a : Fin (Fintype.card t) => ht (e a).property | |
| refine β¨Fintype.card t, j, ?_, ?_β© | |
| Β· have hi := htb.1.comp e e.injective | |
| simpa only [Function.comp_def, β hj] using hi | |
| Β· rw [β htb.cardinalMk_eq_trdeg, Cardinal.mk_fintype] | |
| theorem hilbert_natDegree_eq_trdeg {n : β} {K : Type u} [Field K] | |
| (I : Ideal (MvPolynomial (Fin n) K)) [I.IsPrime] | |
| (P : Polynomial β) | |
| (hT : βαΆ T : β in Filter.atTop, | |
| (Module.finrank K ((totalSpace T).map (Ideal.Quotient.mkβ K I).toLinearMap) : β) = | |
| P.eval (T : β)) : (P.natDegree : Cardinal) = Algebra.trdeg K (MvPolynomial (Fin n) K β§Έ I) := by | |
| obtain β¨Q,j,_,hj,_,Tβ,hQβ© := coordinate_hilbert_degree_independent I Ideal.IsPrime.ne_top' | |
| have hQN : βαΆ T : β in Filter.atTop, | |
| (Module.finrank K ((totalSpace T).map (Ideal.Quotient.mkβ K I).toLinearMap) : β) = | |
| Q.eval (T : β) := Filter.eventually_atTop.mpr β¨Tβ,hQβ© | |
| have hPN : βαΆ T : β in Filter.atTop, 0 β€ P.eval (T : β) := hT.mono (fun T ht => by | |
| rw [β ht]; positivity) | |
| have hQNN : βαΆ T : β in Filter.atTop, 0 β€ Q.eval (T : β) := hQN.mono (fun T ht => by | |
| rw [β ht]; positivity) | |
| have heval : βαΆ T : β in Filter.atTop, P.eval (T : β) = Q.eval (T : β) := by | |
| filter_upwards [hT,hQN] with T hp hq | |
| exact hp.symm.trans hq | |
| have hPQ : P.natDegree = Q.natDegree := le_antisymm | |
| (natDegree_le_of_eventually_nat_eval_bounds P Q hPN (heval.mono fun _ ht => ht.le)) | |
| (natDegree_le_of_eventually_nat_eval_bounds Q P hQNN (heval.mono fun _ ht => ht.ge)) | |
| obtain β¨m, z, hz, hmβ© := coordinate_transcendence_basis I | |
| have h1 : (P.natDegree : Cardinal) β€ Algebra.trdeg K (MvPolynomial (Fin n) K β§Έ I) := by | |
| rw [hPQ] | |
| simpa using hj.lift_cardinalMk_le_trdeg | |
| have h2 : m β€ P.natDegree := by | |
| by_contra hh | |
| have hm' : P.natDegree+1 β€ m := by omega | |
| let v : Fin (P.natDegree+1) β Fin n := fun a => z (Fin.castLE hm' a) | |
| exact not_independent_over_hilbert_degree I P le_rfl hT v | |
| (hz.comp (Fin.castLE hm') (Fin.castLE_injective hm')) | |
| rw [hm] at h1 β’ | |
| exact le_antisymm h1 (by exact_mod_cast h2) | |
| theorem proper_cut_hilbert_inequality {n : β} {K : Type*} [Field K] | |
| (I : Ideal (MvPolynomial (Fin n) K)) [I.IsPrime] | |
| (p : MvPolynomial (Fin n) K) (hp : p β I) (T : β) (hT : p.totalDegree β€ T) : | |
| Module.finrank K ((totalSpace T).map | |
| (Ideal.Quotient.mkβ K (I β Ideal.span {p})).toLinearMap) + | |
| Module.finrank K ((totalSpace (T-p.totalDegree)).map | |
| (Ideal.Quotient.mkβ K I).toLinearMap) β€ | |
| Module.finrank K ((totalSpace T).map (Ideal.Quotient.mkβ K I).toLinearMap) := by | |
| classical | |
| let A := MvPolynomial (Fin n) K β§Έ I | |
| let J := I β Ideal.span {p} | |
| let F := (totalSpace T).map (Ideal.Quotient.mkβ K I).toLinearMap | |
| let G := (totalSpace (T-p.totalDegree)).map (Ideal.Quotient.mkβ K I).toLinearMap | |
| let := totalSpace_finite (n := n) (K := K) T | |
| let := totalSpace_finite (n := n) (K := K) (T-p.totalDegree) | |
| let f := (Ideal.Quotient.factorβ K (show I β€ J from le_sup_left)).toLinearMap.domRestrict F | |
| let g : G ββ[K] F := | |
| { toFun := fun x => β¨Ideal.Quotient.mk I p * x.val, by | |
| obtain β¨q, hq, hqxβ© := x.property | |
| refine β¨p*q, ?_, ?_β© | |
| Β· apply mem_totalSpace.mpr | |
| exact (totalDegree_mul p q).trans ((Nat.add_le_add_left (mem_totalSpace.mp hq) _).trans | |
| (by omega)) | |
| Β· change Ideal.Quotient.mk I (p*q) = _ | |
| rw [map_mul] | |
| exact congrArg (fun y => Ideal.Quotient.mk I p * y) hqxβ© | |
| map_add' := by intros; ext; simp [mul_add] | |
| map_smul' := by intros; ext; simp } | |
| have hpn : Ideal.Quotient.mk I p β 0 := by | |
| exact fun h => hp (Ideal.Quotient.eq_zero_iff_mem.mp h) | |
| have hg : Function.Injective g := by | |
| intro x y h | |
| exact Subtype.ext (mul_left_cancelβ hpn (congrArg Subtype.val h)) | |
| have hgle : LinearMap.range g β€ LinearMap.ker f := by | |
| rintro x β¨y, rflβ© | |
| change (Ideal.Quotient.factorβ K (show I β€ J from le_sup_left)) | |
| (Ideal.Quotient.mk I p * y.val) = 0 | |
| rw [map_mul] | |
| have hpJ : Ideal.Quotient.mk J p = 0 := by | |
| apply Ideal.Quotient.eq_zero_iff_mem.mpr | |
| exact (le_sup_right : Ideal.span {p} β€ J) (Ideal.subset_span (Set.mem_singleton p)) | |
| change Ideal.Quotient.mk J p * _ = 0 | |
| rw [hpJ, zero_mul] | |
| have hk : Module.finrank K G β€ Module.finrank K (LinearMap.ker f) := by | |
| rw [β LinearMap.finrank_range_of_inj hg] | |
| exact Submodule.finrank_mono hgle | |
| have hdim := f.finrank_range_add_finrank_ker | |
| have hr : LinearMap.range f = (totalSpace T).map (Ideal.Quotient.mkβ K J).toLinearMap := by | |
| ext z | |
| constructor | |
| Β· rintro β¨β¨y, q, hq, rflβ©, rflβ© | |
| exact β¨q, hq, rflβ© | |
| Β· rintro β¨q, hq, rflβ© | |
| refine β¨β¨Ideal.Quotient.mk I q, β¨q, hq, rflβ©β©, rflβ© | |
| rw [hr] at hdim | |
| exact (Nat.add_le_add_left hk _).trans_eq hdim | |
| theorem coeff_taylor_high (P : Polynomial β) (a : β) (n : β) | |
| (hn : P.natDegree β€ n) : (Polynomial.taylor a P).coeff n = P.coeff n := by | |
| obtain h | rfl := lt_or_eq_of_le hn | |
| Β· rw [Polynomial.coeff_eq_zero_of_natDegree_lt (p := Polynomial.taylor a P) (by simpa using h), | |
| Polynomial.coeff_eq_zero_of_natDegree_lt h] | |
| Β· rw [Polynomial.coeff_taylor_natDegree, Polynomial.coeff_natDegree] | |
| theorem hilbert_difference_degree (P : Polynomial β) (a : β) (h : β) | |
| (hP : P.natDegree β€ h+1) : (P - Polynomial.taylor a P).natDegree β€ h := by | |
| apply Polynomial.natDegree_le_iff_coeff_eq_zero.mpr | |
| intro n hn | |
| rw [Polynomial.coeff_sub, coeff_taylor_high P a n (by omega), sub_self] | |
| theorem hilbert_difference_coeff (P : Polynomial β) (a : β) (h : β) | |
| (hP : P.natDegree β€ h+1) : | |
| (P - Polynomial.taylor (-a) P).coeff h = a * (h+1) * P.coeff (h+1) := by | |
| have hn : (Polynomial.hasseDeriv h P).natDegree β€ 1 := | |
| (Polynomial.natDegree_hasseDeriv_le P h).trans (by omega) | |
| rw [Polynomial.coeff_sub, Polynomial.taylor_coeff, | |
| Polynomial.eq_X_add_C_of_natDegree_le_one hn] | |
| simp only [Polynomial.eval_add, Polynomial.eval_mul, Polynomial.eval_C, | |
| Polynomial.eval_X, Polynomial.hasseDeriv_coeff, zero_add, Nat.choose_self, | |
| Nat.cast_one, one_mul] | |
| rw [Nat.add_comm 1 h, Nat.choose_succ_self_right] | |
| push_cast | |
| ring | |
| theorem proper_cut_hilbert_polynomial {n : β} {K : Type*} [Field K] | |
| (I : Ideal (MvPolynomial (Fin n) K)) [I.IsPrime] | |
| (p : MvPolynomial (Fin n) K) (hp : p β I) (P Q : Polynomial β) | |
| (hP : βαΆ T : β in Filter.atTop, P.eval (T : β) = | |
| Module.finrank K ((totalSpace T).map (Ideal.Quotient.mkβ K I).toLinearMap)) | |
| (hQ : βαΆ T : β in Filter.atTop, Q.eval (T : β) = | |
| Module.finrank K ((totalSpace T).map | |
| (Ideal.Quotient.mkβ K (I β Ideal.span {p})).toLinearMap)) | |
| (h : β) (hdeg : P.natDegree β€ h+1) : | |
| Q.natDegree β€ h β§ Q.coeff h β€ (p.totalDegree : β) * (h+1) * P.coeff (h+1) := by | |
| let D := P - Polynomial.taylor (-(p.totalDegree : β)) P | |
| have hD : D.natDegree β€ h := hilbert_difference_degree P _ h hdeg | |
| have hn : βαΆ T : β in Filter.atTop, 0 β€ Q.eval (T : β) := hQ.mono (fun T hT => by | |
| rw [hT]; positivity) | |
| have hl : βαΆ T : β in Filter.atTop, Q.eval (T : β) β€ D.eval (T : β) := by | |
| have hs := (Filter.tendsto_sub_atTop_nat p.totalDegree).eventually hP | |
| filter_upwards [hP, hQ, hs, Filter.eventually_ge_atTop p.totalDegree] with T hPT hQT hPS hT | |
| have hi := proper_cut_hilbert_inequality I p hp T hT | |
| have hie : (Module.finrank K ((totalSpace T).map | |
| (Ideal.Quotient.mkβ K (I β Ideal.span {p})).toLinearMap) : β) + | |
| Module.finrank K ((totalSpace (T-p.totalDegree)).map | |
| (Ideal.Quotient.mkβ K I).toLinearMap) β€ | |
| Module.finrank K ((totalSpace T).map (Ideal.Quotient.mkβ K I).toLinearMap) := by | |
| exact_mod_cast hi | |
| dsimp [D] | |
| rw [Polynomial.eval_sub, Polynomial.taylor_eval, β sub_eq_add_neg, | |
| β Nat.cast_sub hT, hPT, hQT, hPS] | |
| exact le_sub_iff_add_le.mpr hie | |
| have hdQ := (natDegree_le_of_eventually_nat_eval_bounds Q D hn hl).trans hD | |
| refine β¨hdQ, ?_β© | |
| have hc := coeff_le_of_eventually_nat_eval_le Q D h hdQ hD hl | |
| exact hc.trans_eq (hilbert_difference_coeff P (p.totalDegree : β) h hdeg) | |
| end QuarticPowerFree | |
| end OAI | |