Download data/lean/OAI/Algebra/FiniteTensor/JacobianAlgebraicity.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 14.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algebra/FiniteTensor/JacobianAlgebraicity.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algebra/FiniteTensor/JacobianAlgebraicity.lean
-
curl -L -o JacobianAlgebraicity.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algebra/FiniteTensor/JacobianAlgebraicity.lean
14.2 kB
| import Mathlib | |
| import OAI.Algebra.FiniteTensor.AdicSystems | |
| namespace OAI | |
| /-! Algebraicity from nondegenerate Jacobians and rectangular correction systems. -/ | |
| noncomputable section | |
| open scoped BigOperators | |
| namespace PD4Tensor.Spreading | |
| noncomputable section | |
| open scoped BigOperators | |
| open MvPolynomial | |
| variable {K L Ο : Type*} [Field K] [Field L] [Algebra K L] | |
| variable [Fintype Ο] [DecidableEq Ο] | |
| theorem derivation_mv_aeval {M : Type*} [AddCommGroup M] [Module L M] | |
| [Module K M] [IsScalarTower K L M] (D : Derivation K L M) | |
| (a : Ο β L) (p : MvPolynomial Ο K) : | |
| D (aeval a p)=β i : Ο,aeval a (pderiv i p) β’ D (a i) := by | |
| induction p using MvPolynomial.induction_on with | |
| | C r => simp | |
| | add p q hp hq => simp only [map_add,hp,hq,add_smul,Finset.sum_add_distrib] | |
| | mul_X p k hp => | |
| simp only [map_mul,aeval_X,D.leibniz,hp,pderiv_mul,map_add,add_smul, | |
| Finset.sum_add_distrib] | |
| rw [Finset.smul_sum] | |
| apply Eq.trans _ (add_comm _ _) | |
| congr 1 | |
| Β· rw [Finset.sum_eq_single k] | |
| Β· simp | |
| Β· intro i hi hik | |
| simp [pderiv_X,Ne.symm hik] | |
| Β· simp | |
| Β· apply Finset.sum_congr rfl | |
| intro i hi | |
| rw [mul_smul,smul_comm] | |
| private theorem matrix_module_kernel_zero {M : Type*} [AddCommGroup M] [Module L M] | |
| (J : Matrix Ο Ο L) (hJ : J.detβ 0) (v : Ο β M) | |
| (hv : β k,β i : Ο,J k i β’ v i=0) : β i,v i=0 := by | |
| intro i | |
| have h : J.det β’ v i=0 := by | |
| calc | |
| J.det β’ v i = β j : Ο,(J.adjugate*J) i j β’ v j := by | |
| rw [Matrix.adjugate_mul] | |
| simp [Matrix.smul_apply,Matrix.one_apply] | |
| _ = β k : Ο,J.adjugate i k β’ (β j : Ο,J k j β’ v j) := by | |
| simp only [Matrix.mul_apply,Finset.sum_smul,Finset.smul_sum,mul_smul] | |
| rw [Finset.sum_comm] | |
| _ = 0 := by simp only [hv,smul_zero,Finset.sum_const_zero] | |
| exact (smul_eq_zero.mp h).resolve_left hJ | |
| theorem isAlgebraic_of_mv_jacobian (f : Ο β MvPolynomial Ο K) (a : Ο β L) | |
| (hf : β k,aeval a (f k)=0) | |
| (hJ : Matrix.det (fun k i=>aeval a (pderiv i (f k)))β 0) : | |
| β i,IsAlgebraic K (a i) := by | |
| let E : IntermediateField K L := IntermediateField.adjoin K (Set.range a) | |
| let b : Ο β E := fun i=>β¨a i,IntermediateField.subset_adjoin K _ (Set.mem_range_self i)β© | |
| have hb (k : Ο) : aeval b (f k)=0 := by | |
| apply E.val.injective | |
| change E.val (aeval b (f k))=E.val 0 | |
| rw [map_zero,MvPolynomial.comp_aeval_apply] | |
| exact hf k | |
| let J : Matrix Ο Ο E := fun k i=>aeval b (pderiv i (f k)) | |
| have hJE : J.detβ 0 := by | |
| intro h | |
| have hh := congrArg E.val h | |
| rw [map_zero,E.val.map_det] at hh | |
| have hm : E.val.mapMatrix J=(fun k i=>aeval a (pderiv i (f k))) := by | |
| ext k i | |
| exact MvPolynomial.comp_aeval_apply b E.val (pderiv i (f k)) | |
| rw [hm] at hh | |
| exact hJ hh | |
| let D := KaehlerDifferential.D K E | |
| have hDb : β i,D (b i)=0 := by | |
| apply matrix_module_kernel_zero J hJE | |
| intro k | |
| rw [βderivation_mv_aeval D b (f k),hb k,map_zero] | |
| have hD : β x : E,D x=0 := by | |
| rintro β¨x,hxβ© | |
| change xβIntermediateField.adjoin K (Set.range a) at hx | |
| induction hx using IntermediateField.adjoin_induction with | |
| | mem x hx => | |
| obtain β¨i,rflβ© := hx | |
| exact hDb i | |
| | algebraMap r => exact D.map_algebraMap r | |
| | add x y hx hy ihx ihy => | |
| change D ((β¨x,hxβ© : E)+β¨y,hyβ©)=0 | |
| rw [map_add,ihx,ihy,add_zero] | |
| | inv x hx ih => | |
| change D ((β¨x,hxβ© : E)β»ΒΉ)=0 | |
| rw [Derivation.leibniz_inv,ih,smul_zero] | |
| | mul x y hx hy ihx ihy => | |
| change D ((β¨x,hxβ© : E)*β¨y,hyβ©)=0 | |
| rw [D.leibniz,ihx,ihy,smul_zero,smul_zero,add_zero] | |
| have hsub : (β€ : Submodule E Ξ©[EβK])β€β₯ := by | |
| rw [βKaehlerDifferential.span_range_derivation,Submodule.span_le] | |
| rintro _ β¨x,rflβ© | |
| exact hD x | |
| let : Algebra.FormallyUnramified K E := β¨ | |
| (subsingleton_iff_forall_eq 0).mpr (fun x=>hsub trivial)β© | |
| let : Algebra.EssFiniteType K E := IntermediateField.essFiniteType_iff.mpr | |
| (IntermediateField.fg_adjoin_of_finite (Set.finite_range a)) | |
| let : Algebra.IsSeparable K E := Algebra.FormallyUnramified.isSeparable K E | |
| intro i | |
| exact (isAlgebraic_algHom_iff E.val E.val.injective).mpr | |
| (Algebra.IsAlgebraic.isAlgebraic (b i)) | |
| end | |
| end PD4Tensor.Spreading | |
| namespace PD4Tensor.Spreading | |
| noncomputable section | |
| open scoped BigOperators | |
| open MvPolynomial | |
| variable {R S L Ο : Type*} [CommRing R] [IsDomain R] | |
| variable [Fintype Ο] [DecidableEq Ο] | |
| theorem isAlgebraic_of_mv_jacobian_domain_field [Field L] [Algebra R L] [FaithfulSMul R L] | |
| (f : Ο β MvPolynomial Ο R) (a : Ο β L) | |
| (hf : β k,aeval a (f k)=0) | |
| (hJ : Matrix.det (fun k i=>aeval a (pderiv i (f k)))β 0) : | |
| β i,IsAlgebraic R (a i) := by | |
| let F := FractionRing R | |
| let : Algebra F L := FractionRing.liftAlgebra R L | |
| let : IsScalarTower R F L := FractionRing.isScalarTower_liftAlgebra R L | |
| have heval (p : MvPolynomial Ο R) : | |
| aeval a (map (algebraMap R F) p)=aeval a p := by | |
| simp only [aeval_def,evalβ_map,βIsScalarTower.algebraMap_eq R F L] | |
| have hf' (k : Ο) : aeval a (map (algebraMap R F) (f k))=0 := by | |
| rw [heval,hf] | |
| have hJ' : Matrix.det (fun k i=>aeval a | |
| (pderiv i (map (algebraMap R F) (f k))))β 0 := by | |
| simpa only [pderiv_map,heval] using hJ | |
| intro i | |
| exact (IsFractionRing.isAlgebraic_iff R F L).mpr | |
| (isAlgebraic_of_mv_jacobian (fun k=>map (algebraMap R F) (f k)) a hf' hJ' i) | |
| theorem isAlgebraic_of_mv_jacobian_domain [CommRing S] [IsDomain S] | |
| [Algebra R S] [FaithfulSMul R S] | |
| (f : Ο β MvPolynomial Ο R) (a : Ο β S) | |
| (hf : β k,aeval a (f k)=0) | |
| (hJ : Matrix.det (fun k i=>aeval a (pderiv i (f k)))β 0) : | |
| β i,IsAlgebraic R (a i) := by | |
| let L := FractionRing S | |
| let b : Ο β L := fun i=>algebraMap S L (a i) | |
| have heval (p : MvPolynomial Ο R) : | |
| aeval b p=algebraMap S L (aeval a p) := by | |
| exact (MvPolynomial.comp_aeval_apply a (IsScalarTower.toAlgHom R S L) p).symm | |
| have hb (k : Ο) : aeval b (f k)=0 := by rw [heval,hf,map_zero] | |
| have hJb : Matrix.det (fun k i=>aeval b (pderiv i (f k)))β 0 := by | |
| simp only [heval] | |
| have hm := (algebraMap S L).map_det | |
| (show Matrix Ο Ο S from fun k i=>aeval a (pderiv i (f k))) | |
| intro h | |
| apply hJ | |
| apply IsFractionRing.injective S L | |
| exact hm.trans (h.trans (map_zero _).symm) | |
| intro i | |
| have ha := isAlgebraic_of_mv_jacobian_domain_field f b hb hJb i | |
| exact (isAlgebraic_algebraMap_iff (IsFractionRing.injective S L)).mp ha | |
| end | |
| end PD4Tensor.Spreading | |
| namespace PD4Tensor.Spreading | |
| noncomputable section | |
| open scoped BigOperators Matrix | |
| open MvPolynomial | |
| variable {K Ο Ο : Type*} [Field K] [Fintype Ο] [DecidableEq Ο] | |
| theorem algebraic_series_of_mv_jacobian | |
| (f : Ο β MvPolynomial Ο (MvPowerSeries Ο K)) | |
| (hcoeff : β k d,IsAlgebraic (MvPolynomial Ο K) ((f k).coeff d)) | |
| (a : Ο β MvPowerSeries Ο K) (hf : β k,eval a (f k)=0) | |
| (hJ : Matrix.det (fun k i=>eval a (pderiv i (f k)))β 0) : | |
| β i,IsAlgebraic (MvPolynomial Ο K) (a i) := by | |
| classical | |
| let : IsDomain (MvPowerSeries Ο K) := NoZeroDivisors.to_isDomain _ | |
| let A := Subalgebra.algebraicClosure (MvPolynomial Ο K) (MvPowerSeries Ο K) | |
| have hp (k : Ο) : f kβRingHom.range (map A.val.toRingHom) := by | |
| apply mem_range_map_iff_coeffs_subset.mpr | |
| intro c hc | |
| obtain β¨d,hd,rflβ© := mem_coeffs_iff.mp hc | |
| exact β¨β¨_,hcoeff k dβ©,rflβ© | |
| choose p hmap using hp | |
| have heval (k : Ο) : aeval a (p k)=eval a (f k) := by | |
| rw [βhmap k,eval_map] | |
| rfl | |
| have hderiv (k i : Ο) : aeval a (pderiv i (p k))=eval a (pderiv i (f k)) := by | |
| rw [βhmap k,pderiv_map,eval_map] | |
| rfl | |
| have hroot (k : Ο) : aeval a (p k)=0 := by rw [heval,hf] | |
| have hJ' : Matrix.det (fun k i=>aeval a (pderiv i (p k)))β 0 := by | |
| simpa only [hderiv] using hJ | |
| intro i | |
| exact (isAlgebraic_of_mv_jacobian_domain p a hroot hJ' i).restrictScalars | |
| (MvPolynomial Ο K) | |
| theorem algebraic_series_mv_tougeron [Finite Ο] | |
| (I : Ideal (MvPowerSeries Ο K)) [IsAdicComplete I (MvPowerSeries Ο K)] | |
| (f : Ο β MvPolynomial Ο (MvPowerSeries Ο K)) | |
| (hcoeff : β k d,IsAlgebraic (MvPolynomial Ο K) ((f k).coeff d)) | |
| (a e : Ο β MvPowerSeries Ο K) (he : β k,e kβI) | |
| (hJ : Matrix.det (fun k i=>eval a (pderiv i (f k)))β 0) | |
| (hf : β k,eval a (f k)= | |
| (Matrix.det (fun k i=>eval a (pderiv i (f k))))^2*e k) : | |
| β b : Ο β MvPowerSeries Ο K,(β k,eval b (f k)=0) β§ | |
| (β i,IsAlgebraic (MvPolynomial Ο K) (b i)) β§ | |
| β i,β vβI,b i=a i+(Matrix.det (fun k j=>eval a (pderiv j (f k))))*v := by | |
| let : IsDomain (MvPowerSeries Ο K) := NoZeroDivisors.to_isDomain _ | |
| obtain β¨b,hb,hJb,hcloseβ© := mv_tougeron_nondegenerate I f a e he hJ hf | |
| exact β¨b,hb,algebraic_series_of_mv_jacobian f hcoeff b hb hJb,hcloseβ© | |
| end | |
| end PD4Tensor.Spreading | |
| namespace PD4Tensor.Spreading | |
| noncomputable section | |
| open MvPolynomial | |
| variable {R S Ο Ο : Type*} [CommRing R] [CommRing S] | |
| def freezeRight (a : Ο β R) : MvPolynomial (Ο β Ο) R β+* MvPolynomial Ο R := | |
| (map (evalβHom (RingHom.id R) a)).comp (sumAlgEquiv R Ο Ο).toRingHom | |
| @[simp] theorem freezeRight_C (a : Ο β R) (r : R) : | |
| freezeRight (Ο:=Ο) a (C r)=C r := by simp [freezeRight] | |
| @[simp] theorem freezeRight_X_left (a : Ο β R) (i : Ο) : | |
| freezeRight a (X (Sum.inl i))=X i := by simp [freezeRight] | |
| @[simp] theorem freezeRight_X_right (a : Ο β R) (i : Ο) : | |
| freezeRight (Ο:=Ο) a (X (Sum.inr i))=C (a i) := by simp [freezeRight] | |
| theorem eval_freezeRight (a : Ο β R) (b : Ο β R) (p : MvPolynomial (Ο β Ο) R) : | |
| eval b (freezeRight a p)=eval (Sum.elim b a) p := by | |
| induction p using MvPolynomial.induction_on with | |
| | C r => simp | |
| | add p q hp hq => simp only [map_add,hp,hq] | |
| | mul_X p i hp => cases i <;> simp only [map_mul,hp,freezeRight_X_left, | |
| freezeRight_X_right,eval_X,eval_C,Sum.elim_inl,Sum.elim_inr] | |
| theorem pderiv_freezeRight (a : Ο β R) (i : Ο) (p : MvPolynomial (Ο β Ο) R) : | |
| pderiv i (freezeRight a p)=freezeRight a (pderiv (Sum.inl i) p) := by | |
| change pderiv i (map (evalβHom (RingHom.id R) a) ((sumAlgEquiv R Ο Ο) p))= | |
| map (evalβHom (RingHom.id R) a) ((sumAlgEquiv R Ο Ο) (pderiv (Sum.inl i) p)) | |
| rw [pderiv_map,pderiv_sumAlgEquiv] | |
| theorem freezeRight_map (Ο : R β+* S) (a : Ο β R) (p : MvPolynomial (Ο β Ο) R) : | |
| freezeRight (fun i=>Ο (a i)) (map Ο p)=map Ο (freezeRight a p) := by | |
| induction p using MvPolynomial.induction_on with | |
| | C r => simp | |
| | add p q hp hq => simp only [map_add,hp,hq] | |
| | mul_X p i hp => cases i <;> simp only [map_mul,map_X,hp,freezeRight_X_left, | |
| freezeRight_X_right,map_C] | |
| theorem freezeRight_algebraic {K Ο : Type*} [Field K] | |
| (f : MvPolynomial (Ο β Ο) (MvPowerSeries Ο K)) | |
| (hf : β d,IsAlgebraic (MvPolynomial Ο K) (f.coeff d)) | |
| (a : Ο β MvPowerSeries Ο K) (ha : β i,IsAlgebraic (MvPolynomial Ο K) (a i)) : | |
| β d,IsAlgebraic (MvPolynomial Ο K) ((freezeRight a f).coeff d) := by | |
| classical | |
| let A := Subalgebra.algebraicClosure (MvPolynomial Ο K) (MvPowerSeries Ο K) | |
| have hp : fβSet.range (map A.val.toRingHom) := by | |
| apply mem_range_map_iff_coeffs_subset.mpr | |
| intro c hc | |
| obtain β¨d,hd,rflβ© := mem_coeffs_iff.mp hc | |
| exact β¨β¨_,hf dβ©,rflβ© | |
| obtain β¨p,hpβ© := hp | |
| let b : Ο β A := fun i=>β¨a i,ha iβ© | |
| have heq : freezeRight a f=map A.val.toRingHom (freezeRight b p) := by | |
| rw [βhp] | |
| exact freezeRight_map A.val.toRingHom b p | |
| intro d | |
| rw [heq,coeff_map] | |
| exact ((freezeRight b p).coeff d).property | |
| end | |
| end PD4Tensor.Spreading | |
| namespace PD4Tensor.Spreading | |
| noncomputable section | |
| open scoped BigOperators Matrix | |
| open MvPolynomial | |
| variable {K Ο Ο Ο : Type*} [Field K] [Finite Ο] [Fintype Ο] [DecidableEq Ο] | |
| theorem algebraic_rectangular_tougeron | |
| (I : Ideal (MvPowerSeries Ο K)) [IsAdicComplete I (MvPowerSeries Ο K)] | |
| (f : Ο β MvPolynomial (Ο β Ο) (MvPowerSeries Ο K)) | |
| (hcoeff : β k d,IsAlgebraic (MvPolynomial Ο K) ((f k).coeff d)) | |
| (a : (Ο β Ο) β MvPowerSeries Ο K) | |
| (ha : β i : Ο,IsAlgebraic (MvPolynomial Ο K) (a (Sum.inr i))) | |
| (e : Ο β MvPowerSeries Ο K) (he : β k,e kβI) | |
| (hJ : Matrix.det (fun k i=>eval a (pderiv (Sum.inl i) (f k)))β 0) | |
| (hf : β k,eval a (f k)= | |
| (Matrix.det (fun k i=>eval a (pderiv (Sum.inl i) (f k))))^2*e k) : | |
| β b : (Ο β Ο) β MvPowerSeries Ο K,(β k,eval b (f k)=0) β§ | |
| (β i,IsAlgebraic (MvPolynomial Ο K) (b i)) β§ | |
| (β i : Ο,b (Sum.inr i)=a (Sum.inr i)) β§ | |
| β i : Ο,β vβI,b (Sum.inl i)=a (Sum.inl i)+ | |
| (Matrix.det (fun k j=>eval a (pderiv (Sum.inl j) (f k))))*v := by | |
| let g : Ο β MvPolynomial Ο (MvPowerSeries Ο K) := | |
| fun k=>freezeRight (fun i=>a (Sum.inr i)) (f k) | |
| have haeq : Sum.elim (fun i=>a (Sum.inl i)) (fun i=>a (Sum.inr i))=a := by | |
| funext i; cases i <;> rfl | |
| have hg (k : Ο) : eval (fun i=>a (Sum.inl i)) (g k)=eval a (f k) := by | |
| change eval _ (freezeRight _ (f k))=eval a (f k) | |
| rw [eval_freezeRight,haeq] | |
| have hgderiv (k i : Ο) : eval (fun j=>a (Sum.inl j)) (pderiv i (g k))= | |
| eval a (pderiv (Sum.inl i) (f k)) := by | |
| change eval _ (pderiv i (freezeRight _ (f k)))=eval a _ | |
| rw [pderiv_freezeRight,eval_freezeRight,haeq] | |
| have hgc (k : Ο) : β d,IsAlgebraic (MvPolynomial Ο K) ((g k).coeff d) := | |
| freezeRight_algebraic (f k) (hcoeff k) _ ha | |
| have hJg : Matrix.det (fun k i=>eval (fun j=>a (Sum.inl j)) (pderiv i (g k)))β 0 := by | |
| simpa only [hgderiv] using hJ | |
| have hfg (k : Ο) : eval (fun j=>a (Sum.inl j)) (g k)= | |
| (Matrix.det (fun k i=>eval (fun j=>a (Sum.inl j)) (pderiv i (g k))))^2*e k := by | |
| simpa only [hg,hgderiv] using hf k | |
| obtain β¨b,hb,halg,hcloseβ© := algebraic_series_mv_tougeron I g hgc _ e he hJg hfg | |
| refine β¨Sum.elim b (fun i=>a (Sum.inr i)),?_,?_,fun _=>rfl,?_β© | |
| Β· intro k | |
| exact (eval_freezeRight _ b (f k)).symm.trans (hb k) | |
| Β· intro i | |
| cases i with | |
| | inl i => exact halg i | |
| | inr i => exact ha i | |
| Β· intro i | |
| simpa only [hgderiv,Sum.elim_inl] using hclose i | |
| end | |
| end PD4Tensor.Spreading | |
| end | |
| end OAI | |