| import OAI.Algebra.Determinantal.ConductorBounds |
|
|
| namespace OAI |
|
|
| namespace PermanentBorder.Conductor |
| open Polynomial Matrix Module |
| section LocalComparison |
| variable {K S Q ι : Type*} [Field K] [Infinite K] |
| [CommRing S] [IsDomain S] [IsPrincipalIdealRing S] [IsLocalRing S] [Algebra K S] |
| [Field Q] [Algebra S Q] [IsFractionRing S Q] |
| [Fintype ι] [DecidableEq ι] |
|
|
| include K in |
|
|
| theorem normalization_conductor_le_adjugate (T : Matrix ι ι S) |
| (hsep : (T.charpoly.map (algebraMap S Q)).Separable) : |
| letI := (normalizationInclusion (Q := Q) T.charpoly T.charpoly_monic).toRingHom.toAlgebra |
| algebraConductor (AdjoinRoot T.charpoly) |
| (integralClosure S (AdjoinRoot (T.charpoly.map (algebraMap S Q)))) ≤ |
| matrixEntryIdeal (T.charmatrix.adjugate.map (AdjoinRoot.mk T.charpoly)) := by |
| let := (normalizationInclusion (Q := Q) T.charpoly T.charpoly_monic).toRingHom.toAlgebra |
| obtain ⟨l, u, hl, hu, hnorm⟩ := exists_normalizing_matrix_generators (K := K) T hsep |
| intro a ha |
| apply conductor_mem_adjugate_of_lattice T (genericBaseChange (Q := Q) T.charpoly) |
| (genericBaseChange_injective (Q := Q) T.charpoly T.charpoly_monic) l hl u hu hnorm a |
| intro x hx |
| obtain ⟨b, hb⟩ := ha (⟨x, hx⟩ : integralClosure S |
| (AdjoinRoot (T.charpoly.map (algebraMap S Q)))) |
| exact ⟨b, congrArg Subtype.val hb⟩ |
|
|
| include K in |
|
|
| theorem normalization_adjugate_length (T : Matrix ι ι S) |
| (hsep : (T.charpoly.map (algebraMap S Q)).Separable) : |
| let R := integralClosure S (AdjoinRoot (T.charpoly.map (algebraMap S Q))) |
| letI := (normalizationInclusion (Q := Q) T.charpoly T.charpoly_monic).toRingHom.toAlgebra |
| Module.length S (AdjoinRoot T.charpoly ⧸ |
| (matrixEntryIdeal (T.charmatrix.adjugate.map (AdjoinRoot.mk T.charpoly))).restrictScalars S) ≤ |
| Module.length S (AdjoinRoot T.charpoly ⧸ |
| (algebraConductor (AdjoinRoot T.charpoly) R).restrictScalars S) ∧ |
| Module.length S (AdjoinRoot T.charpoly ⧸ |
| (algebraConductor (AdjoinRoot T.charpoly) R).restrictScalars S) = |
| Module.length S (R ⧸ LinearMap.range |
| (normalizationInclusion (Q := Q) T.charpoly T.charpoly_monic).toLinearMap) := by |
| let R := integralClosure S (AdjoinRoot (T.charpoly.map (algebraMap S Q))) |
| let := (normalizationInclusion (Q := Q) T.charpoly T.charpoly_monic).toRingHom.toAlgebra |
| refine ⟨?_, normalization_conductor_colength T.charpoly_monic hsep⟩ |
| let c := (algebraConductor (AdjoinRoot T.charpoly) R).restrictScalars S |
| let J := (matrixEntryIdeal |
| (T.charmatrix.adjugate.map (AdjoinRoot.mk T.charpoly))).restrictScalars S |
| have h : c ≤ J := normalization_conductor_le_adjugate (K := K) T hsep |
| exact Module.length_le_of_surjective (Submodule.factor h) |
| (Submodule.factor_surjective h) |
| end LocalComparison |
| end PermanentBorder.Conductor |
|
|
| namespace PermanentBorder.RootLocalization |
| open Polynomial |
|
|
| section BaseChange |
| variable {S U : Type*} [CommRing S] [CommRing U] [Algebra S U] |
| variable (f : S[X]) (g : U[X]) (hfg : f.map (algebraMap S U) = g) |
|
|
| noncomputable def changeRoot : AdjoinRoot f →ₐ[S] AdjoinRoot g := |
| AdjoinRoot.mapAlgHom (Algebra.ofId S U) f g hfg.symm.dvd |
|
|
| @[simp] theorem changeRoot_mk (p : S[X]) : |
| changeRoot f g hfg (AdjoinRoot.mk f p) = |
| AdjoinRoot.mk g (p.map (algebraMap S U)) := by |
| change aeval (AdjoinRoot.root g) p = _ |
| exact AdjoinRoot.aeval_eq_of_algebra (R := S) (S := U) _ p |
|
|
| @[simp] theorem changeRoot_root : |
| changeRoot f g hfg (AdjoinRoot.root f) = AdjoinRoot.root g := by |
| simpa only [AdjoinRoot.root, Polynomial.map_X] using changeRoot_mk f g hfg X |
|
|
| theorem changeRoot_injective (hf : f.Monic) |
| (hSU : Function.Injective (algebraMap S U)) : |
| Function.Injective (changeRoot f g hfg) := by |
| subst g |
| rw [injective_iff_map_eq_zero] |
| intro z hz |
| obtain ⟨p, rfl⟩ := AdjoinRoot.mk_surjective z |
| rw [changeRoot_mk, AdjoinRoot.mk_eq_zero] at hz |
| rw [AdjoinRoot.mk_eq_zero, ← modByMonic_eq_zero_iff_dvd hf] |
| apply Polynomial.map_injective (algebraMap S U) hSU |
| rw [Polynomial.map_zero, map_modByMonic _ hf, (modByMonic_eq_zero_iff_dvd (hf.map _)).mpr hz] |
|
|
| variable (M : Submonoid S) [IsLocalization M U] |
|
|
| theorem changeRoot_denominators (x : AdjoinRoot g) : |
| ∃ s : M, ∃ b : AdjoinRoot f, s • x = changeRoot f g hfg b := by |
| obtain ⟨p, rfl⟩ := AdjoinRoot.mk_surjective x |
| obtain ⟨s, hs, hp⟩ := IsLocalization.integerNormalization_spec M p |
| refine ⟨⟨s, hs⟩, AdjoinRoot.mk f (IsLocalization.integerNormalization M p), ?_⟩ |
| rw [changeRoot_mk, hp] |
| exact (map_smul (((AdjoinRoot.mkₐ g).restrictScalars S).toLinearMap) s p).symm |
|
|
| theorem changeRoot_isLocalizedModule (hf : f.Monic) (hM : M ≤ nonZeroDivisors S) : |
| IsLocalizedModule M (changeRoot f g hfg).toLinearMap where |
| map_units s := by |
| have h := (IsLocalization.map_units U s).map (Algebra.lsmul S S (AdjoinRoot g)).toRingHom |
| convert h using 1 |
| ext z |
| change (s : S) • z = (algebraMap S U (s : S)) • z |
| exact (algebraMap_smul U (s : S) z).symm |
| surj x := by |
| obtain ⟨s, b, hb⟩ := changeRoot_denominators f g hfg M x |
| exact ⟨⟨b,s⟩, hb⟩ |
| exists_of_eq h := by |
| refine ⟨1, ?_⟩ |
| simpa only [one_smul] using |
| changeRoot_injective f g hfg hf (IsLocalization.injective U hM) h |
|
|
| end BaseChange |
| end PermanentBorder.RootLocalization |
|
|
| namespace PermanentBorder.ConductorLocalization |
| section |
| variable {S U B C E : Type*} [CommRing S] [CommRing U] [CommRing B] |
| [CommRing C] [CommRing E] [Algebra S U] [Algebra S B] [Algebra S C] |
| [Algebra U C] [IsScalarTower S U C] [Algebra S E] [Algebra U E] |
| [IsScalarTower S U E] |
| variable (M : Submonoid S) [IsLocalization M U] |
|
|
| include M in |
|
|
| theorem integral_conductor_localizes (j : B →ₐ[S] C) (g : B →ₐ[S] E) |
| (q : C →ₐ[U] E) (hcomp : (q.restrictScalars S).comp j = g) |
| (b : B) (hb : ∀ x : E, IsIntegral S x → ∃ a : B, g a = g b * x) : |
| ∀ x : E, IsIntegral U x → ∃ a : C, q a = q (j b) * x := by |
| intro x hx |
| obtain ⟨s, hs⟩ := IsIntegral.exists_multiple_integral_of_isLocalization (M := M) x hx |
| obtain ⟨a, ha⟩ := hb ((s : S) • x) hs |
| obtain ⟨u, hu⟩ := IsLocalization.map_units U s |
| have hu' : (u : U) = algebraMap S U (s : S) := hu |
| refine ⟨(↑u⁻¹ : U) • j a, ?_⟩ |
| have hj (a : B) : q (j a) = g a := AlgHom.congr_fun hcomp a |
| rw [map_smul, hj, ha, mul_smul_comm, ← hj b] |
| rw [← algebraMap_smul U (s : S), ← hu', smul_smul] |
| simp |
| end |
| end PermanentBorder.ConductorLocalization |
|
|
| namespace PermanentBorder.IdealLocalization |
| section |
| variable {S B C : Type*} [CommRing S] [CommRing B] [CommRing C] |
| [Algebra S B] [Algebra S C] |
| variable (M : Submonoid S) (j : B →ₐ[S] C) [IsLocalizedModule M j.toLinearMap] |
|
|
| noncomputable def localizedIdeal (I : Ideal B) : Ideal C where |
| __ := (I.restrictScalars S).localized₀ M j.toLinearMap |
| smul_mem' c _ hx := by |
| obtain ⟨x,hx,s,rfl⟩ := hx |
| obtain ⟨⟨y,t⟩,hy⟩ := IsLocalizedModule.surj M j.toLinearMap c |
| have hy' : IsLocalizedModule.mk' j.toLinearMap y t = c := |
| IsLocalizedModule.mk'_eq_iff.mpr hy.symm |
| rw [← hy', smul_eq_mul, IsLocalizedModule.mk'_mul_mk'] |
| exact ⟨y*x,I.mul_mem_left y hx,t*s,rfl⟩ |
| |
| theorem map_le_localizedIdeal (I : Ideal B) : |
| I.map j.toRingHom ≤ localizedIdeal M j I := by |
| rw [Ideal.map_le_iff_le_comap] |
| intro x hx |
| exact ⟨x,hx,1, by simp⟩ |
| |
| theorem map_mem_localized (I : Ideal B) (x : C) |
| (hx : x ∈ I.map j.toRingHom) : |
| x ∈ (I.restrictScalars S).localized₀ M j.toLinearMap := |
| map_le_localizedIdeal M j I hx |
| end |
| end PermanentBorder.IdealLocalization |
| |
| namespace PermanentBorder.Conductor |
| open Polynomial Matrix RootLocalization |
| section |
| variable {S U ι : Type*} [CommRing S] [CommRing U] [Algebra S U] |
| [Fintype ι] [DecidableEq ι] |
| |
| noncomputable def matrixRootChange (T : Matrix ι ι S) : |
| AdjoinRoot T.charpoly →ₐ[S] AdjoinRoot (T.map (algebraMap S U)).charpoly := |
| changeRoot T.charpoly (T.map (algebraMap S U)).charpoly (T.charpoly_map _).symm |
| |
| @[simp] theorem matrixRootChange_root (T : Matrix ι ι S) : |
| matrixRootChange (U := U) T (AdjoinRoot.root T.charpoly) = |
| AdjoinRoot.root (T.map (algebraMap S U)).charpoly := changeRoot_root .. |
| |
| theorem matrixRootChange_adjugate (T : Matrix ι ι S) : |
| (T.charmatrix.adjugate.map (AdjoinRoot.mk T.charpoly)).map |
| (matrixRootChange (U := U) T) = |
| (T.map (algebraMap S U)).charmatrix.adjugate.map |
| (AdjoinRoot.mk (T.map (algebraMap S U)).charpoly) := by |
| have h1 : T.charmatrix.adjugate.map (AdjoinRoot.mk T.charpoly) = |
| (T.charmatrix.map (AdjoinRoot.mk T.charpoly)).adjugate := |
| (AdjoinRoot.mk T.charpoly).map_adjugate T.charmatrix |
| have h2 : (T.charmatrix.map (AdjoinRoot.mk T.charpoly)).adjugate.map |
| (matrixRootChange (U := U) T) = |
| ((T.charmatrix.map (AdjoinRoot.mk T.charpoly)).map |
| (matrixRootChange (U := U) T)).adjugate := |
| (matrixRootChange (U := U) T).map_adjugate _ |
| have h3 : (T.map (algebraMap S U)).charmatrix.adjugate.map |
| (AdjoinRoot.mk (T.map (algebraMap S U)).charpoly) = |
| ((T.map (algebraMap S U)).charmatrix.map |
| (AdjoinRoot.mk (T.map (algebraMap S U)).charpoly)).adjugate := |
| (AdjoinRoot.mk (T.map (algebraMap S U)).charpoly).map_adjugate _ |
| rw [h1,h2,h3] |
| congr 1 |
| have hc (x : S) : matrixRootChange (U := U) T (AdjoinRoot.of T.charpoly x) = |
| AdjoinRoot.of (T.map (algebraMap S U)).charpoly (algebraMap S U x) := |
| (matrixRootChange (U := U) T).commutes x |
| ext i j |
| simp only [Matrix.map_apply,charmatrix,Matrix.sub_apply,map_sub, |
| Matrix.scalar_apply,Matrix.diagonal_apply] |
| split_ifs <;> simp only [RingHom.mapMatrix_apply, Matrix.map_apply, map_zero, AdjoinRoot.mk_X, matrixRootChange_root, |
| AdjoinRoot.mk_C, hc] |
| |
| omit [Fintype ι] [DecidableEq ι] in |
| theorem matrixEntryIdeal_map {B C : Type*} [CommRing B] [CommRing C] |
| (f : B →+* C) (N : Matrix ι ι B) : |
| (matrixEntryIdeal N).map f = matrixEntryIdeal (N.map f) := by |
| rw [matrixEntryIdeal,Ideal.map_span,matrixEntryIdeal] |
| congr 1 |
| ext x |
| simp only [Set.mem_image,Set.mem_range,exists_exists_eq_and,Matrix.map_apply] |
| |
| theorem adjugateIdeal_baseChange (T : Matrix ι ι S) : |
| (matrixEntryIdeal (T.charmatrix.adjugate.map (AdjoinRoot.mk T.charpoly))).map |
| (matrixRootChange (U := U) T).toRingHom = |
| matrixEntryIdeal ((T.map (algebraMap S U)).charmatrix.adjugate.map |
| (AdjoinRoot.mk (T.map (algebraMap S U)).charpoly)) := by |
| rw [matrixEntryIdeal_map] |
| congr 1 |
| exact matrixRootChange_adjugate T |
| end |
| end PermanentBorder.Conductor |
| |
| namespace PermanentBorder.Conductor |
| open Polynomial Matrix Module RootLocalization |
| |
| @[simp] theorem genericBaseChange_root {V Q : Type*} [CommRing V] [Field Q] |
| [Algebra V Q] (f : V[X]) : |
| genericBaseChange (Q := Q) f (AdjoinRoot.root f) = |
| AdjoinRoot.root (f.map (algebraMap V Q)) := by |
| simpa only [AdjoinRoot.root, Polynomial.map_X] using genericBaseChange_mk (Q := Q) f X |
| |
| section GenericTransport |
| variable {S U Q ι : Type*} [CommRing S] [CommRing U] [Field Q] |
| [Algebra S U] [Algebra S Q] [Algebra U Q] [IsScalarTower S U Q] |
| [Fintype ι] [DecidableEq ι] |
| |
| theorem charpoly_map_tower (T : Matrix ι ι S) : |
| T.charpoly.map (algebraMap S Q) = |
| (T.map (algebraMap S U)).charpoly.map (algebraMap U Q) := by |
| rw [charpoly_map, Polynomial.map_map, ← IsScalarTower.algebraMap_eq] |
| |
| noncomputable def genericMatrixChange (T : Matrix ι ι S) : |
| AdjoinRoot (T.charpoly.map (algebraMap S Q)) ≃ₐ[Q] |
| AdjoinRoot ((T.map (algebraMap S U)).charpoly.map (algebraMap U Q)) := |
| AdjoinRoot.algEquivOfEq Q _ _ (charpoly_map_tower T) |
| |
| theorem genericMatrixChange_comp (T : Matrix ι ι S) : |
| ((genericBaseChange (Q := Q) (T.map (algebraMap S U)).charpoly).restrictScalars S).comp |
| (matrixRootChange (U := U) T) = |
| ((genericMatrixChange (U := U) (Q := Q) T).restrictScalars S).toAlgHom.comp |
| (genericBaseChange (Q := Q) T.charpoly) := by |
| apply AdjoinRoot.algHom_ext |
| change genericBaseChange (Q := Q) (T.map (algebraMap S U)).charpoly |
| (matrixRootChange (U := U) T (AdjoinRoot.root T.charpoly)) = |
| genericMatrixChange (U := U) (Q := Q) T |
| (genericBaseChange (Q := Q) T.charpoly (AdjoinRoot.root T.charpoly)) |
| rw [matrixRootChange_root,genericBaseChange_root,genericBaseChange_root] |
| exact (AdjoinRoot.algEquivOfEq_root _ _ _).symm |
| end GenericTransport |
| |
| section LocalCondition |
| variable {K S Q ι : Type*} [Field K] [Infinite K] |
| [CommRing S] [IsDomain S] [IsPrincipalIdealRing S] [IsLocalRing S] [Algebra K S] |
| [Field Q] [Algebra S Q] [IsFractionRing S Q] [Fintype ι] [DecidableEq ι] |
| |
| include K in |
| theorem integral_conductor_le_adjugate_local (T : Matrix ι ι S) |
| (hsep : (T.charpoly.map (algebraMap S Q)).Separable) |
| (b : AdjoinRoot T.charpoly) |
| (hb : ∀ x : AdjoinRoot (T.charpoly.map (algebraMap S Q)), IsIntegral S x → |
| ∃ a : AdjoinRoot T.charpoly, |
| genericBaseChange (Q := Q) T.charpoly a = |
| genericBaseChange (Q := Q) T.charpoly b * x) : |
| b ∈ matrixEntryIdeal (T.charmatrix.adjugate.map (AdjoinRoot.mk T.charpoly)) := by |
| let := (normalizationInclusion (Q := Q) T.charpoly T.charpoly_monic).toRingHom.toAlgebra |
| apply normalization_conductor_le_adjugate (K := K) T hsep |
| intro x |
| obtain ⟨a,ha⟩ := hb x.val x.property |
| exact ⟨a,Subtype.ext ha⟩ |
| end LocalCondition |
| |
| section GlobalComparison |
| variable {K S ι : Type*} [Field K] [Infinite K] |
| [CommRing S] [IsDomain S] [IsPrincipalIdealRing S] [Algebra K S] |
| [Fintype ι] [DecidableEq ι] |
| |
| include K in |
| |
| theorem normalization_conductor_le_adjugate_global (T : Matrix ι ι S) |
| (hsep : (T.charpoly.map (algebraMap S (FractionRing S))).Separable) : |
| letI := (normalizationInclusion (Q := FractionRing S) T.charpoly T.charpoly_monic).toRingHom.toAlgebra |
| algebraConductor (AdjoinRoot T.charpoly) |
| (integralClosure S (AdjoinRoot (T.charpoly.map (algebraMap S (FractionRing S))))) ≤ |
| matrixEntryIdeal (T.charmatrix.adjugate.map (AdjoinRoot.mk T.charpoly)) := by |
| let Q := FractionRing S |
| let := (normalizationInclusion (Q := Q) T.charpoly T.charpoly_monic).toRingHom.toAlgebra |
| let J := matrixEntryIdeal (T.charmatrix.adjugate.map (AdjoinRoot.mk T.charpoly)) |
| intro b hb |
| let U (P : Ideal S) [P.IsMaximal] := Localization.AtPrime P |
| let C (P : Ideal S) [P.IsMaximal] := AdjoinRoot (T.map (algebraMap S (U P))).charpoly |
| let j (P : Ideal S) [P.IsMaximal] : AdjoinRoot T.charpoly →ₐ[S] C P := |
| matrixRootChange (U := U P) T |
| have hj (P : Ideal S) [P.IsMaximal] : IsLocalizedModule P.primeCompl (j P).toLinearMap := |
| changeRoot_isLocalizedModule _ _ _ _ T.charpoly_monic P.primeCompl_le_nonZeroDivisors |
| apply @Submodule.mem_of_localization_maximal S (AdjoinRoot T.charpoly) _ _ _ |
| C _ _ (fun P _ => (j P).toLinearMap) hj b (J.restrictScalars S) |
| intro P hP |
| let := hj P |
| let T' := T.map (algebraMap S (U P)) let e := (genericMatrixChange (U := U P) (Q := Q) T).restrictScalars S let g := e.toAlgHom.comp (genericBaseChange (Q := Q) T.charpoly) have hbg : ∀ x : AdjoinRoot (T'.charpoly.map (algebraMap (U P) Q)), |
| IsIntegral S x → ∃ a : AdjoinRoot T.charpoly, g a = g b * x := by |
| intro x hx |
| obtain ⟨a,ha⟩ := hb (⟨e.symm x, IsIntegral.map e.symm.toAlgHom hx⟩ : |
| integralClosure S (AdjoinRoot (T.charpoly.map (algebraMap S Q)))) |
| have ha0 : genericBaseChange (Q := Q) T.charpoly a = |
| genericBaseChange (Q := Q) T.charpoly b * e.symm x := congrArg Subtype.val ha |
| have ha' := congrArg e ha0 refine ⟨a, ?_⟩ simpa only [g,AlgHom.comp_apply,AlgEquiv.coe_toAlgHom,map_mul,AlgEquiv.apply_symm_apply] using ha' |
| have hbP := ConductorLocalization.integral_conductor_localizes P.primeCompl (j P) g |
| (genericBaseChange (Q := Q) T'.charpoly) (genericMatrixChange_comp T) b hbg |
| have hsep' : (T'.charpoly.map (algebraMap (U P) Q)).Separable := by |
| rw [← charpoly_map_tower T] |
| exact hsep |
| have hbJ := integral_conductor_le_adjugate_local (K := K) T' hsep' (j P b) hbP |
| apply IdealLocalization.map_mem_localized P.primeCompl (j P) J |
| rw [show j P = matrixRootChange (U := U P) T from rfl,adjugateIdeal_baseChange] |
| exact hbJ |
| end GlobalComparison |
| end PermanentBorder.Conductor |
|
|
| namespace PermanentBorder.Conductor |
| open Module Polynomial |
| section CokernelEquiv |
| variable {S B A : Type*} [CommRing S] [IsDomain S] [IsPrincipalIdealRing S] |
| [CommRing B] [CommRing A] [Algebra S B] [Algebra S A] [Algebra B A] |
| [IsScalarTower S B A] [NoZeroSMulDivisors S A] [Module.Finite S A] |
|
|
| theorem exists_conductor_cokernel_equiv |
| (hi : Function.Injective (algebraMap B A)) |
| (hden : ∀ x : A, ∃ s : S, s ≠ 0 ∧ ∃ b : B, s • x = algebraMap B A b) |
| (lam : B →ₗ[S] S) (e : B ≃ₗ[S] Module.Dual S B) |
| (he : ∀ a b : B, e a b = lam (a*b)) : |
| Nonempty ((B ⧸ (algebraConductor B A).restrictScalars S) ≃ₗ[S] |
| (A ⧸ LinearMap.range (IsScalarTower.toAlgHom S B A).toLinearMap)) := by |
| classical |
| let i : B →ₗ[S] A := (IsScalarTower.toAlgHom S B A).toLinearMap |
| have hr : Submodule.map e.toLinearMap ((algebraConductor B A).restrictScalars S) = |
| LinearMap.range i.dualMap := by |
| ext ℓ |
| constructor |
| · rintro ⟨a, ha, rfl⟩ |
| obtain ⟨L, hL⟩ := (in_dual_restriction_image_iff hi hden lam e he a).mpr ha |
| refine ⟨L, ?_⟩ |
| ext b |
| exact (hL b).trans (he a b).symm |
| · rintro ⟨L, rfl⟩ |
| refine ⟨e.symm (i.dualMap L), ?_, by simp⟩ |
| apply (in_dual_restriction_image_iff hi hden lam e he _).mp |
| refine ⟨L, ?_⟩ |
| intro b |
| rw [← he, e.apply_symm_apply] |
| rfl |
| let eqv := Submodule.Quotient.equiv _ _ e hr |
| obtain ⟨d⟩ := exists_dual_cokernel_equiv (Module.Free.chooseBasis S A) i hi |
| (finrank_eq_of_denominators hi hden) |
| exact ⟨eqv.trans d.symm⟩ |
| end CokernelEquiv |
|
|
| section NormalizationCokernel |
| variable {S Q : Type*} [CommRing S] [IsDomain S] [IsPrincipalIdealRing S] |
| [Field Q] [Algebra S Q] [IsFractionRing S Q] |
| variable {f : S[X]} (hf : f.Monic) |
| local notation "R" => integralClosure S (AdjoinRoot (f.map (algebraMap S Q))) |
|
|
| theorem exists_normalization_conductor_cokernel_equiv |
| (hsep : (f.map (algebraMap S Q)).Separable) : |
| letI := (normalizationInclusion (Q := Q) f hf).toRingHom.toAlgebra |
| Nonempty ((AdjoinRoot f ⧸ (algebraConductor (AdjoinRoot f) R).restrictScalars S) ≃ₗ[S] |
| (R ⧸ LinearMap.range (normalizationInclusion (Q := Q) f hf).toLinearMap)) := by |
| let := (normalizationInclusion (Q := Q) f hf).toRingHom.toAlgebra |
| have : Module.Finite S R := finite_integralClosure_adjoinRoot (hf.map _) hsep |
| have : NoZeroSMulDivisors S R := normalization_torsionFree (f := f) |
| exact exists_conductor_cokernel_equiv |
| (normalizationInclusion_injective (Q := Q) f hf) |
| (normalizationInclusion_denominators (Q := Q) f hf) |
| (topRemainderCoefficient hf) (coefficientPairingEquiv hf) (coefficientPairingEquiv_apply hf) |
| end NormalizationCokernel |
| end PermanentBorder.Conductor |
|
|
| namespace PermanentBorder.Conductor |
| open Polynomial Module Matrix |
| section ScalarLength |
| variable {K S ι : Type*} [Field K] [Infinite K] |
| [CommRing S] [IsDomain S] [IsPrincipalIdealRing S] [Algebra K S] |
| [Fintype ι] [DecidableEq ι] |
|
|
| theorem normalization_adjugate_length_global (T : Matrix ι ι S) |
| (hsep : (T.charpoly.map (algebraMap S (FractionRing S))).Separable) : |
| let R := integralClosure S (AdjoinRoot (T.charpoly.map (algebraMap S (FractionRing S)))) |
| Module.length K (AdjoinRoot T.charpoly ⧸ |
| (matrixEntryIdeal (T.charmatrix.adjugate.map (AdjoinRoot.mk T.charpoly))).restrictScalars S) ≤ |
| Module.length K (R ⧸ LinearMap.range |
| (normalizationInclusion (Q := FractionRing S) T.charpoly T.charpoly_monic).toLinearMap) := by |
| let Q := FractionRing S |
| let R := integralClosure S (AdjoinRoot (T.charpoly.map (algebraMap S Q))) |
| let := (normalizationInclusion (Q := Q) T.charpoly T.charpoly_monic).toRingHom.toAlgebra |
| let c := (algebraConductor (AdjoinRoot T.charpoly) R).restrictScalars S |
| let J := (matrixEntryIdeal |
| (T.charmatrix.adjugate.map (AdjoinRoot.mk T.charpoly))).restrictScalars S |
| have h : c ≤ J := normalization_conductor_le_adjugate_global (K := K) T hsep |
| obtain ⟨e⟩ := exists_normalization_conductor_cokernel_equiv T.charpoly_monic hsep |
| calc |
| _ ≤ Module.length K (AdjoinRoot T.charpoly ⧸ c) := |
| Module.length_le_of_surjective ((Submodule.factor h).restrictScalars K) |
| (Submodule.factor_surjective h) |
| _ = _ := (e.restrictScalars K).length_eq |
| end ScalarLength |
| end PermanentBorder.Conductor |
|
|
| end OAI |
|
|
