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 ⌀ |
|---|---|---|---|---|---|---|
Ring.KrullDimLE.mk₀ (H : ∀ I : Ideal R, I.IsPrime → I.IsMaximal) : Ring.KrullDimLE 0 R := by
rwa [Ring.krullDimLE_zero_iff] | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | Ring.KrullDimLE.mk₀ | null |
Ideal.isMaximal_of_isPrime [Ring.KrullDimLE 0 R] (I : Ideal R) [I.IsPrime] : I.IsMaximal :=
Ring.krullDimLE_zero_iff.mp ‹_› I ‹_› | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | Ideal.isMaximal_of_isPrime | null |
Ideal.IsPrime.isMaximal' [Ring.KrullDimLE 0 R] {I : Ideal R} (hI : I.IsPrime) : I.IsMaximal :=
I.isMaximal_of_isPrime | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | Ideal.IsPrime.isMaximal' | Also see `Ideal.IsPrime.isMaximal` for the analogous statement for Dedekind domains. |
Ideal.isMaximal_iff_isPrime [Ring.KrullDimLE 0 R] {I : Ideal R} : I.IsMaximal ↔ I.IsPrime :=
⟨IsMaximal.isPrime, fun _ ↦ inferInstance⟩ | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | Ideal.isMaximal_iff_isPrime | null |
Ideal.mem_minimalPrimes_of_krullDimLE_zero [Ring.KrullDimLE 0 R]
(I : Ideal R) [I.IsPrime] : I ∈ minimalPrimes R :=
minimalPrimes_eq_minimals (R := R) ▸
⟨‹_›, fun J hJ hJI ↦ (IsMaximal.eq_of_le inferInstance IsPrime.ne_top' hJI).ge⟩ | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | Ideal.mem_minimalPrimes_of_krullDimLE_zero | null |
Ideal.mem_minimalPrimes_iff_isPrime [Ring.KrullDimLE 0 R] {I : Ideal R} :
I ∈ minimalPrimes R ↔ I.IsPrime :=
⟨(·.1.1), fun _ ↦ I.mem_minimalPrimes_of_krullDimLE_zero⟩ | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | Ideal.mem_minimalPrimes_iff_isPrime | null |
nilradical_le_jacobson (R) [CommRing R] : nilradical R ≤ Ring.jacobson R :=
nilradical_eq_sInf R ▸ le_sInf fun _I hI ↦ sInf_le (Ideal.IsMaximal.isPrime ⟨hI⟩) | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | nilradical_le_jacobson | null |
Ring.jacobson_eq_nilradical_of_krullDimLE_zero (R) [CommRing R] [KrullDimLE 0 R] :
jacobson R = nilradical R :=
(nilradical_le_jacobson R).antisymm' <| nilradical_eq_sInf R ▸ le_sInf fun I (_ : I.IsPrime) ↦
sInf_le Ideal.IsMaximal.out | theorem | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | Ring.jacobson_eq_nilradical_of_krullDimLE_zero | null |
Ring.krullDimLE_one_iff : Ring.KrullDimLE 1 R ↔
∀ I : Ideal R, I.IsPrime → I ∈ minimalPrimes R ∨ I.IsMaximal := by
simp_rw [Ring.KrullDimLE, Order.krullDimLE_iff, Nat.cast_one,
Order.krullDim_le_one_iff, (PrimeSpectrum.equivSubtype R).forall_congr_left,
Subtype.forall, PrimeSpectrum.isMax_iff, PrimeSpectrum.isMin_iff]
rfl | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | Ring.krullDimLE_one_iff | null |
Ring.KrullDimLE.mk₁ (H : ∀ I : Ideal R, I.IsPrime → I ∈ minimalPrimes R ∨ I.IsMaximal) :
Ring.KrullDimLE 1 R := by
rwa [Ring.krullDimLE_one_iff] | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | Ring.KrullDimLE.mk₁ | null |
Ring.krullDimLE_one_iff_of_isPrime_bot [(⊥ : Ideal R).IsPrime] :
Ring.KrullDimLE 1 R ↔ ∀ I : Ideal R, I ≠ ⊥ → I.IsPrime → I.IsMaximal := by
letI : OrderBot (PrimeSpectrum R) := { bot := ⟨⊥, ‹_›⟩, bot_le I := bot_le (a := I.1) }
simp_rw [Ring.KrullDimLE, Order.krullDimLE_iff, Nat.cast_one,
Order.krullDim_le_one_iff_forall_isMax, (PrimeSpectrum.equivSubtype R).forall_congr_left,
Subtype.forall, PrimeSpectrum.isMax_iff, forall_comm (α := _ ≠ ⊥),
ne_eq, PrimeSpectrum.ext_iff]
rfl | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | Ring.krullDimLE_one_iff_of_isPrime_bot | null |
Ring.krullDimLE_one_iff_of_noZeroDivisors [NoZeroDivisors R] :
Ring.KrullDimLE 1 R ↔ ∀ I : Ideal R, I ≠ ⊥ → I.IsPrime → I.IsMaximal := by
cases subsingleton_or_nontrivial R
· exact iff_of_true inferInstance fun I h ↦ (h <| Subsingleton.elim ..).elim
have := Ideal.bot_prime (α := R)
exact Ring.krullDimLE_one_iff_of_isPrime_bot | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | Ring.krullDimLE_one_iff_of_noZeroDivisors | null |
Ring.KrullDimLE.mk₁' (H : ∀ I : Ideal R, I ≠ ⊥ → I.IsPrime → I.IsMaximal) :
Ring.KrullDimLE 1 R := by
by_cases hR : (⊥ : Ideal R).IsPrime
· rwa [Ring.krullDimLE_one_iff_of_isPrime_bot]
suffices Ring.KrullDimLE 0 R from inferInstance
exact .mk₀ fun I hI ↦ H I (fun e ↦ hR (e ▸ hI)) hI | lemma | RingTheory | [
"Mathlib.Algebra.MvPolynomial.CommRing",
"Mathlib.Algebra.Polynomial.Basic",
"Mathlib.Order.KrullDimension",
"Mathlib.RingTheory.Ideal.Quotient.Defs",
"Mathlib.RingTheory.Ideal.MinimalPrime.Basic",
"Mathlib.RingTheory.Jacobson.Radical",
"Mathlib.RingTheory.Spectrum.Prime.Basic"
] | Mathlib/RingTheory/KrullDimension/Basic.lean | Ring.KrullDimLE.mk₁' | Alternative constructor for `Ring.KrullDimLE 1`, convenient for domains. |
@[simp]
ringKrullDim_eq_zero_of_field (F : Type*) [Field F] : ringKrullDim F = 0 :=
krullDim_eq_zero_of_unique | theorem | RingTheory | [
"Mathlib.RingTheory.KrullDimension.Basic"
] | Mathlib/RingTheory/KrullDimension/Field.lean | ringKrullDim_eq_zero_of_field | null |
ringKrullDim_eq_zero_of_isField {F : Type*} [CommRing F] (hF : IsField F) :
ringKrullDim F = 0 :=
@krullDim_eq_zero_of_unique _ _ <| @PrimeSpectrum.instUnique _ hF.toField | theorem | RingTheory | [
"Mathlib.RingTheory.KrullDimension.Basic"
] | Mathlib/RingTheory/KrullDimension/Field.lean | ringKrullDim_eq_zero_of_isField | null |
noncomputable supportDim : WithBot ℕ∞ :=
krullDim (Module.support R M) | def | RingTheory | [
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.Spectrum.Prime.Module"
] | Mathlib/RingTheory/KrullDimension/Module.lean | supportDim | The krull dimension of module, defined as `krullDim` of its support. |
supportDim_eq_bot_of_subsingleton [Subsingleton M] : supportDim R M = ⊥ := by
simpa [supportDim, support_eq_empty_iff] | lemma | RingTheory | [
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.Spectrum.Prime.Module"
] | Mathlib/RingTheory/KrullDimension/Module.lean | supportDim_eq_bot_of_subsingleton | null |
supportDim_ne_bot_of_nontrivial [Nontrivial M] : supportDim R M ≠ ⊥ := by
simpa [supportDim, support_eq_empty_iff, not_subsingleton_iff_nontrivial] | lemma | RingTheory | [
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.Spectrum.Prime.Module"
] | Mathlib/RingTheory/KrullDimension/Module.lean | supportDim_ne_bot_of_nontrivial | null |
supportDim_eq_bot_iff_subsingleton : supportDim R M = ⊥ ↔ Subsingleton M := by
simp [supportDim, krullDim_eq_bot_iff, support_eq_empty_iff] | lemma | RingTheory | [
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.Spectrum.Prime.Module"
] | Mathlib/RingTheory/KrullDimension/Module.lean | supportDim_eq_bot_iff_subsingleton | null |
supportDim_ne_bot_iff_nontrivial : supportDim R M ≠ ⊥ ↔ Nontrivial M := by
simp [supportDim, krullDim_eq_bot_iff, support_eq_empty_iff, not_subsingleton_iff_nontrivial] | lemma | RingTheory | [
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.Spectrum.Prime.Module"
] | Mathlib/RingTheory/KrullDimension/Module.lean | supportDim_ne_bot_iff_nontrivial | null |
supportDim_eq_ringKrullDim_quotient_annihilator [Module.Finite R M] :
supportDim R M = ringKrullDim (R ⧸ annihilator R M) := by
simp only [supportDim]
rw [support_eq_zeroLocus, ringKrullDim_quotient] | lemma | RingTheory | [
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.Spectrum.Prime.Module"
] | Mathlib/RingTheory/KrullDimension/Module.lean | supportDim_eq_ringKrullDim_quotient_annihilator | null |
supportDim_self_eq_ringKrullDim : supportDim R R = ringKrullDim R := by
have : annihilator R R = ⊥ :=
annihilator_eq_bot.mpr ((faithfulSMul_iff_algebraMap_injective R R).mpr fun {a₁ a₂} a ↦ a)
rw [supportDim_eq_ringKrullDim_quotient_annihilator, this]
exact (RingEquiv.ringKrullDim (RingEquiv.quotientBot R)) | lemma | RingTheory | [
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.Spectrum.Prime.Module"
] | Mathlib/RingTheory/KrullDimension/Module.lean | supportDim_self_eq_ringKrullDim | null |
supportDim_le_ringKrullDim : supportDim R M ≤ ringKrullDim R :=
krullDim_le_of_strictMono (fun a ↦ a) fun {_ _} lt ↦ lt
variable {R M N} | lemma | RingTheory | [
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.Spectrum.Prime.Module"
] | Mathlib/RingTheory/KrullDimension/Module.lean | supportDim_le_ringKrullDim | null |
supportDim_quotient_eq_ringKrullDim (I : Ideal R) :
supportDim R (R ⧸ I) = ringKrullDim (R ⧸ I) := by
rw [supportDim_eq_ringKrullDim_quotient_annihilator, Ideal.annihilator_quotient] | lemma | RingTheory | [
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.Spectrum.Prime.Module"
] | Mathlib/RingTheory/KrullDimension/Module.lean | supportDim_quotient_eq_ringKrullDim | null |
supportDim_le_of_injective (f : M →ₗ[R] N) (h : Function.Injective f) :
supportDim R M ≤ supportDim R N :=
krullDim_le_of_strictMono (fun a ↦ ⟨a.1, Module.support_subset_of_injective f h a.2⟩)
(fun {_ _} lt ↦ lt) | lemma | RingTheory | [
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.Spectrum.Prime.Module"
] | Mathlib/RingTheory/KrullDimension/Module.lean | supportDim_le_of_injective | null |
supportDim_le_of_surjective (f : M →ₗ[R] N) (h : Function.Surjective f) :
supportDim R N ≤ supportDim R M :=
krullDim_le_of_strictMono (fun a ↦ ⟨a.1, Module.support_subset_of_surjective f h a.2⟩)
(fun {_ _} lt ↦ lt) | lemma | RingTheory | [
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.Spectrum.Prime.Module"
] | Mathlib/RingTheory/KrullDimension/Module.lean | supportDim_le_of_surjective | null |
supportDim_eq_of_equiv (e : M ≃ₗ[R] N) :
supportDim R M = supportDim R N :=
le_antisymm (supportDim_le_of_injective e e.injective)
(supportDim_le_of_surjective e e.surjective) | lemma | RingTheory | [
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.Spectrum.Prime.Module"
] | Mathlib/RingTheory/KrullDimension/Module.lean | supportDim_eq_of_equiv | null |
support_of_supportDim_eq_zero [IsLocalRing R]
(dim : Module.supportDim R N = 0) :
Module.support R N = PrimeSpectrum.zeroLocus (maximalIdeal R) := by
let _ : Nontrivial N := by simp [← Module.supportDim_ne_bot_iff_nontrivial R, dim]
rw [PrimeSpectrum.zeroLocus_eq_singleton]
apply le_antisymm
· intro p hp
by_contra nmem
simp only [Set.mem_singleton_iff] at nmem
have : p < ⟨maximalIdeal R, IsMaximal.isPrime' (maximalIdeal R)⟩ :=
lt_of_le_of_ne (IsLocalRing.le_maximalIdeal IsPrime.ne_top') nmem
have : Module.supportDim R N > 0 := by
simp only [Module.supportDim, gt_iff_lt, Order.krullDim_pos_iff, Subtype.exists,
Subtype.mk_lt_mk, exists_prop]
use p
simpa [hp] using ⟨_, IsLocalRing.closedPoint_mem_support R N, this⟩
exact (ne_of_lt this) dim.symm
· simpa using IsLocalRing.closedPoint_mem_support R N | lemma | RingTheory | [
"Mathlib.RingTheory.KrullDimension.NonZeroDivisors",
"Mathlib.RingTheory.Spectrum.Prime.Module"
] | Mathlib/RingTheory/KrullDimension/Module.lean | support_of_supportDim_eq_zero | null |
ringKrullDim_quotient (I : Ideal R) :
ringKrullDim (R ⧸ I) = Order.krullDim (PrimeSpectrum.zeroLocus (R := R) I) := by
rw [ringKrullDim, Order.krullDim_eq_of_orderIso I.primeSpectrumQuotientOrderIsoZeroLocus] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization",
"Mathlib.RingTheory.KrullDimension.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.Spectrum.Prime.RingHom"
] | Mathlib/RingTheory/KrullDimension/NonZeroDivisors.lean | ringKrullDim_quotient | null |
ringKrullDim_quotient_succ_le_of_nonZeroDivisor
{r : R} (hr : r ∈ R⁰) :
ringKrullDim (R ⧸ Ideal.span {r}) + 1 ≤ ringKrullDim R := by
by_cases hr' : Ideal.span {r} = ⊤
· rw [hr', ringKrullDim_eq_bot_of_subsingleton]
simp
have : Nonempty (PrimeSpectrum.zeroLocus (R := R) (Ideal.span {r})) := by
rwa [Set.nonempty_coe_sort, Set.nonempty_iff_ne_empty, ne_eq,
PrimeSpectrum.zeroLocus_empty_iff_eq_top]
have := Ideal.Quotient.nontrivial hr'
have := (Ideal.Quotient.mk (Ideal.span {r})).domain_nontrivial
rw [ringKrullDim_quotient, Order.krullDim_eq_iSup_length, ringKrullDim,
Order.krullDim_eq_iSup_length, ← WithBot.coe_one, ← WithBot.coe_add,
ENat.iSup_add, WithBot.coe_le_coe, iSup_le_iff]
intro l
obtain ⟨p, hp, hp'⟩ := Ideal.exists_minimalPrimes_le (J := l.head.1.asIdeal) bot_le
let p' : PrimeSpectrum R := ⟨p, hp.1.1⟩
have hp' : p' < l.head := lt_of_le_of_ne hp' fun h ↦ Set.disjoint_iff.mp
(Ideal.disjoint_nonZeroDivisors_of_mem_minimalPrimes hp)
⟨show r ∈ p by simpa [← h] using l.head.2, hr⟩
refine le_trans ?_ (le_iSup _ ((l.map Subtype.val (fun _ _ ↦ id)).cons p' hp'))
simp | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization",
"Mathlib.RingTheory.KrullDimension.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.Spectrum.Prime.RingHom"
] | Mathlib/RingTheory/KrullDimension/NonZeroDivisors.lean | ringKrullDim_quotient_succ_le_of_nonZeroDivisor | null |
ringKrullDim_succ_le_of_surjective (f : R →+* S) (hf : Function.Surjective f)
{r : R} (hr : r ∈ R⁰) (hr' : f r = 0) : ringKrullDim S + 1 ≤ ringKrullDim R := by
refine le_trans ?_ (ringKrullDim_quotient_succ_le_of_nonZeroDivisor hr)
gcongr
exact ringKrullDim_le_of_surjective (Ideal.Quotient.lift _ f (RingHom.ker f
|>.span_singleton_le_iff_mem.mpr hr')) (Ideal.Quotient.lift_surjective_of_surjective _ _ hf)
open Polynomial in | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization",
"Mathlib.RingTheory.KrullDimension.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.Spectrum.Prime.RingHom"
] | Mathlib/RingTheory/KrullDimension/NonZeroDivisors.lean | ringKrullDim_succ_le_of_surjective | If `R →+* S` is surjective whose kernel contains a nonzero divisor, then `dim S + 1 ≤ dim R`. |
ringKrullDim_succ_le_ringKrullDim_polynomial :
ringKrullDim R + 1 ≤ ringKrullDim R[X] :=
ringKrullDim_succ_le_of_surjective constantCoeff (⟨C ·, coeff_C_zero⟩)
X_mem_nonzeroDivisors coeff_X_zero
open MvPolynomial in
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization",
"Mathlib.RingTheory.KrullDimension.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.Spectrum.Prime.RingHom"
] | Mathlib/RingTheory/KrullDimension/NonZeroDivisors.lean | ringKrullDim_succ_le_ringKrullDim_polynomial | null |
ringKrullDim_mvPolynomial_of_isEmpty (σ : Type*) [IsEmpty σ] :
ringKrullDim (MvPolynomial σ R) = ringKrullDim R :=
ringKrullDim_eq_of_ringEquiv (isEmptyRingEquiv _ _)
open MvPolynomial in | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization",
"Mathlib.RingTheory.KrullDimension.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.Spectrum.Prime.RingHom"
] | Mathlib/RingTheory/KrullDimension/NonZeroDivisors.lean | ringKrullDim_mvPolynomial_of_isEmpty | null |
ringKrullDim_add_natCard_le_ringKrullDim_mvPolynomial (σ : Type*) [Finite σ] :
ringKrullDim R + Nat.card σ ≤ ringKrullDim (MvPolynomial σ R) := by
induction σ using Finite.induction_empty_option with
| of_equiv e H =>
convert ← H using 1
· rw [Nat.card_congr e]
· exact ringKrullDim_eq_of_ringEquiv (renameEquiv _ e).toRingEquiv
| h_empty => simp
| h_option IH =>
simp only [Nat.card_eq_fintype_card, Fintype.card_option, Nat.cast_add, Nat.cast_one,
← add_assoc] at IH ⊢
refine (add_le_add_right IH _).trans (ringKrullDim_succ_le_ringKrullDim_polynomial.trans ?_)
exact (ringKrullDim_eq_of_ringEquiv (MvPolynomial.optionEquivLeft _ _).toRingEquiv).ge
open MvPolynomial in | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization",
"Mathlib.RingTheory.KrullDimension.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.Spectrum.Prime.RingHom"
] | Mathlib/RingTheory/KrullDimension/NonZeroDivisors.lean | ringKrullDim_add_natCard_le_ringKrullDim_mvPolynomial | null |
ringKrullDim_add_enatCard_le_ringKrullDim_mvPolynomial (σ : Type*) :
ringKrullDim R + ENat.card σ ≤ ringKrullDim (MvPolynomial σ R) := by
nontriviality R
cases finite_or_infinite σ
· rw [ENat.card_eq_coe_natCard]
push_cast
exact ringKrullDim_add_natCard_le_ringKrullDim_mvPolynomial _
· simp only [ENat.card_eq_top_of_infinite, WithBot.coe_top]
suffices ringKrullDim (MvPolynomial σ R) = ⊤ by simp_all
rw [WithBot.eq_top_iff_forall_ge]
intro n
let ι := Infinite.natEmbedding σ ∘ Fin.val (n := n + 1)
have := Function.invFun_surjective (f := ι) ((Infinite.natEmbedding σ).2.comp Fin.val_injective)
refine le_trans ?_ (ringKrullDim_le_of_surjective
(rename (R := R) _).toRingHom (rename_surjective _ this))
refine le_trans ?_ (ringKrullDim_add_natCard_le_ringKrullDim_mvPolynomial _)
simp only [ENat.some_eq_coe, Nat.card_eq_fintype_card, Fintype.card_fin, Nat.cast_add,
Nat.cast_one]
trans n + 1
· norm_cast
simp
· exact WithBot.le_add_self Order.bot_lt_krullDim.ne' _
open PowerSeries in | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization",
"Mathlib.RingTheory.KrullDimension.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.Spectrum.Prime.RingHom"
] | Mathlib/RingTheory/KrullDimension/NonZeroDivisors.lean | ringKrullDim_add_enatCard_le_ringKrullDim_mvPolynomial | null |
ringKrullDim_succ_le_ringKrullDim_powerseries :
ringKrullDim R + 1 ≤ ringKrullDim (PowerSeries R) :=
ringKrullDim_succ_le_of_surjective constantCoeff (⟨C ·, rfl⟩)
MvPowerSeries.X_mem_nonzeroDivisors constantCoeff_X | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.MinimalPrime.Localization",
"Mathlib.RingTheory.KrullDimension.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.Spectrum.Prime.RingHom"
] | Mathlib/RingTheory/KrullDimension/NonZeroDivisors.lean | ringKrullDim_succ_le_ringKrullDim_powerseries | null |
IsPrincipalIdealRing.krullDimLE_one (R : Type*) [CommRing R]
[IsPrincipalIdealRing R] : Ring.KrullDimLE 1 R := by
refine Ring.krullDimLE_one_iff.2 fun I hI ↦ or_iff_not_imp_left.2 fun hI' ↦ ?_
rw [minimalPrimes_eq_minimals, Set.notMem_setOf_iff, not_minimal_iff_exists_lt hI] at hI'
obtain ⟨P, hlt, hP⟩ := hI'
have := IsPrincipalIdealRing.of_surjective (Ideal.Quotient.mk P) Ideal.Quotient.mk_surjective
have : (I.map (Ideal.Quotient.mk P)).IsMaximal := by
have := Ideal.map_isPrime_of_surjective (f := Ideal.Quotient.mk P) Ideal.Quotient.mk_surjective
(I := I) (by simpa using hlt.le)
refine IsPrime.to_maximal_ideal ?_
rw [ne_eq, Ideal.map_eq_bot_iff_le_ker, Ideal.mk_ker]
exact hlt.not_ge
have := Ideal.comap_isMaximal_of_surjective (Ideal.Quotient.mk P) Ideal.Quotient.mk_surjective
(K := I.map (Ideal.Quotient.mk P))
simpa [Ideal.comap_map_of_surjective' (Ideal.Quotient.mk P) Ideal.Quotient.mk_surjective,
hlt.le] using this | instance | RingTheory | [
"Mathlib.RingTheory.Ideal.Height",
"Mathlib.RingTheory.KrullDimension.Zero",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/KrullDimension/PID.lean | IsPrincipalIdealRing.krullDimLE_one | null |
IsPrincipalIdealRing.ringKrullDim_eq_one (R : Type*) [CommRing R] [IsDomain R]
[IsPrincipalIdealRing R] (h : ¬ IsField R) : ringKrullDim R = 1 := by
apply eq_of_le_of_not_lt ?_ fun h' ↦ h ?_
· rw [← Nat.cast_one, ← Ring.krullDimLE_iff]
infer_instance
· have h'' : ringKrullDim R ≤ 0 := Order.le_of_lt_succ h'
rw [← Nat.cast_zero, ← Ring.krullDimLE_iff] at h''
exact Ring.KrullDimLE.isField_of_isDomain | theorem | RingTheory | [
"Mathlib.RingTheory.Ideal.Height",
"Mathlib.RingTheory.KrullDimension.Zero",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/KrullDimension/PID.lean | IsPrincipalIdealRing.ringKrullDim_eq_one | null |
IsPrincipalIdealRing.height_eq_one_of_isMaximal {R : Type*} [CommRing R] [IsDomain R]
[IsPrincipalIdealRing R] (m : Ideal R) [m.IsMaximal] (h : ¬ IsField R) :
m.height = 1 := by
refine le_antisymm ?_ ?_
· suffices h : (m.height : WithBot ℕ∞) ≤ 1 by norm_cast at h
rw [← IsPrincipalIdealRing.ringKrullDim_eq_one _ h]
exact Ideal.height_le_ringKrullDim_of_ne_top Ideal.IsPrime.ne_top'
· rw [Order.one_le_iff_pos, Ideal.height_eq_primeHeight, Ideal.primeHeight, Order.height_pos]
exact not_isMin_of_lt (b := ⊥) (Ideal.bot_lt_of_maximal m h) | lemma | RingTheory | [
"Mathlib.RingTheory.Ideal.Height",
"Mathlib.RingTheory.KrullDimension.Zero",
"Mathlib.RingTheory.PrincipalIdealDomain"
] | Mathlib/RingTheory/KrullDimension/PID.lean | IsPrincipalIdealRing.height_eq_one_of_isMaximal | In a PID that is not a field, every maximal ideal has height one. |
Polynomial.ringKrullDim_le {R : Type*} [CommRing R] :
ringKrullDim (Polynomial R) ≤ 2 * (ringKrullDim R) + 1 := by
rw [ringKrullDim, ringKrullDim]
apply Order.krullDim_le_of_krullDim_preimage_le' C.specComap ?_ (fun p ↦ ?_)
· exact fun {a b} h ↦ Ideal.comap_mono h
· rw [show C = (algebraMap R (Polynomial R)) from rfl, Order.krullDim_eq_of_orderIso
(PrimeSpectrum.preimageOrderIsoTensorResidueField R (Polynomial R) p), ← ringKrullDim,
← ringKrullDim_eq_of_ringEquiv (polyEquivTensor R (p.asIdeal.ResidueField)).toRingEquiv,
← Ring.krullDimLE_iff]
infer_instance | theorem | RingTheory | [
"Mathlib.Algebra.Polynomial.FieldDivision",
"Mathlib.RingTheory.KrullDimension.PID",
"Mathlib.RingTheory.LocalRing.ResidueField.Fiber"
] | Mathlib/RingTheory/KrullDimension/Polynomial.lean | Polynomial.ringKrullDim_le | null |
Ring.KrullDimLE.mem_minimalPrimes_iff {I J : Ideal R} :
I ∈ J.minimalPrimes ↔ I.IsPrime ∧ J ≤ I :=
⟨fun H ↦ H.1, fun H ↦ ⟨H, fun _ h e ↦ (h.1.isMaximal'.eq_of_le H.1.ne_top e).ge⟩⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ring",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/KrullDimension/Zero.lean | Ring.KrullDimLE.mem_minimalPrimes_iff | null |
Ring.KrullDimLE.mem_minimalPrimes_iff_le_of_isPrime {I J : Ideal R} [I.IsPrime] :
I ∈ J.minimalPrimes ↔ J ≤ I := by
rwa [mem_minimalPrimes_iff, and_iff_right]
variable (R) in | lemma | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ring",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/KrullDimension/Zero.lean | Ring.KrullDimLE.mem_minimalPrimes_iff_le_of_isPrime | null |
Ring.KrullDimLE.minimalPrimes_eq_setOf_isPrime :
minimalPrimes R = { I | I.IsPrime } := by
ext; simp [minimalPrimes, mem_minimalPrimes_iff]
variable (R) in | lemma | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ring",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/KrullDimension/Zero.lean | Ring.KrullDimLE.minimalPrimes_eq_setOf_isPrime | null |
Ring.KrullDimLE.minimalPrimes_eq_setOf_isMaximal :
minimalPrimes R = { I | I.IsMaximal } := by
ext; simp [minimalPrimes_eq_setOf_isPrime, Ideal.isMaximal_iff_isPrime] | lemma | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ring",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/KrullDimension/Zero.lean | Ring.KrullDimLE.minimalPrimes_eq_setOf_isMaximal | null |
Ring.KrullDimLE.isField_of_isDomain [IsDomain R] : IsField R := by
by_contra h
obtain ⟨p, hp, h⟩ := Ring.not_isField_iff_exists_prime.mp h
exact hp.symm (Ideal.bot_prime.isMaximal'.eq_of_le h.ne_top bot_le)
omit [Ring.KrullDimLE 0 R] in | lemma | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ring",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/KrullDimension/Zero.lean | Ring.KrullDimLE.isField_of_isDomain | null |
ringKrullDimZero_iff_ringKrullDim_eq_zero [Nontrivial R] :
Ring.KrullDimLE 0 R ↔ ringKrullDim R = 0 := by
rw [Ring.KrullDimLE, Order.krullDimLE_iff, le_antisymm_iff, ← ringKrullDim, Nat.cast_zero,
iff_self_and]
exact fun _ ↦ ringKrullDim_nonneg_of_nontrivial | lemma | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ring",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/KrullDimension/Zero.lean | ringKrullDimZero_iff_ringKrullDim_eq_zero | null |
Ring.krullDimLE_zero_and_isLocalRing_tfae :
List.TFAE
[ Ring.KrullDimLE 0 R ∧ IsLocalRing R,
∃! I : Ideal R, I.IsPrime,
∀ x : R, IsNilpotent x ↔ ¬ IsUnit x,
(nilradical R).IsMaximal ] := by
tfae_have 1 → 3 := by
intro ⟨h₁, h₂⟩ x
change x ∈ nilradical R ↔ x ∈ IsLocalRing.maximalIdeal R
rw [nilradical, Ideal.radical_eq_sInf]
simp [← Ideal.isMaximal_iff_isPrime, IsLocalRing.isMaximal_iff]
tfae_have 3 → 4 := by
refine fun H ↦ ⟨fun e ↦ ?_, fun I hI ↦ ?_⟩
· obtain ⟨n, hn⟩ := (Ideal.eq_top_iff_one _).mp e
exact (H 0).mp .zero ((show (1 : R) = 0 by simpa using hn) ▸ isUnit_one)
· obtain ⟨x, hx, hx'⟩ := (SetLike.lt_iff_le_and_exists.mp hI).2
exact Ideal.eq_top_of_isUnit_mem _ hx (not_not.mp ((H x).not.mp hx'))
tfae_have 4 → 2 := fun H ↦ ⟨_, H.isPrime, fun p (hp : p.IsPrime) ↦
(H.eq_of_le hp.ne_top (nilradical_le_prime p)).symm⟩
tfae_have 2 → 1 := by
rintro ⟨P, hP₁, hP₂⟩
obtain ⟨P, hP₃, -⟩ := P.exists_le_maximal hP₁.ne_top
obtain rfl := hP₂ P hP₃.isPrime
exact ⟨.mk₀ fun Q h ↦ hP₂ Q h ▸ hP₃, .of_unique_max_ideal ⟨P, hP₃, fun Q h ↦ hP₂ Q h.isPrime⟩⟩
tfae_finish
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ring",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/KrullDimension/Zero.lean | Ring.krullDimLE_zero_and_isLocalRing_tfae | null |
le_isUnit_iff_zero_notMem [IsLocalRing R]
{M : Submonoid R} : M ≤ IsUnit.submonoid R ↔ 0 ∉ M := by
have := ((Ring.krullDimLE_zero_and_isLocalRing_tfae R).out 0 2 rfl rfl).mp ⟨‹_›, ‹_›⟩
exact ⟨fun h₁ h₂ ↦ not_isUnit_zero (h₁ h₂),
fun H x hx ↦ (this x).not_left.mp fun ⟨n, hn⟩ ↦ H (hn ▸ pow_mem hx n)⟩
@[deprecated (since := "2025-05-23")] alias le_isUnit_iff_zero_not_mem := le_isUnit_iff_zero_notMem
variable (R) in | lemma | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ring",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/KrullDimension/Zero.lean | le_isUnit_iff_zero_notMem | null |
Ring.KrullDimLE.existsUnique_isPrime [IsLocalRing R] :
∃! I : Ideal R, I.IsPrime :=
((Ring.krullDimLE_zero_and_isLocalRing_tfae R).out 0 1 rfl rfl).mp ⟨‹_›, ‹_›⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ring",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/KrullDimension/Zero.lean | Ring.KrullDimLE.existsUnique_isPrime | null |
Ring.KrullDimLE.eq_maximalIdeal_of_isPrime [IsLocalRing R] (J : Ideal R) [J.IsPrime] :
J = IsLocalRing.maximalIdeal R :=
(((Ring.krullDimLE_zero_and_isLocalRing_tfae R).out 0 1 rfl rfl).mp ⟨‹_›, ‹_›⟩).unique
‹_› inferInstance | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ring",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/KrullDimension/Zero.lean | Ring.KrullDimLE.eq_maximalIdeal_of_isPrime | null |
Ring.KrullDimLE.radical_eq_maximalIdeal [IsLocalRing R] (I : Ideal R) (hI : I ≠ ⊤) :
I.radical = IsLocalRing.maximalIdeal R := by
rw [Ideal.radical_eq_sInf]
refine (sInf_le ?_).antisymm (le_sInf ?_)
· exact ⟨IsLocalRing.le_maximalIdeal hI, inferInstance⟩
· rintro J ⟨h₁, h₂⟩
exact (Ring.KrullDimLE.eq_maximalIdeal_of_isPrime J).ge
variable (R) in | lemma | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ring",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/KrullDimension/Zero.lean | Ring.KrullDimLE.radical_eq_maximalIdeal | null |
Ring.KrullDimLE.subsingleton_primeSpectrum [IsLocalRing R] :
Subsingleton (PrimeSpectrum R) :=
⟨fun x y ↦ PrimeSpectrum.ext <|
(eq_maximalIdeal_of_isPrime x.1).trans (eq_maximalIdeal_of_isPrime y.1).symm⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ring",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/KrullDimension/Zero.lean | Ring.KrullDimLE.subsingleton_primeSpectrum | null |
Ring.KrullDimLE.isNilpotent_iff_mem_maximalIdeal [IsLocalRing R] {x} :
IsNilpotent x ↔ x ∈ IsLocalRing.maximalIdeal R :=
((Ring.krullDimLE_zero_and_isLocalRing_tfae R).out 0 2 rfl rfl).mp ⟨‹_›, ‹_›⟩ x | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ring",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/KrullDimension/Zero.lean | Ring.KrullDimLE.isNilpotent_iff_mem_maximalIdeal | null |
Ring.KrullDimLE.isNilpotent_iff_mem_nonunits [IsLocalRing R] {x} :
IsNilpotent x ↔ x ∈ nonunits R :=
isNilpotent_iff_mem_maximalIdeal
variable (R) in | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ring",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/KrullDimension/Zero.lean | Ring.KrullDimLE.isNilpotent_iff_mem_nonunits | null |
Ring.KrullDimLE.nilradical_eq_maximalIdeal [IsLocalRing R] :
nilradical R = IsLocalRing.maximalIdeal R :=
Ideal.ext fun _ ↦ isNilpotent_iff_mem_maximalIdeal
omit [Ring.KrullDimLE 0 R] in
variable (R) in | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ring",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/KrullDimension/Zero.lean | Ring.KrullDimLE.nilradical_eq_maximalIdeal | null |
IsLocalRing.of_isMaximal_nilradical [(nilradical R).IsMaximal] :
IsLocalRing R :=
(((Ring.krullDimLE_zero_and_isLocalRing_tfae R).out 3 0 rfl rfl).mp ‹_›).2
omit [Ring.KrullDimLE 0 R] in
variable (R) in | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ring",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/KrullDimension/Zero.lean | IsLocalRing.of_isMaximal_nilradical | null |
Ring.KrullDimLE.of_isMaximal_nilradical [(nilradical R).IsMaximal] :
Ring.KrullDimLE 0 R :=
(((Ring.krullDimLE_zero_and_isLocalRing_tfae R).out 3 0 rfl rfl).mp ‹_›).1
omit [Ring.KrullDimLE 0 R] in | theorem | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ring",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/KrullDimension/Zero.lean | Ring.KrullDimLE.of_isMaximal_nilradical | null |
Ring.KrullDimLE.of_isLocalization (p : Ideal R) (hp : p ∈ minimalPrimes R)
(S : Type*) [CommSemiring S] [Algebra R S] [IsLocalization.AtPrime S p (hp := hp.1.1)] :
Ring.KrullDimLE 0 S :=
have := IsLocalization.subsingleton_primeSpectrum_of_mem_minimalPrimes p hp S
⟨Order.krullDim_nonpos_of_subsingleton⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ring",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/KrullDimension/Zero.lean | Ring.KrullDimLE.of_isLocalization | null |
Ring.KrullDimLE.isField_of_isReduced [IsReduced R] [IsLocalRing R] : IsField R := by
rw [IsLocalRing.isField_iff_maximalIdeal_eq, ← nilradical_eq_maximalIdeal,
nilradical_eq_zero, Ideal.zero_eq_bot] | lemma | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ring",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/KrullDimension/Zero.lean | Ring.KrullDimLE.isField_of_isReduced | null |
PrimeSpectrum.unique_of_ringKrullDimLE_zero [IsLocalRing R] : Unique (PrimeSpectrum R) :=
⟨⟨IsLocalRing.closedPoint _⟩,
fun _ ↦ PrimeSpectrum.ext (Ring.KrullDimLE.eq_maximalIdeal_of_isPrime _)⟩ | instance | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ring",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/KrullDimension/Zero.lean | PrimeSpectrum.unique_of_ringKrullDimLE_zero | null |
Ideal.jacobson_eq_radical [Ring.KrullDimLE 0 R] : I.jacobson = I.radical := by
simp [jacobson, radical_eq_sInf, Ideal.isMaximal_iff_isPrime] | lemma | RingTheory | [
"Mathlib.RingTheory.Jacobson.Ring",
"Mathlib.RingTheory.Spectrum.Prime.Topology"
] | Mathlib/RingTheory/KrullDimension/Zero.lean | Ideal.jacobson_eq_radical | null |
noncomputable RingHom.toKerIsLocalization (hy : M ≤ Submonoid.comap g T) :
RingHom.ker g →ₗ[R] RingHom.ker (IsLocalization.map Q g hy : S →+* Q) where
toFun x := ⟨algebraMap R S x, by simp [RingHom.mem_ker, RingHom.mem_ker.mp x.property]⟩
map_add' x y := by
simp only [Submodule.coe_add, map_add, AddMemClass.mk_add_mk]
map_smul' a x := by
simp only [SetLike.val_smul, smul_eq_mul, map_mul, id_apply, SetLike.mk_smul_of_tower_mk,
Algebra.smul_def]
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.PolynomialAlgebra"
] | Mathlib/RingTheory/Localization/Algebra.lean | RingHom.toKerIsLocalization | The span of `I` in a localization of `R` at `M` is the localization of `I` at `M`. -/
-- TODO: golf using `Ideal.localized'_eq_map`
instance Algebra.idealMap_isLocalizedModule (I : Ideal R) :
IsLocalizedModule M (Algebra.idealMap I (S := S)) where
map_units x :=
(Module.End.isUnit_iff _).mpr ⟨fun a b e ↦ Subtype.ext ((map_units S x).mul_right_injective
(by simpa [Algebra.smul_def] using congr(($e).1))),
fun a ↦ ⟨⟨_, Ideal.mul_mem_left _ (map_units S x).unit⁻¹.1 a.2⟩,
Subtype.ext (by simp [Algebra.smul_def, ← mul_assoc])⟩⟩
surj y :=
have ⟨x, hx⟩ := (mem_map_algebraMap_iff M S).mp y.property
⟨x, Subtype.ext (by simp [Submonoid.smul_def, Algebra.smul_def, mul_comm, hx])⟩
exists_of_eq h := ⟨_, Subtype.ext (exists_of_eq congr(($h).1)).choose_spec⟩
lemma IsLocalization.ker_map (hT : Submonoid.map g M = T) :
RingHom.ker (IsLocalization.map Q g (hT.symm ▸ M.le_comap_map) : S →+* Q) =
(RingHom.ker g).map (algebraMap R S) := by
ext x
obtain ⟨x, s, rfl⟩ := IsLocalization.mk'_surjective M x
simp [RingHom.mem_ker, IsLocalization.map_mk', IsLocalization.mk'_eq_zero_iff,
IsLocalization.mk'_mem_map_algebraMap_iff, ← hT]
variable (S) in
/-- The canonical linear map from the kernel of `g` to the kernel of its localization. |
RingHom.toKerIsLocalization_apply (hy : M ≤ Submonoid.comap g T) (r : RingHom.ker g) :
(RingHom.toKerIsLocalization S Q g hy r).val = algebraMap R S r :=
rfl | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.PolynomialAlgebra"
] | Mathlib/RingTheory/Localization/Algebra.lean | RingHom.toKerIsLocalization_apply | null |
RingHom.toKerIsLocalization_isLocalizedModule (hT : Submonoid.map g M = T) :
IsLocalizedModule M (toKerIsLocalization S Q g (hT.symm ▸ Submonoid.le_comap_map M)) := by
let e := LinearEquiv.ofEq _ _ (IsLocalization.ker_map (S := S) Q g hT).symm
convert_to IsLocalizedModule M ((e.restrictScalars R).toLinearMap ∘ₗ
Algebra.idealMap S (RingHom.ker g))
apply IsLocalizedModule.of_linearEquiv | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.PolynomialAlgebra"
] | Mathlib/RingTheory/Localization/Algebra.lean | RingHom.toKerIsLocalization_isLocalizedModule | The canonical linear map from the kernel of `g` to the kernel of its localization
is localizing. In other words, localization commutes with taking kernels. |
isLocalization_algebraMapSubmonoid_map_algHom (f : A →ₐ[R] B) :
IsLocalization ((algebraMapSubmonoid A M).map f.toRingHom) Bₚ := by
rw [AlgHom.toRingHom_eq_coe, ← Submonoid.map_coe_toMonoidHom, AlgHom.toRingHom_toMonoidHom,
Submonoid.map_coe_toMonoidHom, algebraMapSubmonoid_map_eq M f]
infer_instance | instance | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.PolynomialAlgebra"
] | Mathlib/RingTheory/Localization/Algebra.lean | isLocalization_algebraMapSubmonoid_map_algHom | null |
noncomputable mapₐ (f : A →ₐ[R] B) : Aₚ →ₐ[Rₚ] Bₚ :=
⟨IsLocalization.map Bₚ f.toRingHom (Algebra.algebraMapSubmonoid_le_comap M f), fun r ↦ by
obtain ⟨a, m, rfl⟩ := IsLocalization.mk'_surjective M r
simp [algebraMap_mk' (S := A), algebraMap_mk' (S := B), map_mk']⟩
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.PolynomialAlgebra"
] | Mathlib/RingTheory/Localization/Algebra.lean | mapₐ | An algebra map `A →ₐ[R] B` induces an algebra map on localizations `Aₚ →ₐ[Rₚ] Bₚ`. |
mapₐ_coe (f : A →ₐ[R] B) :
(mapₐ M Rₚ Aₚ Bₚ f : Aₚ → Bₚ) = map Bₚ f.toRingHom (algebraMapSubmonoid_le_comap M f) :=
rfl | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.PolynomialAlgebra"
] | Mathlib/RingTheory/Localization/Algebra.lean | mapₐ_coe | null |
mapₐ_injective_of_injective (f : A →ₐ[R] B) (hf : Function.Injective f) :
Function.Injective (mapₐ M Rₚ Aₚ Bₚ f) :=
IsLocalization.map_injective_of_injective _ _ _ hf | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.PolynomialAlgebra"
] | Mathlib/RingTheory/Localization/Algebra.lean | mapₐ_injective_of_injective | null |
mapₐ_surjective_of_surjective (f : A →ₐ[R] B) (hf : Function.Surjective f) :
Function.Surjective (mapₐ M Rₚ Aₚ Bₚ f) :=
IsLocalization.map_surjective_of_surjective _ _ _ hf | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.PolynomialAlgebra"
] | Mathlib/RingTheory/Localization/Algebra.lean | mapₐ_surjective_of_surjective | null |
noncomputable AlgHom.toKerIsLocalization (f : A →ₐ[R] B) :
RingHom.ker f →ₗ[A] RingHom.ker (mapₐ M Rₚ Aₚ Bₚ f) :=
RingHom.toKerIsLocalization Aₚ Bₚ f.toRingHom (algebraMapSubmonoid_le_comap M f)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.PolynomialAlgebra"
] | Mathlib/RingTheory/Localization/Algebra.lean | AlgHom.toKerIsLocalization | The canonical linear map from the kernel of an algebra homomorphism to its localization. |
AlgHom.toKerIsLocalization_apply (f : A →ₐ[R] B) (x : RingHom.ker f) :
AlgHom.toKerIsLocalization M Rₚ Aₚ Bₚ f x =
RingHom.toKerIsLocalization Aₚ Bₚ f.toRingHom (algebraMapSubmonoid_le_comap M f) x :=
rfl | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.PolynomialAlgebra"
] | Mathlib/RingTheory/Localization/Algebra.lean | AlgHom.toKerIsLocalization_apply | null |
AlgHom.toKerIsLocalization_isLocalizedModule (f : A →ₐ[R] B) :
IsLocalizedModule (Algebra.algebraMapSubmonoid A M)
(AlgHom.toKerIsLocalization M Rₚ Aₚ Bₚ f) :=
RingHom.toKerIsLocalization_isLocalizedModule Bₚ f.toRingHom
(algebraMapSubmonoid_map_eq M f) | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.PolynomialAlgebra"
] | Mathlib/RingTheory/Localization/Algebra.lean | AlgHom.toKerIsLocalization_isLocalizedModule | The canonical linear map from the kernel of an algebra homomorphism to its localization
is localizing. |
isLocalization {R} [CommSemiring R] (S : Submonoid R) (A) [CommSemiring A] [Algebra R A]
[IsLocalization S A] : letI := (mapRingHom (algebraMap R A)).toAlgebra
IsLocalization (S.map C) A[X] :=
letI := (mapRingHom (algebraMap R A)).toAlgebra
have : IsScalarTower R R[X] A[X] := .of_algebraMap_eq fun _ ↦ (map_C _).symm
isLocalizedModule_iff_isLocalization.mp <| (isLocalizedModule_iff_isBaseChange S A _).mpr <|
.of_equiv (polyEquivTensor' R A).symm.toLinearEquiv fun _ ↦ by simp | lemma | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.IsLocalization",
"Mathlib.RingTheory.Ideal.Maps",
"Mathlib.RingTheory.Localization.BaseChange",
"Mathlib.RingTheory.Localization.Basic",
"Mathlib.RingTheory.Localization.Ideal",
"Mathlib.RingTheory.PolynomialAlgebra"
] | Mathlib/RingTheory/Localization/Algebra.lean | isLocalization | If `A` is the localization of `R` at a submonoid `S`, then `A[X]` is the localization of
`R[X]` at `S.map Polynomial.C`.
See also `MvPolynomial.isLocalization` for the multivariate case. |
map_isUnit_of_le (hS : S ≤ A⁰) (s : S) : IsUnit (algebraMap A K s) := by
apply IsLocalization.map_units K (⟨s.1, hS s.2⟩ : A⁰) | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.LinearAlgebra.FreeModule.Basic",
"Mathlib.Algebra.Algebra.Subalgebra.Tower"
] | Mathlib/RingTheory/Localization/AsSubring.lean | map_isUnit_of_le | null |
noncomputable mapToFractionRing (B : Type*) [CommRing B] [Algebra A B] [IsLocalization S B]
(hS : S ≤ A⁰) : B →ₐ[A] K :=
{ IsLocalization.lift (map_isUnit_of_le K S hS) with commutes' := fun a => by simp }
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.LinearAlgebra.FreeModule.Basic",
"Mathlib.Algebra.Algebra.Subalgebra.Tower"
] | Mathlib/RingTheory/Localization/AsSubring.lean | mapToFractionRing | The canonical map from a localization of `A` at `S` to the fraction ring
of `A`, given that `S ≤ A⁰`. |
mapToFractionRing_apply {B : Type*} [CommRing B] [Algebra A B] [IsLocalization S B]
(hS : S ≤ A⁰) (b : B) :
mapToFractionRing K S B hS b = IsLocalization.lift (map_isUnit_of_le K S hS) b :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.LinearAlgebra.FreeModule.Basic",
"Mathlib.Algebra.Algebra.Subalgebra.Tower"
] | Mathlib/RingTheory/Localization/AsSubring.lean | mapToFractionRing_apply | null |
mem_range_mapToFractionRing_iff (B : Type*) [CommRing B] [Algebra A B] [IsLocalization S B]
(hS : S ≤ A⁰) (x : K) :
x ∈ (mapToFractionRing K S B hS).range ↔
∃ (a s : A) (hs : s ∈ S), x = IsLocalization.mk' K a ⟨s, hS hs⟩ :=
⟨by
rintro ⟨x, rfl⟩
obtain ⟨a, s, rfl⟩ := IsLocalization.mk'_surjective S x
use a, s, s.2
apply IsLocalization.lift_mk', by
rintro ⟨a, s, hs, rfl⟩
use IsLocalization.mk' _ a ⟨s, hs⟩
apply IsLocalization.lift_mk'⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.LinearAlgebra.FreeModule.Basic",
"Mathlib.Algebra.Algebra.Subalgebra.Tower"
] | Mathlib/RingTheory/Localization/AsSubring.lean | mem_range_mapToFractionRing_iff | null |
isLocalization_range_mapToFractionRing (B : Type*) [CommRing B] [Algebra A B]
[IsLocalization S B] (hS : S ≤ A⁰) : IsLocalization S (mapToFractionRing K S B hS).range :=
IsLocalization.isLocalization_of_algEquiv S <|
show B ≃ₐ[A] _ from AlgEquiv.ofBijective (mapToFractionRing K S B hS).rangeRestrict (by
refine ⟨fun a b h => ?_, Set.rangeFactorization_surjective⟩
refine (IsLocalization.lift_injective_iff _).2 (fun a b => ?_) (Subtype.ext_iff.1 h)
exact ⟨fun h => congr_arg _ (IsLocalization.injective _ hS h),
fun h => congr_arg _ (IsFractionRing.injective A K h)⟩) | instance | RingTheory | [
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.LinearAlgebra.FreeModule.Basic",
"Mathlib.Algebra.Algebra.Subalgebra.Tower"
] | Mathlib/RingTheory/Localization/AsSubring.lean | isLocalization_range_mapToFractionRing | null |
isFractionRing_range_mapToFractionRing (B : Type*) [CommRing B] [Algebra A B]
[IsLocalization S B] (hS : S ≤ A⁰) : IsFractionRing (mapToFractionRing K S B hS).range K :=
IsFractionRing.isFractionRing_of_isLocalization S _ _ hS | instance | RingTheory | [
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.LinearAlgebra.FreeModule.Basic",
"Mathlib.Algebra.Algebra.Subalgebra.Tower"
] | Mathlib/RingTheory/Localization/AsSubring.lean | isFractionRing_range_mapToFractionRing | null |
noncomputable subalgebra (hS : S ≤ A⁰) : Subalgebra A K :=
(mapToFractionRing K S (Localization S) hS).range.copy
{ x | ∃ (a s : A) (hs : s ∈ S), x = IsLocalization.mk' K a ⟨s, hS hs⟩ } <| by
ext
symm
apply mem_range_mapToFractionRing_iff | def | RingTheory | [
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.LinearAlgebra.FreeModule.Basic",
"Mathlib.Algebra.Algebra.Subalgebra.Tower"
] | Mathlib/RingTheory/Localization/AsSubring.lean | subalgebra | Given a commutative ring `A` with fraction ring `K`, and a submonoid `S` of `A` which
contains no zero divisor, this is the localization of `A` at `S`, considered as
a subalgebra of `K` over `A`.
The carrier of this subalgebra is defined as the set of all `x : K` of the form
`IsLocalization.mk' K a ⟨s, _⟩`, where `s ∈ S`. |
isLocalization_subalgebra : IsLocalization S (subalgebra K S hS) := by
dsimp only [Localization.subalgebra]
rw [Subalgebra.copy_eq]
infer_instance | instance | RingTheory | [
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.LinearAlgebra.FreeModule.Basic",
"Mathlib.Algebra.Algebra.Subalgebra.Tower"
] | Mathlib/RingTheory/Localization/AsSubring.lean | isLocalization_subalgebra | null |
isFractionRing : IsFractionRing (subalgebra K S hS) K :=
IsFractionRing.isFractionRing_of_isLocalization S _ _ hS | instance | RingTheory | [
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.LinearAlgebra.FreeModule.Basic",
"Mathlib.Algebra.Algebra.Subalgebra.Tower"
] | Mathlib/RingTheory/Localization/AsSubring.lean | isFractionRing | null |
mem_range_mapToFractionRing_iff_ofField (B : Type*) [CommRing B] [Algebra A B]
[IsLocalization S B] (x : K) :
x ∈ (mapToFractionRing K S B hS).range ↔
∃ (a s : A) (_ : s ∈ S), x = algebraMap A K a * (algebraMap A K s)⁻¹ := by
rw [mem_range_mapToFractionRing_iff]
convert Iff.rfl
congr
rw [Units.val_inv_eq_inv_val]
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.LinearAlgebra.FreeModule.Basic",
"Mathlib.Algebra.Algebra.Subalgebra.Tower"
] | Mathlib/RingTheory/Localization/AsSubring.lean | mem_range_mapToFractionRing_iff_ofField | null |
noncomputable ofField : Subalgebra A K :=
(mapToFractionRing K S (Localization S) hS).range.copy
{ x | ∃ (a s : A) (_ : s ∈ S), x = algebraMap A K a * (algebraMap A K s)⁻¹ } <| by
ext
symm
apply mem_range_mapToFractionRing_iff_ofField | def | RingTheory | [
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.LinearAlgebra.FreeModule.Basic",
"Mathlib.Algebra.Algebra.Subalgebra.Tower"
] | Mathlib/RingTheory/Localization/AsSubring.lean | ofField | Given a domain `A` with fraction field `K`, and a submonoid `S` of `A` which
contains no zero divisor, this is the localization of `A` at `S`, considered as
a subalgebra of `K` over `A`.
The carrier of this subalgebra is defined as the set of all `x : K` of the form
`algebraMap A K a * (algebraMap A K s)⁻¹` where `a s : A` and `s ∈ S`. |
ofField_eq : ofField K S hS = subalgebra K S hS := by
simp_rw [ofField, subalgebra, Subalgebra.copy_eq] | theorem | RingTheory | [
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.LinearAlgebra.FreeModule.Basic",
"Mathlib.Algebra.Algebra.Subalgebra.Tower"
] | Mathlib/RingTheory/Localization/AsSubring.lean | ofField_eq | null |
isLocalization_ofField : IsLocalization S (ofField K S hS) := by
rw [ofField_eq]
exact isLocalization_subalgebra K S hS | instance | RingTheory | [
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.LinearAlgebra.FreeModule.Basic",
"Mathlib.Algebra.Algebra.Subalgebra.Tower"
] | Mathlib/RingTheory/Localization/AsSubring.lean | isLocalization_ofField | null |
isFractionRing_ofField : IsFractionRing (ofField K S hS) K :=
inferInstance | instance | RingTheory | [
"Mathlib.RingTheory.Localization.LocalizationLocalization",
"Mathlib.LinearAlgebra.FreeModule.Basic",
"Mathlib.Algebra.Algebra.Subalgebra.Tower"
] | Mathlib/RingTheory/Localization/AsSubring.lean | isFractionRing_ofField | null |
IsLocalizedModule.isBaseChange [IsLocalizedModule S f] : IsBaseChange A f :=
.of_lift_unique _ fun Q _ _ _ _ g ↦ by
obtain ⟨ℓ, rfl, h₂⟩ := IsLocalizedModule.is_universal S f g fun s ↦ by
rw [← (Algebra.lsmul R (A := A) R Q).commutes]; exact (IsLocalization.map_units A s).map _
refine ⟨ℓ.extendScalarsOfIsLocalization S A, by simp, fun g'' h ↦ ?_⟩
cases h₂ (LinearMap.restrictScalars R g'') h; rfl | theorem | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | IsLocalizedModule.isBaseChange | The forward direction of `isLocalizedModule_iff_isBaseChange`. It is also used to prove the
other direction. |
isLocalizedModule_iff_isBaseChange : IsLocalizedModule S f ↔ IsBaseChange A f := by
refine ⟨fun _ ↦ IsLocalizedModule.isBaseChange S A f, fun h ↦ ?_⟩
have : IsBaseChange A (LocalizedModule.mkLinearMap S M) := IsLocalizedModule.isBaseChange S A _
let e := (this.equiv.symm.trans h.equiv).restrictScalars R
convert IsLocalizedModule.of_linearEquiv S (LocalizedModule.mkLinearMap S M) e
ext
rw [LinearMap.coe_comp, LinearEquiv.coe_coe, Function.comp_apply,
LinearEquiv.restrictScalars_apply, LinearEquiv.trans_apply, IsBaseChange.equiv_symm_apply,
IsBaseChange.equiv_tmul, one_smul]
open TensorProduct
variable (M) in | theorem | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | isLocalizedModule_iff_isBaseChange | The map `(f : M →ₗ[R] M')` is a localization of modules iff the map
`(Localization S) × M → N, (s, m) ↦ s • f m` is the tensor product (insomuch as it is the universal
bilinear map).
In particular, there is an isomorphism between `LocalizedModule S M` and `(Localization S) ⊗[R] M`
given by `m/s ↦ (1/s) ⊗ₜ m`. |
noncomputable LocalizedModule.equivTensorProduct :
LocalizedModule S M ≃ₗ[Localization S] Localization S ⊗[R] M :=
IsLocalizedModule.isBaseChange S (Localization S)
(LocalizedModule.mkLinearMap S M) |>.equiv.symm
@[simp] | def | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | LocalizedModule.equivTensorProduct | The localization of an `R`-module `M` at a submonoid `S` is isomorphic to `S⁻¹R ⊗[R] M` as
an `S⁻¹R`-module. |
LocalizedModule.equivTensorProduct_symm_apply_tmul (x : M) (r : R) (s : S) :
(equivTensorProduct S M).symm (Localization.mk r s ⊗ₜ[R] x) = r • mk x s := by
simp [equivTensorProduct, IsBaseChange.equiv_tmul, mk_smul_mk, smul'_mk]
@[simp] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | LocalizedModule.equivTensorProduct_symm_apply_tmul | null |
LocalizedModule.equivTensorProduct_symm_apply_tmul_one (x : M) :
(equivTensorProduct S M).symm (1 ⊗ₜ[R] x) = mk x 1 := by
simp [← Localization.mk_one]
@[simp] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | LocalizedModule.equivTensorProduct_symm_apply_tmul_one | null |
LocalizedModule.equivTensorProduct_apply_mk (x : M) (s : S) :
equivTensorProduct S M (mk x s) = Localization.mk 1 s ⊗ₜ[R] x := by
apply (equivTensorProduct S M).symm.injective
simp | lemma | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | LocalizedModule.equivTensorProduct_apply_mk | null |
tensorProduct_isLocalizedModule : IsLocalizedModule S (TensorProduct.mk R A M 1) :=
(isLocalizedModule_iff_isBaseChange _ A _).mpr (TensorProduct.isBaseChange _ _ _)
variable (M₁ M₂ B C) [AddCommMonoid M₁] [AddCommMonoid M₂] [Module R M₁] [Module R M₂]
[Module A M₁] [Module A M₂] [IsScalarTower R A M₁] [IsScalarTower R A M₂]
[Semiring B] [Algebra R B] [Algebra A B] [IsScalarTower R A B]
[Semiring C] [Algebra R C] [Algebra A C] [IsScalarTower R A C]
include S | instance | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | tensorProduct_isLocalizedModule | null |
tensorProduct_compatibleSMul : CompatibleSMul R A M₁ M₂ where
smul_tmul a _ _ := by
obtain ⟨r, s, rfl⟩ := mk'_surjective S a
rw [← (map_units A s).smul_left_cancel]
simp_rw [algebraMap_smul, smul_tmul', ← smul_assoc, smul_tmul, ← smul_assoc, smul_mk'_self,
algebraMap_smul, smul_tmul] | theorem | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | tensorProduct_compatibleSMul | null |
noncomputable moduleTensorEquiv : M₁ ⊗[A] M₂ ≃ₗ[A] M₁ ⊗[R] M₂ :=
have := tensorProduct_compatibleSMul S A M₁ M₂
equivOfCompatibleSMul R A M₁ M₂ | def | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | moduleTensorEquiv | If `A` is a localization of `R`, tensoring two `A`-modules over `A` is the same as
tensoring them over `R`. |
noncomputable moduleLid : A ⊗[R] M₁ ≃ₗ[A] M₁ :=
have := tensorProduct_compatibleSMul S A A M₁
(equivOfCompatibleSMul R A A M₁).symm ≪≫ₗ TensorProduct.lid _ _ | def | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | moduleLid | If `A` is a localization of `R`, tensoring an `A`-module with `A` over `R` does nothing. |
noncomputable algebraTensorEquiv : B ⊗[A] C ≃ₐ[A] B ⊗[R] C :=
have := tensorProduct_compatibleSMul S A B C
Algebra.TensorProduct.equivOfCompatibleSMul R A B C | def | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | algebraTensorEquiv | If `A` is a localization of `R`, tensoring two `A`-algebras over `A` is the same as
tensoring them over `R`. |
noncomputable algebraLid : A ⊗[R] B ≃ₐ[A] B :=
have := tensorProduct_compatibleSMul S A A B
Algebra.TensorProduct.lidOfCompatibleSMul R A B
set_option linter.docPrime false in | def | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | algebraLid | If `A` is a localization of `R`, tensoring an `A`-algebra with `A` over `R` does nothing. |
bijective_linearMap_mul' : Function.Bijective (LinearMap.mul' R A) :=
have := tensorProduct_compatibleSMul S A A A
(Algebra.TensorProduct.lmulEquiv R A).bijective | theorem | RingTheory | [
"Mathlib.LinearAlgebra.DirectSum.Finsupp",
"Mathlib.RingTheory.IsTensorProduct",
"Mathlib.RingTheory.Localization.Away.Basic",
"Mathlib.RingTheory.Localization.Module"
] | Mathlib/RingTheory/Localization/BaseChange.lean | bijective_linearMap_mul' | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.