fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
@[simps! -fullyApplied apply symm_apply]
noncomputable
galLiftEquiv [Algebra.IsAlgebraic K L₂] (σ : B ≃ₐ[A] B₂) : L ≃ₐ[K] L₂ :=
AlgEquiv.ofAlgHom (galLift K L L₂ σ.toAlgHom) (galLift K L₂ L σ.symm.toAlgHom)
(by simp [← galLift_comp]) (by simp [← galLift_comp]) | def | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | galLiftEquiv | A version of `galLift` for `AlgEquiv`. |
galLiftEquiv_algebraMap_apply [Algebra.IsAlgebraic K L₂] (σ : B ≃ₐ[A] B₂) (x : B) :
galLiftEquiv K L L₂ σ (algebraMap B L x) = algebraMap B₂ L₂ (σ x) := by
simp [galLiftEquiv] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | galLiftEquiv_algebraMap_apply | null |
@[simps -isSimp]
noncomputable
galRestrictHom : (L →ₐ[K] L) ≃* (B →ₐ[A] B) where
toFun f := galRestrict' A B B f
map_mul' σ₁ σ₂ := galRestrict'_comp _ _ _ _ σ₂ σ₁
invFun := galLift K L L
left_inv σ := galLift_galRestrict' _ _ _ σ
right_inv σ := galRestrict'_galLift _ _ _ σ
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | galRestrictHom | The restriction `End(L/K) → End(B/A)` in an AKLB setup.
Also see `galRestrict` for the `AlgEquiv` version. |
algebraMap_galRestrictHom_apply (σ : L →ₐ[K] L) (x : B) :
algebraMap B L (galRestrictHom A K L B σ x) = σ (algebraMap B L x) :=
algebraMap_galRestrict'_apply _ _ _ _ _
@[simp, nolint unusedHavesSuffices] -- false positive from unfolding galRestrictHom | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | algebraMap_galRestrictHom_apply | null |
galRestrictHom_symm_algebraMap_apply (σ : B →ₐ[A] B) (x : B) :
(galRestrictHom A K L B).symm σ (algebraMap B L x) = algebraMap B L (σ x) :=
galLift_algebraMap_apply _ _ _ _ _ | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | galRestrictHom_symm_algebraMap_apply | null |
noncomputable
galRestrict : (L ≃ₐ[K] L) ≃* (B ≃ₐ[A] B) :=
(AlgEquiv.algHomUnitsEquiv K L).symm.trans
((Units.mapEquiv <| galRestrictHom A K L B).trans (AlgEquiv.algHomUnitsEquiv A B))
variable {K L} | def | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | galRestrict | The restriction `Aut(L/K) → Aut(B/A)` in an AKLB setup. |
coe_galRestrict_apply (σ : L ≃ₐ[K] L) :
(galRestrict A K L B σ : B →ₐ[A] B) = galRestrictHom A K L B σ := rfl
variable {B} | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | coe_galRestrict_apply | null |
galRestrict_apply (σ : L ≃ₐ[K] L) (x : B) :
galRestrict A K L B σ x = galRestrictHom A K L B σ x := rfl | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | galRestrict_apply | null |
algebraMap_galRestrict_apply (σ : L ≃ₐ[K] L) (x : B) :
algebraMap B L (galRestrict A K L B σ x) = σ (algebraMap B L x) :=
algebraMap_galRestrictHom_apply A K L B σ.toAlgHom x
variable (K) in | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | algebraMap_galRestrict_apply | null |
galRestrict_symm_algebraMap_apply (σ : B ≃ₐ[A] B) (x : B) :
(galRestrict A K L B).symm σ (algebraMap B L x) = algebraMap B L (σ x) :=
galRestrictHom_symm_algebraMap_apply A K L B σ x | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | galRestrict_symm_algebraMap_apply | null |
prod_galRestrict_eq_norm [IsGalois K L] [IsIntegrallyClosed A] (x : B) :
(∏ σ : L ≃ₐ[K] L, galRestrict A K L B σ x) =
algebraMap A B (IsIntegralClosure.mk' (R := A) A (Algebra.norm K <| algebraMap B L x)
(Algebra.isIntegral_norm K (IsIntegralClosure.isIntegral A L x).algebraMap)) := by
apply IsIntegralClosure.algebraMap_injective B A L
rw [← IsScalarTower.algebraMap_apply, IsScalarTower.algebraMap_eq A K L]
simp only [map_prod, algebraMap_galRestrict_apply, IsIntegralClosure.algebraMap_mk',
Algebra.norm_eq_prod_automorphisms, RingHom.coe_comp, Function.comp_apply]
attribute [local instance] FractionRing.liftAlgebra FractionRing.isScalarTower_liftAlgebra | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | prod_galRestrict_eq_norm | null |
noncomputable
Algebra.intTraceAux [IsIntegrallyClosed A] :
B →ₗ[A] A :=
(IsIntegralClosure.equiv A (integralClosure A K) K A).toLinearMap.comp
((((Algebra.trace K L).restrictScalars A).comp
(IsScalarTower.toAlgHom A B L).toLinearMap).codRestrict
(Subalgebra.toSubmodule <| integralClosure A K) (fun x ↦ isIntegral_trace
(IsIntegral.algebraMap (IsIntegralClosure.isIntegral A L x))))
variable {A K L B} | def | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | Algebra.intTraceAux | The restriction of the trace on `L/K` restricted onto `B/A` in an AKLB setup.
See `Algebra.intTrace` instead. |
Algebra.map_intTraceAux [IsIntegrallyClosed A] (x : B) :
algebraMap A K (Algebra.intTraceAux A K L B x) = Algebra.trace K L (algebraMap B L x) :=
IsIntegralClosure.algebraMap_equiv A (integralClosure A K) K A _
variable (A B)
variable [IsDomain A] [IsIntegrallyClosed A] [IsDomain B] [IsIntegrallyClosed B]
variable [Module.Finite A B] [NoZeroSMulDivisors A B] | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | Algebra.map_intTraceAux | null |
noncomputable
Algebra.intTrace : B →ₗ[A] A :=
haveI : IsIntegralClosure B A (FractionRing B) :=
IsIntegralClosure.of_isIntegrallyClosed _ _ _
haveI : IsLocalization (algebraMapSubmonoid B A⁰) (FractionRing B) :=
IsIntegralClosure.isLocalization _ (FractionRing A) _ _
haveI : FiniteDimensional (FractionRing A) (FractionRing B) := .of_isLocalization A B A⁰
Algebra.intTraceAux A (FractionRing A) (FractionRing B) B
variable {A B} | def | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | Algebra.intTrace | The trace of a finite extension of integrally closed domains `B/A` is the restriction of
the trace on `Frac(B)/Frac(A)` onto `B/A`. See `Algebra.algebraMap_intTrace`. |
Algebra.algebraMap_intTrace (x : B) :
algebraMap A K (Algebra.intTrace A B x) = Algebra.trace K L (algebraMap B L x) := by
haveI : IsIntegralClosure B A (FractionRing B) :=
IsIntegralClosure.of_isIntegrallyClosed _ _ _
haveI : IsLocalization (algebraMapSubmonoid B A⁰) (FractionRing B) :=
IsIntegralClosure.isLocalization _ (FractionRing A) _ _
haveI : FiniteDimensional (FractionRing A) (FractionRing B) := .of_isLocalization A B A⁰
haveI := IsIntegralClosure.isFractionRing_of_finite_extension A K L B
apply (FractionRing.algEquiv A K).symm.injective
rw [AlgEquiv.commutes, Algebra.intTrace, Algebra.map_intTraceAux,
← AlgEquiv.commutes (FractionRing.algEquiv B L)]
apply Algebra.trace_eq_of_equiv_equiv (FractionRing.algEquiv A K).toRingEquiv
(FractionRing.algEquiv B L).toRingEquiv
ext
exact IsFractionRing.algEquiv_commutes (FractionRing.algEquiv A K) (FractionRing.algEquiv B L) _ | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | Algebra.algebraMap_intTrace | null |
Algebra.algebraMap_intTrace_fractionRing (x : B) :
algebraMap A (FractionRing A) (Algebra.intTrace A B x) =
Algebra.trace (FractionRing A) (FractionRing B) (algebraMap B _ x) := by
haveI : IsIntegralClosure B A (FractionRing B) :=
IsIntegralClosure.of_isIntegrallyClosed _ _ _
haveI : IsLocalization (algebraMapSubmonoid B A⁰) (FractionRing B) :=
IsIntegralClosure.isLocalization _ (FractionRing A) _ _
haveI : FiniteDimensional (FractionRing A) (FractionRing B) := .of_isLocalization A B A⁰
exact Algebra.map_intTraceAux x
variable (A B) | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | Algebra.algebraMap_intTrace_fractionRing | null |
Algebra.intTrace_eq_trace [Module.Free A B] : Algebra.intTrace A B = Algebra.trace A B := by
ext x
haveI : IsIntegralClosure B A (FractionRing B) :=
IsIntegralClosure.of_isIntegrallyClosed _ _ _
haveI : IsLocalization (algebraMapSubmonoid B A⁰) (FractionRing B) :=
IsIntegralClosure.isLocalization _ (FractionRing A) _ _
apply IsFractionRing.injective A (FractionRing A)
rw [Algebra.algebraMap_intTrace_fractionRing, Algebra.trace_localization A A⁰]
open nonZeroDivisors
variable [IsDomain Aₘ] [IsIntegrallyClosed Aₘ] [IsDomain Bₘ] [IsIntegrallyClosed Bₘ]
variable [NoZeroSMulDivisors Aₘ Bₘ] [Module.Finite Aₘ Bₘ]
include M in | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | Algebra.intTrace_eq_trace | null |
Algebra.intTrace_eq_of_isLocalization
(x : B) :
algebraMap A Aₘ (Algebra.intTrace A B x) = Algebra.intTrace Aₘ Bₘ (algebraMap B Bₘ x) := by
by_cases hM : 0 ∈ M
· subsingleton [IsLocalization.uniqueOfZeroMem (S := Aₘ) hM]
replace hM : M ≤ A⁰ := fun x hx ↦ mem_nonZeroDivisors_iff_ne_zero.mpr (fun e ↦ hM (e ▸ hx))
let K := FractionRing A
let L := FractionRing B
have : IsIntegralClosure B A L :=
IsIntegralClosure.of_isIntegrallyClosed _ _ _
have : IsLocalization (algebraMapSubmonoid B A⁰) L :=
IsIntegralClosure.isLocalization _ (FractionRing A) _ _
let f : Aₘ →+* K := IsLocalization.map _ (T := A⁰) (RingHom.id A) hM
letI := f.toAlgebra
have : IsScalarTower A Aₘ K := IsScalarTower.of_algebraMap_eq'
(by rw [RingHom.algebraMap_toAlgebra, IsLocalization.map_comp, RingHomCompTriple.comp_eq])
letI := IsFractionRing.isFractionRing_of_isDomain_of_isLocalization M Aₘ K
let g : Bₘ →+* L := IsLocalization.map _
(M := algebraMapSubmonoid B M) (T := algebraMapSubmonoid B A⁰)
(RingHom.id B) (Submonoid.monotone_map hM)
letI := g.toAlgebra
have : IsScalarTower B Bₘ L := IsScalarTower.of_algebraMap_eq'
(by rw [RingHom.algebraMap_toAlgebra, IsLocalization.map_comp, RingHomCompTriple.comp_eq])
letI := ((algebraMap K L).comp f).toAlgebra
have : IsScalarTower Aₘ K L := IsScalarTower.of_algebraMap_eq' rfl
have : IsScalarTower Aₘ Bₘ L := by
apply IsScalarTower.of_algebraMap_eq'
apply IsLocalization.ringHom_ext M
rw [RingHom.algebraMap_toAlgebra, RingHom.algebraMap_toAlgebra (R := Bₘ), RingHom.comp_assoc,
RingHom.comp_assoc, ← IsScalarTower.algebraMap_eq, IsScalarTower.algebraMap_eq A B Bₘ,
IsLocalization.map_comp, RingHom.comp_id, ← RingHom.comp_assoc, IsLocalization.map_comp,
RingHom.comp_id, ← IsScalarTower.algebraMap_eq, ← IsScalarTower.algebraMap_eq]
letI := IsFractionRing.isFractionRing_of_isDomain_of_isLocalization
(algebraMapSubmonoid B M) Bₘ L
have : FiniteDimensional K L := .of_isLocalization A B A⁰
have : IsIntegralClosure Bₘ Aₘ L :=
IsIntegralClosure.of_isIntegrallyClosed _ _ _
apply IsFractionRing.injective Aₘ K
rw [← IsScalarTower.algebraMap_apply, Algebra.algebraMap_intTrace_fractionRing,
Algebra.algebraMap_intTrace (L := L), ← IsScalarTower.algebraMap_apply] | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | Algebra.intTrace_eq_of_isLocalization | null |
noncomputable
Algebra.intNormAux [Algebra.IsSeparable K L] :
B →* A where
toFun := fun s ↦ IsIntegralClosure.mk' (R := A) A (Algebra.norm K (algebraMap B L s))
(isIntegral_norm K <| IsIntegral.map (IsScalarTower.toAlgHom A B L)
(IsIntegralClosure.isIntegral A L s))
map_one' := by simp
map_mul' := fun x y ↦ by simpa using IsIntegralClosure.mk'_mul _ _ _ _ _
variable {A K L B} | def | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | Algebra.intNormAux | The restriction of the norm on `L/K` restricted onto `B/A` in an AKLB setup.
See `Algebra.intNorm` instead. |
Algebra.map_intNormAux [Algebra.IsSeparable K L] (x : B) :
algebraMap A K (Algebra.intNormAux A K L B x) = Algebra.norm K (algebraMap B L x) := by
dsimp [Algebra.intNormAux]
exact IsIntegralClosure.algebraMap_mk' _ _ _
variable (A B)
variable [IsDomain A] [IsDomain B] [IsIntegrallyClosed B]
variable [Module.Finite A B] [NoZeroSMulDivisors A B]
variable [Algebra.IsSeparable (FractionRing A) (FractionRing B)] -- TODO: remove this | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | Algebra.map_intNormAux | null |
noncomputable
Algebra.intNorm : B →* A :=
haveI : IsIntegralClosure B A (FractionRing B) :=
IsIntegralClosure.of_isIntegrallyClosed _ _ _
haveI : IsLocalization (algebraMapSubmonoid B A⁰) (FractionRing B) :=
IsIntegralClosure.isLocalization _ (FractionRing A) _ _
haveI : FiniteDimensional (FractionRing A) (FractionRing B) := .of_isLocalization A B A⁰
Algebra.intNormAux A (FractionRing A) (FractionRing B) B
variable {A B} | def | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | Algebra.intNorm | The norm of a finite extension of integrally closed domains `B/A` is the restriction of
the norm on `Frac(B)/Frac(A)` onto `B/A`. See `Algebra.algebraMap_intNorm`. |
Algebra.algebraMap_intNorm (x : B) :
algebraMap A K (Algebra.intNorm A B x) = Algebra.norm K (algebraMap B L x) := by
haveI : IsIntegralClosure B A (FractionRing B) :=
IsIntegralClosure.of_isIntegrallyClosed _ _ _
haveI : IsLocalization (algebraMapSubmonoid B A⁰) (FractionRing B) :=
IsIntegralClosure.isLocalization _ (FractionRing A) _ _
haveI : FiniteDimensional (FractionRing A) (FractionRing B) := .of_isLocalization A B A⁰
haveI := IsIntegralClosure.isFractionRing_of_finite_extension A K L B
apply (FractionRing.algEquiv A K).symm.injective
rw [AlgEquiv.commutes, Algebra.intNorm, Algebra.map_intNormAux,
← AlgEquiv.commutes (FractionRing.algEquiv B L)]
apply Algebra.norm_eq_of_equiv_equiv (FractionRing.algEquiv A K).toRingEquiv
(FractionRing.algEquiv B L).toRingEquiv
ext
exact IsFractionRing.algEquiv_commutes (FractionRing.algEquiv A K) (FractionRing.algEquiv B L) _
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | Algebra.algebraMap_intNorm | null |
Algebra.algebraMap_intNorm_fractionRing (x : B) :
algebraMap A (FractionRing A) (Algebra.intNorm A B x) =
Algebra.norm (FractionRing A) (algebraMap B (FractionRing B) x) := by
haveI : IsIntegralClosure B A (FractionRing B) :=
IsIntegralClosure.of_isIntegrallyClosed _ _ _
haveI : IsLocalization (algebraMapSubmonoid B A⁰) (FractionRing B) :=
IsIntegralClosure.isLocalization _ (FractionRing A) _ _
haveI : FiniteDimensional (FractionRing A) (FractionRing B) := .of_isLocalization A B A⁰
exact Algebra.map_intNormAux x
variable (A B) | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | Algebra.algebraMap_intNorm_fractionRing | null |
Algebra.intNorm_intNorm {C : Type*} [CommRing C] [IsDomain C] [IsIntegrallyClosed C]
[Algebra A C] [Algebra B C] [IsScalarTower A B C] [Module.Finite A C] [Module.Finite B C]
[NoZeroSMulDivisors A C] [NoZeroSMulDivisors B C]
[Algebra.IsSeparable (FractionRing A) (FractionRing C)]
[Algebra.IsSeparable (FractionRing B) (FractionRing C)] (x : C) :
intNorm A B (intNorm B C x) = intNorm A C x := by
apply FaithfulSMul.algebraMap_injective A (FractionRing A)
rw [algebraMap_intNorm_fractionRing, algebraMap_intNorm_fractionRing,
algebraMap_intNorm_fractionRing, Algebra.norm_norm] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | Algebra.intNorm_intNorm | null |
Algebra.intNorm_eq_norm [Module.Free A B] : Algebra.intNorm A B = Algebra.norm A := by
ext x
haveI : IsIntegralClosure B A (FractionRing B) :=
IsIntegralClosure.of_isIntegrallyClosed _ _ _
haveI : IsLocalization (algebraMapSubmonoid B A⁰) (FractionRing B) :=
IsIntegralClosure.isLocalization _ (FractionRing A) _ _
apply IsFractionRing.injective A (FractionRing A)
rw [Algebra.algebraMap_intNorm_fractionRing, Algebra.norm_localization A A⁰]
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | Algebra.intNorm_eq_norm | null |
Algebra.intNorm_zero : Algebra.intNorm A B 0 = 0 := by
haveI : IsIntegralClosure B A (FractionRing B) :=
IsIntegralClosure.of_isIntegrallyClosed _ _ _
haveI : IsLocalization (algebraMapSubmonoid B A⁰) (FractionRing B) :=
IsIntegralClosure.isLocalization _ (FractionRing A) _ _
haveI : FiniteDimensional (FractionRing A) (FractionRing B) := .of_isLocalization A B A⁰
apply IsFractionRing.injective A (FractionRing A)
simp
variable {A B}
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | Algebra.intNorm_zero | null |
Algebra.intNorm_map_algEquiv [IsDomain B₂] [IsIntegrallyClosed B₂] [Module.Finite A B₂]
[NoZeroSMulDivisors A B₂] [Algebra.IsSeparable (FractionRing A) (FractionRing B₂)] (x : B)
(σ : B ≃ₐ[A] B₂) :
Algebra.intNorm A B₂ (σ x) = Algebra.intNorm A B x := by
apply FaithfulSMul.algebraMap_injective A (FractionRing A)
rw [algebraMap_intNorm_fractionRing, algebraMap_intNorm_fractionRing,
← galLiftEquiv_algebraMap_apply (FractionRing A) (FractionRing B), norm_eq_of_algEquiv]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | Algebra.intNorm_map_algEquiv | null |
Algebra.intNorm_eq_zero {x : B} : Algebra.intNorm A B x = 0 ↔ x = 0 := by
haveI : IsIntegralClosure B A (FractionRing B) :=
IsIntegralClosure.of_isIntegrallyClosed _ _ _
haveI : IsLocalization (algebraMapSubmonoid B A⁰) (FractionRing B) :=
IsIntegralClosure.isLocalization _ (FractionRing A) _ _
haveI : FiniteDimensional (FractionRing A) (FractionRing B) := .of_isLocalization A B A⁰
rw [← (IsFractionRing.injective A (FractionRing A)).eq_iff,
← (IsFractionRing.injective B (FractionRing B)).eq_iff]
simp only [algebraMap_intNorm_fractionRing, map_zero, norm_eq_zero_iff] | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | Algebra.intNorm_eq_zero | null |
Algebra.intNorm_ne_zero {x : B} : Algebra.intNorm A B x ≠ 0 ↔ x ≠ 0 := by simp
variable [IsDomain Aₘ] [IsIntegrallyClosed Aₘ] [IsDomain Bₘ] [IsIntegrallyClosed Bₘ]
variable [NoZeroSMulDivisors Aₘ Bₘ] [Module.Finite Aₘ Bₘ]
variable [Algebra.IsSeparable (FractionRing Aₘ) (FractionRing Bₘ)]
include M in | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | Algebra.intNorm_ne_zero | null |
Algebra.intNorm_eq_of_isLocalization (x : B) :
algebraMap A Aₘ (Algebra.intNorm A B x) = Algebra.intNorm Aₘ Bₘ (algebraMap B Bₘ x) := by
by_cases hM : 0 ∈ M
· subsingleton [IsLocalization.uniqueOfZeroMem (S := Aₘ) hM]
replace hM : M ≤ A⁰ := fun x hx ↦ mem_nonZeroDivisors_iff_ne_zero.mpr (fun e ↦ hM (e ▸ hx))
let K := FractionRing A
let L := FractionRing B
have : IsIntegralClosure B A L :=
IsIntegralClosure.of_isIntegrallyClosed _ _ _
have : IsLocalization (algebraMapSubmonoid B A⁰) L :=
IsIntegralClosure.isLocalization _ (FractionRing A) _ _
let f : Aₘ →+* K := IsLocalization.map _ (T := A⁰) (RingHom.id A) hM
letI := f.toAlgebra
have : IsScalarTower A Aₘ K := IsScalarTower.of_algebraMap_eq'
(by rw [RingHom.algebraMap_toAlgebra, IsLocalization.map_comp, RingHomCompTriple.comp_eq])
letI := IsFractionRing.isFractionRing_of_isDomain_of_isLocalization M Aₘ K
let g : Bₘ →+* L := IsLocalization.map _
(M := algebraMapSubmonoid B M) (T := algebraMapSubmonoid B A⁰)
(RingHom.id B) (Submonoid.monotone_map hM)
letI := g.toAlgebra
have : IsScalarTower B Bₘ L := IsScalarTower.of_algebraMap_eq'
(by rw [RingHom.algebraMap_toAlgebra, IsLocalization.map_comp, RingHomCompTriple.comp_eq])
letI := ((algebraMap K L).comp f).toAlgebra
have : IsScalarTower Aₘ K L := IsScalarTower.of_algebraMap_eq' rfl
have : IsScalarTower Aₘ Bₘ L := by
apply IsScalarTower.of_algebraMap_eq'
apply IsLocalization.ringHom_ext M
rw [RingHom.algebraMap_toAlgebra, RingHom.algebraMap_toAlgebra (R := Bₘ), RingHom.comp_assoc,
RingHom.comp_assoc, ← IsScalarTower.algebraMap_eq, IsScalarTower.algebraMap_eq A B Bₘ,
IsLocalization.map_comp, RingHom.comp_id, ← RingHom.comp_assoc, IsLocalization.map_comp,
RingHom.comp_id, ← IsScalarTower.algebraMap_eq, ← IsScalarTower.algebraMap_eq]
letI := IsFractionRing.isFractionRing_of_isDomain_of_isLocalization
(algebraMapSubmonoid B M) Bₘ L
have : FiniteDimensional K L := .of_isLocalization A B A⁰
have : IsIntegralClosure Bₘ Aₘ L :=
IsIntegralClosure.of_isIntegrallyClosed _ _ _
apply IsFractionRing.injective Aₘ K
rw [← IsScalarTower.algebraMap_apply, Algebra.algebraMap_intNorm_fractionRing,
Algebra.algebraMap_intNorm (L := L), ← IsScalarTower.algebraMap_apply] | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | Algebra.intNorm_eq_of_isLocalization | null |
Algebra.algebraMap_intNorm_of_isGalois [IsGalois (FractionRing A) (FractionRing B)] {x : B} :
algebraMap A B (Algebra.intNorm A B x) = ∏ σ : B ≃ₐ[A] B, σ x := by
haveI : IsIntegralClosure B A (FractionRing B) :=
IsIntegralClosure.of_isIntegrallyClosed _ _ _
haveI : IsLocalization (Algebra.algebraMapSubmonoid B A⁰) (FractionRing B) :=
IsIntegralClosure.isLocalization _ (FractionRing A) _ _
haveI : FiniteDimensional (FractionRing A) (FractionRing B) := .of_isLocalization A B A⁰
rw [← (galRestrict A (FractionRing A) (FractionRing B) B).toEquiv.prod_comp]
simp only [MulEquiv.toEquiv_eq_coe, EquivLike.coe_coe]
convert (prod_galRestrict_eq_norm A (FractionRing A) (FractionRing B) B x).symm | lemma | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | Algebra.algebraMap_intNorm_of_isGalois | null |
Algebra.dvd_algebraMap_intNorm_self [Algebra.IsSeparable (FractionRing A) (FractionRing B)]
(x : B) : x ∣ algebraMap A B (intNorm A B x) := by
classical
by_cases hx : x = 0
· exact ⟨1, by simp [hx]⟩
let K := FractionRing A
let L := FractionRing B
let E := AlgebraicClosure L
suffices IsIntegral A ((algebraMap B L x)⁻¹ * (algebraMap A L (intNorm A B x))) by
obtain ⟨y, hy⟩ := IsIntegrallyClosed.isIntegral_iff.mp <|
_root_.IsIntegral.tower_top (A := B) this
refine ⟨y, ?_⟩
apply FaithfulSMul.algebraMap_injective B L
rw [← IsScalarTower.algebraMap_apply, map_mul, hy, mul_inv_cancel_left₀]
exact (map_ne_zero_iff _ (FaithfulSMul.algebraMap_injective B L)).mpr hx
rw [← isIntegral_algHom_iff (IsScalarTower.toAlgHom A L E)
(FaithfulSMul.algebraMap_injective L E), IsScalarTower.coe_toAlgHom', map_mul, map_inv₀,
IsScalarTower.algebraMap_apply A K L, algebraMap_intNorm (L := L),
← IsScalarTower.algebraMap_apply, ← IsScalarTower.algebraMap_apply, norm_eq_prod_embeddings,
← Finset.univ.mul_prod_erase _ (Finset.mem_univ (IsScalarTower.toAlgHom K L E)),
IsScalarTower.coe_toAlgHom', ← IsScalarTower.algebraMap_apply, inv_mul_cancel_left₀]
· refine _root_.IsIntegral.prod _ fun σ _ ↦ ?_
change IsIntegral A ((σ.restrictScalars A) (IsScalarTower.toAlgHom A B L x))
rw [isIntegral_algHom_iff _ (RingHom.injective _),
isIntegral_algHom_iff _ (FaithfulSMul.algebraMap_injective B L)]
exact IsIntegral.isIntegral x
· have := NoZeroSMulDivisors.trans_faithfulSMul B L E
exact (map_ne_zero_iff _ (FaithfulSMul.algebraMap_injective B E)).mpr hx | theorem | RingTheory | [
"Mathlib.RingTheory.DedekindDomain.IntegralClosure",
"Mathlib.RingTheory.RingHom.Finite",
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.RingTheory.Localization.NormTrace",
"Mathlib.RingTheory.Norm.Transitivity"
] | Mathlib/RingTheory/IntegralClosure/IntegralRestrict.lean | Algebra.dvd_algebraMap_intNorm_self | null |
noncomputable IsIntegralClosure.MulSemiringAction [Algebra.IsAlgebraic K L] :
MulSemiringAction (L ≃ₐ[K] L) B :=
MulSemiringAction.compHom B (galRestrict A K L B).toMonoidHom | def | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | IsIntegralClosure.MulSemiringAction | In the AKLB setup, the Galois group of `L/K` acts on `B`. |
Algebra.isInvariant_of_isGalois [FiniteDimensional K L] [h : IsGalois K L] :
letI := IsIntegralClosure.MulSemiringAction A K L B
Algebra.IsInvariant A B (L ≃ₐ[K] L) := by
replace h := ((IsGalois.tfae (F := K) (E := L)).out 0 1).mp h
letI := IsIntegralClosure.MulSemiringAction A K L B
refine ⟨fun b hb ↦ ?_⟩
replace hb : algebraMap B L b ∈ IntermediateField.fixedField (⊤ : Subgroup (L ≃ₐ[K] L)) := by
rintro ⟨g, -⟩
exact (algebraMap_galRestrict_apply A g b).symm.trans (congrArg (algebraMap B L) (hb g))
rw [h, IntermediateField.mem_bot] at hb
obtain ⟨k, hk⟩ := hb
have hb : IsIntegral A b := IsIntegralClosure.isIntegral A L b
rw [← isIntegral_algebraMap_iff (FaithfulSMul.algebraMap_injective B L), ← hk,
isIntegral_algebraMap_iff (FaithfulSMul.algebraMap_injective K L)] at hb
obtain ⟨a, rfl⟩ := IsIntegrallyClosed.algebraMap_eq_of_integral hb
rw [← IsScalarTower.algebraMap_apply, IsScalarTower.algebraMap_apply A B L,
(FaithfulSMul.algebraMap_injective B L).eq_iff] at hk
exact ⟨a, hk⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | Algebra.isInvariant_of_isGalois | In the AKLB setup, every fixed point of `B` lies in the image of `A`. |
Algebra.isInvariant_of_isGalois' [FiniteDimensional K L] [IsGalois K L] :
Algebra.IsInvariant A B (B ≃ₐ[A] B) :=
⟨fun b h ↦ (isInvariant_of_isGalois A K L B).1 b (fun g ↦ h (galRestrict A K L B g))⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | Algebra.isInvariant_of_isGalois' | A variant of `Algebra.isInvariant_of_isGalois`, replacing `Gal(L/K)` by `Aut(B/A)`. |
noncomputable charpoly (b : B) : B[X] := ∏ g : G, (X - C (g • b)) | def | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | charpoly | Characteristic polynomial of a finite group action on a ring. |
charpoly_eq (b : B) : charpoly G b = ∏ g : G, (X - C (g • b)) := rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | charpoly_eq | null |
charpoly_eq_prod_smul (b : B) : charpoly G b = ∏ g : G, g • (X - C b) := by
simp only [smul_sub, smul_C, smul_X, charpoly_eq] | theorem | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | charpoly_eq_prod_smul | null |
monic_charpoly (b : B) : (charpoly G b).Monic :=
monic_prod_of_monic _ _ (fun _ _ ↦ monic_X_sub_C _) | theorem | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | monic_charpoly | null |
eval_charpoly (b : B) : (charpoly G b).eval b = 0 := by
rw [charpoly_eq, eval_prod]
apply Finset.prod_eq_zero (Finset.mem_univ (1 : G))
rw [one_smul, eval_sub, eval_C, eval_X, sub_self]
variable {G} | theorem | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | eval_charpoly | null |
smul_charpoly (b : B) (g : G) : g • (charpoly G b) = charpoly G b := by
rw [charpoly_eq_prod_smul, Finset.smul_prod_perm] | theorem | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | smul_charpoly | null |
smul_coeff_charpoly (b : B) (n : ℕ) (g : G) :
g • (charpoly G b).coeff n = (charpoly G b).coeff n := by
rw [← coeff_smul, smul_charpoly] | theorem | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | smul_coeff_charpoly | null |
charpoly_mem_lifts [Fintype G] (b : B) :
charpoly G b ∈ Polynomial.lifts (algebraMap A B) :=
(charpoly G b).lifts_iff_coeff_lifts.mpr fun n ↦ isInvariant _ (smul_coeff_charpoly b n) | theorem | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | charpoly_mem_lifts | null |
isIntegral [Finite G] : Algebra.IsIntegral A B := by
cases nonempty_fintype G
refine ⟨fun b ↦ ?_⟩
obtain ⟨p, hp1, -, hp2⟩ := Polynomial.lifts_and_natDegree_eq_and_monic
(charpoly_mem_lifts A B G b) (monic_charpoly G b)
exact ⟨p, hp2, by rw [← eval_map, hp1, eval_charpoly]⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | isIntegral | null |
exists_smul_of_under_eq [Finite G] [SMulCommClass G A B]
(P Q : Ideal B) [hP : P.IsPrime] [hQ : Q.IsPrime]
(hPQ : P.under A = Q.under A) :
∃ g : G, Q = g • P := by
cases nonempty_fintype G
have : ∀ (P Q : Ideal B) [P.IsPrime] [Q.IsPrime], P.under A = Q.under A →
∃ g ∈ (⊤ : Finset G), Q ≤ g • P := by
intro P Q hP hQ hPQ
rw [← Ideal.subset_union_prime 1 1 (fun _ _ _ _ ↦ hP.smul _)]
intro b hb
suffices h : ∃ g ∈ Finset.univ, g • b ∈ P by
obtain ⟨g, -, hg⟩ := h
apply Set.mem_biUnion (Finset.mem_univ g⁻¹) (Ideal.mem_inv_pointwise_smul_iff.mpr hg)
obtain ⟨a, ha⟩ := isInvariant (A := A) (∏ g : G, g • b) (Finset.smul_prod_perm b)
rw [← hP.prod_mem_iff, ← ha, ← P.mem_comap, ← P.under_def A,
hPQ, Q.mem_comap, ha, hQ.prod_mem_iff]
exact ⟨1, Finset.mem_univ 1, (one_smul G b).symm ▸ hb⟩
obtain ⟨g, -, hg⟩ := this P Q hPQ
obtain ⟨g', -, hg'⟩ := this Q (g • P) ((P.under_smul A g).trans hPQ).symm
exact ⟨g, le_antisymm hg (smul_eq_of_le_smul (hg.trans hg') ▸ hg')⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | exists_smul_of_under_eq | `G` acts transitively on the prime ideals of `B` above a given prime ideal of `A`. |
orbit_eq_primesOver [Finite G] [SMulCommClass G A B] (P : Ideal A) (Q : Ideal B)
[hP : Q.LiesOver P] [hQ : Q.IsPrime] : MulAction.orbit G Q = P.primesOver B := by
refine Set.ext fun R ↦ ⟨fun ⟨g, hg⟩ ↦ hg ▸ ⟨hQ.smul g, hP.smul g⟩, fun h ↦ ?_⟩
have : R.IsPrime := h.1
obtain ⟨g, hg⟩ := exists_smul_of_under_eq A B G Q R (hP.over.symm.trans h.2.over)
exact ⟨g, hg.symm⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | orbit_eq_primesOver | null |
private fixed_of_fixed1_aux1 [DecidableEq (Ideal B)] :
∃ a b : B, (∀ g : G, g • a = a) ∧ a ∉ Q ∧
∀ g : G, algebraMap B (B ⧸ Q) (g • b) = algebraMap B (B ⧸ Q) (if g • Q = Q then a else 0) := by
obtain ⟨_⟩ := nonempty_fintype G
let P := Finset.inf {g : G | g • Q ≠ Q} (fun g ↦ g • Q)
have h1 : ¬ P ≤ Q := by
rw [Ideal.IsPrime.inf_le' inferInstance]
rintro ⟨g, hg1, hg2⟩
exact (Finset.mem_filter.mp hg1).2 (smul_eq_of_smul_le hg2)
obtain ⟨b, hbP, hbQ⟩ := SetLike.not_le_iff_exists.mp h1
replace hbP : ∀ g : G, g • Q ≠ Q → b ∈ g • Q :=
fun g hg ↦ (Finset.inf_le (Finset.mem_filter.mpr ⟨Finset.mem_univ g, hg⟩) : P ≤ g • Q) hbP
let f := MulSemiringAction.charpoly G b
obtain ⟨q, hq, hq0⟩ :=
(f.map (algebraMap B (B ⧸ Q))).exists_eq_pow_rootMultiplicity_mul_and_not_dvd
(Polynomial.map_monic_ne_zero (MulSemiringAction.monic_charpoly G b)) 0
rw [map_zero, sub_zero] at hq hq0
let j := (f.map (algebraMap B (B ⧸ Q))).rootMultiplicity 0
let k := q.natDegree
let r := ∑ i ∈ Finset.range (k + 1), Polynomial.monomial i (f.coeff (i + j))
have hr : r.map (algebraMap B (B ⧸ Q)) = q := by
ext n
rw [Polynomial.coeff_map, Polynomial.finset_sum_coeff]
simp only [Polynomial.coeff_monomial, Finset.sum_ite_eq', Finset.mem_range_succ_iff]
split_ifs with hn
· rw [← Polynomial.coeff_map, hq, Polynomial.coeff_X_pow_mul]
· rw [map_zero, eq_comm, Polynomial.coeff_eq_zero_of_natDegree_lt (lt_of_not_ge hn)]
have hf : f.eval b = 0 := MulSemiringAction.eval_charpoly G b
have hr : r.eval b ∈ Q := by
rw [← Ideal.Quotient.eq_zero_iff_mem, ← Ideal.Quotient.algebraMap_eq] at hbQ ⊢
replace hf := congrArg (algebraMap B (B ⧸ Q)) hf
rw [← Polynomial.eval₂_at_apply, ← Polynomial.eval_map] at hf ⊢
rwa [map_zero, hq, ← hr, Polynomial.eval_mul, Polynomial.eval_pow, Polynomial.eval_X,
mul_eq_zero, or_iff_right (pow_ne_zero _ hbQ)] at hf
let a := f.coeff j
have ha : ∀ g : G, g • a = a := MulSemiringAction.smul_coeff_charpoly b j
have hr' : ∀ g : G, g • Q ≠ Q → a - r.eval b ∈ g • Q := by
intro g hg
have hr : r = ∑ i ∈ Finset.range (k + 1), Polynomial.monomial i (f.coeff (i + j)) := rfl
rw [← Ideal.neg_mem_iff, neg_sub, hr, Finset.sum_range_succ', Polynomial.eval_add,
Polynomial.eval_monomial, zero_add, pow_zero, mul_one, add_sub_cancel_right]
simp only [ ← Polynomial.monomial_mul_X]
rw [← Finset.sum_mul, Polynomial.eval_mul_X]
exact Ideal.mul_mem_left (g • Q) _ (hbP g hg)
refine ⟨a, a - r.eval b, ha, ?_, fun h ↦ ?_⟩
· rwa [← Ideal.Quotient.eq_zero_iff_mem, ← Ideal.Quotient.algebraMap_eq, ← Polynomial.coeff_map,
← zero_add j, hq, Polynomial.coeff_X_pow_mul, ← Polynomial.X_dvd_iff]
· rw [← sub_eq_zero, ← map_sub, Ideal.Quotient.algebraMap_eq, Ideal.Quotient.eq_zero_iff_mem,
← Ideal.smul_mem_pointwise_smul_iff (a := h⁻¹), smul_sub, inv_smul_smul]
simp only [← eq_inv_smul_iff (g := h), eq_comm (a := Q)]
split_ifs with hh
... | theorem | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | fixed_of_fixed1_aux1 | A technical lemma for `fixed_of_fixed1`. |
private fixed_of_fixed1_aux2 [DecidableEq (Ideal B)] (b₀ : B)
(hx : ∀ g : G, g • Q = Q → algebraMap B (B ⧸ Q) (g • b₀) = algebraMap B (B ⧸ Q) b₀) :
∃ a b : B, (∀ g : G, g • a = a) ∧ a ∉ Q ∧
(∀ g : G, algebraMap B (B ⧸ Q) (g • b) =
algebraMap B (B ⧸ Q) (if g • Q = Q then a * b₀ else 0)) := by
obtain ⟨a, b, ha1, ha2, hb⟩ := fixed_of_fixed1_aux1 G Q
refine ⟨a, b * b₀, ha1, ha2, fun g ↦ ?_⟩
rw [smul_mul', map_mul, hb]
specialize hb g
split_ifs with hg
· rw [map_mul, hx g hg]
· rw [map_zero, zero_mul] | theorem | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | fixed_of_fixed1_aux2 | A technical lemma for `fixed_of_fixed1`. |
private fixed_of_fixed1_aux3 [NoZeroDivisors B] {b : B} {i j : ℕ} {p : Polynomial A}
(h : p.map (algebraMap A B) = (X - C b) ^ i * X ^ j) (f : B ≃ₐ[A] B) (hi : i ≠ 0) :
f b = b := by
by_cases ha : b = 0
· rw [ha, map_zero]
have hf := congrArg (eval b) (congrArg (Polynomial.mapAlgHom f.toAlgHom) h)
rw [coe_mapAlgHom, map_map, f.toAlgHom.comp_algebraMap, h] at hf
simp_rw [Polynomial.map_mul, Polynomial.map_pow, Polynomial.map_sub, map_X, map_C,
eval_mul, eval_pow, eval_sub, eval_X, eval_C, sub_self, zero_pow hi, zero_mul,
zero_eq_mul, or_iff_left (pow_ne_zero j ha), pow_eq_zero_iff hi, sub_eq_zero] at hf
exact hf.symm | theorem | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | fixed_of_fixed1_aux3 | A technical lemma for `fixed_of_fixed1`. |
private fixed_of_fixed1 [NoZeroSMulDivisors (B ⧸ Q) L] (f : L ≃ₐ[K] L) (b : B ⧸ Q)
(hx : ∀ g : MulAction.stabilizer G Q, Ideal.Quotient.stabilizerHom Q P G g b = b) :
f (algebraMap (B ⧸ Q) L b) = (algebraMap (B ⧸ Q) L b) := by
classical
cases nonempty_fintype G
obtain ⟨b₀, rfl⟩ := Ideal.Quotient.mk_surjective b
rw [← Ideal.Quotient.algebraMap_eq]
obtain ⟨a, b, ha1, ha2, hb⟩ := fixed_of_fixed1_aux2 G Q b₀ (fun g hg ↦ hx ⟨g, hg⟩)
obtain ⟨M, key⟩ := (mem_lifts _).mp (Algebra.IsInvariant.charpoly_mem_lifts A B G b)
replace key := congrArg (map (algebraMap B (B ⧸ Q))) key
rw [map_map, ← algebraMap_eq, algebraMap_eq A (A ⧸ P) (B ⧸ Q),
← map_map, MulSemiringAction.charpoly, Polynomial.map_prod] at key
have key₀ : ∀ g : G, (X - C (g • b)).map (algebraMap B (B ⧸ Q)) =
if g • Q = Q then X - C (algebraMap B (B ⧸ Q) (a * b₀)) else X := by
intro g
rw [Polynomial.map_sub, map_X, map_C, hb]
split_ifs
· rfl
· rw [map_zero, map_zero, sub_zero]
simp only [key₀, Finset.prod_ite, Finset.prod_const] at key
replace key := congrArg (map (algebraMap (B ⧸ Q) L)) key
rw [map_map, ← algebraMap_eq, algebraMap_eq (A ⧸ P) K L,
← map_map, Polynomial.map_mul, Polynomial.map_pow, Polynomial.map_pow, Polynomial.map_sub,
map_X, map_C] at key
replace key := fixed_of_fixed1_aux3 key f (Finset.card_ne_zero_of_mem
(Finset.mem_filter.mpr ⟨Finset.mem_univ 1, one_smul G Q⟩))
simp only [map_mul] at key
obtain ⟨a, rfl⟩ := Algebra.IsInvariant.isInvariant (A := A) a ha1
rwa [← algebraMap_apply A B (B ⧸ Q), algebraMap_apply A (A ⧸ P) (B ⧸ Q),
← algebraMap_apply, algebraMap_apply (A ⧸ P) K L, f.commutes, mul_right_inj'] at key
rwa [← algebraMap_apply, algebraMap_apply (A ⧸ P) (B ⧸ Q) L,
← algebraMap_apply A (A ⧸ P) (B ⧸ Q), algebraMap_apply A B (B ⧸ Q),
Ne, algebraMap_eq_zero_iff, Ideal.Quotient.algebraMap_eq, Ideal.Quotient.eq_zero_iff_mem]
variable [IsFractionRing (A ⧸ P) K] [IsFractionRing (B ⧸ Q) L] | theorem | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | fixed_of_fixed1 | This theorem will be made redundant by `IsFractionRing.stabilizerHom_surjective`. |
noncomputable IsFractionRing.stabilizerHom : MulAction.stabilizer G Q →* (L ≃ₐ[K] L) :=
MonoidHom.comp (IsFractionRing.fieldEquivOfAlgEquivHom K L) (Ideal.Quotient.stabilizerHom Q P G) | def | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | IsFractionRing.stabilizerHom | If `Q` lies over `P`, then the stabilizer of `Q` acts on `Frac(B/Q)/Frac(A/P)`. |
private fixed_of_fixed2 (f : L ≃ₐ[K] L) (x : L)
(hx : ∀ g : MulAction.stabilizer G Q, IsFractionRing.stabilizerHom G P Q K L g x = x) :
f x = x := by
obtain ⟨_⟩ := nonempty_fintype G
have : P.IsPrime := Ideal.over_def Q P ▸ Ideal.IsPrime.under A Q
have : Algebra.IsIntegral A B := Algebra.IsInvariant.isIntegral A B G
obtain ⟨x, y, hy, rfl⟩ := IsFractionRing.div_surjective (A := B ⧸ Q) x
obtain ⟨b, a, ha, h⟩ := (Algebra.IsAlgebraic.isAlgebraic (R := A ⧸ P) y).exists_smul_eq_mul x hy
replace ha : algebraMap (A ⧸ P) L a ≠ 0 := by
rwa [Ne, algebraMap_apply (A ⧸ P) K L, algebraMap_eq_zero_iff, algebraMap_eq_zero_iff]
replace hy : algebraMap (B ⧸ Q) L y ≠ 0 :=
mt (algebraMap_eq_zero_iff (B ⧸ Q) L).mp (nonZeroDivisors.ne_zero hy)
replace h : algebraMap (B ⧸ Q) L x / algebraMap (B ⧸ Q) L y =
algebraMap (B ⧸ Q) L b / algebraMap (A ⧸ P) L a := by
rw [mul_comm, Algebra.smul_def, mul_comm] at h
rw [div_eq_div_iff hy ha, ← map_mul, ← h, map_mul, ← algebraMap_apply]
simp only [h, map_div₀, algebraMap_apply (A ⧸ P) K L, AlgEquiv.commutes] at hx ⊢
simp only [← algebraMap_apply, div_left_inj' ha] at hx ⊢
exact fixed_of_fixed1 G P Q K L f b (fun g ↦ IsFractionRing.injective (B ⧸ Q) L
((IsFractionRing.fieldEquivOfAlgEquiv_algebraMap K L L
(Ideal.Quotient.stabilizerHom Q P G g) b).symm.trans (hx g))) | theorem | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | fixed_of_fixed2 | This theorem will be made redundant by `IsFractionRing.stabilizerHom_surjective`. |
IsFractionRing.stabilizerHom_surjective :
Function.Surjective (stabilizerHom G P Q K L) := by
let _ := MulSemiringAction.compHom L (stabilizerHom G P Q K L)
intro f
obtain ⟨g, hg⟩ := FixedPoints.toAlgAut_surjective (MulAction.stabilizer G Q) L
(AlgEquiv.ofRingEquiv (f := f) (fun x ↦ fixed_of_fixed2 G P Q K L f x x.2))
exact ⟨g, by rwa [AlgEquiv.ext_iff] at hg ⊢⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | IsFractionRing.stabilizerHom_surjective | The stabilizer subgroup of `Q` surjects onto `Aut(Frac(B/Q)/Frac(A/P))`. |
Ideal.Quotient.stabilizerHom_surjective :
Function.Surjective (Ideal.Quotient.stabilizerHom Q P G) := by
have : P.IsPrime := Ideal.over_def Q P ▸ Ideal.IsPrime.under A Q
let _ := FractionRing.liftAlgebra (A ⧸ P) (FractionRing (B ⧸ Q))
have key := IsFractionRing.stabilizerHom_surjective G P Q
(FractionRing (A ⧸ P)) (FractionRing (B ⧸ Q))
rw [IsFractionRing.stabilizerHom, MonoidHom.coe_comp] at key
exact key.of_comp_left (IsFractionRing.fieldEquivOfAlgEquivHom_injective (A ⧸ P) (B ⧸ Q)
(FractionRing (A ⧸ P)) (FractionRing (B ⧸ Q))) | theorem | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | Ideal.Quotient.stabilizerHom_surjective | The stabilizer subgroup of `Q` surjects onto `Aut((B/Q)/(A/P))`. |
Ideal.Quotient.exists_algHom_fixedPoint_quotient_under
(σ : k →ₐ[A ⧸ P] k) :
∃ τ : (B ⧸ Q) →ₐ[A ⧸ P] B ⧸ Q, ∀ x : B ⧸ Q,
algebraMap _ _ (τ x) = σ (algebraMap (B ⧸ Q) k x) := by
let f : (B ⧸ Q) →ₐ[A ⧸ P] k := IsScalarTower.toAlgHom _ _ _
have hf : Function.Injective f := FaithfulSMul.algebraMap_injective _ _
suffices (σ.comp f).range ≤ f.range by
let e := (AlgEquiv.ofInjective f hf)
exact ⟨(e.symm.toAlgHom.comp (Subalgebra.inclusion this)).comp (σ.comp f).rangeRestrict,
fun x ↦ congr_arg Subtype.val (e.apply_symm_apply ⟨_, _⟩)⟩
rintro _ ⟨x, rfl⟩
obtain ⟨x, rfl⟩ := Ideal.Quotient.mk_surjective x
cases nonempty_fintype G
algebraize [(algebraMap (A ⧸ P) k).comp (algebraMap A (A ⧸ P)),
(algebraMap (B ⧸ Q) k).comp (algebraMap B (B ⧸ Q))]
haveI : IsScalarTower A (B ⧸ Q) k := .of_algebraMap_eq fun x ↦
(IsScalarTower.algebraMap_apply (A ⧸ P) (B ⧸ Q) k (mk P x))
haveI : IsScalarTower A B k := .of_algebraMap_eq fun x ↦
(IsScalarTower.algebraMap_apply (A ⧸ P) (B ⧸ Q) k (mk P x))
obtain ⟨P, hp⟩ := Algebra.IsInvariant.charpoly_mem_lifts A B G x
have : Polynomial.aeval x P = 0 := by
rw [Polynomial.aeval_def, ← Polynomial.eval_map,
← Polynomial.coe_mapRingHom (R := A), hp, MulSemiringAction.eval_charpoly]
have : Polynomial.aeval (σ (algebraMap (B ⧸ Q) k (mk _ x))) P = 0 := by
refine (DFunLike.congr_fun (Polynomial.aeval_algHom ((σ.restrictScalars A).comp
(IsScalarTower.toAlgHom A (B ⧸ Q) k)) _) P).trans ?_
rw [AlgHom.comp_apply, ← algebraMap_eq, Polynomial.aeval_algebraMap_apply, this,
map_zero, map_zero]
rw [← Polynomial.aeval_map_algebraMap B, ← Polynomial.coe_mapRingHom, hp] at this
obtain ⟨τ, hτ⟩ : ∃ τ : G, σ (algebraMap _ _ x) = algebraMap _ _ (τ • x) := by
simpa [MulSemiringAction.charpoly, sub_eq_zero, Finset.prod_eq_zero_iff] using this
exact ⟨Ideal.Quotient.mk _ (τ • x), hτ.symm⟩
include G in | lemma | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | Ideal.Quotient.exists_algHom_fixedPoint_quotient_under | For any domain `k` containing `B ⧸ Q`,
any endomorphism of `k` can be restricted to an endomorphism of `B ⧸ Q`.
This is basically the fact that `L/K` normal implies `κ(Q)/κ(P)` normal in the Galois setting. |
Ideal.Quotient.exists_algEquiv_fixedPoint_quotient_under
(σ : k ≃ₐ[A ⧸ P] k) :
∃ τ : (B ⧸ Q) ≃ₐ[A ⧸ P] B ⧸ Q, ∀ x : B ⧸ Q,
algebraMap _ _ (τ x) = σ (algebraMap (B ⧸ Q) k x) := by
let f : (B ⧸ Q) →ₐ[A ⧸ P] k := IsScalarTower.toAlgHom _ _ _
have hf : Function.Injective f := FaithfulSMul.algebraMap_injective _ _
obtain ⟨τ₁, h₁⟩ := Ideal.Quotient.exists_algHom_fixedPoint_quotient_under G P Q σ.toAlgHom
obtain ⟨τ₂, h₂⟩ := Ideal.Quotient.exists_algHom_fixedPoint_quotient_under G P Q σ.symm.toAlgHom
refine ⟨{ __ := τ₁, invFun := τ₂, left_inv := ?_, right_inv := ?_ }, h₁⟩
· intro x
obtain ⟨x, rfl⟩ := Ideal.Quotient.mk_surjective x
obtain ⟨y, e⟩ := Ideal.Quotient.mk_surjective (τ₁ (Ideal.Quotient.mk Q x))
apply hf
dsimp [f] at h₁ h₂ ⊢
refine .trans ?_ (σ.symm_apply_apply _)
rw [← h₁, ← e, h₂]
· intro x
obtain ⟨x, rfl⟩ := Ideal.Quotient.mk_surjective x
obtain ⟨y, e⟩ := Ideal.Quotient.mk_surjective (τ₂ (Ideal.Quotient.mk Q x))
apply hf
dsimp [f] at h₁ h₂ ⊢
refine .trans ?_ (σ.apply_symm_apply _)
rw [← h₂, ← e, h₁]
attribute [local instance] Ideal.Quotient.field in
include G in | lemma | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | Ideal.Quotient.exists_algEquiv_fixedPoint_quotient_under | For any domain `k` containing `B ⧸ Q`,
any endomorphism of `k` can be restricted to an endomorphism of `B ⧸ Q`. |
Ideal.Quotient.normal [P.IsMaximal] [Q.IsMaximal] :
Normal (A ⧸ P) (B ⧸ Q) := by
cases subsingleton_or_nontrivial B
· cases ‹Q.IsMaximal›.ne_top (Subsingleton.elim _ _)
have := Algebra.IsInvariant.isIntegral A B G
constructor
intro x
obtain ⟨x, rfl⟩ := Ideal.Quotient.mk_surjective x
cases nonempty_fintype G
obtain ⟨p, hp, h₁, h₂⟩ := Polynomial.lifts_and_degree_eq_and_monic
(Algebra.IsInvariant.charpoly_mem_lifts A B G x) (MulSemiringAction.monic_charpoly _ _)
have H : Polynomial.aeval x p = 0 := by
rw [Polynomial.aeval_def, ← Polynomial.eval_map, hp, MulSemiringAction.eval_charpoly]
have := minpoly.dvd _ (algebraMap _ (B ⧸ Q) x) (p := p.map (algebraMap _ (A ⧸ P)))
(by rw [Polynomial.aeval_map_algebraMap, Polynomial.aeval_algebraMap_apply, H, map_zero])
refine Polynomial.splits_of_splits_of_dvd (algebraMap (A ⧸ P) (B ⧸ Q)) ?_ ?_ this
· exact (h₂.map (algebraMap A (A ⧸ P))).ne_zero
· rw [Polynomial.splits_map_iff, ← IsScalarTower.algebraMap_eq, IsScalarTower.algebraMap_eq A B,
← Polynomial.splits_map_iff, hp, MulSemiringAction.charpoly_eq]
exact Polynomial.splits_prod _ (fun _ _ ↦ Polynomial.splits_X_sub_C _)
attribute [local instance] Ideal.Quotient.field in
include G in | lemma | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | Ideal.Quotient.normal | For any domain `k` containing `B ⧸ Q`,
any endomorphism of `k` can be restricted to an endomorphism of `B ⧸ Q`. |
Ideal.Quotient.finite_of_isInvariant [P.IsMaximal] [Q.IsMaximal]
[SMulCommClass G A B] [Algebra.IsSeparable (A ⧸ P) (B ⧸ Q)] :
Module.Finite (A ⧸ P) (B ⧸ Q) := by
have : IsGalois (A ⧸ P) (B ⧸ Q) := { __ := Ideal.Quotient.normal (A := A) G P Q }
have := Finite.of_surjective _ (Ideal.Quotient.stabilizerHom_surjective G P Q)
exact IsGalois.finiteDimensional_of_finite _ _ | lemma | RingTheory | [
"Mathlib.RingTheory.Invariant.Defs",
"Mathlib.RingTheory.IntegralClosure.IntegralRestrict"
] | Mathlib/RingTheory/Invariant/Basic.lean | Ideal.Quotient.finite_of_isInvariant | If the extension `B/Q` over `A/P` is separable, then it is finite dimensional. |
@[mk_iff] IsInvariant : Prop where
isInvariant : ∀ b : B, (∀ g : G, g • b = b) → ∃ a : A, algebraMap A B a = b | class | RingTheory | [
"Mathlib.Algebra.Algebra.Defs"
] | Mathlib/RingTheory/Invariant/Defs.lean | IsInvariant | An action of a group `G` on an extension of rings `B/A` is invariant if every fixed point of
`B` lies in the image of `A`. The converse statement that every point in the image of `A` is fixed
by `G` is `smul_algebraMap` (assuming `SMulCommClass A B G`). |
Algebra.IsInvariant.isIntegral_of_profinite
[Algebra.IsInvariant A B G] : Algebra.IsIntegral A B := by
constructor
intro x
obtain ⟨N, hN⟩ := ProfiniteGrp.exist_openNormalSubgroup_sub_open_nhds_of_one
(stabilizer_isOpen G x) (one_mem _)
have := (Algebra.IsInvariant.isIntegral A (FixedPoints.subalgebra A B N.1.1) (G ⧸ N.1.1)).1
⟨x, fun g ↦ hN g.2⟩
exact this.map (FixedPoints.subalgebra A B N.1.1).val | lemma | RingTheory | [
"Mathlib.RingTheory.Invariant.Basic",
"Mathlib.Topology.Algebra.ClopenNhdofOne",
"Mathlib.Topology.Algebra.Category.ProfiniteGrp.Limits",
"Mathlib.CategoryTheory.CofilteredSystem"
] | Mathlib/RingTheory/Invariant/Profinite.lean | Algebra.IsInvariant.isIntegral_of_profinite | null |
Algebra.IsInvariant.exists_smul_of_under_eq_of_profinite
[Algebra.IsInvariant A B G] (P Q : Ideal B) [P.IsPrime] [Q.IsPrime]
(hPQ : P.under A = Q.under A) :
∃ g : G, Q = g • P := by
let B' := FixedPoints.subalgebra A B
let F : OpenNormalSubgroup G ⥤ Type _ :=
{ obj N := { g : G ⧸ N.1.1 // Q.under (B' N.1.1) = g • P.under (B' N.1.1) }
map {N N'} f x := ⟨(QuotientGroup.map _ _ (.id _) (leOfHom f)) x.1, by
have h : B' N'.1.1 ≤ B' N.1.1 := fun x hx n ↦ hx ⟨_, f.le n.2⟩
obtain ⟨x, hx⟩ := x
obtain ⟨x, rfl⟩ := QuotientGroup.mk_surjective x
simpa only [Ideal.comap_comap, Ideal.pointwise_smul_eq_comap, ← Ideal.comap_coe
(F := RingEquiv _ _)] using congr(Ideal.comap (Subalgebra.inclusion h).toRingHom $hx)⟩
map_id N := by ext ⟨⟨x⟩, hx⟩; rfl
map_comp f g := by ext ⟨⟨x⟩, hx⟩; rfl }
have (N : _) : Nonempty (F.obj N) := by
obtain ⟨g, hg⟩ := Algebra.IsInvariant.exists_smul_of_under_eq A
(B' N.1.1) (G ⧸ N.1.1) (P.under _) (Q.under _) hPQ
exact ⟨g, hg⟩
obtain ⟨s, hs⟩ := nonempty_sections_of_finite_cofiltered_system F
let a := (ProfiniteGrp.of G).isoLimittoFiniteQuotientFunctor.inv.hom
⟨fun N ↦ (s N).1, (fun {N N'} f ↦ congr_arg Subtype.val (hs f))⟩
have (N : OpenNormalSubgroup G) : QuotientGroup.mk (s := N.1.1) a = s N := by
change ((ProfiniteGrp.of G).isoLimittoFiniteQuotientFunctor.hom.hom a).1 N = _
simp only [a]
rw [← ProfiniteGrp.comp_apply, Iso.inv_hom_id]
simp
refine ⟨a, ?_⟩
ext x
obtain ⟨N, hN⟩ := ProfiniteGrp.exist_openNormalSubgroup_sub_open_nhds_of_one
(stabilizer_isOpen G x) (one_mem _)
lift x to B' N.1.1 using fun g ↦ hN g.2
change x ∈ Q.under (B' N.1.1) ↔ x ∈ Ideal.under (B' N.1.1) ((_ : G) • P)
rw [(s N).2]
simp only [Ideal.comap_comap, Ideal.pointwise_smul_eq_comap, ← Ideal.comap_coe
(F := RingEquiv _ _)]
congr! 2
ext y
simp [← this]
rfl
attribute [local instance] Subgroup.finiteIndex_of_finite_quotient
omit
[CompactSpace G]
[TotallyDisconnectedSpace G]
[IsTopologicalGroup G]
[TopologicalSpace B]
[DiscreteTopology B]
[ContinuousSMul G B] in | lemma | RingTheory | [
"Mathlib.RingTheory.Invariant.Basic",
"Mathlib.Topology.Algebra.ClopenNhdofOne",
"Mathlib.Topology.Algebra.Category.ProfiniteGrp.Limits",
"Mathlib.CategoryTheory.CofilteredSystem"
] | Mathlib/RingTheory/Invariant/Profinite.lean | Algebra.IsInvariant.exists_smul_of_under_eq_of_profinite | `G` acts transitively on the prime ideals of `B` above a given prime ideal of `A`. |
Ideal.Quotient.stabilizerHomSurjectiveAuxFunctor_aux
(Q : Ideal B)
{N N' : OpenNormalSubgroup G} (e : N ≤ N')
(x : G ⧸ N.1.1)
(hx : x ∈ MulAction.stabilizer (G ⧸ N.1.1) (Q.under (FixedPoints.subalgebra A B N.1.1))) :
QuotientGroup.map _ _ (.id _) e x ∈
MulAction.stabilizer (G ⧸ N'.1.1) (Q.under (FixedPoints.subalgebra A B N'.1.1)) := by
change _ = _
have h : FixedPoints.subalgebra A B N'.1.1 ≤ FixedPoints.subalgebra A B N.1.1 :=
fun x hx n ↦ hx ⟨_, e n.2⟩
obtain ⟨x, rfl⟩ := QuotientGroup.mk_surjective x
replace hx := congr(Ideal.comap (Subalgebra.inclusion h) $hx)
simpa only [Ideal.pointwise_smul_eq_comap,
← Ideal.comap_coe (F := RingEquiv _ _), Ideal.comap_comap] using hx | lemma | RingTheory | [
"Mathlib.RingTheory.Invariant.Basic",
"Mathlib.Topology.Algebra.ClopenNhdofOne",
"Mathlib.Topology.Algebra.Category.ProfiniteGrp.Limits",
"Mathlib.CategoryTheory.CofilteredSystem"
] | Mathlib/RingTheory/Invariant/Profinite.lean | Ideal.Quotient.stabilizerHomSurjectiveAuxFunctor_aux | null |
Ideal.Quotient.stabilizerHomSurjectiveAuxFunctor
(P : Ideal A) (Q : Ideal B) [Q.LiesOver P] (σ : (B ⧸ Q) ≃ₐ[A ⧸ P] B ⧸ Q) :
OpenNormalSubgroup G ⥤ Type _ where
obj N :=
letI B' := FixedPoints.subalgebra A B N.1.1
letI f : (B' ⧸ Q.under B') →ₐ[A ⧸ P] B ⧸ Q :=
{ toRingHom := Ideal.quotientMap _ B'.subtype le_rfl,
commutes' := Quotient.ind fun _ ↦ rfl }
{ σ' // f.comp (Ideal.Quotient.stabilizerHom
(Q.under B') P (G ⧸ N.1.1) σ') = σ.toAlgHom.comp f }
map {N N'} i x := ⟨⟨(QuotientGroup.map _ _ (.id _) (leOfHom i)) x.1,
Ideal.Quotient.stabilizerHomSurjectiveAuxFunctor_aux Q i.le x.1.1 x.1.2⟩, by
have h : FixedPoints.subalgebra A B N'.1.1 ≤ FixedPoints.subalgebra A B N.1.1 :=
fun x hx n ↦ hx ⟨_, i.le n.2⟩
obtain ⟨⟨x, hx⟩, hx'⟩ := x
obtain ⟨x, rfl⟩ := QuotientGroup.mk_surjective x
ext g
obtain ⟨g, rfl⟩ := Ideal.Quotient.mk_surjective g
exact DFunLike.congr_fun hx' (Ideal.Quotient.mk _ (Subalgebra.inclusion h g))⟩
map_id N := by ext ⟨⟨⟨x⟩, hx⟩, hx'⟩; rfl
map_comp f g := by ext ⟨⟨⟨x⟩, hx⟩, hx'⟩; rfl
open Ideal.Quotient in | def | RingTheory | [
"Mathlib.RingTheory.Invariant.Basic",
"Mathlib.Topology.Algebra.ClopenNhdofOne",
"Mathlib.Topology.Algebra.Category.ProfiniteGrp.Limits",
"Mathlib.CategoryTheory.CofilteredSystem"
] | Mathlib/RingTheory/Invariant/Profinite.lean | Ideal.Quotient.stabilizerHomSurjectiveAuxFunctor | (Implementation)
The functor taking an open normal subgroup `N ≤ G` to the set of lifts of `σ` in `G ⧸ N`.
We will show that its inverse limit is nonempty to conclude that there exists a lift in `G`. |
Ideal.Quotient.stabilizerHom_surjective_of_profinite
(P : Ideal A) (Q : Ideal B) [Q.IsPrime] [Q.LiesOver P]
[Algebra.IsInvariant A B G] :
Function.Surjective (Ideal.Quotient.stabilizerHom Q P G) := by
intro σ
let B' := FixedPoints.subalgebra A B
obtain ⟨s, hs⟩ := nonempty_sections_of_finite_cofiltered_system
(stabilizerHomSurjectiveAuxFunctor (G := G) P Q σ)
let a := (ProfiniteGrp.of G).isoLimittoFiniteQuotientFunctor.inv.hom
⟨fun N ↦ (s N).1.1, (fun {N N'} f ↦ congr($(hs f).1.1))⟩
have (N : OpenNormalSubgroup G) : QuotientGroup.mk (s := N.1.1) a = (s N).1 :=
congr_fun (congr_arg Subtype.val (ConcreteCategory.congr_hom (ProfiniteGrp.of
G).isoLimittoFiniteQuotientFunctor.inv_hom_id (Subtype.mk (fun N ↦ (s N).1.1) _))) N
refine ⟨⟨a, ?_⟩, ?_⟩
· ext x
obtain ⟨N, hN⟩ := ProfiniteGrp.exist_openNormalSubgroup_sub_open_nhds_of_one
(stabilizer_isOpen G x) (one_mem _)
lift x to B' N.1.1 using fun g ↦ hN g.2
change x ∈ (a • Q).under (B' N.1.1) ↔ x ∈ Q.under (B' N.1.1)
rw [← (s N).1.2]
simp only [Ideal.comap_comap, Ideal.pointwise_smul_eq_comap, ← Ideal.comap_coe
(F := RingEquiv _ _)]
congr! 2
ext y
rw [← this]
rfl
· ext x
obtain ⟨x, rfl⟩ := Ideal.Quotient.mk_surjective x
obtain ⟨N, hN⟩ := ProfiniteGrp.exist_openNormalSubgroup_sub_open_nhds_of_one
(stabilizer_isOpen G x) (one_mem _)
lift x to B' N.1.1 using fun g ↦ hN g.2
change Ideal.Quotient.mk Q (QuotientGroup.mk (s := N) a • x).1 = _
rw [this]
exact DFunLike.congr_fun (s N).2 (Ideal.Quotient.mk _ x) | theorem | RingTheory | [
"Mathlib.RingTheory.Invariant.Basic",
"Mathlib.Topology.Algebra.ClopenNhdofOne",
"Mathlib.Topology.Algebra.Category.ProfiniteGrp.Limits",
"Mathlib.CategoryTheory.CofilteredSystem"
] | Mathlib/RingTheory/Invariant/Profinite.lean | Ideal.Quotient.stabilizerHom_surjective_of_profinite | The stabilizer subgroup of `Q` surjects onto `Aut((B/Q)/(A/P))`. |
Module.finite_of_isSemisimpleRing [IsJacobsonRing R] [IsSemisimpleRing A] :
Module.Finite R A :=
(Finite.equiv_iff <|
(AlgEquiv.ofRingEquiv (f := IsArtinianRing.equivPi A) fun _ ↦ rfl).toLinearEquiv).mpr <|
have (I : MaximalSpectrum A) := finite_of_finite_type_of_isJacobsonRing R (A ⧸ I.asIdeal)
Finite.pi | lemma | RingTheory | [
"Mathlib.RingTheory.HopkinsLevitzki",
"Mathlib.RingTheory.Jacobson.Ring"
] | Mathlib/RingTheory/Jacobson/Artinian.lean | Module.finite_of_isSemisimpleRing | null |
Module.finite_of_isArtinianRing [IsJacobsonRing R] [IsArtinianRing A] :
Module.Finite R A :=
have := finite_of_isSemisimpleRing R (A ⧸ Ring.jacobson A)
IsSemiprimaryRing.finite_of_isArtinian R A A | lemma | RingTheory | [
"Mathlib.RingTheory.HopkinsLevitzki",
"Mathlib.RingTheory.Jacobson.Ring"
] | Mathlib/RingTheory/Jacobson/Artinian.lean | Module.finite_of_isArtinianRing | If `A` is a finite type algebra over `R`, then `A` is an Artinian ring and `R` is Jacobson
implies `A` is finite over `R`. -/
/- If made an instance, causes timeouts synthesizing `FaithfulSMul R I.ResidueField` at
`Ideal.algebraMap_residueField_eq_zero` and `Ideal.ker_algebraMap_residueField` during
simpNF linting. |
Module.finite_iff_isArtinianRing [IsArtinianRing R] :
Module.Finite R A ↔ IsArtinianRing A :=
⟨isArtinian_of_tower _ ∘ ((IsArtinianRing.tfae R A).out 0 2).mp,
fun _ ↦ finite_of_isArtinianRing R A⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.HopkinsLevitzki",
"Mathlib.RingTheory.Jacobson.Ring"
] | Mathlib/RingTheory/Jacobson/Artinian.lean | Module.finite_iff_isArtinianRing | If `A` is a finite type algebra over an Artinian ring `R`,
then `A` is finite over `R` if and only if `A` is an Artinian ring. |
Module.finite_iff_krullDimLE_zero [IsArtinianRing R] :
Module.Finite R A ↔ Ring.KrullDimLE 0 A := by
have : IsNoetherianRing A := Algebra.FiniteType.isNoetherianRing R A
rw [finite_iff_isArtinianRing, isArtinianRing_iff_isNoetherianRing_krullDimLE_zero,
and_iff_right this] | lemma | RingTheory | [
"Mathlib.RingTheory.HopkinsLevitzki",
"Mathlib.RingTheory.Jacobson.Ring"
] | Mathlib/RingTheory/Jacobson/Artinian.lean | Module.finite_iff_krullDimLE_zero | If `A` is a finite type algebra over an Artinian ring `R`,
then `A` is finite over `R` if and only if `dim A = 0`. |
jacobson (I : Ideal R) : Ideal R :=
sInf { J : Ideal R | I ≤ J ∧ IsMaximal J } | def | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | jacobson | The Jacobson radical of `I` is the infimum of all maximal (left) ideals containing `I`. |
le_jacobson : I ≤ jacobson I := fun _ hx => mem_sInf.mpr fun _ hJ => hJ.left hx
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | le_jacobson | null |
jacobson_idem : jacobson (jacobson I) = jacobson I :=
le_antisymm (sInf_le_sInf fun _ hJ => ⟨sInf_le hJ, hJ.2⟩) le_jacobson
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | jacobson_idem | null |
jacobson_top : jacobson (⊤ : Ideal R) = ⊤ :=
eq_top_iff.2 le_jacobson | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | jacobson_top | null |
jacobson_bot : jacobson (⊥ : Ideal R) = Ring.jacobson R := by
simp_rw [jacobson, Ring.jacobson, Module.jacobson, bot_le, true_and, isMaximal_def]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | jacobson_bot | null |
jacobson_eq_top_iff : jacobson I = ⊤ ↔ I = ⊤ :=
⟨fun H =>
by_contradiction fun hi => let ⟨M, hm, him⟩ := exists_le_maximal I hi
lt_top_iff_ne_top.1
(lt_of_le_of_lt (show jacobson I ≤ M from sInf_le ⟨him, hm⟩) <|
lt_top_iff_ne_top.2 hm.ne_top) H,
fun H => eq_top_iff.2 <| le_sInf fun _ ⟨hij, _⟩ => H ▸ hij⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | jacobson_eq_top_iff | null |
jacobson_eq_bot : jacobson I = ⊥ → I = ⊥ := fun h => eq_bot_iff.mpr (h ▸ le_jacobson) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | jacobson_eq_bot | null |
jacobson_eq_self_of_isMaximal [H : IsMaximal I] : I.jacobson = I :=
le_antisymm (sInf_le ⟨le_of_eq rfl, H⟩) le_jacobson | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | jacobson_eq_self_of_isMaximal | null |
mem_jacobson_iff {x : R} : x ∈ jacobson I ↔ ∀ y, ∃ z, z * y * x + z - 1 ∈ I :=
⟨fun hx y =>
by_cases
(fun hxy : I ⊔ span {y * x + 1} = ⊤ =>
let ⟨p, hpi, q, hq, hpq⟩ := Submodule.mem_sup.1 ((eq_top_iff_one _).1 hxy)
let ⟨r, hr⟩ := mem_span_singleton'.1 hq
⟨r, by
rw [mul_assoc, ← mul_add_one, hr, ← hpq, ← neg_sub, add_sub_cancel_right]
exact I.neg_mem hpi⟩)
fun hxy : I ⊔ span {y * x + 1} ≠ ⊤ => let ⟨M, hm1, hm2⟩ := exists_le_maximal _ hxy
suffices x ∉ M from (this <| mem_sInf.1 hx ⟨le_trans le_sup_left hm2, hm1⟩).elim
fun hxm => hm1.1.1 <| (eq_top_iff_one _).2 <| add_sub_cancel_left (y * x) 1 ▸
M.sub_mem (le_sup_right.trans hm2 <| subset_span rfl) (M.mul_mem_left _ hxm),
fun hx => mem_sInf.2 fun M ⟨him, hm⟩ => by_contradiction fun hxm =>
let ⟨y, i, hi, df⟩ := hm.exists_inv hxm
let ⟨z, hz⟩ := hx (-y)
hm.1.1 <| (eq_top_iff_one _).2 <| sub_sub_cancel (z * -y * x + z) 1 ▸
M.sub_mem (by
rw [mul_assoc, ← mul_add_one, neg_mul, ← sub_eq_iff_eq_add.mpr df.symm, neg_sub,
sub_add_cancel]
exact M.mul_mem_left _ hi) <| him hz⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | mem_jacobson_iff | null |
exists_mul_add_sub_mem_of_mem_jacobson {I : Ideal R} (r : R) (h : r ∈ jacobson I) :
∃ s, s * (r + 1) - 1 ∈ I := by
obtain ⟨s, hs⟩ := mem_jacobson_iff.1 h 1
use s
rw [mul_add, mul_one]
simpa using hs | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | exists_mul_add_sub_mem_of_mem_jacobson | null |
exists_mul_sub_mem_of_sub_one_mem_jacobson {I : Ideal R} (r : R) (h : r - 1 ∈ jacobson I) :
∃ s, s * r - 1 ∈ I := by
convert exists_mul_add_sub_mem_of_mem_jacobson _ h
simp | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | exists_mul_sub_mem_of_sub_one_mem_jacobson | null |
eq_jacobson_iff_sInf_maximal :
I.jacobson = I ↔ ∃ M : Set (Ideal R), (∀ J ∈ M, IsMaximal J ∨ J = ⊤) ∧ I = sInf M := by
use fun hI => ⟨{ J : Ideal R | I ≤ J ∧ J.IsMaximal }, ⟨fun _ hJ => Or.inl hJ.right, hI.symm⟩⟩
rintro ⟨M, hM, hInf⟩
refine le_antisymm (fun x hx => ?_) le_jacobson
rw [hInf, mem_sInf]
intro I hI
rcases hM I hI with is_max | is_top
· exact (mem_sInf.1 hx) ⟨le_sInf_iff.1 (le_of_eq hInf) I hI, is_max⟩
· exact is_top.symm ▸ Submodule.mem_top | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | eq_jacobson_iff_sInf_maximal | An ideal equals its Jacobson radical iff it is the intersection of a set of maximal ideals.
Allowing the set to include ⊤ is equivalent, and is included only to simplify some proofs. |
eq_jacobson_iff_sInf_maximal' :
I.jacobson = I ↔ ∃ M : Set (Ideal R), (∀ J ∈ M, ∀ (K : Ideal R), J < K → K = ⊤) ∧ I = sInf M :=
eq_jacobson_iff_sInf_maximal.trans
⟨fun h =>
let ⟨M, hM⟩ := h
⟨M,
⟨fun J hJ K hK =>
Or.recOn (hM.1 J hJ) (fun h => h.1.2 K hK) fun h => eq_top_iff.2 (le_of_lt (h ▸ hK)),
hM.2⟩⟩,
fun h =>
let ⟨M, hM⟩ := h
⟨M,
⟨fun J hJ =>
Or.recOn (Classical.em (J = ⊤)) (fun h => Or.inr h) fun h => Or.inl ⟨⟨h, hM.1 J hJ⟩⟩,
hM.2⟩⟩⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | eq_jacobson_iff_sInf_maximal' | null |
eq_jacobson_iff_notMem :
I.jacobson = I ↔ ∀ x ∉ I, ∃ M : Ideal R, (I ≤ M ∧ M.IsMaximal) ∧ x ∉ M := by
constructor
· intro h x hx
rw [← h, Ideal.jacobson, mem_sInf] at hx
push_neg at hx
exact hx
· refine fun h => le_antisymm (fun x hx => ?_) le_jacobson
contrapose hx
rw [Ideal.jacobson, mem_sInf]
push_neg
exact h x hx
@[deprecated (since := "2025-05-23")] alias eq_jacobson_iff_not_mem := eq_jacobson_iff_notMem | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | eq_jacobson_iff_notMem | An ideal `I` equals its Jacobson radical if and only if every element outside `I`
also lies outside of a maximal ideal containing `I`. |
map_jacobson_of_surjective {f : R →+* S} (hf : Function.Surjective f) :
RingHom.ker f ≤ I → map f I.jacobson = (map f I).jacobson := by
intro h
unfold Ideal.jacobson
have : ∀ J ∈ { J : Ideal R | I ≤ J ∧ J.IsMaximal }, RingHom.ker f ≤ J :=
fun J hJ => le_trans h hJ.left
refine Trans.trans (map_sInf hf this) (le_antisymm ?_ ?_)
· refine
sInf_le_sInf fun J hJ =>
⟨comap f J, ⟨⟨le_comap_of_map_le hJ.1, ?_⟩, map_comap_of_surjective f hf J⟩⟩
haveI : J.IsMaximal := hJ.right
exact comap_isMaximal_of_surjective f hf
· refine sInf_le_sInf_of_subset_insert_top fun j hj => hj.recOn fun J hJ => ?_
rw [← hJ.2]
rcases map_eq_top_or_isMaximal_of_surjective f hf hJ.left.right with htop | hmax
· exact htop.symm ▸ Set.mem_insert ⊤ _
· exact Set.mem_insert_of_mem ⊤ ⟨map_mono hJ.1.1, hmax⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | map_jacobson_of_surjective | null |
map_jacobson_of_bijective {f : R →+* S} (hf : Function.Bijective f) :
map f I.jacobson = (map f I).jacobson :=
map_jacobson_of_surjective hf.right
(le_trans (le_of_eq ((RingHom.injective_iff_ker_eq_bot f).1 hf.left)) bot_le) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | map_jacobson_of_bijective | null |
comap_jacobson {f : R →+* S} {K : Ideal S} :
comap f K.jacobson = sInf (comap f '' { J : Ideal S | K ≤ J ∧ J.IsMaximal }) :=
Trans.trans (comap_sInf' f _) sInf_eq_iInf.symm | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | comap_jacobson | null |
comap_jacobson_of_surjective {f : R →+* S} (hf : Function.Surjective f) {K : Ideal S} :
comap f K.jacobson = (comap f K).jacobson := by
unfold Ideal.jacobson
refine le_antisymm ?_ ?_
· rw [← top_inf_eq (sInf _), ← sInf_insert, comap_sInf', sInf_eq_iInf]
refine iInf_le_iInf_of_subset fun J hJ => ?_
have : comap f (map f J) = J :=
Trans.trans (comap_map_of_surjective f hf J)
(le_antisymm (sup_le_iff.2 ⟨le_of_eq rfl, le_trans (comap_mono bot_le) hJ.left⟩)
le_sup_left)
rcases map_eq_top_or_isMaximal_of_surjective _ hf hJ.right with htop | hmax
· exact ⟨⊤, Set.mem_insert ⊤ _, htop ▸ this⟩
· exact ⟨map f J, Set.mem_insert_of_mem _ ⟨le_map_of_comap_le_of_surjective f hf hJ.1, hmax⟩,
this⟩
· simp_rw [comap_sInf, le_iInf_iff]
intro J hJ
haveI : J.IsMaximal := hJ.right
exact sInf_le ⟨comap_mono hJ.left, comap_isMaximal_of_surjective _ hf⟩
@[mono] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | comap_jacobson_of_surjective | null |
jacobson_mono {I J : Ideal R} : I ≤ J → I.jacobson ≤ J.jacobson := by
intro h x hx
rw [jacobson, mem_sInf] at hx ⊢
exact fun K ⟨hK, hK_max⟩ => hx ⟨Trans.trans h hK, hK_max⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | jacobson_mono | null |
jacobson_eq_iff_jacobson_quotient_eq_bot :
I.jacobson = I ↔ jacobson (⊥ : Ideal (R ⧸ I)) = ⊥ := by
have hf : Function.Surjective (Ideal.Quotient.mk I) := Submodule.Quotient.mk_surjective I
constructor
· intro h
replace h := congr_arg (Ideal.map (Ideal.Quotient.mk I)) h
rw [map_jacobson_of_surjective hf (le_of_eq mk_ker)] at h
simpa using h
· intro h
replace h := congr_arg (comap (Ideal.Quotient.mk I)) h
rw [comap_jacobson_of_surjective hf, ← RingHom.ker_eq_comap_bot (Ideal.Quotient.mk I)] at h
simpa using h | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | jacobson_eq_iff_jacobson_quotient_eq_bot | The Jacobson radical of a two-sided ideal is two-sided. -/
instance {I : Ideal R} [I.IsTwoSided] : I.jacobson.IsTwoSided where
-- Proof generalized from
-- https://ysharifi.wordpress.com/2022/08/16/the-jacobson-radical-definition-and-basic-results/
mul_mem_of_left {x} r xJ := by
apply mem_sInf.mpr
intro 𝔪 𝔪_mem
by_cases r𝔪 : r ∈ 𝔪
· apply 𝔪.smul_mem _ r𝔪
-- 𝔪₀ := { a : R | a*r ∈ 𝔪 }
let 𝔪₀ : Ideal R := Submodule.comap (DistribMulAction.toLinearMap R (S := Rᵐᵒᵖ) R (.op r)) 𝔪
suffices x ∈ 𝔪₀ by simpa [𝔪₀] using this
have I𝔪₀ : I ≤ 𝔪₀ := fun i iI =>
𝔪_mem.left (I.mul_mem_right _ iI)
have 𝔪₀_maximal : IsMaximal 𝔪₀ := by
refine isMaximal_iff.mpr ⟨
fun h => r𝔪 (by simpa [𝔪₀] using h),
fun J b 𝔪₀J b𝔪₀ bJ => ?_⟩
let K : Ideal R := Ideal.span {b*r} ⊔ 𝔪
have ⟨s, y, y𝔪, sbyr⟩ :=
mem_span_singleton_sup.mp <|
mul_mem_left _ r <|
(isMaximal_iff.mp 𝔪_mem.right).right K (b*r)
le_sup_right b𝔪₀
(mem_sup_left <| mem_span_singleton_self _)
have : 1 - s*b ∈ 𝔪₀ := by
rw [mul_one, add_comm, ← eq_sub_iff_add_eq] at sbyr
rw [sbyr, ← mul_assoc] at y𝔪
simp [𝔪₀, sub_mul, y𝔪]
have : 1 - s*b + s*b ∈ J := by
apply add_mem (𝔪₀J this) (J.mul_mem_left _ bJ)
simpa using this
exact mem_sInf.mp xJ ⟨I𝔪₀, 𝔪₀_maximal⟩
@[deprecated (since := "2025-04-13")] alias jacobson_mul_mem_right := Ideal.instIsTwoSidedJacobson
end Ring
section CommRing
variable [CommRing R] [CommRing S] {I : Ideal R}
theorem radical_le_jacobson : radical I ≤ jacobson I :=
le_sInf fun _ hJ => (radical_eq_sInf I).symm ▸ sInf_le ⟨hJ.left, IsMaximal.isPrime hJ.right⟩
theorem isRadical_of_eq_jacobson (h : jacobson I = I) : I.IsRadical :=
radical_le_jacobson.trans h.le
lemma isRadical_jacobson (I : Ideal R) : I.jacobson.IsRadical :=
isRadical_of_eq_jacobson jacobson_idem
theorem isUnit_of_sub_one_mem_jacobson_bot (r : R) (h : r - 1 ∈ jacobson (⊥ : Ideal R)) :
IsUnit r := by
obtain ⟨s, hs⟩ := exists_mul_sub_mem_of_sub_one_mem_jacobson r h
rw [mem_bot, sub_eq_zero, mul_comm] at hs
exact isUnit_of_mul_eq_one _ _ hs
theorem mem_jacobson_bot {x : R} : x ∈ jacobson (⊥ : Ideal R) ↔ ∀ y, IsUnit (x * y + 1) :=
⟨fun hx y =>
let ⟨z, hz⟩ := (mem_jacobson_iff.1 hx) y
isUnit_iff_exists_inv.2
⟨z, by rwa [add_mul, one_mul, ← sub_eq_zero, mul_right_comm, mul_comm _ z, mul_right_comm]⟩,
fun h =>
mem_jacobson_iff.mpr fun y =>
let ⟨b, hb⟩ := isUnit_iff_exists_inv.1 (h y)
⟨b, (Submodule.mem_bot R).2 (hb ▸ by ring)⟩⟩
/-- An ideal `I` of `R` is equal to its Jacobson radical if and only if
the Jacobson radical of the quotient ring `R/I` is the zero ideal |
radical_eq_jacobson_iff_radical_quotient_eq_jacobson_bot :
I.radical = I.jacobson ↔ radical (⊥ : Ideal (R ⧸ I)) = jacobson ⊥ := by
have hf : Function.Surjective (Ideal.Quotient.mk I) := Submodule.Quotient.mk_surjective I
constructor
· intro h
have := congr_arg (map (Ideal.Quotient.mk I)) h
rw [map_radical_of_surjective hf (le_of_eq mk_ker),
map_jacobson_of_surjective hf (le_of_eq mk_ker)] at this
simpa using this
· intro h
have := congr_arg (comap (Ideal.Quotient.mk I)) h
rw [comap_radical, comap_jacobson_of_surjective hf,
← RingHom.ker_eq_comap_bot (Ideal.Quotient.mk I)] at this
simpa using this | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | radical_eq_jacobson_iff_radical_quotient_eq_jacobson_bot | The standard radical and Jacobson radical of an ideal `I` of `R` are equal if and only if
the nilradical and Jacobson radical of the quotient ring `R/I` coincide |
jacobson_radical_eq_jacobson : I.radical.jacobson = I.jacobson :=
le_antisymm
(le_trans (le_of_eq (congr_arg jacobson (radical_eq_sInf I)))
(sInf_le_sInf fun _ hJ => ⟨sInf_le ⟨hJ.1, hJ.2.isPrime⟩, hJ.2⟩))
(jacobson_mono le_radical) | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | jacobson_radical_eq_jacobson | null |
IsLocal (I : Ideal R) : Prop where
/-- A ring `R` is local if and only if its Jacobson radical is maximal -/
out : IsMaximal (jacobson I) | class | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | IsLocal | An ideal `I` is local iff its Jacobson radical is maximal. |
isLocal_iff {I : Ideal R} : IsLocal I ↔ IsMaximal (jacobson I) :=
⟨fun h => h.1, fun h => ⟨h⟩⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | isLocal_iff | null |
isLocal_of_isMaximal_radical {I : Ideal R} (hi : IsMaximal (radical I)) : IsLocal I :=
⟨have : radical I = jacobson I :=
le_antisymm (le_sInf fun _ ⟨him, hm⟩ => hm.isPrime.radical_le_iff.2 him)
(sInf_le ⟨le_radical, hi⟩)
show IsMaximal (jacobson I) from this ▸ hi⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | isLocal_of_isMaximal_radical | null |
IsLocal.le_jacobson {I J : Ideal R} (hi : IsLocal I) (hij : I ≤ J) (hj : J ≠ ⊤) :
J ≤ jacobson I :=
let ⟨_, hm, hjm⟩ := exists_le_maximal J hj
le_trans hjm <| le_of_eq <| Eq.symm <| hi.1.eq_of_le hm.1.1 <| sInf_le ⟨le_trans hij hjm, hm⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | IsLocal.le_jacobson | null |
IsLocal.mem_jacobson_or_exists_inv {I : Ideal R} (hi : IsLocal I) (x : R) :
x ∈ jacobson I ∨ ∃ y, y * x - 1 ∈ I :=
by_cases
(fun h : I ⊔ span {x} = ⊤ =>
let ⟨p, hpi, q, hq, hpq⟩ := Submodule.mem_sup.1 ((eq_top_iff_one _).1 h)
let ⟨r, hr⟩ := mem_span_singleton.1 hq
Or.inr ⟨r, by
rw [← hpq, mul_comm, ← hr, ← neg_sub, add_sub_cancel_right]; exact I.neg_mem hpi⟩)
fun h : I ⊔ span {x} ≠ ⊤ =>
Or.inl <|
le_trans le_sup_right (hi.le_jacobson le_sup_left h) <| mem_span_singleton.2 <| dvd_refl x | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | IsLocal.mem_jacobson_or_exists_inv | null |
isPrimary_of_isMaximal_radical [CommRing R] {I : Ideal R} (hi : IsMaximal (radical I)) :
I.IsPrimary :=
have : radical I = jacobson I :=
le_antisymm (le_sInf fun _ ⟨him, hm⟩ => hm.isPrime.radical_le_iff.2 him)
(sInf_le ⟨le_radical, hi⟩)
isPrimary_iff.mpr
⟨ne_top_of_lt <| lt_of_le_of_lt le_radical (lt_top_iff_ne_top.2 hi.1.1), fun {x y} hxy =>
((isLocal_of_isMaximal_radical hi).mem_jacobson_or_exists_inv y).symm.imp
(fun ⟨z, hz⟩ => by
rw [← mul_one x, ← sub_sub_cancel (z * y) 1, mul_sub, mul_left_comm]
exact I.sub_mem (I.mul_mem_left _ hxy) (I.mul_mem_left _ hz))
(this ▸ id)⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | isPrimary_of_isMaximal_radical | null |
jacobson (I : TwoSidedIdeal R) : TwoSidedIdeal R :=
(asIdeal I).jacobson.toTwoSided | def | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | jacobson | The Jacobson radical of `I` is the infimum of all maximal (left) ideals containing `I`. |
asIdeal_jacobson (I : TwoSidedIdeal R) : asIdeal I.jacobson = (asIdeal I).jacobson := by
ext; simp [jacobson] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | asIdeal_jacobson | null |
mem_jacobson_iff {x : R} {I : TwoSidedIdeal R} :
x ∈ jacobson I ↔ ∀ y, ∃ z, z * y * x + z - 1 ∈ I := by
simp [jacobson, Ideal.mem_jacobson_iff] | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.IsPrimary",
"Mathlib.RingTheory.Ideal.Quotient.Operations",
"Mathlib.RingTheory.TwoSidedIdeal.Operations",
"Mathlib.RingTheory.Jacobson.Radical"
] | Mathlib/RingTheory/Jacobson/Ideal.lean | mem_jacobson_iff | null |
jacobson_bot_polynomial_le_sInf_map_maximal :
jacobson (⊥ : Ideal R[X]) ≤ sInf (map (C : R →+* R[X]) '' { J : Ideal R | J.IsMaximal }) := by
refine le_sInf fun J => exists_imp.2 fun j hj => ?_
haveI : j.IsMaximal := hj.1
refine Trans.trans (jacobson_mono bot_le) (le_of_eq ?_ : J.jacobson ≤ J)
suffices t : (⊥ : Ideal (Polynomial (R ⧸ j))).jacobson = ⊥ by
rw [← hj.2, jacobson_eq_iff_jacobson_quotient_eq_bot]
replace t := congr_arg (map (polynomialQuotientEquivQuotientPolynomial j).toRingHom) t
rwa [map_jacobson_of_bijective _, map_bot] at t
exact RingEquiv.bijective (polynomialQuotientEquivQuotientPolynomial j)
refine eq_bot_iff.2 fun f hf => ?_
have r1 : (X : (R ⧸ j)[X]) ≠ 0 := ne_of_apply_ne (coeff · 1) <| by simp
simpa [r1] using eq_C_of_degree_eq_zero (degree_eq_zero_of_isUnit ((mem_jacobson_bot.1 hf) X)) | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Polynomial.Quotient"
] | Mathlib/RingTheory/Jacobson/Polynomial.lean | jacobson_bot_polynomial_le_sInf_map_maximal | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.