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 ⌀ |
|---|---|---|---|---|---|---|
jacobson_bot_polynomial_of_jacobson_bot (h : jacobson (⊥ : Ideal R) = ⊥) :
jacobson (⊥ : Ideal R[X]) = ⊥ := by
refine eq_bot_iff.2 (le_trans jacobson_bot_polynomial_le_sInf_map_maximal ?_)
refine fun f hf => (Submodule.mem_bot R[X]).2 <| Polynomial.ext fun n =>
Trans.trans (?_ : coeff f n = 0) (coeff_zero n).symm
suffices f.coeff n ∈ Ideal.jacobson ⊥ by rwa [h, Submodule.mem_bot] at this
exact mem_sInf.2 fun j hj => (mem_map_C_iff.1 ((mem_sInf.1 hf) ⟨j, ⟨hj.2, rfl⟩⟩)) n | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ideal",
"Mathlib.RingTheory.Polynomial.Quotient"
] | Mathlib/RingTheory/Jacobson/Polynomial.lean | jacobson_bot_polynomial_of_jacobson_bot | null |
jacobson : Submodule R M :=
sInf { m : Submodule R M | IsCoatom m }
variable {R R₂ M M₂} | def | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Ideal.Quotient.Defs"
] | Mathlib/RingTheory/Jacobson/Radical.lean | jacobson | The Jacobson radical of an `R`-module `M` is the infimum of all maximal submodules in `M`. |
le_comap_jacobson : jacobson R M ≤ comap f (jacobson R₂ M₂) := by
conv_rhs => rw [jacobson, sInf_eq_iInf', comap_iInf]
refine le_iInf_iff.mpr fun S m hm ↦ ?_
obtain h | h := isCoatom_comap_or_eq_top f S.2
· exact mem_sInf.mp hm _ h
· simpa only [h] using mem_top | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Ideal.Quotient.Defs"
] | Mathlib/RingTheory/Jacobson/Radical.lean | le_comap_jacobson | null |
map_jacobson_le : map f (jacobson R M) ≤ jacobson R₂ M₂ :=
map_le_iff_le_comap.mpr (le_comap_jacobson f)
include τ₁₂ in | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Ideal.Quotient.Defs"
] | Mathlib/RingTheory/Jacobson/Radical.lean | map_jacobson_le | null |
jacobson_eq_bot_of_injective (inj : Function.Injective f) (h : jacobson R₂ M₂ = ⊥) :
jacobson R M = ⊥ :=
le_bot_iff.mp <| (le_comap_jacobson f).trans <| by
simp_rw [h, comap_bot, ((LinearMapClass.ker_eq_bot _).mpr inj).le]
variable {f} | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Ideal.Quotient.Defs"
] | Mathlib/RingTheory/Jacobson/Radical.lean | jacobson_eq_bot_of_injective | null |
map_jacobson_of_ker_le (surj : Function.Surjective f)
(le : LinearMap.ker f ≤ jacobson R M) :
map f (jacobson R M) = jacobson R₂ M₂ :=
le_antisymm (map_jacobson_le f) <| by
rw [jacobson, sInf_eq_iInf'] at le
conv_rhs => rw [jacobson, sInf_eq_iInf', map_iInf_of_ker_le surj le]
exact le_iInf fun m ↦ sInf_le (isCoatom_map_of_ker_le surj (le_iInf_iff.mp le m) m.2) | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Ideal.Quotient.Defs"
] | Mathlib/RingTheory/Jacobson/Radical.lean | map_jacobson_of_ker_le | null |
comap_jacobson_of_ker_le (surj : Function.Surjective f)
(le : LinearMap.ker f ≤ jacobson R M) :
comap f (jacobson R₂ M₂) = jacobson R M := by
rw [← map_jacobson_of_ker_le surj le, comap_map_eq_self le] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Ideal.Quotient.Defs"
] | Mathlib/RingTheory/Jacobson/Radical.lean | comap_jacobson_of_ker_le | null |
map_jacobson_of_bijective (hf : Function.Bijective f) :
map f (jacobson R M) = jacobson R₂ M₂ :=
map_jacobson_of_ker_le hf.2 <| by simp_rw [(LinearMapClass.ker_eq_bot _).mpr hf.1, bot_le] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Ideal.Quotient.Defs"
] | Mathlib/RingTheory/Jacobson/Radical.lean | map_jacobson_of_bijective | null |
comap_jacobson_of_bijective (hf : Function.Bijective f) :
comap f (jacobson R₂ M₂) = jacobson R M :=
comap_jacobson_of_ker_le hf.2 <| by simp_rw [(LinearMapClass.ker_eq_bot _).mpr hf.1, bot_le] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Ideal.Quotient.Defs"
] | Mathlib/RingTheory/Jacobson/Radical.lean | comap_jacobson_of_bijective | null |
jacobson_quotient_of_le {N : Submodule R M} (le : N ≤ jacobson R M) :
jacobson R (M ⧸ N) = map N.mkQ (jacobson R M) :=
(map_jacobson_of_ker_le N.mkQ_surjective <| by rwa [ker_mkQ]).symm | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Ideal.Quotient.Defs"
] | Mathlib/RingTheory/Jacobson/Radical.lean | jacobson_quotient_of_le | null |
jacobson_le_of_eq_bot {N : Submodule R M} (h : jacobson R (M ⧸ N) = ⊥) :
jacobson R M ≤ N := by
simp_rw [← N.ker_mkQ, ← comap_bot, ← h, le_comap_jacobson]
variable (R M)
@[simp] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Ideal.Quotient.Defs"
] | Mathlib/RingTheory/Jacobson/Radical.lean | jacobson_le_of_eq_bot | null |
jacobson_quotient_jacobson : jacobson R (M ⧸ jacobson R M) = ⊥ := by
rw [jacobson_quotient_of_le le_rfl, mkQ_map_self] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Ideal.Quotient.Defs"
] | Mathlib/RingTheory/Jacobson/Radical.lean | jacobson_quotient_jacobson | null |
jacobson_lt_top [Nontrivial M] [IsCoatomic (Submodule R M)] : jacobson R M < ⊤ := by
obtain ⟨m, hm, -⟩ := (eq_top_or_exists_le_coatom (⊥ : Submodule R M)).resolve_left bot_ne_top
exact (sInf_le <| Set.mem_setOf.mpr hm).trans_lt hm.1.lt_top | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Ideal.Quotient.Defs"
] | Mathlib/RingTheory/Jacobson/Radical.lean | jacobson_lt_top | null |
jacobson_pi_le : jacobson R (Π i, M i) ≤ Submodule.pi Set.univ (jacobson R <| M ·) := by
simp_rw [← iInf_comap_proj, jacobson, sInf_eq_iInf', comap_iInf, le_iInf_iff]
intro i m
exact iInf_le_of_le ⟨_, (isCoatom_comap_iff <| LinearMap.proj_surjective i).mpr m.2⟩ le_rfl | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Ideal.Quotient.Defs"
] | Mathlib/RingTheory/Jacobson/Radical.lean | jacobson_pi_le | null |
jacobson_pi_eq_bot (h : ∀ i, jacobson R (M i) = ⊥) : jacobson R (Π i, M i) = ⊥ :=
le_bot_iff.mp <| (jacobson_pi_le R M).trans <| by simp_rw [h, pi_univ_bot, le_rfl] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Ideal.Quotient.Defs"
] | Mathlib/RingTheory/Jacobson/Radical.lean | jacobson_pi_eq_bot | A product of modules with trivial Jacobson radical (e.g. simple modules) also has trivial
Jacobson radical. |
FG.eq_bot_of_le_jacobson_smul {N : Submodule R M} (fg : N.FG)
(le : N ≤ Ring.jacobson R • N) : N = ⊥ := by
contrapose! le; exact (jacobson_smul_lt le fg).not_ge | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Quotient.Basic",
"Mathlib.RingTheory.Finiteness.Basic",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Ideal.Quotient.Defs"
] | Mathlib/RingTheory/Jacobson/Radical.lean | FG.eq_bot_of_le_jacobson_smul | The Jacobson radical of a ring `R` is the Jacobson radical of `R` as an `R`-module. -/
-- TODO: replace all `Ideal.jacobson ⊥` by this.
abbrev jacobson : Ideal R := Module.jacobson R R
theorem jacobson_eq_sInf_isMaximal : jacobson R = sInf {I : Ideal R | I.IsMaximal} := by
simp_rw [jacobson, Module.jacobson, Ideal.isMaximal_def]
instance : (jacobson R).IsTwoSided :=
⟨fun b ha ↦ Module.le_comap_jacobson (f := LinearMap.toSpanSingleton R R b) ha⟩
variable {R R₂}
theorem le_comap_jacobson : jacobson R ≤ Ideal.comap f (jacobson R₂) :=
Module.le_comap_jacobson f.toSemilinearMap
theorem map_jacobson_le : Submodule.map f.toSemilinearMap (jacobson R) ≤ jacobson R₂ :=
Module.map_jacobson_le f.toSemilinearMap
variable {f} in
theorem map_jacobson_of_ker_le (le : RingHom.ker f ≤ jacobson R) :
Submodule.map f.toSemilinearMap (jacobson R) = jacobson R₂ :=
Module.map_jacobson_of_ker_le f.surjective le
theorem coe_jacobson_quotient (I : Ideal R) [I.IsTwoSided] :
(jacobson (R ⧸ I) : Set (R ⧸ I)) = Module.jacobson R (R ⧸ I) := by
let f : R ⧸ I →ₛₗ[Ideal.Quotient.mk I] R ⧸ I := ⟨AddHom.id _, fun _ _ ↦ rfl⟩
rw [jacobson, ← Module.map_jacobson_of_ker_le (f := f) Function.surjective_id]
· apply Set.image_id
· rintro _ rfl; exact zero_mem _
theorem jacobson_quotient_of_le {I : Ideal R} [I.IsTwoSided] (le : I ≤ jacobson R) :
jacobson (R ⧸ I) = Submodule.map (Ideal.Quotient.mk I).toSemilinearMap (jacobson R) :=
.symm <| Module.map_jacobson_of_ker_le (by exact Ideal.Quotient.mk_surjective) <| by
rwa [← I.ker_mkQ] at le
theorem jacobson_le_of_eq_bot {I : Ideal R} [I.IsTwoSided] (h : jacobson (R ⧸ I) = ⊥) :
jacobson R ≤ I :=
Module.jacobson_le_of_eq_bot <| by
rw [← le_bot_iff, ← SetLike.coe_subset_coe] at h ⊢
rwa [← coe_jacobson_quotient]
variable (R)
@[simp]
theorem jacobson_quotient_jacobson : jacobson (R ⧸ jacobson R) = ⊥ :=
(jacobson_quotient_of_le le_rfl).trans <| SetLike.ext' <| by
apply SetLike.ext'_iff.mp (jacobson R).mkQ_map_self
theorem jacobson_lt_top [Nontrivial R] : jacobson R < ⊤ := Module.jacobson_lt_top R R
theorem jacobson_smul_top_le : jacobson R • (⊤ : Submodule R M) ≤ Module.jacobson R M :=
Submodule.smul_le.mpr fun _ hr m _ ↦ Module.le_comap_jacobson (LinearMap.toSpanSingleton R M m) hr
end Ring
namespace Submodule
variable {R M}
theorem jacobson_smul_lt_top [Nontrivial M] [IsCoatomic (Submodule R M)] (N : Submodule R M) :
Ring.jacobson R • N < ⊤ :=
((smul_mono_right _ le_top).trans <| Ring.jacobson_smul_top_le R M).trans_lt
(Module.jacobson_lt_top R M)
theorem FG.jacobson_smul_lt {N : Submodule R M} (ne_bot : N ≠ ⊥) (fg : N.FG) :
Ring.jacobson R • N < N := by
rw [← Module.Finite.iff_fg] at fg
rw [← nontrivial_iff_ne_bot] at ne_bot
convert map_strictMono_of_injective N.injective_subtype (jacobson_smul_lt_top ⊤)
on_goal 1 => rw [map_smul'']
all_goals rw [Submodule.map_top, range_subtype]
/-- A form of Nakayama's lemma for modules over noncommutative rings. |
IsJacobsonRing (R : Type*) [CommRing R] : Prop where
out' : ∀ I : Ideal R, I.IsRadical → I.jacobson = I | class | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | IsJacobsonRing | A ring is a Jacobson ring if for every radical ideal `I`,
the Jacobson radical of `I` is equal to `I`.
See `isJacobsonRing_iff_prime_eq` and `isJacobsonRing_iff_sInf_maximal`
for equivalent definitions. |
isJacobsonRing_iff {R} [CommRing R] :
IsJacobsonRing R ↔ ∀ I : Ideal R, I.IsRadical → I.jacobson = I :=
⟨fun h => h.1, fun h => ⟨h⟩⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | isJacobsonRing_iff | null |
IsJacobsonRing.out {R} [CommRing R] :
IsJacobsonRing R → ∀ {I : Ideal R}, I.IsRadical → I.jacobson = I :=
isJacobsonRing_iff.1 | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | IsJacobsonRing.out | null |
isJacobsonRing_iff_prime_eq :
IsJacobsonRing R ↔ ∀ P : Ideal R, IsPrime P → P.jacobson = P := by
refine isJacobsonRing_iff.trans ⟨fun h I hI => h I hI.isRadical, ?_⟩
refine fun h I hI ↦ le_antisymm (fun x hx ↦ ?_) (fun x hx ↦ mem_sInf.mpr fun _ hJ ↦ hJ.left hx)
rw [← hI.radical, radical_eq_sInf I, mem_sInf]
intro P hP
rw [Set.mem_setOf_eq] at hP
rw [jacobson, mem_sInf] at hx
rw [← h P hP.right, jacobson, mem_sInf]
exact fun J hJ => hx ⟨le_trans hP.left hJ.left, hJ.right⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | isJacobsonRing_iff_prime_eq | A ring is a Jacobson ring if and only if for all prime ideals `P`,
the Jacobson radical of `P` is equal to `P`. |
isJacobsonRing_iff_sInf_maximal : IsJacobsonRing R ↔ ∀ {I : Ideal R}, I.IsPrime →
∃ M : Set (Ideal R), (∀ J ∈ M, IsMaximal J ∨ J = ⊤) ∧ I = sInf M :=
⟨fun H _I h => eq_jacobson_iff_sInf_maximal.1 (H.out h.isRadical), fun H =>
isJacobsonRing_iff_prime_eq.2 fun _P hP => eq_jacobson_iff_sInf_maximal.2 (H hP)⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | isJacobsonRing_iff_sInf_maximal | A ring `R` is Jacobson if and only if for every prime ideal `I`,
`I` can be written as the infimum of some collection of maximal ideals.
Allowing ⊤ in the set `M` of maximal ideals is equivalent, but makes some proofs cleaner. |
isJacobsonRing_iff_sInf_maximal' : IsJacobsonRing R ↔ ∀ {I : Ideal R}, I.IsPrime →
∃ M : Set (Ideal R), (∀ J ∈ M, ∀ (K : Ideal R), J < K → K = ⊤) ∧ I = sInf M :=
⟨fun H _I h => eq_jacobson_iff_sInf_maximal'.1 (H.out h.isRadical), fun H =>
isJacobsonRing_iff_prime_eq.2 fun _P hP => eq_jacobson_iff_sInf_maximal'.2 (H hP)⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | isJacobsonRing_iff_sInf_maximal' | A variant of `isJacobsonRing_iff_sInf_maximal` with a different spelling of "maximal or `⊤`". |
Ideal.radical_eq_jacobson [H : IsJacobsonRing R] (I : Ideal R) : I.radical = I.jacobson :=
le_antisymm (le_sInf fun _J ⟨hJ, hJ_max⟩ => (IsPrime.radical_le_iff hJ_max.isPrime).mpr hJ)
(H.out (radical_isRadical I) ▸ jacobson_mono le_radical) | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | Ideal.radical_eq_jacobson | null |
isJacobsonRing_of_surjective [H : IsJacobsonRing R] :
(∃ f : R →+* S, Function.Surjective ↑f) → IsJacobsonRing S := by
rintro ⟨f, hf⟩
rw [isJacobsonRing_iff_sInf_maximal]
intro p hp
use map f '' { J : Ideal R | comap f p ≤ J ∧ J.IsMaximal }
use fun j ⟨J, hJ, hmap⟩ => hmap ▸ (map_eq_top_or_isMaximal_of_surjective f hf hJ.right).symm
have : p = map f (comap f p).jacobson :=
(IsJacobsonRing.out' _ <| hp.isRadical.comap f).symm ▸ (map_comap_of_surjective f hf p).symm
exact this.trans (map_sInf hf fun J ⟨hJ, _⟩ => le_trans (Ideal.ker_le_comap f) hJ) | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | isJacobsonRing_of_surjective | null |
isJacobsonRing_iso (e : R ≃+* S) : IsJacobsonRing R ↔ IsJacobsonRing S where
mp _ := isJacobsonRing_of_surjective ⟨(e : R →+* S), e.surjective⟩
mpr _ := isJacobsonRing_of_surjective ⟨(e.symm : S →+* R), e.symm.surjective⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | isJacobsonRing_iso | null |
isJacobsonRing_of_isIntegral [Algebra R S] [Algebra.IsIntegral R S] [IsJacobsonRing R] :
IsJacobsonRing S := by
rw [isJacobsonRing_iff_prime_eq]
intro P hP
by_cases hP_top : comap (algebraMap R S) P = ⊤
· simp [comap_eq_top_iff.1 hP_top]
· have : Nontrivial (R ⧸ comap (algebraMap R S) P) := Quotient.nontrivial hP_top
rw [jacobson_eq_iff_jacobson_quotient_eq_bot]
refine eq_bot_of_comap_eq_bot (R := R ⧸ comap (algebraMap R S) P) ?_
rw [eq_bot_iff, ← jacobson_eq_iff_jacobson_quotient_eq_bot.1
((isJacobsonRing_iff_prime_eq.1 ‹_›) (comap (algebraMap R S) P) (comap_isPrime _ _)),
comap_jacobson]
refine sInf_le_sInf fun J hJ => ?_
simp only [true_and, Set.mem_image, bot_le, Set.mem_setOf_eq]
have : J.IsMaximal := by simpa using hJ
exact exists_ideal_over_maximal_of_isIntegral J
(comap_bot_le_of_injective _ algebraMap_quotient_injective) | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | isJacobsonRing_of_isIntegral | null |
isJacobsonRing_of_isIntegral' (f : R →+* S) (hf : f.IsIntegral) [IsJacobsonRing R] :
IsJacobsonRing S :=
let _ : Algebra R S := f.toAlgebra
have : Algebra.IsIntegral R S := ⟨hf⟩
isJacobsonRing_of_isIntegral (R := R) | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | isJacobsonRing_of_isIntegral' | A variant of `isJacobsonRing_of_isIntegral` that takes `RingHom.IsIntegral` instead. |
IsLocalization.isMaximal_iff_isMaximal_disjoint [H : IsJacobsonRing R] (J : Ideal S) :
J.IsMaximal ↔ (comap (algebraMap R S) J).IsMaximal ∧ y ∉ Ideal.comap (algebraMap R S) J := by
constructor
· refine fun h => ⟨?_, fun hy =>
h.ne_top (Ideal.eq_top_of_isUnit_mem _ hy (map_units _ ⟨y, Submonoid.mem_powers _⟩))⟩
have hJ : J.IsPrime := IsMaximal.isPrime h
rw [isPrime_iff_isPrime_disjoint (Submonoid.powers y)] at hJ
have : y ∉ (comap (algebraMap R S) J).1 := Set.disjoint_left.1 hJ.right (Submonoid.mem_powers _)
rw [← H.out hJ.left.isRadical, jacobson, Submodule.mem_toAddSubmonoid, Ideal.mem_sInf] at this
push_neg at this
rcases this with ⟨I, hI, hI'⟩
convert hI.right
by_cases hJ : J = I.map (algebraMap R S)
· rw [hJ, comap_map_of_isPrime_disjoint (powers y) S I (IsMaximal.isPrime hI.right)]
rwa [disjoint_powers_iff_notMem y hI.right.isPrime.isRadical]
· have hI_p : (I.map (algebraMap R S)).IsPrime := by
refine isPrime_of_isPrime_disjoint (powers y) _ I hI.right.isPrime ?_
rwa [disjoint_powers_iff_notMem y hI.right.isPrime.isRadical]
have : J ≤ I.map (algebraMap R S) := map_comap (Submonoid.powers y) S J ▸ map_mono hI.left
exact absurd (h.1.2 _ (lt_of_le_of_ne this hJ)) hI_p.1
· refine fun h => ⟨⟨fun hJ => h.1.ne_top (eq_top_iff.2 ?_), fun I hI => ?_⟩⟩
· rwa [eq_top_iff, ← (IsLocalization.orderEmbedding (powers y) S).le_iff_le] at hJ
· have := congr_arg (Ideal.map (algebraMap R S)) (h.1.1.2 _ ⟨comap_mono (le_of_lt hI), ?_⟩)
· rwa [map_comap (powers y) S I, Ideal.map_top] at this
refine fun hI' => hI.right ?_
rw [← map_comap (powers y) S I, ← map_comap (powers y) S J]
exact map_mono hI' | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | IsLocalization.isMaximal_iff_isMaximal_disjoint | If `R` is a Jacobson ring, then maximal ideals in the localization at `y`
correspond to maximal ideals in the original ring `R` that don't contain `y`.
This lemma gives the correspondence in the particular case of an ideal and its comap.
See `le_relIso_of_maximal` for the more general relation isomorphism |
IsLocalization.isMaximal_of_isMaximal_disjoint
[IsJacobsonRing R] (I : Ideal R) (hI : I.IsMaximal)
(hy : y ∉ I) : (I.map (algebraMap R S)).IsMaximal := by
rw [isMaximal_iff_isMaximal_disjoint S y,
comap_map_of_isPrime_disjoint (powers y) S I (IsMaximal.isPrime hI)
((disjoint_powers_iff_notMem y hI.isPrime.isRadical).2 hy)]
exact ⟨hI, hy⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | IsLocalization.isMaximal_of_isMaximal_disjoint | If `R` is a Jacobson ring, then maximal ideals in the localization at `y`
correspond to maximal ideals in the original ring `R` that don't contain `y`.
This lemma gives the correspondence in the particular case of an ideal and its map.
See `le_relIso_of_maximal` for the more general statement, and the reverse of this implication |
IsLocalization.orderIsoOfMaximal [IsJacobsonRing R] :
{ p : Ideal S // p.IsMaximal } ≃o { p : Ideal R // p.IsMaximal ∧ y ∉ p } where
toFun p := ⟨Ideal.comap (algebraMap R S) p.1, (isMaximal_iff_isMaximal_disjoint S y p.1).1 p.2⟩
invFun p := ⟨Ideal.map (algebraMap R S) p.1, isMaximal_of_isMaximal_disjoint y p.1 p.2.1 p.2.2⟩
left_inv J := Subtype.eq (map_comap (powers y) S J)
right_inv I := Subtype.eq (comap_map_of_isPrime_disjoint _ _ I.1 (IsMaximal.isPrime I.2.1)
((disjoint_powers_iff_notMem y I.2.1.isPrime.isRadical).2 I.2.2))
map_rel_iff' {I I'} := ⟨fun h => show I.val ≤ I'.val from
map_comap (powers y) S I.val ▸ map_comap (powers y) S I'.val ▸ Ideal.map_mono h,
fun h _ hx => h hx⟩
include y in | def | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | IsLocalization.orderIsoOfMaximal | If `R` is a Jacobson ring, then maximal ideals in the localization at `y`
correspond to maximal ideals in the original ring `R` that don't contain `y` |
isJacobsonRing_localization [H : IsJacobsonRing R] : IsJacobsonRing S := by
rw [isJacobsonRing_iff_prime_eq]
refine fun P' hP' => le_antisymm ?_ le_jacobson
obtain ⟨hP', hPM⟩ := (IsLocalization.isPrime_iff_isPrime_disjoint (powers y) S P').mp hP'
have hP := H.out hP'.isRadical
refine (IsLocalization.map_comap (powers y) S P'.jacobson).ge.trans
((map_mono ?_).trans (IsLocalization.map_comap (powers y) S P').le)
have : sInf { I : Ideal R | comap (algebraMap R S) P' ≤ I ∧ I.IsMaximal ∧ y ∉ I } ≤
comap (algebraMap R S) P' := by
intro x hx
have hxy : x * y ∈ (comap (algebraMap R S) P').jacobson := by
rw [Ideal.jacobson, Ideal.mem_sInf]
intro J hJ
by_cases h : y ∈ J
· exact J.mul_mem_left x h
· exact J.mul_mem_right y ((mem_sInf.1 hx) ⟨hJ.left, ⟨hJ.right, h⟩⟩)
rw [hP] at hxy
rcases hP'.mem_or_mem hxy with hxy | hxy
· exact hxy
· exact (hPM.le_bot ⟨Submonoid.mem_powers _, hxy⟩).elim
refine le_trans ?_ this
rw [Ideal.jacobson, comap_sInf', sInf_eq_iInf]
refine iInf_le_iInf_of_subset fun I hI => ⟨map (algebraMap R S) I, ⟨?_, ?_⟩⟩
· exact ⟨le_trans (le_of_eq (IsLocalization.map_comap (powers y) S P').symm) (map_mono hI.1),
isMaximal_of_isMaximal_disjoint y _ hI.2.1 hI.2.2⟩
· exact IsLocalization.comap_map_of_isPrime_disjoint _ S I (IsMaximal.isPrime hI.2.1)
((disjoint_powers_iff_notMem y hI.2.1.isPrime.isRadical).2 hI.2.2) | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | isJacobsonRing_localization | If `S` is the localization of the Jacobson ring `R` at the submonoid generated by `y : R`, then
`S` is Jacobson. |
mem_closure_X_union_C {R : Type*} [Ring R] (p : R[X]) :
p ∈ Subring.closure (insert X {f | f.degree ≤ 0} : Set R[X]) := by
refine Polynomial.induction_on p ?_ ?_ ?_
· intro r
apply Subring.subset_closure
apply Set.mem_insert_of_mem
exact degree_C_le
· intro p1 p2 h1 h2
exact Subring.add_mem _ h1 h2
· intro n r hr
rw [pow_succ, ← mul_assoc]
apply Subring.mul_mem _ hr
apply Subring.subset_closure
apply Set.mem_insert
variable {R S : Type*} [CommRing R] [CommRing S] [IsDomain S]
variable {Rₘ Sₘ : Type*} [CommRing Rₘ] [CommRing Sₘ] | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | mem_closure_X_union_C | null |
isIntegral_isLocalization_polynomial_quotient
(P : Ideal R[X]) (pX : R[X]) (hpX : pX ∈ P) [Algebra (R ⧸ P.comap (C : R →+* R[X])) Rₘ]
[IsLocalization.Away (pX.map (Ideal.Quotient.mk (P.comap (C : R →+* R[X])))).leadingCoeff Rₘ]
[Algebra (R[X] ⧸ P) Sₘ] [IsLocalization ((Submonoid.powers (pX.map (Ideal.Quotient.mk (P.comap
(C : R →+* R[X])))).leadingCoeff).map (quotientMap P C le_rfl) : Submonoid (R[X] ⧸ P)) Sₘ] :
(IsLocalization.map Sₘ (quotientMap P C le_rfl) (Submonoid.powers (pX.map (Ideal.Quotient.mk
(P.comap (C : R →+* R[X])))).leadingCoeff).le_comap_map : Rₘ →+* Sₘ).IsIntegral := by
let P' : Ideal R := P.comap C
let M : Submonoid (R ⧸ P') :=
Submonoid.powers (pX.map (Ideal.Quotient.mk (P.comap (C : R →+* R[X])))).leadingCoeff
let M' : Submonoid (R[X] ⧸ P) :=
(Submonoid.powers (pX.map (Ideal.Quotient.mk (P.comap (C : R →+* R[X])))).leadingCoeff).map
(quotientMap P C le_rfl)
let φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C le_rfl
let φ' : Rₘ →+* Sₘ := IsLocalization.map Sₘ φ M.le_comap_map
have hφ' : φ.comp (Ideal.Quotient.mk P') = (Ideal.Quotient.mk P).comp C := rfl
intro p
obtain ⟨⟨p', ⟨q, hq⟩⟩, hp⟩ := IsLocalization.surj M' p
suffices φ'.IsIntegralElem (algebraMap (R[X] ⧸ P) Sₘ p') by
obtain ⟨q', hq', rfl⟩ := hq
obtain ⟨q'', hq''⟩ := isUnit_iff_exists_inv'.1 (IsLocalization.map_units Rₘ (⟨q', hq'⟩ : M))
refine (hp.symm ▸ this).of_mul_unit φ' p (algebraMap (R[X] ⧸ P) Sₘ (φ q')) q'' ?_
rw [← φ'.map_one, ← congr_arg φ' hq'', φ'.map_mul, ← φ'.comp_apply]
simp only [φ', IsLocalization.map_comp _, RingHom.comp_apply]
dsimp at hp
refine @IsIntegral.of_mem_closure'' Rₘ _ Sₘ _ φ'
((algebraMap (R[X] ⧸ P) Sₘ).comp (Ideal.Quotient.mk P) '' insert X { p | p.degree ≤ 0 }) ?_
((algebraMap (R[X] ⧸ P) Sₘ) p') ?_
· rintro x ⟨p, hp, rfl⟩
simp only [Set.mem_insert_iff] at hp
rcases hp with hy | hy
· rw [hy]
refine φ.isIntegralElem_localization_at_leadingCoeff ((Ideal.Quotient.mk P) X)
(pX.map (Ideal.Quotient.mk P')) ?_ M ?_
· rwa [eval₂_map, hφ', ← hom_eval₂, Quotient.eq_zero_iff_mem, eval₂_C_X]
· use 1
simp only [P', pow_one]
· rw [Set.mem_setOf_eq, degree_le_zero_iff] at hy
rw [hy]
refine ⟨X - C (algebraMap _ _ ((Ideal.Quotient.mk P') (p.coeff 0))), monic_X_sub_C _, ?_⟩
simp only [eval₂_sub, eval₂_X, eval₂_C]
rw [sub_eq_zero, ← φ'.comp_apply]
simp [φ', IsLocalization.map_comp _, P', φ]
· obtain ⟨p, rfl⟩ := Ideal.Quotient.mk_surjective p'
rw [← RingHom.comp_apply]
apply Subring.mem_closure_image_of
apply Polynomial.mem_closure_X_union_C | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | isIntegral_isLocalization_polynomial_quotient | If `I` is a prime ideal of `R[X]` and `pX ∈ I` is a non-constant polynomial,
then the map `R →+* R[x]/I` descends to an integral map when localizing at `pX.leadingCoeff`.
In particular `X` is integral because it satisfies `pX`, and constants are trivially integral,
so integrality of the entire extension follows by closure under addition and multiplication. |
jacobson_bot_of_integral_localization
{R : Type*} [CommRing R] [IsDomain R] [IsJacobsonRing R]
(Rₘ Sₘ : Type*) [CommRing Rₘ] [CommRing Sₘ] (φ : R →+* S) (hφ : Function.Injective ↑φ) (x : R)
(hx : x ≠ 0) [Algebra R Rₘ] [IsLocalization.Away x Rₘ] [Algebra S Sₘ]
[IsLocalization ((Submonoid.powers x).map φ : Submonoid S) Sₘ]
(hφ' :
RingHom.IsIntegral (IsLocalization.map Sₘ φ (Submonoid.powers x).le_comap_map : Rₘ →+* Sₘ)) :
(⊥ : Ideal S).jacobson = (⊥ : Ideal S) := by
have hM : ((Submonoid.powers x).map φ : Submonoid S) ≤ nonZeroDivisors S :=
map_le_nonZeroDivisors_of_injective φ hφ (powers_le_nonZeroDivisors_of_noZeroDivisors hx)
letI : IsDomain Sₘ := IsLocalization.isDomain_of_le_nonZeroDivisors _ hM
let φ' : Rₘ →+* Sₘ := IsLocalization.map _ φ (Submonoid.powers x).le_comap_map
suffices ∀ I : Ideal Sₘ, I.IsMaximal → (I.comap (algebraMap S Sₘ)).IsMaximal by
have hϕ' : comap (algebraMap S Sₘ) (⊥ : Ideal Sₘ) = (⊥ : Ideal S) := by
rw [← RingHom.ker_eq_comap_bot, ← RingHom.injective_iff_ker_eq_bot]
exact IsLocalization.injective Sₘ hM
have hRₘ : IsJacobsonRing Rₘ := isJacobsonRing_localization x
have hSₘ : IsJacobsonRing Sₘ := isJacobsonRing_of_isIntegral' φ' hφ'
refine eq_bot_iff.mpr (le_trans ?_ (le_of_eq hϕ'))
rw [← hSₘ.out isRadical_bot_of_noZeroDivisors, comap_jacobson]
exact sInf_le_sInf fun j hj => ⟨bot_le,
let ⟨J, hJ⟩ := hj
hJ.2 ▸ this J hJ.1.2⟩
intro I hI
have : (I.comap (algebraMap S Sₘ)).IsPrime := comap_isPrime _ I
have : (I.comap φ').IsPrime := comap_isPrime φ' I
have : (⊥ : Ideal (S ⧸ I.comap (algebraMap S Sₘ))).IsPrime := bot_prime
have hcomm : φ'.comp (algebraMap R Rₘ) = (algebraMap S Sₘ).comp φ := IsLocalization.map_comp _
let f := quotientMap (I.comap (algebraMap S Sₘ)) φ le_rfl
let g := quotientMap I (algebraMap S Sₘ) le_rfl
have := isMaximal_comap_of_isIntegral_of_isMaximal' φ' hφ' I
have := ((IsLocalization.isMaximal_iff_isMaximal_disjoint Rₘ x _).1 this).left
have : ((I.comap (algebraMap S Sₘ)).comap φ).IsMaximal := by
rwa [comap_comap, hcomm, ← comap_comap] at this
rw [← bot_quotient_isMaximal_iff] at this ⊢
refine isMaximal_of_isIntegral_of_isMaximal_comap' f ?_ ⊥
((eq_bot_iff.2 (comap_bot_le_of_injective f quotientMap_injective)).symm ▸ this)
exact RingHom.IsIntegral.tower_bot f g quotientMap_injective
((comp_quotientMap_eq_of_comp_eq hcomm I).symm ▸
(RingHom.isIntegral_of_surjective _
(IsLocalization.surjective_quotientMap_of_maximal_of_localization (Submonoid.powers x) Rₘ
(by rwa [comap_comap, hcomm, ← bot_quotient_isMaximal_iff]))).trans _ _ (hφ'.quotient _)) | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | jacobson_bot_of_integral_localization | If `f : R → S` descends to an integral map in the localization at `x`,
and `R` is a Jacobson ring, then the intersection of all maximal ideals in `S` is trivial |
private isJacobsonRing_polynomial_of_domain (R : Type*) [CommRing R] [IsDomain R]
[hR : IsJacobsonRing R] (P : Ideal R[X]) [IsPrime P] (hP : ∀ x : R, C x ∈ P → x = 0) :
P.jacobson = P := by
by_cases Pb : P = ⊥
· exact Pb.symm ▸
jacobson_bot_polynomial_of_jacobson_bot (hR.out isRadical_bot_of_noZeroDivisors)
· rw [jacobson_eq_iff_jacobson_quotient_eq_bot]
let P' := P.comap (C : R →+* R[X])
have : P'.IsPrime := comap_isPrime C P
have hR' : IsJacobsonRing (R ⧸ P') := by infer_instance
obtain ⟨p, pP, p0⟩ := exists_nonzero_mem_of_ne_bot Pb hP
let x := (Polynomial.map (Ideal.Quotient.mk P') p).leadingCoeff
have hx : x ≠ 0 := by rwa [Ne, leadingCoeff_eq_zero]
let φ : R ⧸ P' →+* R[X] ⧸ P := Ideal.quotientMap P (C : R →+* R[X]) le_rfl
let hφ : Function.Injective ↑φ := quotientMap_injective
let Rₘ := Localization.Away x
let Sₘ := (Localization ((Submonoid.powers x).map φ : Submonoid (R[X] ⧸ P)))
refine jacobson_bot_of_integral_localization (S := R[X] ⧸ P) (R := R ⧸ P') Rₘ Sₘ _ hφ _ hx ?_
exact isIntegral_isLocalization_polynomial_quotient P p pP | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | isJacobsonRing_polynomial_of_domain | Used to bootstrap the proof of `isJacobsonRing_polynomial_iff_isJacobsonRing`.
That theorem is more general and should be used instead of this one. |
isJacobsonRing_polynomial_of_isJacobsonRing (hR : IsJacobsonRing R) :
IsJacobsonRing R[X] := by
rw [isJacobsonRing_iff_prime_eq]
intro I hI
let R' : Subring (R[X] ⧸ I) := ((Ideal.Quotient.mk I).comp C).range
let i : R →+* R' := ((Ideal.Quotient.mk I).comp C).rangeRestrict
have hi : Function.Surjective ↑i := ((Ideal.Quotient.mk I).comp C).rangeRestrict_surjective
have hi' : RingHom.ker (mapRingHom i) ≤ I := by
intro f hf
apply polynomial_mem_ideal_of_coeff_mem_ideal I f
intro n
replace hf := congrArg (fun g : Polynomial ((Ideal.Quotient.mk I).comp C).range => g.coeff n) hf
change (Polynomial.map ((Ideal.Quotient.mk I).comp C).rangeRestrict f).coeff n = 0 at hf
rw [coeff_map, Subtype.ext_iff] at hf
rwa [mem_comap, ← Quotient.eq_zero_iff_mem, ← RingHom.comp_apply]
have R'_jacob : IsJacobsonRing R' := isJacobsonRing_of_surjective ⟨i, hi⟩
let J := I.map (mapRingHom i)
have h_surj : Function.Surjective (mapRingHom i) := Polynomial.map_surjective i hi
have : IsPrime J := map_isPrime_of_surjective h_surj hi'
suffices h : J.jacobson = J by
replace h := congrArg (comap (Polynomial.mapRingHom i)) h
rw [← map_jacobson_of_surjective h_surj hi', comap_map_of_surjective _ h_surj,
comap_map_of_surjective _ h_surj] at h
refine le_antisymm ?_ le_jacobson
exact le_trans (le_sup_of_le_left le_rfl) (le_trans (le_of_eq h) (sup_le le_rfl hi'))
apply isJacobsonRing_polynomial_of_domain R' J
exact eq_zero_of_polynomial_mem_map_range I | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | isJacobsonRing_polynomial_of_isJacobsonRing | null |
isJacobsonRing_polynomial_iff_isJacobsonRing : IsJacobsonRing R[X] ↔ IsJacobsonRing R := by
refine ⟨?_, isJacobsonRing_polynomial_of_isJacobsonRing⟩
intro H
exact isJacobsonRing_of_surjective ⟨eval₂RingHom (RingHom.id _) 1, fun x =>
⟨C x, by simp only [coe_eval₂RingHom, RingHom.id_apply, eval₂_C]⟩⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | isJacobsonRing_polynomial_iff_isJacobsonRing | null |
isMaximal_comap_C_of_isMaximal [IsJacobsonRing R] [Nontrivial R]
(hP' : ∀ x : R, C x ∈ P → x = 0) :
IsMaximal (comap (C : R →+* R[X]) P : Ideal R) := by
let P' := comap (C : R →+* R[X]) P
have hP'_prime : P'.IsPrime := comap_isPrime C P
obtain ⟨⟨m, hmem_P⟩, hm⟩ :=
Submodule.nonzero_mem_of_bot_lt (bot_lt_of_maximal P polynomial_not_isField)
have hm' : m ≠ 0 := by
simpa [Submodule.coe_eq_zero] using hm
let φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P (C : R →+* R[X]) le_rfl
let a : R ⧸ P' := (m.map (Ideal.Quotient.mk P')).leadingCoeff
let M : Submonoid (R ⧸ P') := Submonoid.powers a
rw [← bot_quotient_isMaximal_iff]
have hp0 : a ≠ 0 := fun hp0' =>
hm' <| map_injective (Ideal.Quotient.mk (P.comap (C : R →+* R[X]) : Ideal R))
((injective_iff_map_eq_zero (Ideal.Quotient.mk (P.comap (C : R →+* R[X]) : Ideal R))).2
fun x hx => by
rwa [Quotient.eq_zero_iff_mem, (by rwa [eq_bot_iff] : (P.comap C : Ideal R) = ⊥)] at hx)
(by simpa only [a, leadingCoeff_eq_zero, Polynomial.map_zero] using hp0')
have hM : (0 : R ⧸ P') ∉ M := fun ⟨n, hn⟩ => hp0 (pow_eq_zero hn)
suffices (⊥ : Ideal (Localization M)).IsMaximal by
rw [← IsLocalization.comap_map_of_isPrime_disjoint M (Localization M) ⊥ bot_prime
(disjoint_iff_inf_le.mpr fun x hx => hM (hx.2 ▸ hx.1))]
exact ((IsLocalization.isMaximal_iff_isMaximal_disjoint (Localization M) a _).mp
(by rwa [Ideal.map_bot])).1
let M' : Submonoid (R[X] ⧸ P) := M.map φ
have hM' : (0 : R[X] ⧸ P) ∉ M' := fun ⟨z, hz⟩ =>
hM (quotientMap_injective (_root_.trans hz.2 φ.map_zero.symm) ▸ hz.1)
suffices (⊥ : Ideal (Localization M')).IsMaximal by
rw [le_antisymm bot_le (comap_bot_le_of_injective _
(IsLocalization.map_injective_of_injective M (Localization M) (Localization M')
quotientMap_injective))]
refine isMaximal_comap_of_isIntegral_of_isMaximal' _ ?_ ⊥
have isloc : IsLocalization (Submonoid.map φ M) (Localization M') := by infer_instance
exact @isIntegral_isLocalization_polynomial_quotient R _
(Localization M) (Localization M') _ _ P m hmem_P _ _ _ isloc
rw [(map_bot.symm :
(⊥ : Ideal (Localization M')) = Ideal.map (algebraMap (R[X] ⧸ P) (Localization M')) ⊥)]
let bot_maximal := (bot_quotient_isMaximal_iff _).mpr hP
refine bot_maximal.map_bijective (algebraMap (R[X] ⧸ P) (Localization M')) ?_
apply IsField.localization_map_bijective hM'
rwa [← Quotient.maximal_ideal_iff_isField_quotient, ← bot_quotient_isMaximal_iff] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | isMaximal_comap_C_of_isMaximal | null |
private quotient_mk_comp_C_isIntegral_of_jacobson' [Nontrivial R] (hR : IsJacobsonRing R)
(hP' : ∀ x : R, C x ∈ P → x = 0) :
((Ideal.Quotient.mk P).comp C : R →+* R[X] ⧸ P).IsIntegral := by
refine (isIntegral_quotientMap_iff _).mp ?_
let P' : Ideal R := P.comap C
obtain ⟨pX, hpX, hp0⟩ :=
exists_nonzero_mem_of_ne_bot (ne_of_lt (bot_lt_of_maximal P polynomial_not_isField)).symm hP'
let a : R ⧸ P' := (pX.map (Ideal.Quotient.mk P')).leadingCoeff
let M : Submonoid (R ⧸ P') := Submonoid.powers a
let φ : R ⧸ P' →+* R[X] ⧸ P := quotientMap P C le_rfl
have hP'_prime : P'.IsPrime := comap_isPrime C P
have hM : (0 : R ⧸ P') ∉ M := fun ⟨n, hn⟩ => hp0 <| leadingCoeff_eq_zero.mp (pow_eq_zero hn)
let M' : Submonoid (R[X] ⧸ P) := M.map φ
refine RingHom.IsIntegral.tower_bot φ (algebraMap _ (Localization M')) ?_ ?_
· refine IsLocalization.injective (Localization M')
(show M' ≤ _ from le_nonZeroDivisors_of_noZeroDivisors fun hM' => hM ?_)
exact
let ⟨z, zM, z0⟩ := hM'
quotientMap_injective (_root_.trans z0 φ.map_zero.symm) ▸ zM
· suffices RingHom.comp (algebraMap (R[X] ⧸ P) (Localization M')) φ =
(IsLocalization.map (Localization M') φ M.le_comap_map).comp
(algebraMap (R ⧸ P') (Localization M)) by
rw [this]
refine RingHom.IsIntegral.trans (algebraMap (R ⧸ P') (Localization M))
(IsLocalization.map (Localization M') φ M.le_comap_map) ?_ ?_
· exact (algebraMap (R ⧸ P') (Localization M)).isIntegral_of_surjective
(IsField.localization_map_bijective hM ((Quotient.maximal_ideal_iff_isField_quotient _).mp
(isMaximal_comap_C_of_isMaximal P hP'))).2
· -- `convert` here is faster than `exact`, and this proof is near the time limit.
have isloc : IsLocalization M' (Localization M') := by infer_instance
exact @isIntegral_isLocalization_polynomial_quotient R _
(Localization M) (Localization M') _ _ P pX hpX _ _ _ isloc
rw [IsLocalization.map_comp M.le_comap_map]
variable [IsJacobsonRing R] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | quotient_mk_comp_C_isIntegral_of_jacobson' | Used to bootstrap the more general `quotient_mk_comp_C_isIntegral_of_jacobson` |
quotient_mk_comp_C_isIntegral_of_isJacobsonRing :
((Ideal.Quotient.mk P).comp C : R →+* R[X] ⧸ P).IsIntegral := by
let P' : Ideal R := P.comap C
have : P'.IsPrime := comap_isPrime C P
let f : R[X] →+* Polynomial (R ⧸ P') := Polynomial.mapRingHom (Ideal.Quotient.mk P')
have hf : Function.Surjective ↑f := map_surjective (Ideal.Quotient.mk P') Quotient.mk_surjective
have hPJ : P = (P.map f).comap f := by
rw [comap_map_of_surjective _ hf]
refine le_antisymm (le_sup_of_le_left le_rfl) (sup_le le_rfl ?_)
refine fun p hp =>
polynomial_mem_ideal_of_coeff_mem_ideal P p fun n => Quotient.eq_zero_iff_mem.mp ?_
simpa only [f, coeff_map, coe_mapRingHom] using (Polynomial.ext_iff.mp hp) n
refine RingHom.IsIntegral.tower_bot
(T := (R ⧸ comap C P)[X] ⧸ _) _ _ (injective_quotient_le_comap_map P) ?_
rw [← quotient_mk_maps_eq]
refine ((Ideal.Quotient.mk P').isIntegral_of_surjective Quotient.mk_surjective).trans _ _ ?_
have : IsMaximal (Ideal.map (mapRingHom (Ideal.Quotient.mk (comap C P))) P) :=
Or.recOn (map_eq_top_or_isMaximal_of_surjective f hf hP)
(fun h => absurd (_root_.trans (h ▸ hPJ : P = comap f ⊤) comap_top : P = ⊤) hP.ne_top) id
apply quotient_mk_comp_C_isIntegral_of_jacobson' _ ?_ (fun x hx => ?_)
any_goals exact isJacobsonRing_quotient
obtain ⟨z, rfl⟩ := Ideal.Quotient.mk_surjective x
rwa [Quotient.eq_zero_iff_mem, mem_comap, hPJ, mem_comap, coe_mapRingHom, map_C] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | quotient_mk_comp_C_isIntegral_of_isJacobsonRing | If `R` is a Jacobson ring, and `P` is a maximal ideal of `R[X]`,
then `R → R[X]/P` is an integral map. |
isMaximal_comap_C_of_isJacobsonRing : (P.comap (C : R →+* R[X])).IsMaximal := by
rw [← @mk_ker _ _ P, RingHom.ker_eq_comap_bot, comap_comap]
have := (bot_quotient_isMaximal_iff _).mpr hP
exact isMaximal_comap_of_isIntegral_of_isMaximal' _
(quotient_mk_comp_C_isIntegral_of_isJacobsonRing P) ⊥ | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | isMaximal_comap_C_of_isJacobsonRing | null |
comp_C_integral_of_surjective_of_isJacobsonRing {S : Type*} [Field S] (f : R[X] →+* S)
(hf : Function.Surjective ↑f) : (f.comp C).IsIntegral := by
have : (RingHom.ker f).IsMaximal := RingHom.ker_isMaximal_of_surjective f hf
let g : R[X] ⧸ (RingHom.ker f) →+* S := Ideal.Quotient.lift (RingHom.ker f) f fun _ h => h
have hfg : g.comp (Ideal.Quotient.mk (RingHom.ker f)) = f := ringHom_ext' rfl rfl
rw [← hfg, RingHom.comp_assoc]
refine (quotient_mk_comp_C_isIntegral_of_isJacobsonRing (RingHom.ker f)).trans _ g
(g.isIntegral_of_surjective ?_)
rw [← hfg] at hf
norm_num at hf
exact Function.Surjective.of_comp hf | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | comp_C_integral_of_surjective_of_isJacobsonRing | null |
isJacobsonRing_MvPolynomial_fin {R : Type u} [CommRing R] [H : IsJacobsonRing R] :
∀ n : ℕ, IsJacobsonRing (MvPolynomial (Fin n) R)
| 0 => (isJacobsonRing_iso ((renameEquiv R (Equiv.equivPEmpty (Fin 0))).toRingEquiv.trans
(isEmptyRingEquiv R PEmpty.{u+1}))).mpr H
| n + 1 => (isJacobsonRing_iso (finSuccEquiv R n).toRingEquiv).2
(Polynomial.isJacobsonRing_polynomial_iff_isJacobsonRing.2 (isJacobsonRing_MvPolynomial_fin n)) | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | isJacobsonRing_MvPolynomial_fin | null |
isJacobsonRing {R : Type*} [CommRing R] {ι : Type*} [Finite ι] [IsJacobsonRing R] :
IsJacobsonRing (MvPolynomial ι R) := by
cases nonempty_fintype ι
let e := Fintype.equivFin ι
rw [isJacobsonRing_iso (renameEquiv R e).toRingEquiv]
exact isJacobsonRing_MvPolynomial_fin _
variable {n : ℕ}
universe v w | instance | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | isJacobsonRing | General form of the Nullstellensatz for Jacobson rings, since in a Jacobson ring we have
`Inf {P maximal | P ≥ I} = Inf {P prime | P ≥ I} = I.radical`. Fields are always Jacobson,
and in that special case this is (most of) the classical Nullstellensatz,
since `I(V(I))` is the intersection of maximal ideals containing `I`, which is then `I.radical` |
private noncomputable Cₐ (R : Type u) (S : Type v)
[CommRing R] [CommRing S] [Algebra R S] : S →ₐ[R] S[X] :=
{ Polynomial.C with commutes' := fun r => by rfl } | def | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | Cₐ | The constant coefficient as an R-linear morphism |
private aux_IH {R : Type u} {S : Type v} {T : Type w}
[CommRing R] [CommRing S] [CommRing T] [IsJacobsonRing S] [Algebra R S] [Algebra R T]
(IH : ∀ (Q : Ideal S), (IsMaximal Q) → RingHom.IsIntegral (algebraMap R (S ⧸ Q)))
(v : S[X] ≃ₐ[R] T) (P : Ideal T) (hP : P.IsMaximal) :
RingHom.IsIntegral (algebraMap R (T ⧸ P)) := by
let Q := P.comap v.toAlgHom.toRingHom
have hw : Ideal.map v Q = P := map_comap_of_surjective v v.surjective P
have hQ : IsMaximal Q := comap_isMaximal_of_surjective _ v.surjective
let w : (S[X] ⧸ Q) ≃ₐ[R] (T ⧸ P) := Ideal.quotientEquivAlg Q P v hw.symm
let Q' := Q.comap (Polynomial.C)
let w' : (S ⧸ Q') →ₐ[R] (S[X] ⧸ Q) := Ideal.quotientMapₐ Q (Cₐ R S) le_rfl
have h_eq : algebraMap R (T ⧸ P) =
w.toRingEquiv.toRingHom.comp (w'.toRingHom.comp (algebraMap R (S ⧸ Q'))) := by
ext r
simp only [AlgHom.toRingHom_eq_coe, AlgEquiv.toRingEquiv_eq_coe,
RingEquiv.toRingHom_eq_coe, AlgHom.comp_algebraMap_of_tower, coe_comp, coe_coe,
AlgEquiv.coe_ringEquiv, Function.comp_apply, AlgEquiv.commutes]
rw [h_eq]
apply RingHom.IsIntegral.trans
· apply RingHom.IsIntegral.trans
· apply IH
apply Polynomial.isMaximal_comap_C_of_isJacobsonRing
· suffices w'.toRingHom = Ideal.quotientMap Q (Polynomial.C) le_rfl by
rw [this]
rw [isIntegral_quotientMap_iff _]
apply Polynomial.quotient_mk_comp_C_isIntegral_of_isJacobsonRing
rfl
· apply RingHom.isIntegral_of_surjective
exact w.surjective | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | aux_IH | null |
private quotient_mk_comp_C_isIntegral_of_isJacobsonRing'
{R : Type*} [CommRing R] [IsJacobsonRing R]
(P : Ideal (MvPolynomial (Fin n) R)) (hP : P.IsMaximal) :
RingHom.IsIntegral (algebraMap R (MvPolynomial (Fin n) R ⧸ P)) := by
induction n with
| zero =>
apply RingHom.isIntegral_of_surjective
apply Function.Surjective.comp Quotient.mk_surjective
exact C_surjective (Fin 0)
| succ n IH => apply aux_IH IH (finSuccEquiv R n).symm P hP | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | quotient_mk_comp_C_isIntegral_of_isJacobsonRing' | null |
quotient_mk_comp_C_isIntegral_of_isJacobsonRing {R : Type*} [CommRing R] [IsJacobsonRing R]
(P : Ideal (MvPolynomial (Fin n) R)) [hP : P.IsMaximal] :
RingHom.IsIntegral (RingHom.comp (Ideal.Quotient.mk P) (MvPolynomial.C)) := by
change RingHom.IsIntegral (algebraMap R (MvPolynomial (Fin n) R ⧸ P))
apply quotient_mk_comp_C_isIntegral_of_isJacobsonRing'
infer_instance | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | quotient_mk_comp_C_isIntegral_of_isJacobsonRing | null |
comp_C_integral_of_surjective_of_isJacobsonRing {R : Type*} [CommRing R] [IsJacobsonRing R]
{σ : Type*} [Finite σ] {S : Type*} [Field S] (f : MvPolynomial σ R →+* S)
(hf : Function.Surjective ↑f) : (f.comp C).IsIntegral := by
cases nonempty_fintype σ
have e := (Fintype.equivFin σ).symm
let f' : MvPolynomial (Fin _) R →+* S := f.comp (renameEquiv R e).toRingEquiv.toRingHom
have hf' := Function.Surjective.comp hf (renameEquiv R e).surjective
change Function.Surjective ↑f' at hf'
have : (f'.comp C).IsIntegral := by
have : (RingHom.ker f').IsMaximal := ker_isMaximal_of_surjective f' hf'
let g : MvPolynomial _ R ⧸ (RingHom.ker f') →+* S :=
Ideal.Quotient.lift (RingHom.ker f') f' fun _ h => h
have hfg : g.comp (Ideal.Quotient.mk (RingHom.ker f')) = f' :=
ringHom_ext (fun r => rfl) fun i => rfl
rw [← hfg, RingHom.comp_assoc]
refine (quotient_mk_comp_C_isIntegral_of_isJacobsonRing (RingHom.ker f')).trans _ g
(g.isIntegral_of_surjective ?_)
rw [← hfg] at hf'
norm_num at hf'
exact Function.Surjective.of_comp hf'
rw [RingHom.comp_assoc] at this
convert this
refine RingHom.ext fun x => ?_
exact ((renameEquiv R e).commutes' x).symm | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | comp_C_integral_of_surjective_of_isJacobsonRing | null |
isJacobsonRing_of_finiteType {A B : Type*} [CommRing A] [CommRing B]
[Algebra A B] [IsJacobsonRing A] [Algebra.FiniteType A B] : IsJacobsonRing B := by
obtain ⟨ι, hι, f, hf⟩ := Algebra.FiniteType.iff_quotient_mvPolynomial'.mp ‹_›
exact isJacobsonRing_of_surjective ⟨f.toRingHom, hf⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | isJacobsonRing_of_finiteType | null |
RingHom.FiniteType.isJacobsonRing {A B : Type*} [CommRing A] [CommRing B]
{f : A →+* B} [IsJacobsonRing A] (H : f.FiniteType) : IsJacobsonRing B :=
@isJacobsonRing_of_finiteType A B _ _ f.toAlgebra _ H
@[stacks 0CY7 "See also https://en.wikipedia.org/wiki/Zariski%27s_lemma."] | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | RingHom.FiniteType.isJacobsonRing | null |
finite_of_finite_type_of_isJacobsonRing (R S : Type*) [CommRing R] [Field S]
[Algebra R S] [IsJacobsonRing R] [Algebra.FiniteType R S] :
Module.Finite R S := by
obtain ⟨ι, hι, f, hf⟩ := Algebra.FiniteType.iff_quotient_mvPolynomial'.mp ‹_›
have : (algebraMap R S).IsIntegral := by
rw [← f.comp_algebraMap]
exact MvPolynomial.comp_C_integral_of_surjective_of_isJacobsonRing f.toRingHom hf
have : Algebra.IsIntegral R S := Algebra.isIntegral_def.mpr this
exact Algebra.IsIntegral.finite | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | finite_of_finite_type_of_isJacobsonRing | null |
RingHom.finite_iff_finiteType_of_isJacobsonRing
{R S : Type*} [CommRing R] [IsJacobsonRing R] [Field S]
{f : R →+* S} : f.Finite ↔ f.FiniteType :=
⟨RingHom.FiniteType.of_finite,
by intro; algebraize [f]; exact finite_of_finite_type_of_isJacobsonRing R S⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | RingHom.finite_iff_finiteType_of_isJacobsonRing | If `f : R →+* S` is a ring homomorphism from a Jacobson ring to a field,
then it is finite if and only if it is finite type. |
finite_of_algHom_finiteType_of_isJacobsonRing
{K L A : Type*} [CommRing K] [DivisionRing L] [CommRing A]
[IsJacobsonRing K] [IsNoetherianRing K] [Nontrivial A]
[Algebra K L] [Algebra K A]
[Algebra.FiniteType K A] (f : L →ₐ[K] A) :
Module.Finite K L := by
obtain ⟨m, hm⟩ := Ideal.exists_maximal A
letI := Ideal.Quotient.field m
have := finite_of_finite_type_of_isJacobsonRing K (A ⧸ m)
exact Module.Finite.of_injective ((Ideal.Quotient.mkₐ K m).comp f).toLinearMap
(RingHom.injective _) | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Ideal.GoingUp",
"Mathlib.RingTheory.Jacobson.Polynomial",
"Mathlib.RingTheory.Artinian.Module"
] | Mathlib/RingTheory/Jacobson/Ring.lean | finite_of_algHom_finiteType_of_isJacobsonRing | If `K` is a Jacobson Noetherian ring, `A` a nontrivial `K`-algebra of finite type,
then any `K`-subfield of `A` is finite over `K`. |
IsSimpleModule.jacobson_eq_bot [IsSimpleModule R M] : Module.jacobson R M = ⊥ :=
le_bot_iff.mp <| sInf_le isCoatom_bot | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/Jacobson/Semiprimary.lean | IsSimpleModule.jacobson_eq_bot | null |
IsSemisimpleModule.jacobson_eq_bot [IsSemisimpleModule R M] :
Module.jacobson R M = ⊥ :=
have ⟨s, e, simple⟩ := isSemisimpleModule_iff_exists_linearEquiv_dfinsupp.mp ‹_›
let f : M →ₗ[R] ∀ m : s, m.1 := (LinearMap.pi DFinsupp.lapply).comp e.toLinearMap
Module.jacobson_eq_bot_of_injective f (DFinsupp.injective_pi_lapply (R := R).comp e.injective)
(Module.jacobson_pi_eq_bot _ _ fun i ↦ IsSimpleModule.jacobson_eq_bot R _) | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/Jacobson/Semiprimary.lean | IsSemisimpleModule.jacobson_eq_bot | null |
IsSemisimpleRing.jacobson_eq_bot [IsSemisimpleRing R] : Ring.jacobson R = ⊥ :=
IsSemisimpleModule.jacobson_eq_bot R R | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/Jacobson/Semiprimary.lean | IsSemisimpleRing.jacobson_eq_bot | null |
IsSemisimpleModule.jacobson_le_ker [IsSemisimpleModule R₂ M₂] :
Module.jacobson R M ≤ LinearMap.ker f :=
(Module.le_comap_jacobson f).trans <| by simp_rw [jacobson_eq_bot, LinearMap.ker, le_rfl] | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/Jacobson/Semiprimary.lean | IsSemisimpleModule.jacobson_le_ker | null |
IsSemisimpleModule.jacobson_le_annihilator [IsSemisimpleModule R M] :
Ring.jacobson R ≤ Module.annihilator R M :=
fun r hr ↦ Module.mem_annihilator.mpr fun m ↦ by
have := Module.le_comap_jacobson (LinearMap.toSpanSingleton R M m) hr
rwa [jacobson_eq_bot] at this | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/Jacobson/Semiprimary.lean | IsSemisimpleModule.jacobson_le_annihilator | The Jacobson radical of a ring annihilates every semisimple module. |
@[mk_iff] IsSemiprimaryRing : Prop where
isSemisimpleRing : IsSemisimpleRing (R ⧸ Ring.jacobson R)
isNilpotent : IsNilpotent (Ring.jacobson R)
attribute [instance] IsSemiprimaryRing.isSemisimpleRing | class | RingTheory | [
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Nilpotent.Defs",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/Jacobson/Semiprimary.lean | IsSemiprimaryRing | A ring is semiprimary if its Jacobson radical is nilpotent and its quotient by the
Jacobson radical is semisimple. |
KaehlerDifferential.ideal : Ideal (S ⊗[R] S) :=
RingHom.ker (TensorProduct.lmul' R : S ⊗[R] S →ₐ[R] S)
variable {S} | abbrev | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.ideal | The kernel of the multiplication map `S ⊗[R] S →ₐ[R] S`. |
KaehlerDifferential.one_smul_sub_smul_one_mem_ideal (a : S) :
(1 : S) ⊗ₜ[R] a - a ⊗ₜ[R] (1 : S) ∈ KaehlerDifferential.ideal R S := by simp [RingHom.mem_ker]
variable {R}
variable {M : Type*} [AddCommGroup M] [Module R M] [Module S M] [IsScalarTower R S M] | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.one_smul_sub_smul_one_mem_ideal | null |
Derivation.tensorProductTo (D : Derivation R S M) : S ⊗[R] S →ₗ[S] M :=
TensorProduct.AlgebraTensorModule.lift ((LinearMap.lsmul S (S →ₗ[R] M)).flip D.toLinearMap) | def | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | Derivation.tensorProductTo | For a `R`-derivation `S → M`, this is the map `S ⊗[R] S →ₗ[S] M` sending `s ⊗ₜ t ↦ s • D t`. |
Derivation.tensorProductTo_tmul (D : Derivation R S M) (s t : S) :
D.tensorProductTo (s ⊗ₜ t) = s • D t := rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | Derivation.tensorProductTo_tmul | null |
Derivation.tensorProductTo_mul (D : Derivation R S M) (x y : S ⊗[R] S) :
D.tensorProductTo (x * y) =
TensorProduct.lmul' (S := S) R x • D.tensorProductTo y +
TensorProduct.lmul' (S := S) R y • D.tensorProductTo x := by
refine TensorProduct.induction_on x ?_ ?_ ?_
· rw [zero_mul, map_zero, map_zero, zero_smul, smul_zero, add_zero]
swap
· intro x₁ y₁ h₁ h₂
rw [add_mul, map_add, map_add, map_add, add_smul, smul_add, h₁, h₂, add_add_add_comm]
intro x₁ x₂
refine TensorProduct.induction_on y ?_ ?_ ?_
· rw [mul_zero, map_zero, map_zero, zero_smul, smul_zero, add_zero]
swap
· intro x₁ y₁ h₁ h₂
rw [mul_add, map_add, map_add, map_add, add_smul, smul_add, h₁, h₂, add_add_add_comm]
intro x y
simp only [TensorProduct.tmul_mul_tmul, Derivation.tensorProductTo,
TensorProduct.AlgebraTensorModule.lift_apply,
TensorProduct.lmul'_apply_tmul]
dsimp
rw [D.leibniz]
simp only [smul_smul, smul_add, mul_comm (x * y) x₁, mul_right_comm x₁ x₂, ← mul_assoc]
variable (R S) | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | Derivation.tensorProductTo_mul | null |
KaehlerDifferential.submodule_span_range_eq_ideal :
Submodule.span S (Set.range fun s : S => (1 : S) ⊗ₜ[R] s - s ⊗ₜ[R] (1 : S)) =
(KaehlerDifferential.ideal R S).restrictScalars S := by
apply le_antisymm
· rw [Submodule.span_le]
rintro _ ⟨s, rfl⟩
exact KaehlerDifferential.one_smul_sub_smul_one_mem_ideal _ _
· rintro x (hx : _ = _)
have : x - TensorProduct.lmul' (S := S) R x ⊗ₜ[R] (1 : S) = x := by
rw [hx, TensorProduct.zero_tmul, sub_zero]
rw [← this]
clear this hx
refine TensorProduct.induction_on x ?_ ?_ ?_
· rw [map_zero, TensorProduct.zero_tmul, sub_zero]; exact zero_mem _
· intro x y
have : x ⊗ₜ[R] y - (x * y) ⊗ₜ[R] (1 : S) = x • ((1 : S) ⊗ₜ y - y ⊗ₜ (1 : S)) := by
simp_rw [smul_sub, TensorProduct.smul_tmul', smul_eq_mul, mul_one]
rw [TensorProduct.lmul'_apply_tmul, this]
refine Submodule.smul_mem _ x ?_
apply Submodule.subset_span
exact Set.mem_range_self y
· intro x y hx hy
rw [map_add, TensorProduct.add_tmul, ← sub_add_sub_comm]
exact add_mem hx hy | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.submodule_span_range_eq_ideal | The kernel of `S ⊗[R] S →ₐ[R] S` is generated by `1 ⊗ s - s ⊗ 1` as a `S`-module. |
KaehlerDifferential.span_range_eq_ideal :
Ideal.span (Set.range fun s : S => (1 : S) ⊗ₜ[R] s - s ⊗ₜ[R] (1 : S)) =
KaehlerDifferential.ideal R S := by
apply le_antisymm
· rw [Ideal.span_le]
rintro _ ⟨s, rfl⟩
exact KaehlerDifferential.one_smul_sub_smul_one_mem_ideal _ _
· change (KaehlerDifferential.ideal R S).restrictScalars S ≤ (Ideal.span _).restrictScalars S
rw [← KaehlerDifferential.submodule_span_range_eq_ideal, Ideal.span]
conv_rhs => rw [← Submodule.span_span_of_tower S]
exact Submodule.subset_span | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.span_range_eq_ideal | null |
KaehlerDifferential : Type v :=
(KaehlerDifferential.ideal R S).Cotangent
deriving AddCommGroup, Module (S ⊗[R] S), IsScalarTower S (S ⊗[R] S), Inhabited
@[inherit_doc KaehlerDifferential]
notation "Ω[" S "⁄" R "]" => KaehlerDifferential R S | def | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential | The module of Kähler differentials (Kahler differentials, Kaehler differentials).
This is implemented as `I / I ^ 2` with `I` the kernel of the multiplication map `S ⊗[R] S →ₐ[R] S`.
To view elements as a linear combination of the form `s • D s'`, use
`KaehlerDifferential.tensorProductTo_surjective` and `Derivation.tensorProductTo_tmul`.
We also provide the notation `Ω[S⁄R]` for `KaehlerDifferential R S`.
Note that the slash is `\textfractionsolidus`. |
KaehlerDifferential.module' {R' : Type*} [CommRing R'] [Algebra R' S]
[SMulCommClass R R' S] :
Module R' Ω[S⁄R] :=
Submodule.Quotient.module' _ | instance | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.module' | null |
KaehlerDifferential.isScalarTower_of_tower {R₁ R₂ : Type*} [CommRing R₁] [CommRing R₂]
[Algebra R₁ S] [Algebra R₂ S] [SMul R₁ R₂]
[SMulCommClass R R₁ S] [SMulCommClass R R₂ S] [IsScalarTower R₁ R₂ S] :
IsScalarTower R₁ R₂ Ω[S⁄R] :=
Submodule.Quotient.isScalarTower _ _ | instance | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.isScalarTower_of_tower | null |
KaehlerDifferential.isScalarTower' : IsScalarTower R (S ⊗[R] S) Ω[S⁄R] :=
Submodule.Quotient.isScalarTower _ _ | instance | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.isScalarTower' | null |
KaehlerDifferential.fromIdeal : KaehlerDifferential.ideal R S →ₗ[S ⊗[R] S] Ω[S⁄R] :=
(KaehlerDifferential.ideal R S).toCotangent | def | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.fromIdeal | The quotient map `I → Ω[S⁄R]` with `I` being the kernel of `S ⊗[R] S → S`. |
KaehlerDifferential.DLinearMap : S →ₗ[R] Ω[S⁄R] :=
((KaehlerDifferential.fromIdeal R S).restrictScalars R).comp
((TensorProduct.includeRight.toLinearMap - TensorProduct.includeLeft.toLinearMap :
S →ₗ[R] S ⊗[R] S).codRestrict
((KaehlerDifferential.ideal R S).restrictScalars R)
(KaehlerDifferential.one_smul_sub_smul_one_mem_ideal R) :
_ →ₗ[R] _) | def | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.DLinearMap | (Implementation) The underlying linear map of the derivation into `Ω[S⁄R]`. |
KaehlerDifferential.DLinearMap_apply (s : S) :
KaehlerDifferential.DLinearMap R S s =
(KaehlerDifferential.ideal R S).toCotangent
⟨1 ⊗ₜ s - s ⊗ₜ 1, KaehlerDifferential.one_smul_sub_smul_one_mem_ideal R s⟩ := rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.DLinearMap_apply | null |
KaehlerDifferential.D : Derivation R S Ω[S⁄R] :=
{ toLinearMap := KaehlerDifferential.DLinearMap R S
map_one_eq_zero' := by
dsimp [KaehlerDifferential.DLinearMap_apply, Ideal.toCotangent_apply]
congr
rw [sub_self]
leibniz' := fun a b => by
have : LinearMap.CompatibleSMul { x // x ∈ ideal R S } Ω[S⁄R] S (S ⊗[R] S) := inferInstance
dsimp [KaehlerDifferential.DLinearMap_apply]
rw [← LinearMap.map_smul_of_tower (ideal R S).toCotangent,
← LinearMap.map_smul_of_tower (ideal R S).toCotangent,
← map_add (ideal R S).toCotangent, Ideal.toCotangent_eq, pow_two]
convert Submodule.mul_mem_mul (KaehlerDifferential.one_smul_sub_smul_one_mem_ideal R a :)
(KaehlerDifferential.one_smul_sub_smul_one_mem_ideal R b :) using 1
simp only [Submodule.coe_add,
TensorProduct.tmul_mul_tmul, mul_sub, sub_mul, mul_comm b, Submodule.coe_smul_of_tower,
smul_sub, TensorProduct.smul_tmul', smul_eq_mul, mul_one]
ring_nf } | def | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.D | The universal derivation into `Ω[S⁄R]`. |
KaehlerDifferential.D_apply (s : S) :
KaehlerDifferential.D R S s =
(KaehlerDifferential.ideal R S).toCotangent
⟨1 ⊗ₜ s - s ⊗ₜ 1, KaehlerDifferential.one_smul_sub_smul_one_mem_ideal R s⟩ := rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.D_apply | null |
KaehlerDifferential.span_range_derivation :
Submodule.span S (Set.range <| KaehlerDifferential.D R S) = ⊤ := by
rw [_root_.eq_top_iff]
rintro x -
obtain ⟨⟨x, hx⟩, rfl⟩ := Ideal.toCotangent_surjective _ x
have : x ∈ (KaehlerDifferential.ideal R S).restrictScalars S := hx
rw [← KaehlerDifferential.submodule_span_range_eq_ideal] at this
suffices ∃ hx, (KaehlerDifferential.ideal R S).toCotangent ⟨x, hx⟩ ∈
Submodule.span S (Set.range <| KaehlerDifferential.D R S) by
exact this.choose_spec
refine Submodule.span_induction ?_ ?_ ?_ ?_ this
· rintro _ ⟨x, rfl⟩
refine ⟨KaehlerDifferential.one_smul_sub_smul_one_mem_ideal R x, ?_⟩
apply Submodule.subset_span
exact ⟨x, KaehlerDifferential.DLinearMap_apply R S x⟩
· exact ⟨zero_mem _, Submodule.zero_mem _⟩
· rintro x y - - ⟨hx₁, hx₂⟩ ⟨hy₁, hy₂⟩; exact ⟨add_mem hx₁ hy₁, Submodule.add_mem _ hx₂ hy₂⟩
· rintro r x - ⟨hx₁, hx₂⟩
exact ⟨((KaehlerDifferential.ideal R S).restrictScalars S).smul_mem r hx₁,
Submodule.smul_mem _ r hx₂⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.span_range_derivation | null |
KaehlerDifferential.subsingleton_of_surjective (h : Function.Surjective (algebraMap R S)) :
Subsingleton Ω[S⁄R] := by
suffices (⊤ : Submodule S Ω[S⁄R]) ≤ ⊥ from
(subsingleton_iff_forall_eq 0).mpr fun y ↦ this trivial
rw [← KaehlerDifferential.span_range_derivation, Submodule.span_le]
rintro _ ⟨x, rfl⟩; obtain ⟨x, rfl⟩ := h x; simp
variable {R S} | lemma | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.subsingleton_of_surjective | `Ω[S⁄R]` is trivial if `R → S` is surjective.
Also see `Algebra.FormallyUnramified.iff_subsingleton_kaehlerDifferential`. |
Derivation.liftKaehlerDifferential (D : Derivation R S M) : Ω[S⁄R] →ₗ[S] M := by
refine LinearMap.comp ((((KaehlerDifferential.ideal R S) •
(⊤ : Submodule (S ⊗[R] S) (KaehlerDifferential.ideal R S))).restrictScalars S).liftQ ?_ ?_)
(Submodule.Quotient.restrictScalarsEquiv S _).symm.toLinearMap
· exact D.tensorProductTo.comp ((KaehlerDifferential.ideal R S).subtype.restrictScalars S)
· intro x hx
rw [LinearMap.mem_ker]
refine Submodule.smul_induction_on ((Submodule.restrictScalars_mem _ _ _).mp hx) ?_ ?_
· rintro x hx y -
rw [RingHom.mem_ker] at hx
dsimp
rw [Derivation.tensorProductTo_mul, hx, y.prop, zero_smul, zero_smul, zero_add]
· intro x y ex ey; rw [map_add, ex, ey, zero_add] | def | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | Derivation.liftKaehlerDifferential | The linear map from `Ω[S⁄R]`, associated with a derivation. |
Derivation.liftKaehlerDifferential_apply (D : Derivation R S M) (x) :
D.liftKaehlerDifferential ((KaehlerDifferential.ideal R S).toCotangent x) =
D.tensorProductTo x := rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | Derivation.liftKaehlerDifferential_apply | null |
Derivation.liftKaehlerDifferential_comp (D : Derivation R S M) :
D.liftKaehlerDifferential.compDer (KaehlerDifferential.D R S) = D := by
ext a
dsimp [KaehlerDifferential.D_apply]
refine (D.liftKaehlerDifferential_apply _).trans ?_
rw [Subtype.coe_mk, map_sub, Derivation.tensorProductTo_tmul, Derivation.tensorProductTo_tmul,
one_smul, D.map_one_eq_zero, smul_zero, sub_zero]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | Derivation.liftKaehlerDifferential_comp | null |
Derivation.liftKaehlerDifferential_comp_D (D' : Derivation R S M) (x : S) :
D'.liftKaehlerDifferential (KaehlerDifferential.D R S x) = D' x :=
Derivation.congr_fun D'.liftKaehlerDifferential_comp x
@[ext] | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | Derivation.liftKaehlerDifferential_comp_D | null |
Derivation.liftKaehlerDifferential_unique (f f' : Ω[S⁄R] →ₗ[S] M)
(hf : f.compDer (KaehlerDifferential.D R S) = f'.compDer (KaehlerDifferential.D R S)) :
f = f' := by
apply LinearMap.ext
intro x
have : x ∈ Submodule.span S (Set.range <| KaehlerDifferential.D R S) := by
rw [KaehlerDifferential.span_range_derivation]; trivial
refine Submodule.span_induction ?_ ?_ ?_ ?_ this
· rintro _ ⟨x, rfl⟩; exact congr_arg (fun D : Derivation R S M => D x) hf
· rw [map_zero, map_zero]
· intro x y _ _ hx hy; rw [map_add, map_add, hx, hy]
· intro a x _ e; simp [e]
variable (R S) | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | Derivation.liftKaehlerDifferential_unique | null |
Derivation.liftKaehlerDifferential_D :
(KaehlerDifferential.D R S).liftKaehlerDifferential = LinearMap.id :=
Derivation.liftKaehlerDifferential_unique _ _
(KaehlerDifferential.D R S).liftKaehlerDifferential_comp
variable {R S} | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | Derivation.liftKaehlerDifferential_D | null |
KaehlerDifferential.D_tensorProductTo (x : KaehlerDifferential.ideal R S) :
(KaehlerDifferential.D R S).tensorProductTo x =
(KaehlerDifferential.ideal R S).toCotangent x := by
rw [← Derivation.liftKaehlerDifferential_apply, Derivation.liftKaehlerDifferential_D]
rfl
variable (R S) | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.D_tensorProductTo | null |
KaehlerDifferential.tensorProductTo_surjective :
Function.Surjective (KaehlerDifferential.D R S).tensorProductTo := by
intro x; obtain ⟨x, rfl⟩ := (KaehlerDifferential.ideal R S).toCotangent_surjective x
exact ⟨x, KaehlerDifferential.D_tensorProductTo x⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.tensorProductTo_surjective | null |
@[simps! symm_apply apply_apply]
KaehlerDifferential.linearMapEquivDerivation : (Ω[S⁄R] →ₗ[S] M) ≃ₗ[S] Derivation R S M :=
{ Derivation.llcomp.flip <| KaehlerDifferential.D R S with
invFun := Derivation.liftKaehlerDifferential
left_inv := fun _ =>
Derivation.liftKaehlerDifferential_unique _ _ (Derivation.liftKaehlerDifferential_comp _)
right_inv := Derivation.liftKaehlerDifferential_comp } | def | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.linearMapEquivDerivation | The `S`-linear maps from `Ω[S⁄R]` to `M` are (`S`-linearly) equivalent to `R`-derivations
from `S` to `M`. |
KaehlerDifferential.quotientCotangentIdealRingEquiv :
(S ⊗ S ⧸ KaehlerDifferential.ideal R S ^ 2) ⧸ (KaehlerDifferential.ideal R S).cotangentIdeal ≃+*
S := by
have : Function.RightInverse (TensorProduct.includeLeft (R := R) (S := R) (A := S) (B := S))
(↑(TensorProduct.lmul' R : S ⊗[R] S →ₐ[R] S) : S ⊗[R] S →+* S) := by
intro x; rw [AlgHom.coe_toRingHom, ← AlgHom.comp_apply, TensorProduct.lmul'_comp_includeLeft]
rfl
refine (Ideal.quotCotangent _).trans ?_
refine (Ideal.quotEquivOfEq ?_).trans (RingHom.quotientKerEquivOfRightInverse this)
ext; rfl | def | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.quotientCotangentIdealRingEquiv | The quotient ring of `S ⊗ S ⧸ J ^ 2` by `Ω[S⁄R]` is isomorphic to `S`. |
KaehlerDifferential.quotientCotangentIdeal :
((S ⊗ S ⧸ KaehlerDifferential.ideal R S ^ 2) ⧸
(KaehlerDifferential.ideal R S).cotangentIdeal) ≃ₐ[S] S :=
{ KaehlerDifferential.quotientCotangentIdealRingEquiv R S with
commutes' := (KaehlerDifferential.quotientCotangentIdealRingEquiv R S).apply_symm_apply } | def | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.quotientCotangentIdeal | The quotient ring of `S ⊗ S ⧸ J ^ 2` by `Ω[S⁄R]` is isomorphic to `S` as an `S`-algebra. |
KaehlerDifferential.End_equiv_aux (f : S →ₐ[R] S ⊗ S ⧸ KaehlerDifferential.ideal R S ^ 2) :
(Ideal.Quotient.mkₐ R (KaehlerDifferential.ideal R S).cotangentIdeal).comp f =
IsScalarTower.toAlgHom R S _ ↔
(TensorProduct.lmul' R : S ⊗[R] S →ₐ[R] S).kerSquareLift.comp f = AlgHom.id R S := by
rw [AlgHom.ext_iff, AlgHom.ext_iff]
apply forall_congr'
intro x
have e₁ : (TensorProduct.lmul' R : S ⊗[R] S →ₐ[R] S).kerSquareLift (f x) =
KaehlerDifferential.quotientCotangentIdealRingEquiv R S
(Ideal.Quotient.mk (KaehlerDifferential.ideal R S).cotangentIdeal <| f x) := by
generalize f x = y; obtain ⟨y, rfl⟩ := Ideal.Quotient.mk_surjective y; rfl
have e₂ :
x = KaehlerDifferential.quotientCotangentIdealRingEquiv R S (IsScalarTower.toAlgHom R S _ x) :=
(mul_one x).symm
constructor
· intro e
exact (e₁.trans (@RingEquiv.congr_arg _ _ _ _ _ _
(KaehlerDifferential.quotientCotangentIdealRingEquiv R S) _ _ e)).trans e₂.symm
· intro e; apply (KaehlerDifferential.quotientCotangentIdealRingEquiv R S).injective
exact e₁.symm.trans (e.trans e₂)
/- Note: Lean is slow to synthesize these instances (times out).
Without them the endEquivDerivation' and endEquivAuxEquiv both have significant timeouts.
In Mathlib 3, it was slow but not this slow. -/ | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.End_equiv_aux | null |
noncomputable KaehlerDifferential.endEquivDerivation' :
Derivation R S Ω[S⁄R] ≃ₗ[R] Derivation R S (ideal R S).cotangentIdeal :=
LinearEquiv.compDer ((KaehlerDifferential.ideal R S).cotangentEquivIdeal.restrictScalars S) | def | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.endEquivDerivation' | A shortcut instance to prevent timing out. Hopefully to be removed in the future. -/
local instance smul_SSmod_SSmod : SMul (S ⊗[R] S ⧸ KaehlerDifferential.ideal R S ^ 2)
(S ⊗[R] S ⧸ KaehlerDifferential.ideal R S ^ 2) := Mul.toSMul _
/-- A shortcut instance to prevent timing out. Hopefully to be removed in the future. -/
@[nolint defLemma]
local instance isScalarTower_S_right :
IsScalarTower S (S ⊗[R] S ⧸ KaehlerDifferential.ideal R S ^ 2)
(S ⊗[R] S ⧸ KaehlerDifferential.ideal R S ^ 2) := Ideal.Quotient.isScalarTower_right
/-- A shortcut instance to prevent timing out. Hopefully to be removed in the future. -/
@[nolint defLemma]
local instance isScalarTower_R_right :
IsScalarTower R (S ⊗[R] S ⧸ KaehlerDifferential.ideal R S ^ 2)
(S ⊗[R] S ⧸ KaehlerDifferential.ideal R S ^ 2) := Ideal.Quotient.isScalarTower_right
/-- A shortcut instance to prevent timing out. Hopefully to be removed in the future. -/
@[nolint defLemma]
local instance isScalarTower_SS_right : IsScalarTower (S ⊗[R] S)
(S ⊗[R] S ⧸ KaehlerDifferential.ideal R S ^ 2) (S ⊗[R] S ⧸ KaehlerDifferential.ideal R S ^ 2) :=
Ideal.Quotient.isScalarTower_right
/-- A shortcut instance to prevent timing out. Hopefully to be removed in the future. -/
local instance instS : Module S (KaehlerDifferential.ideal R S).cotangentIdeal :=
Submodule.module' _
/-- A shortcut instance to prevent timing out. Hopefully to be removed in the future. -/
local instance instR : Module R (KaehlerDifferential.ideal R S).cotangentIdeal :=
Submodule.module' _
/-- A shortcut instance to prevent timing out. Hopefully to be removed in the future. -/
local instance instSS : Module (S ⊗[R] S) (KaehlerDifferential.ideal R S).cotangentIdeal :=
Submodule.module' _
/-- Derivations into `Ω[S⁄R]` is equivalent to derivations
into `(KaehlerDifferential.ideal R S).cotangentIdeal`. |
KaehlerDifferential.endEquivAuxEquiv :
{ f //
(Ideal.Quotient.mkₐ R (KaehlerDifferential.ideal R S).cotangentIdeal).comp f =
IsScalarTower.toAlgHom R S _ } ≃
{ f // (TensorProduct.lmul' R : S ⊗[R] S →ₐ[R] S).kerSquareLift.comp f = AlgHom.id R S } :=
(Equiv.refl _).subtypeEquiv (KaehlerDifferential.End_equiv_aux R S) | def | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.endEquivAuxEquiv | (Implementation) An `Equiv` version of `KaehlerDifferential.End_equiv_aux`.
Used in `KaehlerDifferential.endEquiv`. |
noncomputable KaehlerDifferential.endEquiv :
Module.End S Ω[S⁄R] ≃
{ f // (TensorProduct.lmul' R : S ⊗[R] S →ₐ[R] S).kerSquareLift.comp f = AlgHom.id R S } :=
(KaehlerDifferential.linearMapEquivDerivation R S).toEquiv.trans <|
(KaehlerDifferential.endEquivDerivation' R S).toEquiv.trans <|
(derivationToSquareZeroEquivLift (KaehlerDifferential.ideal R S).cotangentIdeal
(KaehlerDifferential.ideal R S).cotangentIdeal_square).trans <|
KaehlerDifferential.endEquivAuxEquiv R S | def | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.endEquiv | The endomorphisms of `Ω[S⁄R]` corresponds to sections of the surjection `S ⊗[R] S ⧸ J ^ 2 →ₐ[R] S`,
with `J` being the kernel of the multiplication map `S ⊗[R] S →ₐ[R] S`. |
KaehlerDifferential.ideal_fg [EssFiniteType R S] :
(KaehlerDifferential.ideal R S).FG := by
classical
use (EssFiniteType.finset R S).image (fun s ↦ (1 : S) ⊗ₜ[R] s - s ⊗ₜ[R] (1 : S))
apply le_antisymm
· rw [Finset.coe_image, Ideal.span_le]
rintro _ ⟨x, _, rfl⟩
exact KaehlerDifferential.one_smul_sub_smul_one_mem_ideal R x
· rw [← KaehlerDifferential.span_range_eq_ideal, Ideal.span_le]
rintro _ ⟨x, rfl⟩
let I : Ideal (S ⊗[R] S) := Ideal.span
((EssFiniteType.finset R S).image (fun s ↦ (1 : S) ⊗ₜ[R] s - s ⊗ₜ[R] (1 : S)))
change _ - _ ∈ I
have : (IsScalarTower.toAlgHom R (S ⊗[R] S) (S ⊗[R] S ⧸ I)).comp TensorProduct.includeRight =
(IsScalarTower.toAlgHom R (S ⊗[R] S) (S ⊗[R] S ⧸ I)).comp TensorProduct.includeLeft := by
apply EssFiniteType.algHom_ext
intro a ha
simp only [AlgHom.coe_comp, IsScalarTower.coe_toAlgHom', Ideal.Quotient.algebraMap_eq,
Function.comp_apply, TensorProduct.includeLeft_apply, TensorProduct.includeRight_apply,
Ideal.Quotient.mk_eq_mk_iff_sub_mem]
refine Ideal.subset_span ?_
simp only [Finset.coe_image, Set.mem_image, Finset.mem_coe]
exact ⟨a, ha, rfl⟩
simpa [Ideal.Quotient.mk_eq_mk_iff_sub_mem] using AlgHom.congr_fun this x | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.ideal_fg | null |
KaehlerDifferential.finite [EssFiniteType R S] :
Module.Finite S Ω[S⁄R] := by
classical
let s := (EssFiniteType.finset R S).image (fun s ↦ D R S s)
refine ⟨⟨s, top_le_iff.mp ?_⟩⟩
rw [← span_range_derivation, Submodule.span_le]
rintro _ ⟨x, rfl⟩
have : ∀ x ∈ adjoin R (EssFiniteType.finset R S).toSet,
.D _ _ x ∈ Submodule.span S s.toSet := by
intro x hx
refine adjoin_induction ?_ ?_ ?_ ?_ hx
· exact fun x hx ↦ Submodule.subset_span (Finset.mem_image_of_mem _ hx)
· simp
· exact fun x y _ _ hx hy ↦ (D R S).map_add x y ▸ add_mem hx hy
· intro x y _ _ hx hy
simp only [Derivation.leibniz]
exact add_mem (Submodule.smul_mem _ _ hy) (Submodule.smul_mem _ _ hx)
obtain ⟨t, ht, ht', hxt⟩ := (essFiniteType_cond_iff R S (EssFiniteType.finset R S)).mp
EssFiniteType.cond.choose_spec x
rw [show D R S x =
ht'.unit⁻¹ • (D R S (x * t) - x • D R S t) by simp [smul_smul, Units.smul_def]]
exact Submodule.smul_mem _ _ (sub_mem (this _ hxt) (Submodule.smul_mem _ _ (this _ ht))) | instance | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.finite | null |
noncomputable KaehlerDifferential.kerTotal : Submodule S (S →₀ S) :=
Submodule.span S
(((Set.range fun x : S × S => single x.1 1 + single x.2 1 - single (x.1 + x.2) 1) ∪
Set.range fun x : S × S => single x.2 x.1 + single x.1 x.2 - single (x.1 * x.2) 1) ∪
Set.range fun x : R => single (algebraMap R S x) 1)
unsuppress_compilation in
local notation3 x "𝖣" y => (KaehlerDifferential.kerTotal R S).mkQ (single y x) | def | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.kerTotal | The `S`-submodule of `S →₀ S` (the direct sum of copies of `S` indexed by `S`) generated by
the relations:
1. `dx + dy = d(x + y)`
2. `x dy + y dx = d(x * y)`
3. `dr = 0` for `r ∈ R`
where `db` is the unit in the copy of `S` with index `b`.
This is the kernel of the surjection
`Finsupp.linearCombination S Ω[S⁄R] S (KaehlerDifferential.D R S)`.
See `KaehlerDifferential.kerTotal_eq` and `KaehlerDifferential.linearCombination_surjective`. |
KaehlerDifferential.kerTotal_mkQ_single_add (x y z) : (z𝖣x + y) = (z𝖣x) + z𝖣y := by
rw [← map_add, eq_comm, ← sub_eq_zero, ← map_sub (Submodule.mkQ (kerTotal R S)),
Submodule.mkQ_apply, Submodule.Quotient.mk_eq_zero]
simp_rw [← Finsupp.smul_single_one _ z, ← smul_add, ← smul_sub]
exact Submodule.smul_mem _ _ (Submodule.subset_span (Or.inl <| Or.inl <| ⟨⟨_, _⟩, rfl⟩)) | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.kerTotal_mkQ_single_add | null |
KaehlerDifferential.kerTotal_mkQ_single_mul (x y z) :
(z𝖣x * y) = ((z * x)𝖣y) + (z * y)𝖣x := by
rw [← map_add, eq_comm, ← sub_eq_zero, ← map_sub (Submodule.mkQ (kerTotal R S)),
Submodule.mkQ_apply, Submodule.Quotient.mk_eq_zero]
simp_rw [← Finsupp.smul_single_one _ z, ← @smul_eq_mul _ _ z, ← Finsupp.smul_single, ← smul_add,
← smul_sub]
exact Submodule.smul_mem _ _ (Submodule.subset_span (Or.inl <| Or.inr <| ⟨⟨_, _⟩, rfl⟩)) | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.kerTotal_mkQ_single_mul | null |
KaehlerDifferential.kerTotal_mkQ_single_algebraMap (x y) : (y𝖣algebraMap R S x) = 0 := by
rw [Submodule.mkQ_apply, Submodule.Quotient.mk_eq_zero, ← Finsupp.smul_single_one _ y]
exact Submodule.smul_mem _ _ (Submodule.subset_span (Or.inr <| ⟨_, rfl⟩)) | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.kerTotal_mkQ_single_algebraMap | null |
KaehlerDifferential.kerTotal_mkQ_single_algebraMap_one (x) : (x𝖣1) = 0 := by
rw [← (algebraMap R S).map_one, KaehlerDifferential.kerTotal_mkQ_single_algebraMap] | theorem | RingTheory | [
"Mathlib.RingTheory.Derivation.ToSquareZero",
"Mathlib.RingTheory.Ideal.Cotangent",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.EssentialFiniteness",
"Mathlib.Algebra.Exact",
"Mathlib.LinearAlgebra.TensorProduct.RightExactness"
] | Mathlib/RingTheory/Kaehler/Basic.lean | KaehlerDifferential.kerTotal_mkQ_single_algebraMap_one | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.