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 ⌀ |
|---|---|---|---|---|---|---|
spanSingleton_eq_zero_iff {y : P} : spanSingleton S y = 0 ↔ y = 0 :=
⟨fun h =>
span_eq_bot.mp (by simpa using congr_arg Subtype.val h : span R {y} = ⊥) y (mem_singleton y),
fun h => by simp [h]⟩ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | spanSingleton_eq_zero_iff | null |
spanSingleton_ne_zero_iff {y : P} : spanSingleton S y ≠ 0 ↔ y ≠ 0 :=
not_congr spanSingleton_eq_zero_iff
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | spanSingleton_ne_zero_iff | null |
spanSingleton_one : spanSingleton S (1 : P) = 1 := by
ext
refine (mem_spanSingleton S).trans ((exists_congr ?_).trans (mem_one_iff S).symm)
intro x'
rw [Algebra.smul_def, mul_one]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | spanSingleton_one | null |
spanSingleton_mul_spanSingleton (x y : P) :
spanSingleton S x * spanSingleton S y = spanSingleton S (x * y) := by
apply coeToSubmodule_injective
simp only [coe_mul, coe_spanSingleton, span_mul_span, singleton_mul_singleton]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | spanSingleton_mul_spanSingleton | null |
spanSingleton_pow (x : P) (n : ℕ) : spanSingleton S x ^ n = spanSingleton S (x ^ n) := by
induction n with
| zero => rw [pow_zero, pow_zero, spanSingleton_one]
| succ n hn => rw [pow_succ, hn, spanSingleton_mul_spanSingleton, pow_succ]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | spanSingleton_pow | null |
coeIdeal_span_singleton (x : R) :
(↑(Ideal.span {x} : Ideal R) : FractionalIdeal S P) = spanSingleton S (algebraMap R P x) := by
ext y
refine (mem_coeIdeal S).trans (Iff.trans ?_ (mem_spanSingleton S).symm)
constructor
· rintro ⟨y', hy', rfl⟩
obtain ⟨x', rfl⟩ := Submodule.mem_span_singleton.mp hy'
use x'
rw [smul_eq_mul, RingHom.map_mul, Algebra.smul_def]
· rintro ⟨y', rfl⟩
refine ⟨y' * x, Submodule.mem_span_singleton.mpr ⟨y', rfl⟩, ?_⟩
rw [RingHom.map_mul, Algebra.smul_def]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | coeIdeal_span_singleton | null |
canonicalEquiv_spanSingleton {P'} [CommRing P'] [Algebra R P'] [IsLocalization S P']
(x : P) :
canonicalEquiv S P P' (spanSingleton S x) =
spanSingleton S
(IsLocalization.map P' (RingHom.id R)
(fun y (hy : y ∈ S) => show RingHom.id R y ∈ S from hy) x) := by
apply SetLike.ext_iff.mpr
intro y
constructor <;> intro h
· rw [mem_spanSingleton]
obtain ⟨x', hx', rfl⟩ := (mem_canonicalEquiv_apply _ _ _).mp h
obtain ⟨z, rfl⟩ := (mem_spanSingleton _).mp hx'
use z
rw [IsLocalization.map_smul, RingHom.id_apply]
· rw [mem_canonicalEquiv_apply]
obtain ⟨z, rfl⟩ := (mem_spanSingleton _).mp h
use z • x
use (mem_spanSingleton _).mpr ⟨z, rfl⟩
simp [IsLocalization.map_smul] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | canonicalEquiv_spanSingleton | null |
mem_singleton_mul {x y : P} {I : FractionalIdeal S P} :
y ∈ spanSingleton S x * I ↔ ∃ y' ∈ I, y = x * y' := by
constructor
· intro h
refine FractionalIdeal.mul_induction_on h ?_ ?_
· intro x' hx' y' hy'
obtain ⟨a, ha⟩ := (mem_spanSingleton S).mp hx'
use a • y', Submodule.smul_mem (I : Submodule R P) a hy'
rw [← ha, Algebra.mul_smul_comm, Algebra.smul_mul_assoc]
· rintro _ _ ⟨y, hy, rfl⟩ ⟨y', hy', rfl⟩
exact ⟨y + y', Submodule.add_mem (I : Submodule R P) hy hy', (mul_add _ _ _).symm⟩
· rintro ⟨y', hy', rfl⟩
exact mul_mem_mul ((mem_spanSingleton S).mpr ⟨1, one_smul _ _⟩) hy'
variable (K) in | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | mem_singleton_mul | null |
mk'_mul_coeIdeal_eq_coeIdeal {I J : Ideal R₁} {x y : R₁} (hy : y ∈ R₁⁰) :
spanSingleton R₁⁰ (IsLocalization.mk' K x ⟨y, hy⟩) * I = (J : FractionalIdeal R₁⁰ K) ↔
Ideal.span {x} * I = Ideal.span {y} * J := by
have :
spanSingleton R₁⁰ (IsLocalization.mk' _ (1 : R₁) ⟨y, hy⟩) *
spanSingleton R₁⁰ (algebraMap R₁ K y) =
1 := by
rw [spanSingleton_mul_spanSingleton, mul_comm, ← IsLocalization.mk'_eq_mul_mk'_one,
IsLocalization.mk'_self, spanSingleton_one]
let y' : (FractionalIdeal R₁⁰ K)ˣ := Units.mkOfMulEqOne _ _ this
have coe_y' : ↑y' = spanSingleton R₁⁰ (IsLocalization.mk' K (1 : R₁) ⟨y, hy⟩) := rfl
refine Iff.trans ?_ (y'.mul_right_inj.trans coeIdeal_inj)
rw [coe_y', coeIdeal_mul, coeIdeal_span_singleton, coeIdeal_mul, coeIdeal_span_singleton, ←
mul_assoc, spanSingleton_mul_spanSingleton, ← mul_assoc, spanSingleton_mul_spanSingleton,
mul_comm (mk' _ _ _), ← IsLocalization.mk'_eq_mul_mk'_one, mul_comm (mk' _ _ _), ←
IsLocalization.mk'_eq_mul_mk'_one, IsLocalization.mk'_self, spanSingleton_one, one_mul] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | mk'_mul_coeIdeal_eq_coeIdeal | null |
spanSingleton_mul_coeIdeal_eq_coeIdeal {I J : Ideal R₁} {z : K} :
spanSingleton R₁⁰ z * (I : FractionalIdeal R₁⁰ K) = J ↔
Ideal.span {((IsLocalization.sec R₁⁰ z).1 : R₁)} * I =
Ideal.span {((IsLocalization.sec R₁⁰ z).2 : R₁)} * J := by
rw [← mk'_mul_coeIdeal_eq_coeIdeal K (IsLocalization.sec R₁⁰ z).2.prop,
IsLocalization.mk'_sec K z]
variable [IsDomain R₁] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | spanSingleton_mul_coeIdeal_eq_coeIdeal | null |
one_div_spanSingleton (x : K) : 1 / spanSingleton R₁⁰ x = spanSingleton R₁⁰ x⁻¹ := by
classical
exact if h : x = 0 then by simp [h] else (eq_one_div_of_mul_eq_one_right _ _ (by simp [h])).symm
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | one_div_spanSingleton | null |
div_spanSingleton (J : FractionalIdeal R₁⁰ K) (d : K) :
J / spanSingleton R₁⁰ d = spanSingleton R₁⁰ d⁻¹ * J := by
rw [← one_div_spanSingleton]
by_cases hd : d = 0
· simp only [hd, spanSingleton_zero, div_zero, zero_mul]
have h_spand : spanSingleton R₁⁰ d ≠ 0 := mt spanSingleton_eq_zero_iff.mp hd
apply le_antisymm
· intro x hx
dsimp only [val_eq_coe] at hx ⊢ -- Porting note: get rid of the partially applied `coe`s
rw [coe_div h_spand, Submodule.mem_div_iff_forall_mul_mem] at hx
specialize hx d (mem_spanSingleton_self R₁⁰ d)
have h_xd : x = d⁻¹ * (x * d) := by field_simp
rw [coe_mul, one_div_spanSingleton, h_xd]
exact Submodule.mul_mem_mul (mem_spanSingleton_self R₁⁰ _) hx
· rw [le_div_iff_mul_le h_spand, mul_assoc, mul_left_comm, one_div_spanSingleton,
spanSingleton_mul_spanSingleton, inv_mul_cancel₀ hd, spanSingleton_one, mul_one] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | div_spanSingleton | null |
exists_eq_spanSingleton_mul (I : FractionalIdeal R₁⁰ K) :
∃ (a : R₁) (aI : Ideal R₁), a ≠ 0 ∧ I = spanSingleton R₁⁰ (algebraMap R₁ K a)⁻¹ * aI := by
obtain ⟨a_inv, nonzero, ha⟩ := I.isFractional
have nonzero := mem_nonZeroDivisors_iff_ne_zero.mp nonzero
have map_a_nonzero : algebraMap R₁ K a_inv ≠ 0 :=
mt IsFractionRing.to_map_eq_zero_iff.mp nonzero
refine
⟨a_inv,
Submodule.comap (Algebra.linearMap R₁ K) ↑(spanSingleton R₁⁰ (algebraMap R₁ K a_inv) * I),
nonzero, ext fun x => Iff.trans ⟨?_, ?_⟩ mem_singleton_mul.symm⟩
· intro hx
obtain ⟨x', hx'⟩ := ha x hx
rw [Algebra.smul_def] at hx'
refine ⟨algebraMap R₁ K x', (mem_coeIdeal _).mpr ⟨x', mem_singleton_mul.mpr ?_, rfl⟩, ?_⟩
· exact ⟨x, hx, hx'⟩
· rw [hx', ← mul_assoc, inv_mul_cancel₀ map_a_nonzero, one_mul]
· rintro ⟨y, hy, rfl⟩
obtain ⟨x', hx', rfl⟩ := (mem_coeIdeal _).mp hy
obtain ⟨y', hy', hx'⟩ := mem_singleton_mul.mp hx'
rw [Algebra.linearMap_apply] at hx'
rwa [hx', ← mul_assoc, inv_mul_cancel₀ map_a_nonzero, one_mul] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | exists_eq_spanSingleton_mul | null |
ideal_factor_ne_zero {R} [CommRing R] {K : Type*} [Field K] [Algebra R K]
[IsFractionRing R K] {I : FractionalIdeal R⁰ K} (hI : I ≠ 0) {a : R} {J : Ideal R}
(haJ : I = spanSingleton R⁰ ((algebraMap R K) a)⁻¹ * ↑J) : J ≠ 0 := fun h ↦ by
rw [h, Ideal.zero_eq_bot, coeIdeal_bot, mul_zero] at haJ
exact hI haJ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | ideal_factor_ne_zero | If `I` is a nonzero fractional ideal, `a ∈ R`, and `J` is an ideal of `R` such that
`I = a⁻¹J`, then `J` is nonzero. |
constant_factor_ne_zero {R} [CommRing R] {K : Type*} [Field K] [Algebra R K]
[IsFractionRing R K] {I : FractionalIdeal R⁰ K} (hI : I ≠ 0) {a : R} {J : Ideal R}
(haJ : I = spanSingleton R⁰ ((algebraMap R K) a)⁻¹ * ↑J) :
(Ideal.span {a} : Ideal R) ≠ 0 := fun h ↦ by
rw [Ideal.zero_eq_bot, Ideal.span_singleton_eq_bot] at h
rw [h, RingHom.map_zero, inv_zero, spanSingleton_zero, zero_mul] at haJ
exact hI haJ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | constant_factor_ne_zero | If `I` is a nonzero fractional ideal, `a ∈ R`, and `J` is an ideal of `R` such that
`I = a⁻¹J`, then `a` is nonzero. |
isPrincipal {R} [CommRing R] [IsDomain R] [IsPrincipalIdealRing R] [Algebra R K]
[IsFractionRing R K] (I : FractionalIdeal R⁰ K) : (I : Submodule R K).IsPrincipal := by
obtain ⟨a, aI, -, ha⟩ := exists_eq_spanSingleton_mul I
use (algebraMap R K a)⁻¹ * algebraMap R K (generator aI)
suffices I = spanSingleton R⁰ ((algebraMap R K a)⁻¹ * algebraMap R K (generator aI)) by
rw [spanSingleton] at this
exact congr_arg Subtype.val this
conv_lhs => rw [ha, ← span_singleton_generator aI]
rw [Ideal.submodule_span_eq, coeIdeal_span_singleton (generator aI),
spanSingleton_mul_spanSingleton] | instance | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | isPrincipal | null |
le_spanSingleton_mul_iff {x : P} {I J : FractionalIdeal S P} :
I ≤ spanSingleton S x * J ↔ ∀ zI ∈ I, ∃ zJ ∈ J, x * zJ = zI :=
show (∀ {zI} (_ : zI ∈ I), zI ∈ spanSingleton _ x * J) ↔ ∀ zI ∈ I, ∃ zJ ∈ J, x * zJ = zI by
simp only [mem_singleton_mul, eq_comm] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | le_spanSingleton_mul_iff | null |
spanSingleton_mul_le_iff {x : P} {I J : FractionalIdeal S P} :
spanSingleton _ x * I ≤ J ↔ ∀ z ∈ I, x * z ∈ J := by
simp only [mul_le, mem_spanSingleton]
constructor
· intro h zI hzI
exact h x ⟨1, one_smul _ _⟩ zI hzI
· rintro h _ ⟨z, rfl⟩ zI hzI
rw [Algebra.smul_mul_assoc]
exact Submodule.smul_mem J.1 _ (h zI hzI) | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | spanSingleton_mul_le_iff | null |
eq_spanSingleton_mul {x : P} {I J : FractionalIdeal S P} :
I = spanSingleton _ x * J ↔ (∀ zI ∈ I, ∃ zJ ∈ J, x * zJ = zI) ∧ ∀ z ∈ J, x * z ∈ I := by
simp only [le_antisymm_iff, le_spanSingleton_mul_iff, spanSingleton_mul_le_iff] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | eq_spanSingleton_mul | null |
num_le (I : FractionalIdeal S P) :
(I.num : FractionalIdeal S P) ≤ I := by
rw [← I.den_mul_self_eq_num', spanSingleton_mul_le_iff]
intro _ h
rw [← Algebra.smul_def]
exact Submodule.smul_mem _ _ h | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | num_le | null |
isNoetherian_zero : IsNoetherian R₁ (0 : FractionalIdeal R₁⁰ K) :=
isNoetherian_submodule.mpr fun I (hI : I ≤ (0 : FractionalIdeal R₁⁰ K)) => by
rw [coe_zero, le_bot_iff] at hI
rw [hI]
exact fg_bot | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | isNoetherian_zero | null |
isNoetherian_iff {I : FractionalIdeal R₁⁰ K} :
IsNoetherian R₁ I ↔ ∀ J ≤ I, (J : Submodule R₁ K).FG :=
isNoetherian_submodule.trans ⟨fun h _ hJ => h _ hJ, fun h J hJ => h ⟨J, isFractional_of_le hJ⟩ hJ⟩ | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | isNoetherian_iff | null |
isNoetherian_coeIdeal [IsNoetherianRing R₁] (I : Ideal R₁) :
IsNoetherian R₁ (I : FractionalIdeal R₁⁰ K) := by
rw [isNoetherian_iff]
intro J hJ
obtain ⟨J, rfl⟩ := le_one_iff_exists_coeIdeal.mp (le_trans hJ coeIdeal_le_one)
exact (IsNoetherian.noetherian J).map _
variable [IsFractionRing R₁ K] [IsDomain R₁] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | isNoetherian_coeIdeal | null |
isNoetherian_spanSingleton_inv_to_map_mul (x : R₁) {I : FractionalIdeal R₁⁰ K}
(hI : IsNoetherian R₁ I) :
IsNoetherian R₁ (spanSingleton R₁⁰ (algebraMap R₁ K x)⁻¹ * I : FractionalIdeal R₁⁰ K) := by
classical
by_cases hx : x = 0
· rw [hx, RingHom.map_zero, inv_zero, spanSingleton_zero, zero_mul]
exact isNoetherian_zero
have h_gx : algebraMap R₁ K x ≠ 0 :=
mt ((injective_iff_map_eq_zero (algebraMap R₁ K)).mp (IsFractionRing.injective _ _) x) hx
have h_spanx : spanSingleton R₁⁰ (algebraMap R₁ K x) ≠ 0 := spanSingleton_ne_zero_iff.mpr h_gx
rw [isNoetherian_iff] at hI ⊢
intro J hJ
rw [← div_spanSingleton, le_div_iff_mul_le h_spanx] at hJ
obtain ⟨s, hs⟩ := hI _ hJ
use s * {(algebraMap R₁ K x)⁻¹}
rw [Finset.coe_mul, Finset.coe_singleton, ← span_mul_span, hs, ← coe_spanSingleton R₁⁰, ←
coe_mul, mul_assoc, spanSingleton_mul_spanSingleton, mul_inv_cancel₀ h_gx, spanSingleton_one,
mul_one] | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | isNoetherian_spanSingleton_inv_to_map_mul | null |
isNoetherian [IsNoetherianRing R₁] (I : FractionalIdeal R₁⁰ K) : IsNoetherian R₁ I := by
obtain ⟨d, J, _, rfl⟩ := exists_eq_spanSingleton_mul I
apply isNoetherian_spanSingleton_inv_to_map_mul
apply isNoetherian_coeIdeal | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | isNoetherian | Every fractional ideal of a Noetherian integral domain is Noetherian. |
isFractional_adjoin_integral (hx : IsIntegral R x) :
IsFractional S (Subalgebra.toSubmodule (Algebra.adjoin R ({x} : Set P))) :=
isFractional_of_fg hx.fg_adjoin_singleton | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | isFractional_adjoin_integral | `A[x]` is a fractional ideal for every integral `x`. |
adjoinIntegral (hx : IsIntegral R x) : FractionalIdeal S P :=
⟨_, isFractional_adjoin_integral S x hx⟩
@[simp] | def | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | adjoinIntegral | null |
adjoinIntegral_coe (hx : IsIntegral R x) :
(adjoinIntegral S x hx : Submodule R P) =
(Subalgebra.toSubmodule (Algebra.adjoin R ({x} : Set P))) :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | adjoinIntegral_coe | null |
mem_adjoinIntegral_self (hx : IsIntegral R x) : x ∈ adjoinIntegral S x hx :=
Algebra.subset_adjoin (Set.mem_singleton x) | theorem | RingTheory | [
"Mathlib.Algebra.EuclideanDomain.Basic",
"Mathlib.RingTheory.FractionalIdeal.Basic",
"Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic",
"Mathlib.RingTheory.LocalRing.Basic",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Tactic.FieldSimp"
] | Mathlib/RingTheory/FractionalIdeal/Operations.lean | mem_adjoinIntegral_self | null |
GradedRing (𝒜 : ι → σ) extends SetLike.GradedMonoid 𝒜, DirectSum.Decomposition 𝒜
variable [GradedRing 𝒜] | class | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | GradedRing | An internally-graded `R`-algebra `A` is one that can be decomposed into a collection
of `Submodule R A`s indexed by `ι` such that the canonical map `A → ⨁ i, 𝒜 i` is bijective and
respects multiplication, i.e. the product of an element of degree `i` and an element of degree `j`
is an element of degree `i + j`.
Note that the fact that `A` is internally-graded, `GradedAlgebra 𝒜`, implies an externally-graded
algebra structure `DirectSum.GAlgebra R (fun i ↦ ↥(𝒜 i))`, which in turn makes available an
`Algebra R (⨁ i, 𝒜 i)` instance. |
decomposeRingEquiv : A ≃+* ⨁ i, 𝒜 i :=
RingEquiv.symm
{ (decomposeAddEquiv 𝒜).symm with
map_mul' := (coeRingHom 𝒜).map_mul }
@[simp] | def | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | decomposeRingEquiv | If `A` is graded by `ι` with degree `i` component `𝒜 i`, then it is isomorphic as
a ring to a direct sum of components. |
decompose_one : decompose 𝒜 (1 : A) = 1 :=
map_one (decomposeRingEquiv 𝒜)
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | decompose_one | null |
decompose_symm_one : (decompose 𝒜).symm 1 = (1 : A) :=
map_one (decomposeRingEquiv 𝒜).symm
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | decompose_symm_one | null |
decompose_mul (x y : A) : decompose 𝒜 (x * y) = decompose 𝒜 x * decompose 𝒜 y :=
map_mul (decomposeRingEquiv 𝒜) x y
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | decompose_mul | null |
decompose_symm_mul (x y : ⨁ i, 𝒜 i) :
(decompose 𝒜).symm (x * y) = (decompose 𝒜).symm x * (decompose 𝒜).symm y :=
map_mul (decomposeRingEquiv 𝒜).symm x y | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | decompose_symm_mul | null |
GradedRing.proj (i : ι) : A →+ A :=
(AddSubmonoidClass.subtype (𝒜 i)).comp <|
(DFinsupp.evalAddMonoidHom i).comp <|
RingHom.toAddMonoidHom <| RingEquiv.toRingHom <| DirectSum.decomposeRingEquiv 𝒜
@[simp] | def | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | GradedRing.proj | The projection maps of a graded ring |
GradedRing.proj_apply (i : ι) (r : A) :
GradedRing.proj 𝒜 i r = (decompose 𝒜 r : ⨁ i, 𝒜 i) i :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | GradedRing.proj_apply | null |
GradedRing.proj_recompose (a : ⨁ i, 𝒜 i) (i : ι) :
GradedRing.proj 𝒜 i ((decompose 𝒜).symm a) = (decompose 𝒜).symm (DirectSum.of _ i (a i)) := by
rw [GradedRing.proj_apply, decompose_symm_of, Equiv.apply_symm_apply] | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | GradedRing.proj_recompose | null |
GradedRing.mem_support_iff [∀ (i) (x : 𝒜 i), Decidable (x ≠ 0)] (r : A) (i : ι) :
i ∈ (decompose 𝒜 r).support ↔ GradedRing.proj 𝒜 i r ≠ 0 :=
DFinsupp.mem_support_iff.trans ZeroMemClass.coe_eq_zero.not.symm | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | GradedRing.mem_support_iff | null |
coe_decompose_mul_add_of_left_mem [AddLeftCancelMonoid ι] [GradedRing 𝒜] {a b : A}
(a_mem : a ∈ 𝒜 i) : (decompose 𝒜 (a * b) (i + j) : A) = a * decompose 𝒜 b j := by
lift a to 𝒜 i using a_mem
rw [decompose_mul, decompose_coe, coe_of_mul_apply_add] | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | coe_decompose_mul_add_of_left_mem | null |
coe_decompose_mul_add_of_right_mem [AddRightCancelMonoid ι] [GradedRing 𝒜] {a b : A}
(b_mem : b ∈ 𝒜 j) : (decompose 𝒜 (a * b) (i + j) : A) = decompose 𝒜 a i * b := by
lift b to 𝒜 j using b_mem
rw [decompose_mul, decompose_coe, coe_mul_of_apply_add] | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | coe_decompose_mul_add_of_right_mem | null |
decompose_mul_add_left [AddLeftCancelMonoid ι] [GradedRing 𝒜] (a : 𝒜 i) {b : A} :
decompose 𝒜 (↑a * b) (i + j) =
@GradedMonoid.GMul.mul ι (fun i => 𝒜 i) _ _ _ _ a (decompose 𝒜 b j) :=
Subtype.ext <| coe_decompose_mul_add_of_left_mem 𝒜 a.2 | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | decompose_mul_add_left | null |
decompose_mul_add_right [AddRightCancelMonoid ι] [GradedRing 𝒜] {a : A} (b : 𝒜 j) :
decompose 𝒜 (a * ↑b) (i + j) =
@GradedMonoid.GMul.mul ι (fun i => 𝒜 i) _ _ _ _ (decompose 𝒜 a i) b :=
Subtype.ext <| coe_decompose_mul_add_of_right_mem 𝒜 b.2 | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | decompose_mul_add_right | null |
coe_decompose_mul_of_left_mem_zero [AddMonoid ι] [GradedRing 𝒜] {a b : A}
(a_mem : a ∈ 𝒜 0) : (decompose 𝒜 (a * b) j : A) = a * decompose 𝒜 b j := by
lift a to 𝒜 0 using a_mem
rw [decompose_mul, decompose_coe, coe_of_mul_apply_of_mem_zero] | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | coe_decompose_mul_of_left_mem_zero | null |
coe_decompose_mul_of_right_mem_zero [AddMonoid ι] [GradedRing 𝒜] {a b : A}
(b_mem : b ∈ 𝒜 0) : (decompose 𝒜 (a * b) i : A) = decompose 𝒜 a i * b := by
lift b to 𝒜 0 using b_mem
rw [decompose_mul, decompose_coe, coe_mul_of_apply_of_mem_zero] | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | coe_decompose_mul_of_right_mem_zero | null |
GradedAlgebra :=
GradedRing 𝒜 | abbrev | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | GradedAlgebra | A special case of `GradedRing` with `σ = Submodule R A`. This is useful both because it
can avoid typeclass search, and because it provides a more concise name. |
GradedAlgebra.ofAlgHom [SetLike.GradedMonoid 𝒜] (decompose : A →ₐ[R] ⨁ i, 𝒜 i)
(right_inv : (DirectSum.coeAlgHom 𝒜).comp decompose = AlgHom.id R A)
(left_inv : ∀ i (x : 𝒜 i), decompose (x : A) = DirectSum.of (fun i => ↥(𝒜 i)) i x) :
GradedAlgebra 𝒜 where
decompose' := decompose
left_inv := AlgHom.congr_fun right_inv
right_inv := by
suffices decompose.comp (DirectSum.coeAlgHom 𝒜) = AlgHom.id _ _ from AlgHom.congr_fun this
ext i x : 2
exact (decompose.congr_arg <| DirectSum.coeAlgHom_of _ _ _).trans (left_inv i x)
variable [GradedAlgebra 𝒜] | abbrev | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | GradedAlgebra.ofAlgHom | A helper to construct a `GradedAlgebra` when the `SetLike.GradedMonoid` structure is already
available. This makes the `left_inv` condition easier to prove, and phrases the `right_inv`
condition in a way that allows custom `@[ext]` lemmas to apply.
See note [reducible non-instances]. |
GradedAlgebra.proj (𝒜 : ι → Submodule R A) [GradedAlgebra 𝒜] (i : ι) : A →ₗ[R] A :=
(𝒜 i).subtype.comp <| (DFinsupp.lapply i).comp <| (decomposeAlgEquiv 𝒜).toAlgHom.toLinearMap
@[simp] | def | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | GradedAlgebra.proj | If `A` is graded by `ι` with degree `i` component `𝒜 i`, then it is isomorphic as
an algebra to a direct sum of components. -/
-- We have to write the `@[simps]` lemmas by hand to see through the
-- `AlgEquiv.symm (decomposeAddEquiv 𝒜).symm`.
def decomposeAlgEquiv : A ≃ₐ[R] ⨁ i, 𝒜 i :=
AlgEquiv.symm
{ (decomposeAddEquiv 𝒜).symm with
map_mul' := map_mul (coeAlgHom 𝒜)
commutes' := (coeAlgHom 𝒜).commutes }
@[simp]
lemma decomposeAlgEquiv_apply (a : A) :
decomposeAlgEquiv 𝒜 a = decompose 𝒜 a := rfl
@[simp]
lemma decomposeAlgEquiv_symm_apply (a : ⨁ i, 𝒜 i) :
(decomposeAlgEquiv 𝒜).symm a = (decompose 𝒜).symm a := rfl
@[simp]
lemma decompose_algebraMap (r : R) :
decompose 𝒜 (algebraMap R A r) = algebraMap R (⨁ i, 𝒜 i) r :=
(decomposeAlgEquiv 𝒜).commutes r
@[simp]
lemma decompose_symm_algebraMap (r : R) :
(decompose 𝒜).symm (algebraMap R (⨁ i, 𝒜 i) r) = algebraMap R A r :=
(decomposeAlgEquiv 𝒜).symm.commutes r
end DirectSum
open DirectSum
/-- The projection maps of graded algebra |
GradedAlgebra.proj_apply (i : ι) (r : A) :
GradedAlgebra.proj 𝒜 i r = (decompose 𝒜 r : ⨁ i, 𝒜 i) i :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | GradedAlgebra.proj_apply | null |
GradedAlgebra.proj_recompose (a : ⨁ i, 𝒜 i) (i : ι) :
GradedAlgebra.proj 𝒜 i ((decompose 𝒜).symm a) = (decompose 𝒜).symm (of _ i (a i)) := by
rw [GradedAlgebra.proj_apply, decompose_symm_of, Equiv.apply_symm_apply] | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | GradedAlgebra.proj_recompose | null |
GradedAlgebra.mem_support_iff [DecidableEq A] (r : A) (i : ι) :
i ∈ (decompose 𝒜 r).support ↔ GradedAlgebra.proj 𝒜 i r ≠ 0 :=
DFinsupp.mem_support_iff.trans Submodule.coe_eq_zero.not.symm | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | GradedAlgebra.mem_support_iff | null |
@[simps]
GradedRing.projZeroRingHom : A →+* A where
toFun a := decompose 𝒜 a 0
map_one' := decompose_of_mem_same 𝒜 SetLike.GradedOne.one_mem
map_zero' := by rw [decompose_zero, zero_apply, ZeroMemClass.coe_zero]
map_add' _ _ := by rw [decompose_add, add_apply, AddMemClass.coe_add]
map_mul' := by
refine DirectSum.Decomposition.inductionOn 𝒜 (fun x => ?_) ?_ ?_
· simp only [zero_mul, decompose_zero, zero_apply, ZeroMemClass.coe_zero]
· rintro i ⟨c, hc⟩
refine DirectSum.Decomposition.inductionOn 𝒜 ?_ ?_ ?_
· simp only [mul_zero, decompose_zero, zero_apply, ZeroMemClass.coe_zero]
· rintro j ⟨c', hc'⟩
simp only
by_cases h : i + j = 0
· rw [decompose_of_mem_same 𝒜
(show c * c' ∈ 𝒜 0 from h ▸ SetLike.GradedMul.mul_mem hc hc'),
decompose_of_mem_same 𝒜 (show c ∈ 𝒜 0 from (add_eq_zero.mp h).1 ▸ hc),
decompose_of_mem_same 𝒜 (show c' ∈ 𝒜 0 from (add_eq_zero.mp h).2 ▸ hc')]
· rw [decompose_of_mem_ne 𝒜 (SetLike.GradedMul.mul_mem hc hc') h]
rcases show i ≠ 0 ∨ j ≠ 0 by rwa [add_eq_zero, not_and_or] at h with h' | h'
· simp only [decompose_of_mem_ne 𝒜 hc h', zero_mul]
· simp only [decompose_of_mem_ne 𝒜 hc' h', mul_zero]
· intro _ _ hd he
simp only [mul_add, decompose_add, add_apply, AddMemClass.coe_add, hd, he]
· rintro _ _ ha hb _
simp only [add_mul, decompose_add, add_apply, AddMemClass.coe_add, ha, hb] | def | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | GradedRing.projZeroRingHom | If `A` is graded by a canonically ordered additive monoid, then the projection map `x ↦ x₀`
is a ring homomorphism. |
GradedRing.projZeroRingHom' : A →+* 𝒜 0 :=
((GradedRing.projZeroRingHom 𝒜).codRestrict _ fun _x => SetLike.coe_mem _ :
A →+* SetLike.GradeZero.subsemiring 𝒜)
@[simp] lemma GradedRing.coe_projZeroRingHom'_apply (a : A) :
(GradedRing.projZeroRingHom' 𝒜 a : A) = GradedRing.projZeroRingHom 𝒜 a := rfl
@[simp] lemma GradedRing.projZeroRingHom'_apply_coe (a : 𝒜 0) :
GradedRing.projZeroRingHom' 𝒜 a = a := by
ext; simp only [coe_projZeroRingHom'_apply, projZeroRingHom_apply, decompose_coe, of_eq_same] | def | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | GradedRing.projZeroRingHom' | The ring homomorphism from `A` to `𝒜 0` sending every `a : A` to `a₀`. |
GradedRing.projZeroRingHom'_surjective :
Function.Surjective (GradedRing.projZeroRingHom' 𝒜) :=
Function.RightInverse.surjective (GradedRing.projZeroRingHom'_apply_coe 𝒜) | lemma | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | GradedRing.projZeroRingHom'_surjective | The ring homomorphism `GradedRing.projZeroRingHom' 𝒜` is surjective. |
coe_decompose_mul_of_left_mem_of_not_le (a_mem : a ∈ 𝒜 i) (h : ¬i ≤ n) :
(decompose 𝒜 (a * b) n : A) = 0 := by
lift a to 𝒜 i using a_mem
rwa [decompose_mul, decompose_coe, coe_of_mul_apply_of_not_le] | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | coe_decompose_mul_of_left_mem_of_not_le | null |
coe_decompose_mul_of_right_mem_of_not_le (b_mem : b ∈ 𝒜 i) (h : ¬i ≤ n) :
(decompose 𝒜 (a * b) n : A) = 0 := by
lift b to 𝒜 i using b_mem
rwa [decompose_mul, decompose_coe, coe_mul_of_apply_of_not_le]
variable [Sub ι] [OrderedSub ι] [AddLeftReflectLE ι] | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | coe_decompose_mul_of_right_mem_of_not_le | null |
coe_decompose_mul_of_left_mem_of_le (a_mem : a ∈ 𝒜 i) (h : i ≤ n) :
(decompose 𝒜 (a * b) n : A) = a * decompose 𝒜 b (n - i) := by
lift a to 𝒜 i using a_mem
rwa [decompose_mul, decompose_coe, coe_of_mul_apply_of_le] | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | coe_decompose_mul_of_left_mem_of_le | null |
coe_decompose_mul_of_right_mem_of_le (b_mem : b ∈ 𝒜 i) (h : i ≤ n) :
(decompose 𝒜 (a * b) n : A) = decompose 𝒜 a (n - i) * b := by
lift b to 𝒜 i using b_mem
rwa [decompose_mul, decompose_coe, coe_mul_of_apply_of_le] | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | coe_decompose_mul_of_right_mem_of_le | null |
coe_decompose_mul_of_left_mem (n) [Decidable (i ≤ n)] (a_mem : a ∈ 𝒜 i) :
(decompose 𝒜 (a * b) n : A) = if i ≤ n then a * decompose 𝒜 b (n - i) else 0 := by
lift a to 𝒜 i using a_mem
rw [decompose_mul, decompose_coe, coe_of_mul_apply] | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | coe_decompose_mul_of_left_mem | null |
coe_decompose_mul_of_right_mem (n) [Decidable (i ≤ n)] (b_mem : b ∈ 𝒜 i) :
(decompose 𝒜 (a * b) n : A) = if i ≤ n then decompose 𝒜 a (n - i) * b else 0 := by
lift b to 𝒜 i using b_mem
rw [decompose_mul, decompose_coe, coe_mul_of_apply] | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | coe_decompose_mul_of_right_mem | null |
noncomputable coeAlgEquiv (hM : DirectSum.IsInternal M) :
(DirectSum ι fun i => ↥(M i)) ≃ₐ[R] A :=
{ RingEquiv.ofBijective (DirectSum.coeAlgHom M) hM with commutes' := fun r => by simp } | def | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | coeAlgEquiv | The canonical isomorphism of an internal direct sum with the ambient algebra |
noncomputable gradedAlgebra (hM : DirectSum.IsInternal M) : GradedAlgebra M :=
{ (inferInstance : SetLike.GradedMonoid M) with
decompose' := hM.coeAlgEquiv.symm
left_inv := hM.coeAlgEquiv.symm.left_inv
right_inv := hM.coeAlgEquiv.left_inv } | def | RingTheory | [
"Mathlib.Algebra.DirectSum.Algebra",
"Mathlib.Algebra.DirectSum.Decomposition",
"Mathlib.Algebra.DirectSum.Internal",
"Mathlib.Algebra.DirectSum.Ring"
] | Mathlib/RingTheory/GradedAlgebra/Basic.lean | gradedAlgebra | Given an `R`-algebra `A` and a family `ι → Submodule R A` of submodules
parameterized by an additive monoid `ι`
and satisfying `SetLike.GradedMonoid M` (essentially, is multiplicative)
such that `DirectSum.IsInternal M` (`A` is the direct sum of the `M i`),
we endow `A` with the structure of a graded algebra.
The submodules are the *homogeneous* parts. |
exists_finset_adjoin_eq_top_and_homogeneous :
∃ s : Finset S, Algebra.adjoin (A := S) (𝒜 0) s = ⊤ ∧
∀ i ∈ s, SetLike.IsHomogeneousElem 𝒜 i := by
classical
obtain ⟨F, hF⟩ := Algebra.FiniteType.out (R := 𝒜 0) (A := S)
let ι₀ := Σ (x : F), (DirectSum.decompose 𝒜 x.1).support
let x (i : ι₀) : S := ((DirectSum.decompose 𝒜) i.1 i.2).1
refine ⟨Finset.univ.image x, ?_, by simpa using fun f ↦ ⟨_, (DirectSum.decompose 𝒜 f.1 f.2).2⟩⟩
rw [← top_le_iff, ← hF, Algebra.adjoin_le_iff]
intro s hs
rw [← DirectSum.sum_support_decompose 𝒜 s]
exact sum_mem fun n hn ↦ Algebra.subset_adjoin (by simpa using ⟨⟨⟨s, hs⟩, n, hn⟩, rfl⟩) | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/GradedAlgebra/FiniteType.lean | exists_finset_adjoin_eq_top_and_homogeneous | null |
exists_finset_adjoin_eq_top_and_homogeneous_ne_zero :
∃ s : Finset S, Algebra.adjoin (A := S) (𝒜 0) s = ⊤ ∧ ∀ i ∈ s, ∃ n ≠ 0, i ∈ 𝒜 n := by
obtain ⟨s, h₁, h₂⟩ := exists_finset_adjoin_eq_top_and_homogeneous 𝒜
choose! n hn using h₂
refine ⟨s.filter (n · ≠ 0), ?_, by simpa using fun i hi hin ↦ ⟨n i, hin, hn i hi⟩⟩
rw [← top_le_iff, ← h₁, Algebra.adjoin_le_iff]
rintro i hi
by_cases hi0 : n i = 0
· exact Subalgebra.algebraMap_mem
(Algebra.adjoin (𝒜 0) (s.filter (n · ≠ 0)).toSet) ⟨i, hi0 ▸ hn i hi⟩
· exact Algebra.subset_adjoin (by simpa [hi0] using hi) | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteType",
"Mathlib.RingTheory.GradedAlgebra.Basic"
] | Mathlib/RingTheory/GradedAlgebra/FiniteType.lean | exists_finset_adjoin_eq_top_and_homogeneous_ne_zero | null |
NumDenSameDeg where
deg : ι
(num den : 𝒜 deg)
den_mem : (den : A) ∈ x | structure | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | NumDenSameDeg | Let `x` be a submonoid of `A`, then `NumDenSameDeg 𝒜 x` is a structure with a numerator and a
denominator with same grading such that the denominator is contained in `x`. |
@[ext]
ext {c1 c2 : NumDenSameDeg 𝒜 x} (hdeg : c1.deg = c2.deg) (hnum : (c1.num : A) = c2.num)
(hden : (c1.den : A) = c2.den) : c1 = c2 := by
rcases c1 with ⟨i1, ⟨n1, hn1⟩, ⟨d1, hd1⟩, h1⟩
rcases c2 with ⟨i2, ⟨n2, hn2⟩, ⟨d2, hd2⟩, h2⟩
dsimp only [Subtype.coe_mk] at *
subst hdeg hnum hden
congr | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | ext | null |
@[simp]
deg_neg (c : NumDenSameDeg 𝒜 x) : (-c).deg = c.deg :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | deg_neg | null |
num_neg (c : NumDenSameDeg 𝒜 x) : ((-c).num : A) = -c.num :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | num_neg | null |
den_neg (c : NumDenSameDeg 𝒜 x) : ((-c).den : A) = c.den :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | den_neg | null |
@[simp]
deg_smul (c : NumDenSameDeg 𝒜 x) (m : α) : (m • c).deg = c.deg :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | deg_smul | null |
num_smul (c : NumDenSameDeg 𝒜 x) (m : α) : ((m • c).num : A) = m • c.num :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | num_smul | null |
den_smul (c : NumDenSameDeg 𝒜 x) (m : α) : ((m • c).den : A) = c.den :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | den_smul | null |
@[simp]
deg_one : (1 : NumDenSameDeg 𝒜 x).deg = 0 :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | deg_one | null |
num_one : ((1 : NumDenSameDeg 𝒜 x).num : A) = 1 :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | num_one | null |
den_one : ((1 : NumDenSameDeg 𝒜 x).den : A) = 1 :=
rfl
open GradedOne in | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | den_one | null |
@[simp]
deg_zero : (0 : NumDenSameDeg 𝒜 x).deg = 0 :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | deg_zero | null |
num_zero : (0 : NumDenSameDeg 𝒜 x).num = 0 :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | num_zero | null |
den_zero : ((0 : NumDenSameDeg 𝒜 x).den : A) = 1 :=
rfl
open GradedMul in | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | den_zero | null |
@[simp]
deg_mul (c1 c2 : NumDenSameDeg 𝒜 x) : (c1 * c2).deg = c1.deg + c2.deg :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | deg_mul | null |
num_mul (c1 c2 : NumDenSameDeg 𝒜 x) : ((c1 * c2).num : A) = c1.num * c2.num :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | num_mul | null |
den_mul (c1 c2 : NumDenSameDeg 𝒜 x) : ((c1 * c2).den : A) = c1.den * c2.den :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | den_mul | null |
@[simp]
deg_add (c1 c2 : NumDenSameDeg 𝒜 x) : (c1 + c2).deg = c1.deg + c2.deg :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | deg_add | null |
num_add (c1 c2 : NumDenSameDeg 𝒜 x) :
((c1 + c2).num : A) = c1.den * c2.num + c2.den * c1.num :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | num_add | null |
den_add (c1 c2 : NumDenSameDeg 𝒜 x) : ((c1 + c2).den : A) = c1.den * c2.den :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | den_add | null |
@[simp]
deg_pow (c : NumDenSameDeg 𝒜 x) (n : ℕ) : (c ^ n).deg = n • c.deg :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | deg_pow | null |
num_pow (c : NumDenSameDeg 𝒜 x) (n : ℕ) : ((c ^ n).num : A) = (c.num : A) ^ n :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | num_pow | null |
den_pow (c : NumDenSameDeg 𝒜 x) (n : ℕ) : ((c ^ n).den : A) = (c.den : A) ^ n :=
rfl
variable (𝒜) | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | den_pow | null |
embedding (p : NumDenSameDeg 𝒜 x) : at x :=
Localization.mk p.num ⟨p.den, p.den_mem⟩ | def | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | embedding | For `x : prime ideal of A` and any `p : NumDenSameDeg 𝒜 x`, or equivalent a numerator and a
denominator of the same degree, we get an element `p.num / p.den` of `Aₓ`. |
HomogeneousLocalization : Type _ :=
Quotient (Setoid.ker <| HomogeneousLocalization.NumDenSameDeg.embedding 𝒜 x) | def | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | HomogeneousLocalization | For `x : prime ideal of A`, `HomogeneousLocalization 𝒜 x` is `NumDenSameDeg 𝒜 x` modulo the
kernel of `embedding 𝒜 x`. This is essentially the subring of `Aₓ` where the numerator and
denominator share the same grading. |
mk (y : HomogeneousLocalization.NumDenSameDeg 𝒜 x) : HomogeneousLocalization 𝒜 x :=
Quotient.mk'' y | abbrev | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | mk | Construct an element of `HomogeneousLocalization 𝒜 x` from a homogeneous fraction. |
mk_surjective : Function.Surjective (mk (𝒜 := 𝒜) (x := x)) :=
Quotient.mk''_surjective | lemma | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | mk_surjective | null |
val (y : HomogeneousLocalization 𝒜 x) : at x :=
Quotient.liftOn' y (NumDenSameDeg.embedding 𝒜 x) fun _ _ => id
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | val | View an element of `HomogeneousLocalization 𝒜 x` as an element of `Aₓ` by forgetting that the
numerator and denominator are of the same grading. |
val_mk (i : NumDenSameDeg 𝒜 x) :
val (mk i) = Localization.mk (i.num : A) ⟨i.den, i.den_mem⟩ :=
rfl
variable (x)
@[ext] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | val_mk | null |
val_injective : Function.Injective (HomogeneousLocalization.val (𝒜 := 𝒜) (x := x)) :=
fun a b => Quotient.recOnSubsingleton₂' a b fun _ _ h => Quotient.sound' h
variable (𝒜) {x} in | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | val_injective | null |
subsingleton (hx : 0 ∈ x) : Subsingleton (HomogeneousLocalization 𝒜 x) :=
have := IsLocalization.subsingleton (S := at x) hx
(HomogeneousLocalization.val_injective (𝒜 := 𝒜) (x := x)).subsingleton | lemma | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | subsingleton | null |
@[simp] mk_smul (i : NumDenSameDeg 𝒜 x) (m : α) : mk (m • i) = m • mk i := rfl
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | mk_smul | null |
val_smul (n : α) : ∀ y : HomogeneousLocalization 𝒜 x, (n • y).val = n • y.val :=
Quotient.ind' fun _ ↦ by rw [← mk_smul, val_mk, val_mk, Localization.smul_mk]; rfl | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | val_smul | null |
val_nsmul (n : ℕ) (y : HomogeneousLocalization 𝒜 x) : (n • y).val = n • y.val := by
rw [val_smul, OreLocalization.nsmul_eq_nsmul] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | val_nsmul | null |
val_zsmul (n : ℤ) (y : HomogeneousLocalization 𝒜 x) : (n • y).val = n • y.val := by
rw [val_smul, OreLocalization.zsmul_eq_zsmul] | theorem | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | val_zsmul | null |
@[simp] mk_neg (i : NumDenSameDeg 𝒜 x) : mk (-i) = -mk i := rfl
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.Group.Submonoid.Finsupp",
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.RingTheory.Adjoin.Basic",
"Mathlib.RingTheory.GradedAlgebra.FiniteType",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Localization.Away.Basic"
] | Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean | mk_neg | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.