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 ⌀ |
|---|---|---|---|---|---|---|
Module.finrank_of_isLocalizedModule_of_free
(Rₛ : Type*) {Mₛ : Type*} [AddCommGroup Mₛ] [Module R Mₛ]
[CommRing Rₛ] [Algebra R Rₛ] [Module Rₛ Mₛ] [IsScalarTower R Rₛ Mₛ] (S : Submonoid R)
(f : M →ₗ[R] Mₛ) [IsLocalization S Rₛ] [IsLocalizedModule S f] [Module.Free R M]
[Nontrivial Rₛ] :
Module.finrank Rₛ Mₛ = Module.finrank R M := by
simpa using congr(Cardinal.toNat $(Module.lift_rank_of_isLocalizedModule_of_free Rₛ S f)) | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.Dimension.Constructions",
"Mathlib.LinearAlgebra.FreeModule.StrongRankCondition",
"Mathlib.RingTheory.LocalProperties.Submodule"
] | Mathlib/RingTheory/LocalProperties/Projective.lean | Module.finrank_of_isLocalizedModule_of_free | null |
Module.projective_of_isLocalizedModule {Rₛ Mₛ} [AddCommGroup Mₛ] [Module R Mₛ]
[CommRing Rₛ] [Algebra R Rₛ] [Module Rₛ Mₛ] [IsScalarTower R Rₛ Mₛ]
(S) (f : M →ₗ[R] Mₛ) [IsLocalization S Rₛ] [IsLocalizedModule S f] [Module.Projective R M] :
Module.Projective Rₛ Mₛ :=
Projective.of_equiv (IsLocalizedModule.isBaseChange S Rₛ f).equiv | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.Dimension.Constructions",
"Mathlib.LinearAlgebra.FreeModule.StrongRankCondition",
"Mathlib.RingTheory.LocalProperties.Submodule"
] | Mathlib/RingTheory/LocalProperties/Projective.lean | Module.projective_of_isLocalizedModule | null |
LinearMap.split_surjective_of_localization_maximal
(f : M →ₗ[R] N) [Module.FinitePresentation R N]
(H : ∀ (I : Ideal R) (_ : I.IsMaximal),
∃ (g : _ →ₗ[Localization.AtPrime I] _),
(LocalizedModule.map I.primeCompl f).comp g = LinearMap.id) :
∃ (g : N →ₗ[R] M), f.comp g = LinearMap.id := by
change LinearMap.id ∈ LinearMap.range (LinearMap.llcomp R N M N f)
refine Submodule.mem_of_localization_maximal _ (fun P _ ↦ LocalizedModule.map P.primeCompl) _ _
fun I hI ↦ ?_
rw [LocalizedModule.map_id]
have : LinearMap.id ∈ LinearMap.range (LinearMap.llcomp _
(LocalizedModule I.primeCompl N) _ _ (LocalizedModule.map I.primeCompl f)) := H I hI
convert this
· ext f
constructor
· intro hf
obtain ⟨a, ha, c, rfl⟩ := hf
obtain ⟨g, rfl⟩ := ha
use IsLocalizedModule.mk' (LocalizedModule.map I.primeCompl) g c
apply ((Module.End.isUnit_iff _).mp <| IsLocalizedModule.map_units
(LocalizedModule.map I.primeCompl) c).injective
dsimp
conv_rhs => rw [← Submonoid.smul_def]
conv_lhs => rw [← LinearMap.map_smul_of_tower]
rw [← Submonoid.smul_def, IsLocalizedModule.mk'_cancel', IsLocalizedModule.mk'_cancel']
apply LinearMap.restrictScalars_injective R
apply IsLocalizedModule.ext I.primeCompl (LocalizedModule.mkLinearMap I.primeCompl N)
· exact IsLocalizedModule.map_units (LocalizedModule.mkLinearMap I.primeCompl N)
ext
simp only [LocalizedModule.map_mk, LinearMap.coe_comp, LinearMap.coe_restrictScalars,
Function.comp_apply, LocalizedModule.mkLinearMap_apply, LinearMap.llcomp_apply,
LocalizedModule.map_mk]
· rintro ⟨g, rfl⟩
obtain ⟨⟨g, s⟩, rfl⟩ :=
IsLocalizedModule.mk'_surjective I.primeCompl (LocalizedModule.map I.primeCompl) g
simp only [Function.uncurry_apply_pair]
refine ⟨f.comp g, ⟨g, rfl⟩, s, ?_⟩
apply ((Module.End.isUnit_iff _).mp <| IsLocalizedModule.map_units
(LocalizedModule.map I.primeCompl) s).injective
simp only [Module.algebraMap_end_apply, ← Submonoid.smul_def, IsLocalizedModule.mk'_cancel',
← LinearMap.map_smul_of_tower]
apply LinearMap.restrictScalars_injective R
apply IsLocalizedModule.ext I.primeCompl (LocalizedModule.mkLinearMap I.primeCompl N)
· exact IsLocalizedModule.map_units (LocalizedModule.mkLinearMap I.primeCompl N)
ext
simp only [coe_comp, coe_restrictScalars, Function.comp_apply,
LocalizedModule.mkLinearMap_apply, LocalizedModule.map_mk, llcomp_apply] | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.Dimension.Constructions",
"Mathlib.LinearAlgebra.FreeModule.StrongRankCondition",
"Mathlib.RingTheory.LocalProperties.Submodule"
] | Mathlib/RingTheory/LocalProperties/Projective.lean | LinearMap.split_surjective_of_localization_maximal | null |
Module.projective_of_localization_maximal (H : ∀ (I : Ideal R) (_ : I.IsMaximal),
Module.Projective (Localization.AtPrime I) (LocalizedModule I.primeCompl M))
[Module.FinitePresentation R M] : Module.Projective R M := by
have : Module.Finite R M := by infer_instance
have : (⊤ : Submodule R M).FG := this.fg_top
have : ∃ (s : Finset M), _ := this
obtain ⟨s, hs⟩ := this
let N := s →₀ R
let f : N →ₗ[R] M := Finsupp.linearCombination R (Subtype.val : s → M)
have hf : Function.Surjective f := by
rw [← LinearMap.range_eq_top, Finsupp.range_linearCombination, Subtype.range_val]
convert hs
have (I : Ideal R) (hI : I.IsMaximal) :=
letI := H I hI
Module.projective_lifting_property (LocalizedModule.map I.primeCompl f) LinearMap.id
(LocalizedModule.map_surjective _ _ hf)
obtain ⟨g, hg⟩ := LinearMap.split_surjective_of_localization_maximal _ this
exact Module.Projective.of_split _ _ hg
variable
(Rₚ : ∀ (P : Ideal R) [P.IsMaximal], Type*)
[∀ (P : Ideal R) [P.IsMaximal], CommRing (Rₚ P)]
[∀ (P : Ideal R) [P.IsMaximal], Algebra R (Rₚ P)]
[∀ (P : Ideal R) [P.IsMaximal], IsLocalization.AtPrime (Rₚ P) P]
(Mₚ : ∀ (P : Ideal R) [P.IsMaximal], Type*)
[∀ (P : Ideal R) [P.IsMaximal], AddCommGroup (Mₚ P)]
[∀ (P : Ideal R) [P.IsMaximal], Module R (Mₚ P)]
[∀ (P : Ideal R) [P.IsMaximal], Module (Rₚ P) (Mₚ P)]
[∀ (P : Ideal R) [P.IsMaximal], IsScalarTower R (Rₚ P) (Mₚ P)]
(f : ∀ (P : Ideal R) [P.IsMaximal], M →ₗ[R] Mₚ P)
[inst : ∀ (P : Ideal R) [P.IsMaximal], IsLocalizedModule P.primeCompl (f P)]
attribute [local instance] RingHomInvPair.of_ringEquiv in
include f in | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.Dimension.Constructions",
"Mathlib.LinearAlgebra.FreeModule.StrongRankCondition",
"Mathlib.RingTheory.LocalProperties.Submodule"
] | Mathlib/RingTheory/LocalProperties/Projective.lean | Module.projective_of_localization_maximal | null |
Module.projective_of_localization_maximal'
(H : ∀ (I : Ideal R) (_ : I.IsMaximal), Module.Projective (Rₚ I) (Mₚ I))
[Module.FinitePresentation R M] : Module.Projective R M := by
apply Module.projective_of_localization_maximal
intro P hP
refine Module.Projective.of_ringEquiv (M := Mₚ P)
(IsLocalization.algEquiv P.primeCompl (Rₚ P) (Localization.AtPrime P)).toRingEquiv
{ __ := IsLocalizedModule.linearEquiv P.primeCompl (f P)
(LocalizedModule.mkLinearMap P.primeCompl M)
map_smul' := ?_ }
· intro r m
obtain ⟨r, s, rfl⟩ := IsLocalization.mk'_surjective P.primeCompl r
apply ((Module.End.isUnit_iff _).mp
(IsLocalizedModule.map_units (LocalizedModule.mkLinearMap P.primeCompl M) s)).1
dsimp
simp only [← map_smul, ← smul_assoc, IsLocalization.smul_mk'_self, algebraMap_smul,
IsLocalization.map_id_mk'] | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Projective",
"Mathlib.LinearAlgebra.Dimension.Constructions",
"Mathlib.LinearAlgebra.FreeModule.StrongRankCondition",
"Mathlib.RingTheory.LocalProperties.Submodule"
] | Mathlib/RingTheory/LocalProperties/Projective.lean | Module.projective_of_localization_maximal' | A variant of `Module.projective_of_localization_maximal` that accepts `IsLocalizedModule`. |
isReduced_localizationPreserves : LocalizationPreserves fun R _ => IsReduced R := by
introv R _ _
constructor
rintro x ⟨_ | n, e⟩
· simpa using congr_arg (· * x) e
obtain ⟨⟨y, m⟩, hx⟩ := IsLocalization.surj M x
dsimp only at hx
let hx' := congr_arg (· ^ n.succ) hx
simp only [mul_pow, e, zero_mul, ← RingHom.map_pow] at hx'
rw [← (algebraMap R S).map_zero] at hx'
obtain ⟨m', hm'⟩ := (IsLocalization.eq_iff_exists M S).mp hx'
apply_fun (· * (m' : R) ^ n) at hm'
simp only [mul_assoc, zero_mul, mul_zero] at hm'
rw [← mul_left_comm, ← pow_succ', ← mul_pow] at hm'
replace hm' := IsNilpotent.eq_zero ⟨_, hm'.symm⟩
rw [← (IsLocalization.map_units S m).mul_left_inj, hx, zero_mul,
IsLocalization.map_eq_zero_iff M]
exact ⟨m', by rw [← hm', mul_comm]⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/LocalProperties/Reduced.lean | isReduced_localizationPreserves | `M⁻¹R` is reduced if `R` is reduced. |
isReduced_ofLocalizationMaximal : OfLocalizationMaximal fun R _ => IsReduced R := by
introv R h
constructor
intro x hx
apply eq_zero_of_localization
intro J hJ
specialize h J hJ
exact (hx.map <| algebraMap R <| Localization.AtPrime J).eq_zero | theorem | RingTheory | [
"Mathlib.RingTheory.LocalProperties.Basic",
"Mathlib.RingTheory.Nilpotent.Defs"
] | Mathlib/RingTheory/LocalProperties/Reduced.lean | isReduced_ofLocalizationMaximal | `R` is reduced if `Rₘ` is reduced for all maximal ideal `m`. |
Submodule.mem_of_localization_maximal (m : M) (N : Submodule R M)
(h : ∀ (P : Ideal R) [P.IsMaximal], f P m ∈ N.localized₀ P.primeCompl (f P)) :
m ∈ N := by
let I : Ideal R := N.comap (LinearMap.toSpanSingleton R M m)
suffices I = ⊤ by simpa [I] using I.eq_top_iff_one.mp this
refine Not.imp_symm I.exists_le_maximal fun ⟨P, hP, le⟩ ↦ ?_
obtain ⟨a, ha, s, e⟩ := h P
rw [← IsLocalizedModule.mk'_one P.primeCompl, IsLocalizedModule.mk'_eq_mk'_iff] at e
obtain ⟨t, ht⟩ := e
simp_rw [smul_smul] at ht
exact (t * s).2 (le <| by apply ht ▸ smul_mem _ _ ha) | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | Submodule.mem_of_localization_maximal | null |
Submodule.le_of_localization_maximal {N₁ N₂ : Submodule R M}
(h : ∀ (P : Ideal R) [P.IsMaximal],
N₁.localized₀ P.primeCompl (f P) ≤ N₂.localized₀ P.primeCompl (f P)) :
N₁ ≤ N₂ :=
fun m hm ↦ mem_of_localization_maximal _ f _ _ fun P hP ↦ h P ⟨m, hm, 1, by simp⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | Submodule.le_of_localization_maximal | Let `N₁ N₂ : Submodule R M`. If the localization of `N₁` at each maximal ideal `P` is
included in the localization of `N₂` at `P`, then `N₁ ≤ N₂`. |
Submodule.eq_of_localization₀_maximal {N₁ N₂ : Submodule R M}
(h : ∀ (P : Ideal R) [P.IsMaximal],
N₁.localized₀ P.primeCompl (f P) = N₂.localized₀ P.primeCompl (f P)) :
N₁ = N₂ :=
le_antisymm (Submodule.le_of_localization_maximal Mₚ f fun P _ ↦ (h P).le)
(Submodule.le_of_localization_maximal Mₚ f fun P _ ↦ (h P).ge) | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | Submodule.eq_of_localization₀_maximal | Let `N₁ N₂ : Submodule R M`. If the localization of `N₁` at each maximal ideal `P` is equal to
the localization of `N₂` at `P`, then `N₁ = N₂`. |
Submodule.eq_bot_of_localization₀_maximal (N : Submodule R M)
(h : ∀ (P : Ideal R) [P.IsMaximal], N.localized₀ P.primeCompl (f P) = ⊥) :
N = ⊥ :=
Submodule.eq_of_localization₀_maximal Mₚ f fun P hP ↦ by simpa using h P | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | Submodule.eq_bot_of_localization₀_maximal | A submodule is trivial if its localization at every maximal ideal is trivial. |
Submodule.eq_top_of_localization₀_maximal (N : Submodule R M)
(h : ∀ (P : Ideal R) [P.IsMaximal], N.localized₀ P.primeCompl (f P) = ⊤) :
N = ⊤ :=
Submodule.eq_of_localization₀_maximal Mₚ f fun P hP ↦ by simpa using h P | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | Submodule.eq_top_of_localization₀_maximal | null |
Module.eq_of_localization_maximal (m m' : M)
(h : ∀ (P : Ideal R) [P.IsMaximal], f P m = f P m') :
m = m' := by
rw [← one_smul R m, ← one_smul R m']
by_contra ne
have ⟨P, mP, le⟩ := (eqIdeal R m m').exists_le_maximal ((Ideal.ne_top_iff_one _).mpr ne)
have ⟨s, hs⟩ := (IsLocalizedModule.eq_iff_exists P.primeCompl _).mp (h P)
exact s.2 (le hs) | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | Module.eq_of_localization_maximal | null |
Module.eq_zero_of_localization_maximal (m : M)
(h : ∀ (P : Ideal R) [P.IsMaximal], f P m = 0) :
m = 0 :=
eq_of_localization_maximal _ f _ _ fun P _ ↦ by rw [h, map_zero] | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | Module.eq_zero_of_localization_maximal | null |
LinearMap.eq_of_localization_maximal (g g' : M →ₗ[R] M₁)
(h : ∀ (P : Ideal R) [P.IsMaximal],
IsLocalizedModule.map P.primeCompl (f P) (f₁ P) g =
IsLocalizedModule.map P.primeCompl (f P) (f₁ P) g') :
g = g' :=
ext fun x ↦ Module.eq_of_localization_maximal _ f₁ _ _ fun P _ ↦ by
simpa only [IsLocalizedModule.map_apply] using DFunLike.congr_fun (h P) (f P x)
include f in | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | LinearMap.eq_of_localization_maximal | null |
Module.subsingleton_of_localization_maximal
(h : ∀ (P : Ideal R) [P.IsMaximal], Subsingleton (Mₚ P)) :
Subsingleton M := by
rw [subsingleton_iff_forall_eq 0]
intro x
exact Module.eq_of_localization_maximal Mₚ f x 0 fun _ _ ↦ Subsingleton.elim _ _ | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | Module.subsingleton_of_localization_maximal | null |
Submodule.eq_of_localization_maximal {N₁ N₂ : Submodule R M}
(h : ∀ (P : Ideal R) [P.IsMaximal],
N₁.localized' (Rₚ P) P.primeCompl (f P) = N₂.localized' (Rₚ P) P.primeCompl (f P)) :
N₁ = N₂ :=
eq_of_localization₀_maximal Mₚ f fun P _ ↦ congr(restrictScalars _ $(h P)) | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | Submodule.eq_of_localization_maximal | null |
Submodule.eq_bot_of_localization_maximal (N : Submodule R M)
(h : ∀ (P : Ideal R) [P.IsMaximal], N.localized' (Rₚ P) P.primeCompl (f P) = ⊥) :
N = ⊥ :=
Submodule.eq_of_localization_maximal Rₚ Mₚ f fun P hP ↦ by simpa using h P | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | Submodule.eq_bot_of_localization_maximal | null |
Submodule.eq_top_of_localization_maximal (N : Submodule R M)
(h : ∀ (P : Ideal R) [P.IsMaximal], N.localized' (Rₚ P) P.primeCompl (f P) = ⊤) :
N = ⊤ :=
Submodule.eq_of_localization_maximal Rₚ Mₚ f fun P hP ↦ by simpa using h P | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | Submodule.eq_top_of_localization_maximal | null |
Module.eq_of_isLocalized_span (x y : M) (h : ∀ r : s, f r x = f r y) : x = y := by
suffices Module.eqIdeal R x y = ⊤ by simpa [Module.eqIdeal] using (eq_top_iff_one _).mp this
by_contra ne
have ⟨r, hrs, disj⟩ := exists_disjoint_powers_of_span_eq_top s span_eq _ ne
let r : s := ⟨r, hrs⟩
have ⟨⟨_, n, rfl⟩, eq⟩ := (IsLocalizedModule.eq_iff_exists (.powers r.1) _).mp (h r)
exact Set.disjoint_left.mp disj eq ⟨n, rfl⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | Module.eq_of_isLocalized_span | null |
Module.eq_zero_of_isLocalized_span (x : M) (h : ∀ r : s, f r x = 0) : x = 0 :=
eq_of_isLocalized_span s span_eq _ f x 0 <| by simpa only [map_zero] using h | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | Module.eq_zero_of_isLocalized_span | null |
Submodule.mem_of_isLocalized_span {m : M} {N : Submodule R M}
(h : ∀ r : s, f r m ∈ N.localized₀ (.powers r.1) (f r)) : m ∈ N := by
let I : Ideal R := N.comap (LinearMap.toSpanSingleton R M m)
suffices I = ⊤ by simpa [I] using I.eq_top_iff_one.mp this
by_contra! ne
have ⟨r, hrs, disj⟩ := exists_disjoint_powers_of_span_eq_top s span_eq _ ne
let r : s := ⟨r, hrs⟩
obtain ⟨a, ha, t, e⟩ := h r
rw [← IsLocalizedModule.mk'_one (.powers r.1), IsLocalizedModule.mk'_eq_mk'_iff] at e
have ⟨u, hu⟩ := e
simp_rw [smul_smul] at hu
exact Set.disjoint_right.mp disj (u * t).2 (by apply hu ▸ smul_mem _ _ ha) | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | Submodule.mem_of_isLocalized_span | null |
Submodule.le_of_isLocalized_span {N P : Submodule R M}
(h : ∀ r : s, N.localized₀ (.powers r.1) (f r) ≤ P.localized₀ (.powers r.1) (f r)) : N ≤ P :=
fun m hm ↦ mem_of_isLocalized_span s span_eq _ f fun r ↦ h r ⟨m, hm, 1, by simp⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | Submodule.le_of_isLocalized_span | null |
Submodule.eq_of_isLocalized₀_span {N P : Submodule R M}
(h : ∀ r : s, N.localized₀ (.powers r.1) (f r) = P.localized₀ (.powers r.1) (f r)) : N = P :=
le_antisymm (le_of_isLocalized_span s span_eq _ _ fun r ↦ (h r).le)
(le_of_isLocalized_span s span_eq _ _ fun r ↦ (h r).ge) | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | Submodule.eq_of_isLocalized₀_span | null |
Submodule.eq_bot_of_isLocalized₀_span {N : Submodule R M}
(h : ∀ r : s, N.localized₀ (.powers r.1) (f r) = ⊥) : N = ⊥ :=
eq_of_isLocalized₀_span s span_eq Mₚ f fun _ ↦ by simp only [h, Submodule.localized₀_bot] | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | Submodule.eq_bot_of_isLocalized₀_span | null |
Submodule.eq_top_of_isLocalized₀_span {N : Submodule R M}
(h : ∀ r : s, N.localized₀ (.powers r.1) (f r) = ⊤) : N = ⊤ :=
eq_of_isLocalized₀_span s span_eq Mₚ f fun _ ↦ by simp only [h, Submodule.localized₀_top] | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | Submodule.eq_top_of_isLocalized₀_span | null |
Submodule.eq_of_isLocalized'_span {N P : Submodule R M}
(h : ∀ r, N.localized' (Rₚ r) (.powers r.1) (f r) = P.localized' (Rₚ r) (.powers r.1) (f r)) :
N = P :=
eq_of_isLocalized₀_span s span_eq _ f fun r ↦ congr(restrictScalars _ $(h r)) | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | Submodule.eq_of_isLocalized'_span | null |
Submodule.eq_bot_of_isLocalized'_span {N : Submodule R M}
(h : ∀ r : s, N.localized' (Rₚ r) (.powers r.1) (f r) = ⊥) : N = ⊥ :=
eq_of_isLocalized'_span s span_eq Rₚ Mₚ f fun _ ↦ by simp only [h, Submodule.localized'_bot] | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | Submodule.eq_bot_of_isLocalized'_span | null |
Submodule.eq_top_of_isLocalized'_span {N : Submodule R M}
(h : ∀ r : s, N.localized' (Rₚ r) (.powers r.1) (f r) = ⊤) : N = ⊤ :=
eq_of_isLocalized'_span s span_eq Rₚ Mₚ f fun _ ↦ by simp only [h, Submodule.localized'_top] | theorem | RingTheory | [
"Mathlib.Algebra.Module.LocalizedModule.Submodule",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/LocalProperties/Submodule.lean | Submodule.eq_top_of_isLocalized'_span | null |
of_isUnit_or_isUnit_of_isUnit_add [Nontrivial R]
(h : ∀ a b : R, IsUnit (a + b) → IsUnit a ∨ IsUnit b) : IsLocalRing R :=
⟨fun {a b} hab => h a b <| hab.symm ▸ isUnit_one⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.Defs",
"Mathlib.RingTheory.Ideal.Nonunits"
] | Mathlib/RingTheory/LocalRing/Basic.lean | of_isUnit_or_isUnit_of_isUnit_add | null |
of_nonunits_add [Nontrivial R]
(h : ∀ a b : R, a ∈ nonunits R → b ∈ nonunits R → a + b ∈ nonunits R) : IsLocalRing R where
isUnit_or_isUnit_of_add_one {a b} hab :=
or_iff_not_and_not.2 fun H => h a b H.1 H.2 <| hab.symm ▸ isUnit_one | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.Defs",
"Mathlib.RingTheory.Ideal.Nonunits"
] | Mathlib/RingTheory/LocalRing/Basic.lean | of_nonunits_add | A semiring is local if it is nontrivial and the set of nonunits is closed under the addition. |
of_unique_max_ideal (h : ∃! I : Ideal R, I.IsMaximal) : IsLocalRing R :=
@of_nonunits_add _ _
(nontrivial_of_ne (0 : R) 1 <|
let ⟨I, Imax, _⟩ := h
fun H : 0 = 1 => Imax.1.1 <| I.eq_top_iff_one.2 <| H ▸ I.zero_mem)
fun x y hx hy H =>
let ⟨I, Imax, Iuniq⟩ := h
let ⟨Ix, Ixmax, Hx⟩ := exists_max_ideal_of_mem_nonunits hx
let ⟨Iy, Iymax, Hy⟩ := exists_max_ideal_of_mem_nonunits hy
have xmemI : x ∈ I := Iuniq Ix Ixmax ▸ Hx
have ymemI : y ∈ I := Iuniq Iy Iymax ▸ Hy
Imax.1.1 <| I.eq_top_of_isUnit_mem (I.add_mem xmemI ymemI) H | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.Defs",
"Mathlib.RingTheory.Ideal.Nonunits"
] | Mathlib/RingTheory/LocalRing/Basic.lean | of_unique_max_ideal | A semiring is local if it has a unique maximal ideal. |
of_unique_nonzero_prime (h : ∃! P : Ideal R, P ≠ ⊥ ∧ Ideal.IsPrime P) : IsLocalRing R :=
of_unique_max_ideal
(by
rcases h with ⟨P, ⟨hPnonzero, hPnot_top, _⟩, hPunique⟩
refine ⟨P, ⟨⟨hPnot_top, ?_⟩⟩, fun M hM => hPunique _ ⟨?_, Ideal.IsMaximal.isPrime hM⟩⟩
· refine Ideal.maximal_of_no_maximal fun M hPM hM => ne_of_lt hPM ?_
exact (hPunique _ ⟨ne_bot_of_gt hPM, Ideal.IsMaximal.isPrime hM⟩).symm
· rintro rfl
exact hPnot_top (hM.1.2 P (bot_lt_iff_ne_bot.2 hPnonzero)))
variable [IsLocalRing R] | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.Defs",
"Mathlib.RingTheory.Ideal.Nonunits"
] | Mathlib/RingTheory/LocalRing/Basic.lean | of_unique_nonzero_prime | null |
isUnit_or_isUnit_of_isUnit_add {a b : R} (h : IsUnit (a + b)) : IsUnit a ∨ IsUnit b := by
rcases h with ⟨u, hu⟩
rw [← Units.inv_mul_eq_one, mul_add] at hu
apply Or.imp _ _ (isUnit_or_isUnit_of_add_one hu) <;> exact isUnit_of_mul_isUnit_right | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.Defs",
"Mathlib.RingTheory.Ideal.Nonunits"
] | Mathlib/RingTheory/LocalRing/Basic.lean | isUnit_or_isUnit_of_isUnit_add | null |
nonunits_add {a b : R} (ha : a ∈ nonunits R) (hb : b ∈ nonunits R) : a + b ∈ nonunits R :=
fun H => not_or_intro ha hb (isUnit_or_isUnit_of_isUnit_add H) | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.Defs",
"Mathlib.RingTheory.Ideal.Nonunits"
] | Mathlib/RingTheory/LocalRing/Basic.lean | nonunits_add | null |
of_isUnit_or_isUnit_one_sub_self [Nontrivial R] (h : ∀ a : R, IsUnit a ∨ IsUnit (1 - a)) :
IsLocalRing R :=
⟨fun {a b} hab => add_sub_cancel_left a b ▸ hab.symm ▸ h a⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.Defs",
"Mathlib.RingTheory.Ideal.Nonunits"
] | Mathlib/RingTheory/LocalRing/Basic.lean | of_isUnit_or_isUnit_one_sub_self | null |
isUnit_or_isUnit_one_sub_self (a : R) : IsUnit a ∨ IsUnit (1 - a) :=
isUnit_or_isUnit_of_isUnit_add <| (add_sub_cancel a 1).symm ▸ isUnit_one | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.Defs",
"Mathlib.RingTheory.Ideal.Nonunits"
] | Mathlib/RingTheory/LocalRing/Basic.lean | isUnit_or_isUnit_one_sub_self | null |
isUnit_of_mem_nonunits_one_sub_self (a : R) (h : 1 - a ∈ nonunits R) : IsUnit a :=
or_iff_not_imp_right.1 (isUnit_or_isUnit_one_sub_self a) h | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.Defs",
"Mathlib.RingTheory.Ideal.Nonunits"
] | Mathlib/RingTheory/LocalRing/Basic.lean | isUnit_of_mem_nonunits_one_sub_self | null |
isUnit_one_sub_self_of_mem_nonunits (a : R) (h : a ∈ nonunits R) : IsUnit (1 - a) :=
or_iff_not_imp_left.1 (isUnit_or_isUnit_one_sub_self a) h | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.Defs",
"Mathlib.RingTheory.Ideal.Nonunits"
] | Mathlib/RingTheory/LocalRing/Basic.lean | isUnit_one_sub_self_of_mem_nonunits | null |
of_surjective' [Ring S] [Nontrivial S] (f : R →+* S) (hf : Function.Surjective f) :
IsLocalRing S :=
of_isUnit_or_isUnit_one_sub_self (by
intro b
obtain ⟨a, rfl⟩ := hf b
apply (isUnit_or_isUnit_one_sub_self a).imp <| RingHom.isUnit_map _
rw [← f.map_one, ← f.map_sub]
apply f.isUnit_map) | theorem | RingTheory | [
"Mathlib.RingTheory.LocalRing.Defs",
"Mathlib.RingTheory.Ideal.Nonunits"
] | Mathlib/RingTheory/LocalRing/Basic.lean | of_surjective' | null |
IsLocalRing (R : Type*) [Semiring R] : Prop extends Nontrivial R where
of_is_unit_or_is_unit_of_add_one ::
/-- in a local ring `R`, if `a + b = 1`, then either `a` is a unit or `b` is a unit. In another
word, for every `a : R`, either `a` is a unit or `1 - a` is a unit. -/
isUnit_or_isUnit_of_add_one {a b : R} (h : a + b = 1) : IsUnit a ∨ IsUnit b | class | RingTheory | [
"Mathlib.Algebra.Group.Units.Defs",
"Mathlib.Algebra.Ring.Defs"
] | Mathlib/RingTheory/LocalRing/Defs.lean | IsLocalRing | A semiring is local if it is nontrivial and `a` or `b` is a unit whenever `a + b = 1`.
Note that `IsLocalRing` is a predicate. |
isLocalRing_top [IsLocalRing R] : IsLocalRing (⊤ : Subring R) :=
Subring.topEquiv.symm.isLocalRing
variable (R) in | instance | RingTheory | [
"Mathlib.Tactic.FieldSimp",
"Mathlib.RingTheory.LocalRing.RingHom.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/LocalRing/LocalSubring.lean | isLocalRing_top | null |
@[ext]
LocalSubring where
/-- The underlying subring of a local subring. -/
toSubring : Subring R
[isLocalRing : IsLocalRing toSubring] | structure | RingTheory | [
"Mathlib.Tactic.FieldSimp",
"Mathlib.RingTheory.LocalRing.RingHom.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/LocalRing/LocalSubring.lean | LocalSubring | The class of local subrings of a commutative ring. |
toSubring_injective : Function.Injective (toSubring (R := R)) := by
rintro ⟨a, b⟩ ⟨c, d⟩ rfl; rfl | lemma | RingTheory | [
"Mathlib.Tactic.FieldSimp",
"Mathlib.RingTheory.LocalRing.RingHom.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/LocalRing/LocalSubring.lean | toSubring_injective | null |
protected copy (S : LocalSubring R) (s : Set R) (hs : s = ↑S.toSubring) : LocalSubring R :=
LocalSubring.mk (S.toSubring.copy s hs) (isLocalRing := hs ▸ S.2) | def | RingTheory | [
"Mathlib.Tactic.FieldSimp",
"Mathlib.RingTheory.LocalRing.RingHom.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/LocalRing/LocalSubring.lean | copy | Copy of a local subring with a new `carrier` equal to the old one.
Useful to fix definitional equalities. |
@[simps! toSubring]
map [Nontrivial S] (f : R →+* S) (s : LocalSubring R) : LocalSubring S :=
mk (s.1.map f) | def | RingTheory | [
"Mathlib.Tactic.FieldSimp",
"Mathlib.RingTheory.LocalRing.RingHom.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/LocalRing/LocalSubring.lean | map | The image of a `LocalSubring` as a `LocalSubring`. |
@[simps! toSubring]
range [IsLocalRing R] [Nontrivial S] (f : R →+* S) : LocalSubring S :=
.copy (map f (mk ⊤)) f.range (by ext x; exact congr(x ∈ $(Set.image_univ.symm))) | def | RingTheory | [
"Mathlib.Tactic.FieldSimp",
"Mathlib.RingTheory.LocalRing.RingHom.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/LocalRing/LocalSubring.lean | range | The range of a ring homomorphism from a local ring as a `LocalSubring`. |
le_def {A B : LocalSubring R} :
A ≤ B ↔ ∃ h : A.toSubring ≤ B.toSubring, IsLocalHom (Subring.inclusion h) := Iff.rfl | lemma | RingTheory | [
"Mathlib.Tactic.FieldSimp",
"Mathlib.RingTheory.LocalRing.RingHom.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/LocalRing/LocalSubring.lean | le_def | The domination order on local subrings.
`A` dominates `B` if and only if `B ≤ A` (as subrings) and `m_A ∩ B = m_B`.
-/
@[stacks 00I9]
instance : PartialOrder (LocalSubring R) where
le A B := ∃ h : A.1 ≤ B.1, IsLocalHom (Subring.inclusion h)
le_refl a := ⟨le_rfl, ⟨fun _ ↦ id⟩⟩
le_trans A B C h₁ h₂ := ⟨h₁.1.trans h₂.1, @RingHom.isLocalHom_comp _ _ _ _ _ _ _ _ h₂.2 h₁.2⟩
le_antisymm A B h₁ h₂ := toSubring_injective (le_antisymm h₁.1 h₂.1)
/-- `A` dominates `B` if and only if `B ≤ A` (as subrings) and `m_A ∩ B = m_B`. |
toSubring_mono : Monotone (toSubring (R := R)) :=
fun _ _ e ↦ e.1 | lemma | RingTheory | [
"Mathlib.Tactic.FieldSimp",
"Mathlib.RingTheory.LocalRing.RingHom.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/LocalRing/LocalSubring.lean | toSubring_mono | null |
noncomputable
ofPrime (A : Subring K) (P : Ideal A) [P.IsPrime] : LocalSubring K :=
range (IsLocalization.lift (M := P.primeCompl) (S := Localization.AtPrime P)
(g := A.subtype) (by simp [Ideal.primeCompl, not_imp_not])) | def | RingTheory | [
"Mathlib.Tactic.FieldSimp",
"Mathlib.RingTheory.LocalRing.RingHom.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/LocalRing/LocalSubring.lean | ofPrime | The localization of a subring at a prime, as a local subring.
Also see `Localization.subalgebra.ofField` |
le_ofPrime : A ≤ (ofPrime A P).toSubring := by
intro x hx
exact ⟨algebraMap A _ ⟨x, hx⟩, by simp⟩ | lemma | RingTheory | [
"Mathlib.Tactic.FieldSimp",
"Mathlib.RingTheory.LocalRing.RingHom.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/LocalRing/LocalSubring.lean | le_ofPrime | null |
noncomputable
ofPrimeEquiv : Localization.AtPrime P ≃ₐ[A] (ofPrime A P).toSubring := by
refine AlgEquiv.ofInjective (IsLocalization.liftAlgHom (M := P.primeCompl)
(S := Localization.AtPrime P) (f := Algebra.ofId A K) _) ?_
intro x y e
obtain ⟨x, s, rfl⟩ := IsLocalization.mk'_surjective P.primeCompl x
obtain ⟨y, t, rfl⟩ := IsLocalization.mk'_surjective P.primeCompl y
have H (x : P.primeCompl) : x.1 ≠ 0 := by aesop
have : x.1 = y.1 * t.1.1⁻¹ * s.1.1 := by
simpa [IsLocalization.lift_mk', Algebra.ofId_apply, H,
Algebra.algebraMap_ofSubring_apply, IsUnit.coe_liftRight] using congr($e * s.1.1)
rw [IsLocalization.mk'_eq_iff_eq]
congr 1
ext
simp [field, H t, this, mul_comm] | def | RingTheory | [
"Mathlib.Tactic.FieldSimp",
"Mathlib.RingTheory.LocalRing.RingHom.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic"
] | Mathlib/RingTheory/LocalRing/LocalSubring.lean | ofPrimeEquiv | The localization of a subring at a prime is indeed isomorphic to its abstract localization. |
map_mkQ_eq {N₁ N₂ : Submodule R M} (h : N₁ ≤ N₂) (h' : N₂.FG) :
N₁.map (Submodule.mkQ (𝔪 • N₂)) = N₂.map (Submodule.mkQ (𝔪 • N₂)) ↔ N₁ = N₂ := by
constructor
· intro hN
have : N₂ ≤ 𝔪 • N₂ ⊔ N₁ := by
simpa using Submodule.comap_mono (f := Submodule.mkQ (𝔪 • N₂)) hN.ge
rw [sup_comm] at this
exact h.antisymm (Submodule.le_of_le_smul_of_le_jacobson_bot h'
(by rw [jacobson_eq_maximalIdeal]; exact bot_ne_top) this)
· rintro rfl; simp | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Torsion",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Flat.EquationalCriterion",
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mat... | Mathlib/RingTheory/LocalRing/Module.lean | map_mkQ_eq | null |
map_mkQ_eq_top {N : Submodule R M} [Module.Finite R M] :
N.map (Submodule.mkQ (𝔪 • ⊤)) = ⊤ ↔ N = ⊤ := by
rw [← map_mkQ_eq (N₁ := N) le_top Module.Finite.fg_top, Submodule.map_top, Submodule.range_mkQ] | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Torsion",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Flat.EquationalCriterion",
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mat... | Mathlib/RingTheory/LocalRing/Module.lean | map_mkQ_eq_top | null |
map_tensorProduct_mk_eq_top {N : Submodule R M} [Module.Finite R M] :
N.map (TensorProduct.mk R k M 1) = ⊤ ↔ N = ⊤ := by
constructor
· intro hN
letI : Module k (M ⧸ (𝔪 • ⊤ : Submodule R M)) :=
inferInstanceAs (Module (R ⧸ 𝔪) (M ⧸ 𝔪 • (⊤ : Submodule R M)))
letI : IsScalarTower R k (M ⧸ (𝔪 • ⊤ : Submodule R M)) :=
inferInstanceAs (IsScalarTower R (R ⧸ 𝔪) (M ⧸ 𝔪 • (⊤ : Submodule R M)))
let f := AlgebraTensorModule.lift (((LinearMap.ringLmapEquivSelf k k _).symm
(Submodule.mkQ (𝔪 • ⊤ : Submodule R M))).restrictScalars R)
have : f.comp (TensorProduct.mk R k M 1) = Submodule.mkQ (𝔪 • ⊤) := by ext; simp [f]
have hf : Function.Surjective f := by
intro x; obtain ⟨x, rfl⟩ := Submodule.mkQ_surjective _ x
rw [← this, LinearMap.comp_apply]; exact ⟨_, rfl⟩
apply_fun Submodule.map f at hN
rwa [← Submodule.map_comp, this, Submodule.map_top, LinearMap.range_eq_top.2 hf,
map_mkQ_eq_top] at hN
· rintro rfl; rw [Submodule.map_top, LinearMap.range_eq_top]
exact TensorProduct.mk_surjective R M k Ideal.Quotient.mk_surjective | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Torsion",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Flat.EquationalCriterion",
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mat... | Mathlib/RingTheory/LocalRing/Module.lean | map_tensorProduct_mk_eq_top | null |
subsingleton_tensorProduct [Module.Finite R M] :
Subsingleton (k ⊗[R] M) ↔ Subsingleton M := by
rw [← Submodule.subsingleton_iff R, ← subsingleton_iff_bot_eq_top,
← Submodule.subsingleton_iff R, ← subsingleton_iff_bot_eq_top,
← map_tensorProduct_mk_eq_top (M := M), Submodule.map_bot] | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Torsion",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Flat.EquationalCriterion",
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mat... | Mathlib/RingTheory/LocalRing/Module.lean | subsingleton_tensorProduct | null |
span_eq_top_of_tmul_eq_basis [Module.Finite R M] {ι}
(f : ι → M) (b : Basis ι k (k ⊗[R] M))
(hb : ∀ i, 1 ⊗ₜ f i = b i) : Submodule.span R (Set.range f) = ⊤ := by
rw [← map_tensorProduct_mk_eq_top, Submodule.map_span, ← Submodule.restrictScalars_span R k
Ideal.Quotient.mk_surjective, Submodule.restrictScalars_eq_top_iff,
← b.span_eq, ← Set.range_comp]
simp only [Function.comp_def, mk_apply, hb, Basis.span_eq] | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Torsion",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Flat.EquationalCriterion",
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mat... | Mathlib/RingTheory/LocalRing/Module.lean | span_eq_top_of_tmul_eq_basis | null |
Module.mem_support_iff_nontrivial_residueField_tensorProduct [Module.Finite R M]
(p : PrimeSpectrum R) :
p ∈ Module.support R M ↔ Nontrivial (p.asIdeal.ResidueField ⊗[R] M) := by
let K := p.asIdeal.ResidueField
let e := (AlgebraTensorModule.cancelBaseChange R (Localization.AtPrime p.asIdeal) K K M).symm
rw [e.nontrivial_congr, Module.mem_support_iff,
(LocalizedModule.equivTensorProduct p.asIdeal.primeCompl M).nontrivial_congr,
← not_iff_not, not_nontrivial_iff_subsingleton, not_nontrivial_iff_subsingleton,
IsLocalRing.subsingleton_tensorProduct]
open Function in | lemma | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Torsion",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Flat.EquationalCriterion",
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mat... | Mathlib/RingTheory/LocalRing/Module.lean | Module.mem_support_iff_nontrivial_residueField_tensorProduct | null |
lTensor_injective_of_exact_of_exact_of_rTensor_injective
{M₁ M₂ M₃ N₁ N₂ N₃}
[AddCommGroup M₁] [Module R M₁] [AddCommGroup M₂] [Module R M₂] [AddCommGroup M₃] [Module R M₃]
[AddCommGroup N₁] [Module R N₁] [AddCommGroup N₂] [Module R N₂] [AddCommGroup N₃] [Module R N₃]
{f₁ : M₁ →ₗ[R] M₂} {f₂ : M₂ →ₗ[R] M₃} {g₁ : N₁ →ₗ[R] N₂} {g₂ : N₂ →ₗ[R] N₃}
(hfexact : Exact f₁ f₂) (hfsurj : Surjective f₂)
(hgexact : Exact g₁ g₂) (hgsurj : Surjective g₂)
(hfinj : Injective (f₁.rTensor N₃)) (hginj : Injective (g₁.lTensor M₂)) :
Injective (g₁.lTensor M₃) := by
rw [injective_iff_map_eq_zero]
intro x hx
obtain ⟨x, rfl⟩ := f₂.rTensor_surjective N₁ hfsurj x
have : f₂.rTensor N₂ (g₁.lTensor M₂ x) = 0 := by
rw [← hx, ← LinearMap.comp_apply, ← LinearMap.comp_apply, LinearMap.rTensor_comp_lTensor,
LinearMap.lTensor_comp_rTensor]
obtain ⟨y, hy⟩ := (rTensor_exact N₂ hfexact hfsurj _).mp this
have : g₂.lTensor M₁ y = 0 := by
apply hfinj
trans g₂.lTensor M₂ (g₁.lTensor M₂ x)
· rw [← hy, ← LinearMap.comp_apply, ← LinearMap.comp_apply, LinearMap.rTensor_comp_lTensor,
LinearMap.lTensor_comp_rTensor]
rw [← LinearMap.comp_apply, ← LinearMap.lTensor_comp, hgexact.linearMap_comp_eq_zero]
simp
obtain ⟨z, rfl⟩ := (lTensor_exact _ hgexact hgsurj _).mp this
obtain rfl : f₁.rTensor N₁ z = x := by
apply hginj
simp only [← hy, ← LinearMap.comp_apply, ← LinearMap.comp_apply, LinearMap.lTensor_comp_rTensor,
LinearMap.rTensor_comp_lTensor]
rw [← LinearMap.comp_apply, ← LinearMap.rTensor_comp, hfexact.linearMap_comp_eq_zero]
simp | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Torsion",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Flat.EquationalCriterion",
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mat... | Mathlib/RingTheory/LocalRing/Module.lean | lTensor_injective_of_exact_of_exact_of_rTensor_injective | Given `M₁ → M₂ → M₃ → 0` and `N₁ → N₂ → N₃ → 0`,
if `M₁ ⊗ N₃ → M₂ ⊗ N₃` and `M₂ ⊗ N₁ → M₂ ⊗ N₂` are both injective,
then `M₃ ⊗ N₁ → M₃ ⊗ N₂` is also injective. |
exists_basis_of_basis_baseChange [Module.FinitePresentation R M]
{ι : Type*} (v : ι → M) (hli : LinearIndependent k (TensorProduct.mk R k M 1 ∘ v))
(hsp : Submodule.span k (Set.range (TensorProduct.mk R k M 1 ∘ v)) = ⊤)
(H : Function.Injective ((𝔪).subtype.rTensor M)) :
∃ (b : Basis ι R M), ∀ i, b i = v i := by
let bk : Basis ι k (k ⊗[R] M) := Basis.mk hli (by rw [hsp])
haveI : Finite ι := Module.Finite.finite_basis bk
letI : Fintype ι := Fintype.ofFinite ι
let i := Finsupp.linearCombination R v
have hi : Surjective i := by
rw [← LinearMap.range_eq_top, Finsupp.range_linearCombination]
refine IsLocalRing.span_eq_top_of_tmul_eq_basis (R := R) (f := v) bk
(fun _ ↦ by simp [bk])
have : Module.Finite R (LinearMap.ker i) := by
constructor
exact (Submodule.fg_top _).mpr (Module.FinitePresentation.fg_ker i hi)
let iequiv : (ι →₀ R) ≃ₗ[R] M := by
refine LinearEquiv.ofBijective i ⟨?_, hi⟩
rw [← LinearMap.ker_eq_bot, ← Submodule.subsingleton_iff_eq_bot,
← IsLocalRing.subsingleton_tensorProduct (R := R), subsingleton_iff_forall_eq 0]
have : Function.Surjective (i.baseChange k) := i.lTensor_surjective _ hi
have hi' : Function.Bijective (i.baseChange k) := by
refine ⟨?_, this⟩
rw [← LinearMap.ker_eq_bot (M := k ⊗[R] (ι →₀ R)) (f := i.baseChange k),
← Submodule.finrank_eq_zero (R := k) (M := k ⊗[R] (ι →₀ R)),
← Nat.add_right_inj (n := Module.finrank k (LinearMap.range <| i.baseChange k)),
LinearMap.finrank_range_add_finrank_ker (V := k ⊗[R] (ι →₀ R)),
LinearMap.range_eq_top.mpr this, finrank_top]
simp only [Module.finrank_tensorProduct, Module.finrank_self,
Module.finrank_finsupp_self, one_mul, add_zero]
rw [Module.finrank_eq_card_basis bk]
intro x
refine lTensor_injective_of_exact_of_exact_of_rTensor_injective
(N₁ := LinearMap.ker i) (N₂ := ι →₀ R) (N₃ := M)
(f₁ := (𝔪).subtype) (f₂ := Submodule.mkQ 𝔪)
(g₁ := (LinearMap.ker i).subtype) (g₂ := i) (LinearMap.exact_subtype_mkQ 𝔪)
(Submodule.mkQ_surjective _) (LinearMap.exact_subtype_ker_map i) hi H ?_ ?_
· apply Module.Flat.lTensor_preserves_injective_linearMap
exact Subtype.val_injective
· apply hi'.injective
rw [LinearMap.baseChange_eq_ltensor]
erw [← LinearMap.comp_apply (i.lTensor k), ← LinearMap.lTensor_comp]
rw [(LinearMap.exact_subtype_ker_map i).linearMap_comp_eq_zero]
simp only [LinearMap.lTensor_zero, LinearMap.zero_apply, map_zero]
use Basis.ofRepr iequiv.symm
intro j
simp [iequiv, i] | lemma | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Torsion",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Flat.EquationalCriterion",
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mat... | Mathlib/RingTheory/LocalRing/Module.lean | exists_basis_of_basis_baseChange | If `M` is of finite presentation over a local ring `(R, 𝔪, k)` such that
`𝔪 ⊗ M → M` is injective, then every family of elements that is a `k`-basis of
`k ⊗ M` is an `R`-basis of `M`. |
exists_basis_of_span_of_maximalIdeal_rTensor_injective [Module.FinitePresentation R M]
(H : Function.Injective ((𝔪).subtype.rTensor M))
{ι : Type u} (v : ι → M) (hv : Submodule.span R (Set.range v) = ⊤) :
∃ (κ : Type u) (a : κ → ι) (b : Basis κ R M), ∀ i, b i = v (a i) := by
have := (map_tensorProduct_mk_eq_top (N := Submodule.span R (Set.range v))).mpr hv
rw [← Submodule.span_image, ← Set.range_comp, eq_top_iff, ← SetLike.coe_subset_coe,
Submodule.top_coe] at this
have : Submodule.span k (Set.range (TensorProduct.mk R k M 1 ∘ v)) = ⊤ := by
rw [eq_top_iff]
exact Set.Subset.trans this (Submodule.span_subset_span _ _ _)
obtain ⟨κ, a, ha, hsp, hli⟩ := exists_linearIndependent' k (TensorProduct.mk R k M 1 ∘ v)
rw [this] at hsp
obtain ⟨b, hb⟩ := exists_basis_of_basis_baseChange (v ∘ a) hli hsp H
use κ, a, b, hb | lemma | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Torsion",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Flat.EquationalCriterion",
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mat... | Mathlib/RingTheory/LocalRing/Module.lean | exists_basis_of_span_of_maximalIdeal_rTensor_injective | If `M` is a finitely presented module over a local ring `(R, 𝔪)` such that `m ⊗ M → M` is
injective, then every generating family contains a basis. |
exists_basis_of_span_of_flat [Module.FinitePresentation R M] [Module.Flat R M]
{ι : Type u} (v : ι → M) (hv : Submodule.span R (Set.range v) = ⊤) :
∃ (κ : Type u) (a : κ → ι) (b : Basis κ R M), ∀ i, b i = v (a i) :=
exists_basis_of_span_of_maximalIdeal_rTensor_injective
(Module.Flat.rTensor_preserves_injective_linearMap (𝔪).subtype Subtype.val_injective) v hv | lemma | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Torsion",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Flat.EquationalCriterion",
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mat... | Mathlib/RingTheory/LocalRing/Module.lean | exists_basis_of_span_of_flat | null |
free_of_maximalIdeal_rTensor_injective [Module.FinitePresentation R M]
(H : Function.Injective ((𝔪).subtype.rTensor M)) :
Module.Free R M := by
obtain ⟨_, _, b, _⟩ := exists_basis_of_span_of_maximalIdeal_rTensor_injective H id (by simp)
exact Free.of_basis b | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Torsion",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Flat.EquationalCriterion",
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mat... | Mathlib/RingTheory/LocalRing/Module.lean | free_of_maximalIdeal_rTensor_injective | If `M` is a finitely presented module over a local ring `(R, 𝔪)` such that `m ⊗ M → M` is
injective, then `M` is free. |
IsLocalRing.linearIndependent_of_flat [Flat R M] {ι : Type u} (v : ι → M)
(h : LinearIndependent k (TensorProduct.mk R k M 1 ∘ v)) : LinearIndependent R v := by
rw [linearIndependent_iff']; intro s f hfv i hi
classical
induction s using Finset.induction generalizing v i with
| empty => exact (Finset.notMem_empty _ hi).elim
| insert n s hn ih => ?_
rw [← Finset.sum_coe_sort] at hfv
have ⟨l, a, y, hay, hfa⟩ := Flat.isTrivialRelation_of_sum_smul_eq_zero hfv
have : v n ∉ 𝔪 • (⊤ : Submodule R M) := by
simpa only [← LinearMap.ker_tensorProductMk] using h.ne_zero n
set n : ↥(insert n s) := ⟨n, Finset.mem_insert_self ..⟩ with n_def
obtain ⟨j, hj⟩ : ∃ j, IsUnit (a n j) := by
contrapose! this
rw [show v n = _ from hay n]
exact sum_mem fun _ _ ↦ Submodule.smul_mem_smul (this _) ⟨⟩
let a' (i : ι) : R := if hi : _ then a ⟨i, hi⟩ j else 0
have a_eq i : a i j = a' i.1 := by simp_rw [a', dif_pos i.2]
have hfn : f n = -(∑ i ∈ s, f i * a' i) * hj.unit⁻¹ := by
rw [← hj.mul_left_inj, mul_assoc, hj.val_inv_mul, mul_one, eq_neg_iff_add_eq_zero]
convert hfa j
simp_rw [a_eq, Finset.sum_coe_sort _ (fun i ↦ f i * a' i), s.sum_insert hn, n_def]
let c (i : ι) : R := -(if i = n then 0 else a' i) * hj.unit⁻¹
specialize ih (v + (c · • v n)) ?_ ?_
· convert (linearIndependent_add_smul_iff (c := Ideal.Quotient.mk _ ∘ c) (i := n.1) ?_).mpr h
· ext; simp [tmul_add]; rfl
simp_rw [Function.comp_def, c, if_pos, neg_zero, zero_mul, map_zero]
· rw [Finset.sum_coe_sort _ (fun i ↦ f i • v i), s.sum_insert hn, add_comm, hfn] at hfv
simp_rw [Pi.add_apply, smul_add, s.sum_add_distrib, c, smul_smul, ← s.sum_smul, ← mul_assoc,
← s.sum_mul, mul_neg, s.sum_neg_distrib, ← hfv]
congr 4
exact s.sum_congr rfl fun i hi ↦ by rw [if_neg (ne_of_mem_of_not_mem hi hn)]
obtain hi | hi := Finset.mem_insert.mp hi
· rw [hi, hfn, Finset.sum_eq_zero, neg_zero, zero_mul]
intro i hi; rw [ih i hi, zero_mul]
· exact ih i hi
@[stacks 00NZ] | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Torsion",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Flat.EquationalCriterion",
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mat... | Mathlib/RingTheory/LocalRing/Module.lean | IsLocalRing.linearIndependent_of_flat | null |
free_of_flat_of_isLocalRing [Module.Finite R P] [Flat R P] : Free R P :=
let w := Free.chooseBasis k (k ⊗[R] P)
have ⟨v, eq⟩ := (TensorProduct.mk_surjective R P k Quotient.mk_surjective).comp_left w
.of_basis <| .mk (IsLocalRing.linearIndependent_of_flat _ (eq ▸ w.linearIndependent)) <| by
exact (span_eq_top_of_tmul_eq_basis _ w <| congr_fun eq).ge | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Torsion",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Flat.EquationalCriterion",
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mat... | Mathlib/RingTheory/LocalRing/Module.lean | free_of_flat_of_isLocalRing | null |
free_of_lTensor_residueField_injective (hg : Surjective g) (h : Exact f g)
[Module.Finite R M] [Module.Finite R N] [Module.Free R N]
(hf : Function.Injective (f.lTensor k)) :
Module.Free R P := by
have := Module.finitePresentation_of_free_of_surjective g hg
(by rw [h.linearMap_ker_eq, LinearMap.range_eq_map]; exact (Module.Finite.fg_top).map f)
apply free_of_maximalIdeal_rTensor_injective
rw [← LinearMap.lTensor_inj_iff_rTensor_inj]
apply lTensor_injective_of_exact_of_exact_of_rTensor_injective
h hg (LinearMap.exact_subtype_mkQ 𝔪) (Submodule.mkQ_surjective _)
((LinearMap.lTensor_inj_iff_rTensor_inj _ _).mp hf)
(Module.Flat.lTensor_preserves_injective_linearMap _ Subtype.val_injective) | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Torsion",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Flat.EquationalCriterion",
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mat... | Mathlib/RingTheory/LocalRing/Module.lean | free_of_lTensor_residueField_injective | If `M → N → P → 0` is a presentation of `P` over a local ring `(R, 𝔪, k)` with
`M` finite and `N` finite free, then injectivity of `k ⊗ M → k ⊗ N` implies that `P` is free. |
IsLocalRing.split_injective_iff_lTensor_residueField_injective [IsLocalRing R]
[Module.Finite R M] [Module.Finite R N] [Module.Free R N] (l : M →ₗ[R] N) :
(∃ l', l' ∘ₗ l = LinearMap.id) ↔ Function.Injective (l.lTensor (ResidueField R)) := by
constructor
· intro ⟨l', hl⟩
have : l'.lTensor (ResidueField R) ∘ₗ l.lTensor (ResidueField R) = .id := by
rw [← LinearMap.lTensor_comp, hl, LinearMap.lTensor_id]
exact Function.HasLeftInverse.injective ⟨_, LinearMap.congr_fun this⟩
· intro h
have := Module.free_of_lTensor_residueField_injective l (LinearMap.range l).mkQ
(Submodule.mkQ_surjective _) l.exact_map_mkQ_range h
have : Module.Projective R (LinearMap.range l) := by
have := (Exact.split_tfae (LinearMap.exact_subtype_mkQ (LinearMap.range l))
Subtype.val_injective (Submodule.mkQ_surjective _)).out 0 1
obtain ⟨l', hl'⟩ := this.mp
(Module.projective_lifting_property _ _ (Submodule.mkQ_surjective _))
exact Module.Projective.of_split _ _ hl'
obtain ⟨l', hl'⟩ : ∃ l', l' ∘ₗ (LinearMap.ker l).subtype = LinearMap.id := by
have : Function.Exact (LinearMap.ker l).subtype
(l.codRestrict (LinearMap.range l) (LinearMap.mem_range_self l)) := by
rw [LinearMap.exact_iff, LinearMap.ker_rangeRestrict, Submodule.range_subtype]
have := (Exact.split_tfae this
Subtype.val_injective (fun ⟨x, y, e⟩ ↦ ⟨y, Subtype.ext e⟩)).out 0 1
exact this.mp (Module.projective_lifting_property _ _ (fun ⟨x, y, e⟩ ↦ ⟨y, Subtype.ext e⟩))
have : Module.Finite R (LinearMap.ker l) := by
refine Module.Finite.of_surjective l' ?_
exact Function.HasRightInverse.surjective ⟨_, DFunLike.congr_fun hl'⟩
have H : Function.Injective ((LinearMap.ker l).subtype.lTensor k) := by
apply_fun (LinearMap.lTensor k) at hl'
rw [LinearMap.lTensor_comp, LinearMap.lTensor_id] at hl'
exact Function.HasLeftInverse.injective ⟨l'.lTensor k, DFunLike.congr_fun hl'⟩
have : Subsingleton (k ⊗[R] LinearMap.ker l) := by
refine (subsingleton_iff_forall_eq 0).mpr fun y ↦ H (h ?_)
rw [map_zero, map_zero, ← LinearMap.comp_apply, ← LinearMap.lTensor_comp,
l.exact_subtype_ker_map.linearMap_comp_eq_zero, LinearMap.lTensor_zero,
LinearMap.zero_apply]
have : Function.Injective l := by
rwa [← LinearMap.ker_eq_bot, ← Submodule.subsingleton_iff_eq_bot,
← IsLocalRing.subsingleton_tensorProduct (R := R)]
have := (Exact.split_tfae l.exact_map_mkQ_range this (Submodule.mkQ_surjective _)).out 0 1
rw [← this]
exact Module.projective_lifting_property _ _ (Submodule.mkQ_surjective _) | theorem | RingTheory | [
"Mathlib.Algebra.Module.FinitePresentation",
"Mathlib.Algebra.Module.Torsion",
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.Flat.EquationalCriterion",
"Mathlib.RingTheory.LocalRing.ResidueField.Basic",
"Mathlib.RingTheory.LocalRing.ResidueField.Ideal",
"Mat... | Mathlib/RingTheory/LocalRing/Module.lean | IsLocalRing.split_injective_iff_lTensor_residueField_injective | Given a linear map `l : M → N` over a local ring `(R, 𝔪, k)`
with `M` finite and `N` finite free,
`l` is a split injection if and only if `k ⊗ l` is a (split) injection. |
not_isLocalRing_def {R : Type*} [Semiring R] {a b : R} (ha : ¬IsUnit a) (hb : ¬IsUnit b)
(hab : a + b = 1) : ¬IsLocalRing R :=
fun _ ↦ hb <| (isUnit_or_isUnit_of_add_one hab).resolve_left ha | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Pi",
"Mathlib.Algebra.Ring.Prod",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Spectrum.Maximal.Basic"
] | Mathlib/RingTheory/LocalRing/NonLocalRing.lean | not_isLocalRing_def | If two non-units sum to 1 in a (semi)ring `R` then `R` is not local. |
not_isLocalRing_of_nontrivial_pi {ι : Type*} [Nontrivial ι] (R : ι → Type*)
[∀ i, Semiring (R i)] [∀ i, Nontrivial (R i)] : ¬IsLocalRing (Π i, R i) := by
classical
let ⟨i₁, i₂, hi⟩ := exists_pair_ne ι
have ha : ¬IsUnit (fun i ↦ if i = i₁ then 0 else 1 : Π i, R i) :=
fun h ↦ not_isUnit_zero (M₀ := R i₁) (by simpa using h.map (Pi.evalRingHom R i₁))
have hb : ¬IsUnit (fun i ↦ if i = i₁ then 1 else 0 : Π i, R i) :=
fun h ↦ not_isUnit_zero (M₀ := R i₂) (by simpa [hi.symm] using h.map (Pi.evalRingHom R i₂))
exact not_isLocalRing_def ha hb (by ext; dsimp; split <;> simp) | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Pi",
"Mathlib.Algebra.Ring.Prod",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Spectrum.Maximal.Basic"
] | Mathlib/RingTheory/LocalRing/NonLocalRing.lean | not_isLocalRing_of_nontrivial_pi | For an index type `ι` with at least two elements and an indexed family of (semi)rings
`R : ι → Type*`, the indexed product (semi)ring `Π i, R i` is not local. |
not_isLocalRing_of_prod_of_nontrivial (R₁ R₂ : Type*) [Semiring R₁] [Semiring R₂]
[Nontrivial R₁] [Nontrivial R₂] : ¬IsLocalRing (R₁ × R₂) :=
have ha : ¬IsUnit ((1, 0) : R₁ × R₂) :=
fun h ↦ not_isUnit_zero (M₀ := R₁) (by simpa using h.map (RingHom.snd R₁ R₂))
have hb : ¬IsUnit ((0, 1) : R₁ × R₂) :=
fun h ↦ not_isUnit_zero (M₀ := R₂) (by simpa using h.map (RingHom.fst R₁ R₂))
not_isLocalRing_def ha hb (by simp) | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Pi",
"Mathlib.Algebra.Ring.Prod",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Spectrum.Maximal.Basic"
] | Mathlib/RingTheory/LocalRing/NonLocalRing.lean | not_isLocalRing_of_prod_of_nontrivial | The product of two nontrivial (semi)rings is not local. |
not_isLocalRing_tfae {R : Type*} [CommSemiring R] [Nontrivial R] :
List.TFAE [
¬IsLocalRing R,
Nontrivial (MaximalSpectrum R),
∃ m₁ m₂ : Ideal R, m₁.IsMaximal ∧ m₂.IsMaximal ∧ m₁ ≠ m₂] := by
tfae_have 1 → 2
| h => not_subsingleton_iff_nontrivial.mp fun _ ↦ h of_singleton_maximalSpectrum
tfae_have 2 → 3
| ⟨⟨m₁, hm₁⟩, ⟨m₂, hm₂⟩, h⟩ => ⟨m₁, m₂, ⟨hm₁, hm₂, fun _ ↦ h (by congr)⟩⟩
tfae_have 3 → 1
| ⟨m₁, m₂, ⟨hm₁, hm₂, h⟩⟩ => fun _ ↦ h <| (eq_maximalIdeal hm₁).trans (eq_maximalIdeal hm₂).symm
tfae_finish | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Pi",
"Mathlib.Algebra.Ring.Prod",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Spectrum.Maximal.Basic"
] | Mathlib/RingTheory/LocalRing/NonLocalRing.lean | not_isLocalRing_tfae | The following conditions are equivalent for a commutative (semi)ring `R`:
* `R` is not local,
* the maximal spectrum of `R` is nontrivial,
* `R` has two distinct maximal ideals. |
exists_surjective_of_not_isLocalRing.{u} {R : Type u} [CommRing R] [Nontrivial R]
(h : ¬IsLocalRing R) :
∃ (K₁ K₂ : Type u) (_ : Field K₁) (_ : Field K₂) (f : R →+* K₁ × K₂),
Function.Surjective f := by
/- get two different maximal ideals and project on the product of quotients -/
obtain ⟨m₁, m₂, _, _, hm₁m₂⟩ := (not_isLocalRing_tfae.out 0 2).mp h
let e := Ideal.quotientInfEquivQuotientProd m₁ m₂ <| Ideal.isCoprime_of_isMaximal hm₁m₂
let f := e.toRingHom.comp <| Ideal.Quotient.mk (m₁ ⊓ m₂)
use R ⧸ m₁, R ⧸ m₂, Ideal.Quotient.field m₁, Ideal.Quotient.field m₂, f
apply Function.Surjective.comp e.surjective Ideal.Quotient.mk_surjective | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Pi",
"Mathlib.Algebra.Ring.Prod",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic",
"Mathlib.RingTheory.Spectrum.Maximal.Basic"
] | Mathlib/RingTheory/LocalRing/NonLocalRing.lean | exists_surjective_of_not_isLocalRing. | There exists a surjective ring homomorphism from a non-local commutative ring onto a product
of two fields. |
quotient_span_eq_top_iff_span_eq_top (s : Set S) :
span (R ⧸ p) ((Ideal.Quotient.mk (I := pS)) '' s) = ⊤ ↔ span R s = ⊤ := by
have H : (span (R ⧸ p) ((Ideal.Quotient.mk (I := pS)) '' s)).restrictScalars R =
(span R s).map (IsScalarTower.toAlgHom R S (S ⧸ pS)) := by
rw [map_span, ← restrictScalars_span R (R ⧸ p) Ideal.Quotient.mk_surjective,
IsScalarTower.coe_toAlgHom', Ideal.Quotient.algebraMap_eq]
constructor
· intro hs
rw [← top_le_iff]
apply le_of_le_smul_of_le_jacobson_bot
· exact Module.finite_def.mp ‹_›
· exact (jacobson_eq_maximalIdeal ⊥ bot_ne_top).ge
· rw [Ideal.smul_top_eq_map]
rintro x -
have : LinearMap.ker (IsScalarTower.toAlgHom R S (S ⧸ pS)) =
restrictScalars R pS := by
ext; simp [Ideal.Quotient.eq_zero_iff_mem]
rw [← this, ← comap_map_eq, mem_comap, ← H, hs, restrictScalars_top]
exact mem_top
· intro hs
rwa [hs, Submodule.map_top, LinearMap.range_eq_top.mpr,
restrictScalars_eq_top_iff] at H
rw [IsScalarTower.coe_toAlgHom', Ideal.Quotient.algebraMap_eq]
exact Ideal.Quotient.mk_surjective
attribute [local instance] Ideal.Quotient.field
variable [Module.Free R S] {ι : Type*} | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.DivisionRing",
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.StrongRankCondition",
"Mathlib.RingTheory.Artinian.Ring",
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Ideal.Quotient.Index",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs"... | Mathlib/RingTheory/LocalRing/Quotient.lean | quotient_span_eq_top_iff_span_eq_top | null |
finrank_quotient_map :
finrank (R ⧸ p) (S ⧸ pS) = finrank R S := by
classical
have : Module.Finite R (S ⧸ pS) := Module.Finite.of_surjective
(IsScalarTower.toAlgHom R S (S ⧸ pS)).toLinearMap (Ideal.Quotient.mk_surjective (I := pS))
have : Module.Finite (R ⧸ p) (S ⧸ pS) := Module.Finite.of_restrictScalars_finite R _ _
apply le_antisymm
· let b := Module.Free.chooseBasis R S
conv_rhs => rw [finrank_eq_card_chooseBasisIndex]
apply finrank_le_of_span_eq_top
rw [Set.range_comp]
apply (quotient_span_eq_top_iff_span_eq_top _).mpr b.span_eq
· let b := Module.Free.chooseBasis (R ⧸ p) (S ⧸ pS)
choose b' hb' using fun i ↦ Ideal.Quotient.mk_surjective (b i)
conv_rhs => rw [finrank_eq_card_chooseBasisIndex]
refine finrank_le_of_span_eq_top (v := b') ?_
apply (quotient_span_eq_top_iff_span_eq_top _).mp
rw [← Set.range_comp, show Ideal.Quotient.mk pS ∘ b' = ⇑b from funext hb']
exact b.span_eq | theorem | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.DivisionRing",
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.StrongRankCondition",
"Mathlib.RingTheory.Artinian.Ring",
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Ideal.Quotient.Index",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs"... | Mathlib/RingTheory/LocalRing/Quotient.lean | finrank_quotient_map | null |
noncomputable
basisQuotient [Fintype ι] (b : Basis ι R S) : Basis ι (R ⧸ p) (S ⧸ pS) :=
basisOfTopLeSpanOfCardEqFinrank (Ideal.Quotient.mk pS ∘ b)
(by
rw [Set.range_comp]
exact ((quotient_span_eq_top_iff_span_eq_top _).mpr b.span_eq).ge)
(by rw [finrank_quotient_map, finrank_eq_card_basis b]) | def | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.DivisionRing",
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.StrongRankCondition",
"Mathlib.RingTheory.Artinian.Ring",
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Ideal.Quotient.Index",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs"... | Mathlib/RingTheory/LocalRing/Quotient.lean | basisQuotient | Given a basis of `S`, the induced basis of `S / Ideal.map (algebraMap R S) p`. |
basisQuotient_apply [Fintype ι] (b : Basis ι R S) (i) :
(basisQuotient b) i = Ideal.Quotient.mk pS (b i) := by
delta basisQuotient
rw [coe_basisOfTopLeSpanOfCardEqFinrank, Function.comp_apply] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.DivisionRing",
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.StrongRankCondition",
"Mathlib.RingTheory.Artinian.Ring",
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Ideal.Quotient.Index",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs"... | Mathlib/RingTheory/LocalRing/Quotient.lean | basisQuotient_apply | null |
basisQuotient_repr {ι} [Fintype ι] (b : Basis ι R S) (x) (i) :
(basisQuotient b).repr (Ideal.Quotient.mk pS x) i =
Ideal.Quotient.mk p (b.repr x i) := by
refine congr_fun (g := Ideal.Quotient.mk p ∘ b.repr x) ?_ i
apply (Finsupp.linearEquivFunOnFinite (R ⧸ p) _ _).symm.injective
apply (basisQuotient b).repr.symm.injective
simp only [Finsupp.linearEquivFunOnFinite_symm_coe, LinearEquiv.symm_apply_apply,
Basis.repr_symm_apply]
rw [Finsupp.linearCombination_eq_fintype_linearCombination_apply (R ⧸ p),
Fintype.linearCombination_apply]
simp only [Function.comp_apply, basisQuotient_apply,
Ideal.Quotient.mk_smul_mk_quotient_map_quotient, ← Algebra.smul_def]
rw [← map_sum, Basis.sum_repr b x] | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.DivisionRing",
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.StrongRankCondition",
"Mathlib.RingTheory.Artinian.Ring",
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Ideal.Quotient.Index",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs"... | Mathlib/RingTheory/LocalRing/Quotient.lean | basisQuotient_repr | null |
exists_maximalIdeal_pow_le_of_isArtinianRing_quotient
(I : Ideal R) [IsArtinianRing (R ⧸ I)] : ∃ n, maximalIdeal R ^ n ≤ I := by
by_cases hI : I = ⊤
· simp [hI]
have : Nontrivial (R ⧸ I) := Ideal.Quotient.nontrivial hI
have := IsLocalRing.of_surjective' (Ideal.Quotient.mk I) Ideal.Quotient.mk_surjective
have := IsLocalHom.of_surjective (Ideal.Quotient.mk I) Ideal.Quotient.mk_surjective
obtain ⟨n, hn⟩ := IsArtinianRing.isNilpotent_jacobson_bot (R := R ⧸ I)
have : (maximalIdeal R).map (Ideal.Quotient.mk I) = maximalIdeal (R ⧸ I) := by
ext x
obtain ⟨x, rfl⟩ := Ideal.Quotient.mk_surjective x
simp [sup_eq_left.mpr (le_maximalIdeal hI)]
rw [jacobson_eq_maximalIdeal _ bot_ne_top, ← this, ← Ideal.map_pow, Ideal.zero_eq_bot,
Ideal.map_eq_bot_iff_le_ker, Ideal.mk_ker] at hn
exact ⟨n, hn⟩
@[deprecated (since := "2025-09-27")]
alias exists_maximalIdeal_pow_le_of_finite_quotient :=
exists_maximalIdeal_pow_le_of_isArtinianRing_quotient | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.DivisionRing",
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.StrongRankCondition",
"Mathlib.RingTheory.Artinian.Ring",
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Ideal.Quotient.Index",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs"... | Mathlib/RingTheory/LocalRing/Quotient.lean | exists_maximalIdeal_pow_le_of_isArtinianRing_quotient | null |
finite_quotient_iff [IsNoetherianRing R] [Finite (ResidueField R)] {I : Ideal R} :
Finite (R ⧸ I) ↔ ∃ n, (maximalIdeal R) ^ n ≤ I := by
refine ⟨fun _ ↦ exists_maximalIdeal_pow_le_of_isArtinianRing_quotient I, ?_⟩
rintro ⟨n, hn⟩
have : Finite (R ⧸ maximalIdeal R) := ‹_›
have := (Ideal.finite_quotient_pow (IsNoetherian.noetherian (maximalIdeal R)) n)
exact Finite.of_surjective _ (Ideal.Quotient.factor_surjective hn) | lemma | RingTheory | [
"Mathlib.LinearAlgebra.Dimension.DivisionRing",
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.StrongRankCondition",
"Mathlib.RingTheory.Artinian.Ring",
"Mathlib.RingTheory.Ideal.Over",
"Mathlib.RingTheory.Ideal.Quotient.Index",
"Mathlib.RingTheory.LocalRing.ResidueField.Defs"... | Mathlib/RingTheory/LocalRing/Quotient.lean | finite_quotient_iff | null |
of_injective [IsLocalRing S] {f : R →+* S} (hf : Function.Injective f)
(h : ∀ a, a ∈ R⁰ → IsUnit a) : IsLocalRing R := by
haveI : Nontrivial R := f.domain_nontrivial
refine .of_is_unit_or_is_unit_of_add_one fun {a b} hab ↦
(IsLocalRing.isUnit_or_isUnit_of_add_one (map_add f .. ▸ map_one f ▸ congrArg f hab)).imp ?_ ?_
<;> exact h _ ∘ mem_nonZeroDivisors_of_injective hf ∘ IsUnit.mem_nonZeroDivisors | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Subsemiring.Basic",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.RingTheory.LocalRing.Defs"
] | Mathlib/RingTheory/LocalRing/Subring.lean | of_injective | If a (semi)ring `R` in which every element is either invertible or a zero divisor
embeds in a local (semi)ring `S`, then `R` is local. |
of_subring [IsLocalRing S] {R : Subsemiring S} (h : ∀ a, a ∈ R⁰ → IsUnit a) :
IsLocalRing R :=
of_injective R.subtype_injective h | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Subsemiring.Basic",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.RingTheory.LocalRing.Defs"
] | Mathlib/RingTheory/LocalRing/Subring.lean | of_subring | If in a sub(semi)ring `R` of a local (semi)ring `S` every element is either
invertible or a zero divisor, then `R` is local. |
of_subring' {R R' : Subsemiring S} [IsLocalRing R'] (inc : R ≤ R')
(h : ∀ a, a ∈ R⁰ → IsUnit a) : IsLocalRing R :=
of_injective (Subsemiring.inclusion_injective inc) h | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Subsemiring.Basic",
"Mathlib.Algebra.GroupWithZero.NonZeroDivisors",
"Mathlib.RingTheory.LocalRing.Defs"
] | Mathlib/RingTheory/LocalRing/Subring.lean | of_subring' | If in a sub(semi)ring `R` of a local (semi)ring `R'` every element is either
invertible or a zero divisor, then `R` is local.
This version is for `R` and `R'` that are both sub(semi)rings of a (semi)ring `S`. |
MoritaEquivalence
(A : Type u₁) [Ring A] [Algebra R A]
(B : Type u₂) [Ring B] [Algebra R B] where
/-- The underlying equivalence of categories -/
eqv : ModuleCat.{max u₁ u₂} A ≌ ModuleCat.{max u₁ u₂} B
linear : eqv.functor.Linear R := by infer_instance | structure | RingTheory | [
"Mathlib.Algebra.Category.ModuleCat.ChangeOfRings",
"Mathlib.CategoryTheory.Linear.LinearFunctor",
"Mathlib.Algebra.Category.ModuleCat.Basic",
"Mathlib.CategoryTheory.Adjunction.Limits"
] | Mathlib/RingTheory/Morita/Basic.lean | MoritaEquivalence | Let `A` and `B` be `R`-algebras. A Morita equivalence between `A` and `B` is an `R`-linear
equivalence between the categories of `A`-modules and `B`-modules. |
refl (A : Type u₁) [Ring A] [Algebra R A] : MoritaEquivalence R A A where
eqv := CategoryTheory.Equivalence.refl
linear := Functor.instLinearId | def | RingTheory | [
"Mathlib.Algebra.Category.ModuleCat.ChangeOfRings",
"Mathlib.CategoryTheory.Linear.LinearFunctor",
"Mathlib.Algebra.Category.ModuleCat.Basic",
"Mathlib.CategoryTheory.Adjunction.Limits"
] | Mathlib/RingTheory/Morita/Basic.lean | refl | For any `R`-algebra `A`, `A` is Morita equivalent to itself. |
symm {A : Type u₁} [Ring A] [Algebra R A] {B : Type u₂} [Ring B] [Algebra R B]
(e : MoritaEquivalence R A B) : MoritaEquivalence R B A where
eqv := e.eqv.symm
linear := e.eqv.inverseLinear R | def | RingTheory | [
"Mathlib.Algebra.Category.ModuleCat.ChangeOfRings",
"Mathlib.CategoryTheory.Linear.LinearFunctor",
"Mathlib.Algebra.Category.ModuleCat.Basic",
"Mathlib.CategoryTheory.Adjunction.Limits"
] | Mathlib/RingTheory/Morita/Basic.lean | symm | For any `R`-algebras `A` and `B`, if `A` is Morita equivalent to `B`, then `B` is Morita equivalent
to `A`. |
trans {A B C : Type u₁}
[Ring A] [Algebra R A] [Ring B] [Algebra R B] [Ring C] [Algebra R C]
(e : MoritaEquivalence R A B) (e' : MoritaEquivalence R B C) :
MoritaEquivalence R A C where
eqv := e.eqv.trans e'.eqv
linear := e.eqv.functor.instLinearComp e'.eqv.functor
variable {R} in | def | RingTheory | [
"Mathlib.Algebra.Category.ModuleCat.ChangeOfRings",
"Mathlib.CategoryTheory.Linear.LinearFunctor",
"Mathlib.Algebra.Category.ModuleCat.Basic",
"Mathlib.CategoryTheory.Adjunction.Limits"
] | Mathlib/RingTheory/Morita/Basic.lean | trans | For any `R`-algebras `A`, `B`, and `C`, if `A` is Morita equivalent to `B` and `B` is Morita
equivalent to `C`, then `A` is Morita equivalent to `C`. |
noncomputable ofAlgEquiv {A : Type u₁} {B : Type u₂}
[Ring A] [Algebra R A] [Ring B] [Algebra R B] (f : A ≃ₐ[R] B) :
MoritaEquivalence R A B where
eqv := ModuleCat.restrictScalarsEquivalenceOfRingEquiv f.symm.toRingEquiv
linear := ModuleCat.Algebra.restrictScalarsEquivalenceOfRingEquiv_linear f.symm | def | RingTheory | [
"Mathlib.Algebra.Category.ModuleCat.ChangeOfRings",
"Mathlib.CategoryTheory.Linear.LinearFunctor",
"Mathlib.Algebra.Category.ModuleCat.Basic",
"Mathlib.CategoryTheory.Adjunction.Limits"
] | Mathlib/RingTheory/Morita/Basic.lean | ofAlgEquiv | Isomorphic `R`-algebras are Morita equivalent. |
IsMoritaEquivalent
(A : Type u₁) [Ring A] [Algebra R A]
(B : Type u₂) [Ring B] [Algebra R B] : Prop where
cond : Nonempty <| MoritaEquivalence R A B | structure | RingTheory | [
"Mathlib.Algebra.Category.ModuleCat.ChangeOfRings",
"Mathlib.CategoryTheory.Linear.LinearFunctor",
"Mathlib.Algebra.Category.ModuleCat.Basic",
"Mathlib.CategoryTheory.Adjunction.Limits"
] | Mathlib/RingTheory/Morita/Basic.lean | IsMoritaEquivalent | Let `A` and `B` be `R`-algebras. We say that `A` and `B` are Morita equivalent if the categories of
`A`-modules and `B`-modules are equivalent as `R`-linear categories. |
refl (A : Type u₁) [Ring A] [Algebra R A] : IsMoritaEquivalent R A A where
cond := ⟨.refl R A⟩ | lemma | RingTheory | [
"Mathlib.Algebra.Category.ModuleCat.ChangeOfRings",
"Mathlib.CategoryTheory.Linear.LinearFunctor",
"Mathlib.Algebra.Category.ModuleCat.Basic",
"Mathlib.CategoryTheory.Adjunction.Limits"
] | Mathlib/RingTheory/Morita/Basic.lean | refl | null |
symm {A : Type u₁} [Ring A] [Algebra R A] {B : Type u₂} [Ring B] [Algebra R B]
(h : IsMoritaEquivalent R A B) : IsMoritaEquivalent R B A where
cond := h.cond.map <| .symm R | lemma | RingTheory | [
"Mathlib.Algebra.Category.ModuleCat.ChangeOfRings",
"Mathlib.CategoryTheory.Linear.LinearFunctor",
"Mathlib.Algebra.Category.ModuleCat.Basic",
"Mathlib.CategoryTheory.Adjunction.Limits"
] | Mathlib/RingTheory/Morita/Basic.lean | symm | null |
trans {A B C : Type u₁} [Ring A] [Ring B] [Ring C] [Algebra R A] [Algebra R B] [Algebra R C]
(h : IsMoritaEquivalent R A B) (h' : IsMoritaEquivalent R B C) :
IsMoritaEquivalent R A C where
cond := Nonempty.map2 (.trans R) h.cond h'.cond | lemma | RingTheory | [
"Mathlib.Algebra.Category.ModuleCat.ChangeOfRings",
"Mathlib.CategoryTheory.Linear.LinearFunctor",
"Mathlib.Algebra.Category.ModuleCat.Basic",
"Mathlib.CategoryTheory.Adjunction.Limits"
] | Mathlib/RingTheory/Morita/Basic.lean | trans | null |
of_algEquiv {A : Type u₁} [Ring A] [Algebra R A] {B : Type u₂} [Ring B] [Algebra R B]
(f : A ≃ₐ[R] B) : IsMoritaEquivalent R A B where
cond := ⟨.ofAlgEquiv f⟩ | lemma | RingTheory | [
"Mathlib.Algebra.Category.ModuleCat.ChangeOfRings",
"Mathlib.CategoryTheory.Linear.LinearFunctor",
"Mathlib.Algebra.Category.ModuleCat.Basic",
"Mathlib.CategoryTheory.Adjunction.Limits"
] | Mathlib/RingTheory/Morita/Basic.lean | of_algEquiv | null |
mapRange_eq_map {R S : Type*} [CommSemiring R] [CommSemiring S] (p : MvPolynomial σ R)
(f : R →+* S) : Finsupp.mapRange f f.map_zero p = map f p := by
rw [p.as_sum, Finsupp.mapRange_finset_sum, map_sum (map f)]
refine Finset.sum_congr rfl fun n _ => ?_
rw [map_monomial, ← single_eq_monomial, Finsupp.mapRange_single, single_eq_monomial] | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.MvPolynomial.Degrees",
"Mathlib.Data.DFinsupp.Small",
"Mathlib.Data.Fintype.Pi",
"Mathlib.LinearAlgebra.Finsupp.VectorSpace",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic"
] | Mathlib/RingTheory/MvPolynomial/Basic.lean | mapRange_eq_map | null |
restrictSupport (s : Set (σ →₀ ℕ)) : Submodule R (MvPolynomial σ R) :=
Finsupp.supported _ _ s | def | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.MvPolynomial.Degrees",
"Mathlib.Data.DFinsupp.Small",
"Mathlib.Data.Fintype.Pi",
"Mathlib.LinearAlgebra.Finsupp.VectorSpace",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic"
] | Mathlib/RingTheory/MvPolynomial/Basic.lean | restrictSupport | The submodule of polynomials that are sum of monomials in the set `s`. |
basisRestrictSupport (s : Set (σ →₀ ℕ)) : Basis s R (restrictSupport R s) where
repr := Finsupp.supportedEquivFinsupp s | def | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.MvPolynomial.Degrees",
"Mathlib.Data.DFinsupp.Small",
"Mathlib.Data.Fintype.Pi",
"Mathlib.LinearAlgebra.Finsupp.VectorSpace",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic"
] | Mathlib/RingTheory/MvPolynomial/Basic.lean | basisRestrictSupport | `restrictSupport R s` has a canonical `R`-basis indexed by `s`. |
restrictSupport_mono {s t : Set (σ →₀ ℕ)} (h : s ⊆ t) :
restrictSupport R s ≤ restrictSupport R t := Finsupp.supported_mono h
variable (σ) | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.MvPolynomial.Degrees",
"Mathlib.Data.DFinsupp.Small",
"Mathlib.Data.Fintype.Pi",
"Mathlib.LinearAlgebra.Finsupp.VectorSpace",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic"
] | Mathlib/RingTheory/MvPolynomial/Basic.lean | restrictSupport_mono | null |
restrictTotalDegree (m : ℕ) : Submodule R (MvPolynomial σ R) :=
restrictSupport R { n | (n.sum fun _ e => e) ≤ m } | def | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.MvPolynomial.Degrees",
"Mathlib.Data.DFinsupp.Small",
"Mathlib.Data.Fintype.Pi",
"Mathlib.LinearAlgebra.Finsupp.VectorSpace",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic"
] | Mathlib/RingTheory/MvPolynomial/Basic.lean | restrictTotalDegree | The submodule of polynomials of total degree less than or equal to `m`. |
restrictDegree (m : ℕ) : Submodule R (MvPolynomial σ R) :=
restrictSupport R { n | ∀ i, n i ≤ m }
variable {R} | def | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.MvPolynomial.Degrees",
"Mathlib.Data.DFinsupp.Small",
"Mathlib.Data.Fintype.Pi",
"Mathlib.LinearAlgebra.Finsupp.VectorSpace",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic"
] | Mathlib/RingTheory/MvPolynomial/Basic.lean | restrictDegree | The submodule of polynomials such that the degree with respect to each individual variable is
less than or equal to `m`. |
mem_restrictTotalDegree (p : MvPolynomial σ R) :
p ∈ restrictTotalDegree σ R m ↔ p.totalDegree ≤ m := by
rw [totalDegree, Finset.sup_le_iff]
rfl | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.MvPolynomial.Degrees",
"Mathlib.Data.DFinsupp.Small",
"Mathlib.Data.Fintype.Pi",
"Mathlib.LinearAlgebra.Finsupp.VectorSpace",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic"
] | Mathlib/RingTheory/MvPolynomial/Basic.lean | mem_restrictTotalDegree | null |
mem_restrictDegree (p : MvPolynomial σ R) (n : ℕ) :
p ∈ restrictDegree σ R n ↔ ∀ s ∈ p.support, ∀ i, (s : σ →₀ ℕ) i ≤ n := by
rw [restrictDegree, restrictSupport, Finsupp.mem_supported]
rfl | theorem | RingTheory | [
"Mathlib.Algebra.CharP.Defs",
"Mathlib.Algebra.MvPolynomial.Degrees",
"Mathlib.Data.DFinsupp.Small",
"Mathlib.Data.Fintype.Pi",
"Mathlib.LinearAlgebra.Finsupp.VectorSpace",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic"
] | Mathlib/RingTheory/MvPolynomial/Basic.lean | mem_restrictDegree | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.