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 ⌀ |
|---|---|---|---|---|---|---|
val_neg {x} : ∀ y : HomogeneousLocalization 𝒜 x, (-y).val = -y.val :=
Quotient.ind' fun y ↦ by rw [← mk_neg, val_mk, val_mk, Localization.neg_mk]; rfl
variable [AddCommMonoid ι] [DecidableEq ι] [GradedAlgebra 𝒜] | 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_neg | null |
hasPow : Pow (HomogeneousLocalization 𝒜 x) ℕ where
pow z n :=
(Quotient.map' (· ^ n) fun c1 c2 (h : Localization.mk _ _ = Localization.mk _ _) => by
change Localization.mk _ _ = Localization.mk _ _
simp only [num_pow, den_pow]
convert congr_arg (fun z : at x => z ^ n) h <;> rw [Localization.mk_pow] <;> rfl :
HomogeneousLocalization 𝒜 x → HomogeneousLocalization 𝒜 x)
z
@[simp] lemma mk_pow (i : NumDenSameDeg 𝒜 x) (n : ℕ) : mk (i ^ n) = mk i ^ n := rfl | instance | 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 | hasPow | null |
@[simp] mk_add (i j : NumDenSameDeg 𝒜 x) : mk (i + j) = mk i + mk j := rfl | 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_add | null |
@[simp] mk_mul (i j : NumDenSameDeg 𝒜 x) : mk (i * j) = mk i * mk j := rfl | 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_mul | null |
@[simp] mk_one : mk (1 : NumDenSameDeg 𝒜 x) = 1 := rfl | 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_one | null |
@[simp] mk_zero : mk (0 : NumDenSameDeg 𝒜 x) = 0 := rfl | 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_zero | null |
zero_eq : (0 : HomogeneousLocalization 𝒜 x) = Quotient.mk'' 0 :=
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 | zero_eq | null |
one_eq : (1 : HomogeneousLocalization 𝒜 x) = Quotient.mk'' 1 :=
rfl
variable {x}
@[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 | one_eq | null |
val_zero : (0 : HomogeneousLocalization 𝒜 x).val = 0 :=
Localization.mk_zero _
@[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 | val_zero | null |
val_one : (1 : HomogeneousLocalization 𝒜 x).val = 1 :=
Localization.mk_one
@[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 | val_one | null |
val_add : ∀ y1 y2 : HomogeneousLocalization 𝒜 x, (y1 + y2).val = y1.val + y2.val :=
Quotient.ind₂' fun y1 y2 ↦ by rw [← mk_add, val_mk, val_mk, val_mk, Localization.add_mk]; 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 | val_add | null |
val_mul : ∀ y1 y2 : HomogeneousLocalization 𝒜 x, (y1 * y2).val = y1.val * y2.val :=
Quotient.ind₂' fun y1 y2 ↦ by rw [← mk_mul, val_mk, val_mk, val_mk, Localization.mk_mul]; 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 | val_mul | null |
val_sub (y1 y2 : HomogeneousLocalization 𝒜 x) : (y1 - y2).val = y1.val - y2.val := by
rw [sub_eq_add_neg, ← val_neg, ← val_add]; 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 | val_sub | null |
val_pow : ∀ (y : HomogeneousLocalization 𝒜 x) (n : ℕ), (y ^ n).val = y.val ^ n :=
Quotient.ind' fun y n ↦ by rw [← mk_pow, val_mk, val_mk, Localization.mk_pow]; 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_pow | null |
@[simp]
val_natCast (n : ℕ) : (n : HomogeneousLocalization 𝒜 x).val = n :=
show val (Nat.unaryCast n) = _ by induction n <;> simp [Nat.unaryCast, *]
@[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 | val_natCast | null |
val_intCast (n : ℤ) : (n : HomogeneousLocalization 𝒜 x).val = n :=
show val (Int.castDef n) = _ by cases n <;> simp [Int.castDef, *] | 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_intCast | null |
homogeneousLocalizationCommRing : CommRing (HomogeneousLocalization 𝒜 x) :=
(HomogeneousLocalization.val_injective x).commRing _ val_zero val_one val_add val_mul val_neg
val_sub (val_nsmul x · ·) (val_zsmul x · ·) val_pow val_natCast val_intCast | instance | 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 | homogeneousLocalizationCommRing | null |
homogeneousLocalizationAlgebra :
Algebra (HomogeneousLocalization 𝒜 x) (Localization x) where
smul p q := p.val * q
algebraMap :=
{ toFun := val
map_one' := val_one
map_mul' := val_mul
map_zero' := val_zero
map_add' := val_add }
commutes' _ _ := mul_comm _ _
smul_def' _ _ := rfl
@[simp] lemma algebraMap_apply (y) :
algebraMap (HomogeneousLocalization 𝒜 x) (Localization x) y = y.val := rfl | instance | 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 | homogeneousLocalizationAlgebra | null |
mk_eq_zero_of_num (f : NumDenSameDeg 𝒜 x) (h : f.num = 0) : mk f = 0 := by
apply val_injective
simp only [val_mk, val_zero, h, ZeroMemClass.coe_zero, Localization.mk_zero] | 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_eq_zero_of_num | null |
mk_eq_zero_of_den (f : NumDenSameDeg 𝒜 x) (h : f.den = 0) : mk f = 0 := by
have := subsingleton 𝒜 (h ▸ f.den_mem)
exact Subsingleton.elim _ _
variable (𝒜 x) in | 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_eq_zero_of_den | null |
fromZeroRingHom : 𝒜 0 →+* HomogeneousLocalization 𝒜 x where
toFun f := .mk ⟨0, f, 1, one_mem _⟩
map_one' := rfl
map_mul' f g := by ext; simp [Localization.mk_mul]
map_zero' := rfl
map_add' f g := by ext; simp [Localization.add_mk, add_comm f.1 g.1] | 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 | fromZeroRingHom | The map from `𝒜 0` to the degree `0` part of `𝒜ₓ` sending `f ↦ f/1`. |
algebraMap_eq : algebraMap (𝒜 0) (HomogeneousLocalization 𝒜 x) = fromZeroRingHom 𝒜 x := rfl | 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 | algebraMap_eq | null |
num (f : HomogeneousLocalization 𝒜 x) : A :=
(Quotient.out f).num | 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 | num | Numerator of an element in `HomogeneousLocalization x`. |
den (f : HomogeneousLocalization 𝒜 x) : A :=
(Quotient.out f).den | 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 | den | Denominator of an element in `HomogeneousLocalization x`. |
deg (f : HomogeneousLocalization 𝒜 x) : ι :=
(Quotient.out f).deg | 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 | deg | For an element in `HomogeneousLocalization x`, degree is the natural number `i` such that
`𝒜 i` contains both numerator and denominator. |
den_mem (f : HomogeneousLocalization 𝒜 x) : f.den ∈ x :=
(Quotient.out f).den_mem | 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_mem | null |
num_mem_deg (f : HomogeneousLocalization 𝒜 x) : f.num ∈ 𝒜 f.deg :=
(Quotient.out f).num.2 | 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_mem_deg | null |
den_mem_deg (f : HomogeneousLocalization 𝒜 x) : f.den ∈ 𝒜 f.deg :=
(Quotient.out f).den.2 | 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_mem_deg | null |
eq_num_div_den (f : HomogeneousLocalization 𝒜 x) :
f.val = Localization.mk f.num ⟨f.den, f.den_mem⟩ :=
congr_arg HomogeneousLocalization.val (Quotient.out_eq' f).symm | 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 | eq_num_div_den | null |
den_smul_val (f : HomogeneousLocalization 𝒜 x) :
f.den • f.val = algebraMap _ _ f.num := by
rw [eq_num_div_den, Localization.mk_eq_mk', IsLocalization.smul_mk']
exact IsLocalization.mk'_mul_cancel_left _ ⟨_, _⟩ | 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_val | null |
ext_iff_val (f g : HomogeneousLocalization 𝒜 x) : f = g ↔ f.val = g.val :=
⟨congr_arg val, fun e ↦ val_injective x e⟩ | 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_iff_val | null |
AtPrime :=
HomogeneousLocalization 𝒜 𝔭.primeCompl | 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 | AtPrime | Localizing a ring homogeneously at a prime ideal. |
isUnit_iff_isUnit_val (f : HomogeneousLocalization.AtPrime 𝒜 𝔭) :
IsUnit f.val ↔ IsUnit f := by
refine ⟨fun h1 ↦ ?_, IsUnit.map (algebraMap _ _)⟩
rcases h1 with ⟨⟨a, b, eq0, eq1⟩, rfl : a = f.val⟩
obtain ⟨f, rfl⟩ := mk_surjective f
obtain ⟨b, s, rfl⟩ := IsLocalization.mk'_surjective 𝔭.primeCompl b
rw [val_mk, Localization.mk_eq_mk', ← IsLocalization.mk'_mul, IsLocalization.mk'_eq_iff_eq_mul,
one_mul, IsLocalization.eq_iff_exists (M := 𝔭.primeCompl)] at eq0
obtain ⟨c, hc : _ = c.1 * (f.den.1 * s.1)⟩ := eq0
have : f.num.1 ∉ 𝔭 := by
exact fun h ↦ mul_mem c.2 (mul_mem f.den_mem s.2)
(hc ▸ Ideal.mul_mem_left _ c.1 (Ideal.mul_mem_right b _ h))
refine isUnit_of_mul_eq_one _ (Quotient.mk'' ⟨f.1, f.3, f.2, this⟩) ?_
rw [← mk_mul, ext_iff_val, val_mk]
simp [mul_comm f.den.1] | 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 | isUnit_iff_isUnit_val | null |
isLocalRing : IsLocalRing (HomogeneousLocalization.AtPrime 𝒜 𝔭) :=
IsLocalRing.of_isUnit_or_isUnit_one_sub_self fun a => by
simpa only [← isUnit_iff_isUnit_val, val_sub, val_one]
using IsLocalRing.isUnit_or_isUnit_one_sub_self _ | instance | 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 | isLocalRing | null |
Away :=
HomogeneousLocalization 𝒜 (Submonoid.powers f)
variable [AddCommMonoid ι] [DecidableEq ι] [GradedAlgebra 𝒜]
variable {𝒜} {f} | 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 | Away | Localizing away from powers of `f` homogeneously. |
Away.eventually_smul_mem {m} (hf : f ∈ 𝒜 m) (z : Away 𝒜 f) :
∀ᶠ n in Filter.atTop, f ^ n • z.val ∈ algebraMap _ _ '' (𝒜 (n • m) : Set A) := by
obtain ⟨k, hk : f ^ k = _⟩ := z.den_mem
apply Filter.mem_of_superset (Filter.Ici_mem_atTop k)
rintro k' (hk' : k ≤ k')
simp only [Set.mem_image, SetLike.mem_coe, Set.mem_setOf_eq]
by_cases hfk : f ^ k = 0
· refine ⟨0, zero_mem _, ?_⟩
rw [← tsub_add_cancel_of_le hk', map_zero, pow_add, hfk, mul_zero, zero_smul]
rw [← tsub_add_cancel_of_le hk', pow_add, mul_smul, hk, den_smul_val,
Algebra.smul_def, ← map_mul]
rw [← smul_eq_mul, add_smul,
DirectSum.degree_eq_of_mem_mem 𝒜 (SetLike.pow_mem_graded _ hf) (hk.symm ▸ z.den_mem_deg) hfk]
exact ⟨_, SetLike.mul_mem_graded (SetLike.pow_mem_graded _ hf) z.num_mem_deg, 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 | Away.eventually_smul_mem | null |
map (g : A →+* B)
(comap_le : P ≤ Q.comap g) (hg : ∀ i, ∀ a ∈ 𝒜 i, g a ∈ ℬ i) :
HomogeneousLocalization 𝒜 P →+* HomogeneousLocalization ℬ Q where
toFun := Quotient.map'
(fun x ↦ ⟨x.1, ⟨_, hg _ _ x.2.2⟩, ⟨_, hg _ _ x.3.2⟩, comap_le x.4⟩)
fun x y (e : x.embedding = y.embedding) ↦ by
apply_fun IsLocalization.map (Localization Q) g comap_le at e
simp_rw [HomogeneousLocalization.NumDenSameDeg.embedding, Localization.mk_eq_mk',
IsLocalization.map_mk', ← Localization.mk_eq_mk'] at e
exact e
map_add' := Quotient.ind₂' fun x y ↦ by
simp only [← mk_add, Quotient.map'_mk'', num_add, map_add, map_mul, den_add]; rfl
map_mul' := Quotient.ind₂' fun x y ↦ by
simp only [← mk_mul, Quotient.map'_mk'', num_mul, map_mul, den_mul]; rfl
map_zero' := by simp only [← mk_zero (𝒜 := 𝒜), Quotient.map'_mk'', deg_zero,
num_zero, ZeroMemClass.coe_zero, map_zero, den_zero, map_one]; rfl
map_one' := by simp only [← mk_one (𝒜 := 𝒜), Quotient.map'_mk'',
num_one, den_one, map_one]; rfl | 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 | map | Let `A, B` be two graded algebras with the same indexing set and `g : A → B` be a graded algebra
homomorphism (i.e. `g(Aₘ) ⊆ Bₘ`). Let `P ≤ A` be a submonoid and `Q ≤ B` be a submonoid such that
`P ≤ g⁻¹ Q`, then `g` induce a map from the homogeneous localizations `A⁰_P` to the homogeneous
localizations `B⁰_Q`. |
mapId {P Q : Submonoid A} (h : P ≤ Q) :
HomogeneousLocalization 𝒜 P →+* HomogeneousLocalization 𝒜 Q :=
map 𝒜 𝒜 (RingHom.id _) h (fun _ _ ↦ id) | 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 | mapId | Let `A` be a graded algebra and `P ≤ Q` be two submonoids, then the homogeneous localization of `A`
at `P` embeds into the homogeneous localization of `A` at `Q`. |
map_mk (g : A →+* B)
(comap_le : P ≤ Q.comap g) (hg : ∀ i, ∀ a ∈ 𝒜 i, g a ∈ ℬ i) (x) :
map 𝒜 ℬ g comap_le hg (mk x) =
mk ⟨x.1, ⟨_, hg _ _ x.2.2⟩, ⟨_, hg _ _ x.3.2⟩, comap_le x.4⟩ :=
rfl | 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 | map_mk | null |
private awayMapAux (hx : f ∣ x) : Away 𝒜 f →+* Localization.Away x :=
(Localization.awayLift (algebraMap A _) _
(isUnit_of_dvd_unit (map_dvd _ hx) (IsLocalization.Away.algebraMap_isUnit x))).comp
(algebraMap (Away 𝒜 f) (Localization.Away f)) | 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 | awayMapAux | Given `f ∣ x`, this is the map `A_{(f)} → A_f → A_x`. We will lift this to a map
`A_{(f)} → A_{(x)}` in `awayMap`. |
awayMapAux_mk (n a i hi) :
awayMapAux 𝒜 ⟨_, hx⟩ (mk ⟨n, a, ⟨f ^ i, hi⟩, ⟨i, rfl⟩⟩) =
Localization.mk (a * g ^ i) ⟨x ^ i, (Submonoid.mem_powers_iff _ _).mpr ⟨i, rfl⟩⟩ := by
have : algebraMap A (Localization.Away x) f *
(Localization.mk g ⟨f * g, (Submonoid.mem_powers_iff _ _).mpr ⟨1, by simp [hx]⟩⟩) = 1 := by
rw [← Algebra.smul_def, Localization.smul_mk]
exact Localization.mk_self ⟨f*g, _⟩
simp [awayMapAux]
rw [Localization.awayLift_mk (hv := this), ← Algebra.smul_def,
Localization.mk_pow, Localization.smul_mk]
subst hx
rfl
include hg in | 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 | awayMapAux_mk | null |
range_awayMapAux_subset :
Set.range (awayMapAux 𝒜 (f := f) ⟨_, hx⟩) ⊆ Set.range (val (𝒜 := 𝒜)) := by
rintro _ ⟨z, rfl⟩
obtain ⟨⟨n, ⟨a, ha⟩, ⟨b, hb'⟩, j, rfl : _ = b⟩, rfl⟩ := mk_surjective z
use mk ⟨n+j•e,⟨a*g^j, ?_⟩, ⟨x^j, ?_⟩, j, rfl⟩
· simp [awayMapAux_mk 𝒜 (hx := hx)]
· apply SetLike.mul_mem_graded ha
exact SetLike.pow_mem_graded _ hg
· rw [hx, mul_pow]
apply SetLike.mul_mem_graded hb'
exact SetLike.pow_mem_graded _ hg | 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 | range_awayMapAux_subset | null |
awayMap : Away 𝒜 f →+* Away 𝒜 x := by
let e := RingEquiv.ofLeftInverse (f := algebraMap (Away 𝒜 x) (Localization.Away x))
(h := (val_injective _).hasLeftInverse.choose_spec)
refine RingHom.comp (e.symm.toRingHom.comp (Subring.inclusion ?_))
(awayMapAux 𝒜 (f := f) ⟨_, hx⟩).rangeRestrict
exact range_awayMapAux_subset 𝒜 hg hx | 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 | awayMap | Given `x = f * g` with `g` homogeneous of positive degree,
this is the map `A_{(f)} → A_{(x)}` taking `a/f^i` to `ag^i/(fg)^i`. |
val_awayMap_eq_aux (a) : (awayMap 𝒜 hg hx a).val = awayMapAux 𝒜 ⟨_, hx⟩ a := by
let e := RingEquiv.ofLeftInverse (f := algebraMap (Away 𝒜 x) (Localization.Away x))
(h := (val_injective _).hasLeftInverse.choose_spec)
dsimp [awayMap]
convert_to (e (e.symm ⟨awayMapAux 𝒜 (f := f) ⟨_, hx⟩ a,
range_awayMapAux_subset 𝒜 hg hx ⟨_, rfl⟩⟩)).1 = _
rw [e.apply_symm_apply] | 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 | val_awayMap_eq_aux | null |
val_awayMap (a) : (awayMap 𝒜 hg hx a).val = Localization.awayLift (algebraMap A _) _
(isUnit_of_dvd_unit (map_dvd _ ⟨_, hx⟩) (IsLocalization.Away.algebraMap_isUnit x)) a.val := by
rw [val_awayMap_eq_aux]
rfl | 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 | val_awayMap | null |
awayMap_fromZeroRingHom (a) :
awayMap 𝒜 hg hx (fromZeroRingHom 𝒜 _ a) = fromZeroRingHom 𝒜 _ a := by
ext
simp only [fromZeroRingHom, RingHom.coe_mk, MonoidHom.coe_mk, OneHom.coe_mk,
val_awayMap, val_mk, SetLike.GradeZero.coe_one]
convert IsLocalization.lift_eq _ _ | 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 | awayMap_fromZeroRingHom | null |
val_awayMap_mk (n a i hi) : (awayMap 𝒜 hg hx (mk ⟨n, a, ⟨f ^ i, hi⟩, ⟨i, rfl⟩⟩)).val =
Localization.mk (a * g ^ i) ⟨x ^ i, (Submonoid.mem_powers_iff _ _).mpr ⟨i, rfl⟩⟩ := by
rw [val_awayMap_eq_aux, awayMapAux_mk 𝒜 (hx := hx)] | 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 | val_awayMap_mk | null |
awayMapₐ : Away 𝒜 f →ₐ[𝒜 0] Away 𝒜 x where
__ := awayMap 𝒜 hg hx
commutes' _ := awayMap_fromZeroRingHom ..
@[simp] lemma awayMapₐ_apply (a) : awayMapₐ 𝒜 hg hx a = awayMap 𝒜 hg hx a := rfl | 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 | awayMapₐ | Given `x = f * g` with `g` homogeneous of positive degree,
this is the map `A_{(f)} → A_{(x)}` taking `a/f^i` to `ag^i/(fg)^i`. |
protected Away.mk {d : ι} (hf : f ∈ 𝒜 d) (n : ℕ) (x : A) (hx : x ∈ 𝒜 (n • d)) : Away 𝒜 f :=
HomogeneousLocalization.mk ⟨n • d, ⟨x, hx⟩, ⟨f ^ n, SetLike.pow_mem_graded n hf⟩, ⟨n, rfl⟩⟩
@[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 | Away.mk | This is a convenient constructor for `Away 𝒜 f` when `f` is homogeneous.
`Away.mk 𝒜 hf n x hx` is the fraction `x / f ^ n`. |
Away.val_mk {d : ι} (n : ℕ) (hf : f ∈ 𝒜 d) (x : A) (hx : x ∈ 𝒜 (n • d)) :
(Away.mk 𝒜 hf n x hx).val = Localization.mk x ⟨f ^ n, by use n⟩ :=
rfl | 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 | Away.val_mk | null |
protected
Away.mk_surjective {d : ι} (hf : f ∈ 𝒜 d) (x : Away 𝒜 f) :
∃ n a ha, Away.mk 𝒜 hf n a ha = x := by
obtain ⟨⟨N, ⟨s, hs⟩, ⟨b, hn⟩, ⟨n, (rfl : _ = b)⟩⟩, rfl⟩ := mk_surjective x
by_cases hfn : f ^ n = 0
· have := HomogeneousLocalization.subsingleton 𝒜 (x := .powers f) ⟨n, hfn⟩
exact ⟨0, 0, zero_mem _, Subsingleton.elim _ _⟩
obtain rfl := DirectSum.degree_eq_of_mem_mem 𝒜 hn (SetLike.pow_mem_graded n hf) hfn
exact ⟨n, s, hs, by ext; simp⟩
open SetLike in
@[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 | Away.mk_surjective | null |
awayMap_mk {d : ι} (n : ℕ) (hf : f ∈ 𝒜 d) (a : A) (ha : a ∈ 𝒜 (n • d)) :
awayMap 𝒜 hg hx (Away.mk 𝒜 hf n a ha) = Away.mk 𝒜 (hx ▸ mul_mem_graded hf hg) n
(a * g ^ n) (by rw [smul_add]; exact mul_mem_graded ha (pow_mem_graded n hg)) := by
ext
exact val_awayMap_mk .. | 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 | awayMap_mk | null |
Away.isLocalizationElem : Away 𝒜 f :=
Away.mk 𝒜 hf e (g ^ d) (by convert SetLike.pow_mem_graded d hg using 2; exact mul_comm _ _)
variable {x : A} (hx : x = f * g) | 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 | Away.isLocalizationElem | The element `t := g ^ d / f ^ e` such that `A_{(fg)} = A_{(f)}[1/t]`. |
Away.isLocalization_mul (hd : d ≠ 0) :
letI := (awayMap 𝒜 hg hx).toAlgebra
IsLocalization.Away (isLocalizationElem hf hg) (Away 𝒜 x) := by
letI := (awayMap 𝒜 hg hx).toAlgebra
constructor
· rintro ⟨r, n, rfl⟩
rw [map_pow, RingHom.algebraMap_toAlgebra]
let z : Away 𝒜 x := Away.mk 𝒜 (hx ▸ SetLike.mul_mem_graded hf hg) (d + e)
(g ^ e * f ^ (2 * e + d)) <| by
convert SetLike.mul_mem_graded (SetLike.pow_mem_graded e hg)
(SetLike.pow_mem_graded (2 * e + d) hf) using 2
ring
refine (isUnit_iff_exists_inv.mpr ⟨z, ?_⟩).pow _
ext
simp only [val_mul, val_one, awayMap_mk, Away.val_mk, z, Localization.mk_mul]
rw [← Localization.mk_one, Localization.mk_eq_mk_iff, Localization.r_iff_exists]
use 1
simp only [OneMemClass.coe_one, one_mul, Submonoid.coe_mul, mul_one, hx]
ring
· intro z
obtain ⟨n, s, hs, rfl⟩ := Away.mk_surjective 𝒜 (hx ▸ SetLike.mul_mem_graded hf hg) z
rcases d with - | d
· contradiction
let t : Away 𝒜 f := Away.mk 𝒜 hf (n * (e + 1)) (s * g ^ (n * d)) <| by
convert SetLike.mul_mem_graded hs (SetLike.pow_mem_graded _ hg) using 2; simp; ring
refine ⟨⟨t, ⟨_, ⟨n, rfl⟩⟩⟩, ?_⟩
ext
simp only [RingHom.algebraMap_toAlgebra, map_pow, awayMap_mk, val_mul, val_mk, val_pow,
Localization.mk_pow, Localization.mk_mul, t]
rw [Localization.mk_eq_mk_iff, Localization.r_iff_exists]
exact ⟨1, by simp; ring⟩
· intro a b e
obtain ⟨n, a, ha, rfl⟩ := Away.mk_surjective 𝒜 hf a
obtain ⟨m, b, hb, rfl⟩ := Away.mk_surjective 𝒜 hf b
replace e := congr_arg val e
simp only [RingHom.algebraMap_toAlgebra, awayMap_mk, val_mk,
Localization.mk_eq_mk_iff, Localization.r_iff_exists] at e
obtain ⟨⟨_, k, rfl⟩, hc⟩ := e
refine ⟨⟨_, k + m + n, rfl⟩, ?_⟩
ext
simp only [val_mul, val_pow, val_mk, Localization.mk_pow,
Localization.mk_eq_mk_iff, Localization.r_iff_exists, Submonoid.coe_mul, Localization.mk_mul,
SubmonoidClass.coe_pow, Subtype.exists, exists_prop]
refine ⟨_, ⟨k, rfl⟩, ?_⟩
rcases d with - | d
· contradiction
subst hx
convert congr(f ^ (e * (k + m + n)) * g ^ (d * (k + m + n)) * $hc) using 1 <;> ring | 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 | Away.isLocalization_mul | Let `t := g ^ d / f ^ e`, then `A_{(fg)} = A_{(f)}[1/t]`. |
Away.span_mk_prod_pow_eq_top {f : A} {d : ι} (hf : f ∈ 𝒜 d)
{ι' : Type*} [Fintype ι'] (v : ι' → A)
(hx : Algebra.adjoin (𝒜 0) (Set.range v) = ⊤) (dv : ι' → ι) (hxd : ∀ i, v i ∈ 𝒜 (dv i)) :
Submodule.span (𝒜 0) { (Away.mk 𝒜 hf a (∏ i, v i ^ ai i)
(hai ▸ SetLike.prod_pow_mem_graded _ _ _ _ fun i _ ↦ hxd i) : Away 𝒜 f) |
(a : ℕ) (ai : ι' → ℕ) (hai : ∑ i, ai i • dv i = a • d) } = ⊤ := by
by_cases HH : Subsingleton (HomogeneousLocalization.Away 𝒜 f)
· exact Subsingleton.elim _ _
rw [← top_le_iff]
rintro x -
obtain ⟨⟨n, ⟨a, ha⟩, ⟨b, hb'⟩, ⟨j, (rfl : _ = b)⟩⟩, rfl⟩ := mk_surjective x
by_cases hfj : f ^ j = 0
· exact (HH (HomogeneousLocalization.subsingleton _ ⟨_, hfj⟩)).elim
have : DirectSum.decompose 𝒜 a n = ⟨a, ha⟩ := Subtype.ext (DirectSum.decompose_of_mem_same 𝒜 ha)
simp_rw [← this]
clear this ha
have : a ∈ Submodule.span (𝒜 0) (Submonoid.closure (Set.range v)) := by
rw [← Algebra.adjoin_eq_span, hx]
trivial
induction this using Submodule.span_induction with
| mem a ha' =>
obtain ⟨ai, rfl⟩ := Submonoid.exists_of_mem_closure_range _ _ ha'
clear ha'
by_cases H : ∑ i, ai i • dv i = n
· apply Submodule.subset_span
refine ⟨j, ai, H.trans ?_, ?_⟩
· exact DirectSum.degree_eq_of_mem_mem 𝒜 hb'
(SetLike.pow_mem_graded j hf) hfj
· ext
simp only [val_mk, Away.val_mk]
congr
refine (DirectSum.decompose_of_mem_same _ ?_).symm
exact H ▸ SetLike.prod_pow_mem_graded _ _ _ _ fun i _ ↦ hxd i
· convert zero_mem (Submodule.span (𝒜 0) _)
ext
have : (DirectSum.decompose 𝒜 (∏ i : ι', v i ^ ai i) n).1 = 0 := by
refine DirectSum.decompose_of_mem_ne _ ?_ H
exact SetLike.prod_pow_mem_graded _ _ _ _ fun i _ ↦ hxd i
simp [this, Localization.mk_zero]
| zero =>
convert zero_mem (Submodule.span (𝒜 0) _)
ext; simp [Localization.mk_zero]
| add s t hs ht hs' ht' =>
convert add_mem hs' ht'
ext; simp [← Localization.add_mk_self]
| smul r x hx hx' =>
convert Submodule.smul_mem _ r hx'
ext
simp [Algebra.smul_def, algebraMap_eq, fromZeroRingHom, Localization.mk_mul,
-decompose_mul, coe_decompose_mul_of_left_mem_zero 𝒜 r.2]
variable {𝒜 : ℕ → Submodule R A} [GradedAlgebra 𝒜] 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 | Away.span_mk_prod_pow_eq_top | Let `𝒜` be a graded algebra, finitely generated (as an algebra) over `𝒜₀` by `{ vᵢ }`,
where `vᵢ` has degree `dvᵢ`.
If `f : A` has degree `d`, then `𝒜_(f)` is generated (as a module) over `𝒜₀` by
elements of the form `(∏ i, vᵢ ^ aᵢ) / fᵃ` such that `∑ aᵢ • dvᵢ = a • d`. |
private
Away.adjoin_mk_prod_pow_eq_top_of_pos {f : A} {d : ℕ} (hf : f ∈ 𝒜 d)
{ι' : Type*} [Fintype ι'] (v : ι' → A)
(hx : Algebra.adjoin (𝒜 0) (Set.range v) = ⊤) (dv : ι' → ℕ)
(hxd : ∀ i, v i ∈ 𝒜 (dv i)) (hxd' : ∀ i, 0 < dv i) :
Algebra.adjoin (𝒜 0) { Away.mk 𝒜 hf a (∏ i, v i ^ ai i)
(hai ▸ SetLike.prod_pow_mem_graded _ _ _ _ fun i _ ↦ hxd i) |
(a : ℕ) (ai : ι' → ℕ) (hai : ∑ i, ai i • dv i = a • d) (_ : ∀ i, ai i ≤ d) } = ⊤ := by
rw [← top_le_iff]
change ⊤ ≤ (Algebra.adjoin (𝒜 0) _).toSubmodule
rw [← HomogeneousLocalization.Away.span_mk_prod_pow_eq_top hf v hx dv hxd, Submodule.span_le]
rintro _ ⟨a, ai, hai, rfl⟩
have H₀ : (a - ∑ i : ι', dv i * (ai i / d)) • d = ∑ k : ι', (ai k % d) • dv k := by
rw [smul_eq_mul, tsub_mul, ← smul_eq_mul, ← hai]
conv => enter [1, 1, 2, i]; rw [← Nat.mod_add_div (ai i) d]
simp_rw [smul_eq_mul, add_mul, Finset.sum_add_distrib,
mul_assoc, ← Finset.mul_sum, mul_comm d, mul_comm (_ / _)]
simp only [add_tsub_cancel_right]
have H : Away.mk 𝒜 hf a (∏ i, v i ^ ai i)
(hai ▸ SetLike.prod_pow_mem_graded _ _ _ _ fun i _ ↦ hxd i) =
Away.mk 𝒜 hf (a - ∑ i : ι', dv i * (ai i / d)) (∏ i, v i ^ (ai i % d))
(H₀ ▸ SetLike.prod_pow_mem_graded _ _ _ _ fun i _ ↦ hxd i) *
∏ i, Away.isLocalizationElem hf (hxd i) ^ (ai i / d) := by
apply (show Function.Injective (algebraMap (Away 𝒜 f) (Localization.Away f))
from val_injective _)
simp only [map_pow, map_prod, map_mul]
simp only [HomogeneousLocalization.algebraMap_apply, val_mk,
Localization.mk_pow, Localization.mk_prod, Localization.mk_mul,
← Finset.prod_mul_distrib, ← pow_add, ← pow_mul]
congr
· ext i
congr
exact Eq.symm (Nat.mod_add_div (ai i) d)
· simp only [SubmonoidClass.coe_finset_prod, ← pow_add, ← pow_mul,
Finset.prod_pow_eq_pow_sum, SubmonoidClass.coe_pow]
rw [tsub_add_cancel_of_le]
rcases d.eq_zero_or_pos with hd | hd
· simp [hd]
rw [← mul_le_mul_iff_of_pos_right hd, ← smul_eq_mul (a := a), ← hai, Finset.sum_mul]
simp_rw [smul_eq_mul, mul_comm (ai _), mul_assoc]
gcongr
exact Nat.div_mul_le_self (ai _) d
rw [H, SetLike.mem_coe]
apply (Algebra.adjoin (𝒜 0) _).mul_mem
· apply Algebra.subset_adjoin
refine ⟨a - ∑ i : ι', dv i * (ai i / d), (ai · % d), H₀.symm, ?_, rfl⟩
rcases d.eq_zero_or_pos with hd | hd
· have : ∀ (x : ι'), ai x = 0 := by simpa [hd, fun i ↦ (hxd' i).ne'] using hai
simp [this]
exact fun i ↦ (Nat.mod_lt _ hd).le
apply prod_mem
... | 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 | Away.adjoin_mk_prod_pow_eq_top_of_pos | This is strictly weaker than `Away.adjoin_mk_prod_pow_eq_top`. |
Away.adjoin_mk_prod_pow_eq_top {f : A} {d : ℕ} (hf : f ∈ 𝒜 d)
(ι' : Type*) [Fintype ι'] (v : ι' → A)
(hx : Algebra.adjoin (𝒜 0) (Set.range v) = ⊤) (dv : ι' → ℕ) (hxd : ∀ i, v i ∈ 𝒜 (dv i)) :
Algebra.adjoin (𝒜 0) { Away.mk 𝒜 hf a (∏ i, v i ^ ai i)
(hai ▸ SetLike.prod_pow_mem_graded _ _ _ _ fun i _ ↦ hxd i) |
(a : ℕ) (ai : ι' → ℕ) (hai : ∑ i, ai i • dv i = a • d) (_ : ∀ i, ai i ≤ d) } = ⊤ := by
classical
let s := Finset.univ.filter (0 < dv ·)
have := Away.adjoin_mk_prod_pow_eq_top_of_pos hf (ι' := s) (v ∘ Subtype.val) ?_
(dv ∘ Subtype.val) (fun _ ↦ hxd _) (by simp [s])
swap
· rw [← top_le_iff, ← hx, Algebra.adjoin_le_iff, Set.range_subset_iff]
intro i
rcases (dv i).eq_zero_or_pos with hi | hi
· exact algebraMap_mem (R := 𝒜 0) _ ⟨v i, hi ▸ hxd i⟩
exact Algebra.subset_adjoin ⟨⟨i, by simpa [s] using hi⟩, rfl⟩
rw [← top_le_iff, ← this]
apply Algebra.adjoin_mono
rintro _ ⟨a, ai, hai : ∑ x ∈ s.attach, _ = _, h, rfl⟩
refine ⟨a, fun i ↦ if hi : i ∈ s then ai ⟨i, hi⟩ else 0, ?_, ?_, ?_⟩
· simpa [Finset.sum_attach_eq_sum_dite] using hai
· simp [apply_dite, dite_apply, h]
· congr 1
change _ = ∏ x ∈ s.attach, _
simp [Finset.prod_attach_eq_prod_dite]
variable {𝒜 : ℕ → Submodule R A} [GradedAlgebra 𝒜] [Algebra.FiniteType (𝒜 0) A] 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 | Away.adjoin_mk_prod_pow_eq_top | Let `𝒜` be a graded algebra, finitely generated (as an algebra) over `𝒜₀` by `{ vᵢ }`,
where `vᵢ` has degree `dvᵢ`.
If `f : A` has degree `d`, then `𝒜_(f)` is generated (as an algebra) over `𝒜₀` by
elements of the form `(∏ i, vᵢ ^ aᵢ) / fᵃ` such that `∑ aᵢ • dvᵢ = a • d` and `∀ i, aᵢ ≤ d`. |
Away.finiteType (f : A) (d : ℕ) (hf : f ∈ 𝒜 d) :
Algebra.FiniteType (𝒜 0) (Away 𝒜 f) := by
constructor
obtain ⟨s, hs, hs'⟩ := GradedAlgebra.exists_finset_adjoin_eq_top_and_homogeneous_ne_zero 𝒜
choose dx hdx hxd using Subtype.forall'.mp hs'
simp_rw [Subalgebra.fg_def, ← top_le_iff,
← Away.adjoin_mk_prod_pow_eq_top hf (ι' := s) Subtype.val (by simpa) dx hxd]
rcases d.eq_zero_or_pos with hd | hd
· let f' := Away.mk 𝒜 hf 1 1 (by simp [hd, GradedOne.one_mem])
refine ⟨{f'}, Set.finite_singleton f', ?_⟩
rw [Algebra.adjoin_le_iff]
rintro _ ⟨a, ai, hai, hai', rfl⟩
obtain rfl : ai = 0 := funext <| by simpa [hd, hdx] using hai
simp only [Finset.univ_eq_attach, Pi.zero_apply, pow_zero, Finset.prod_const_one, mem_coe]
convert pow_mem (Algebra.self_mem_adjoin_singleton (𝒜 0) f') a using 1
ext
simp [f', Localization.mk_pow]
refine ⟨_, ?_, le_rfl⟩
let b := ∑ i, dx i
let s' : Set ((Fin (b + 1)) × (s → Fin (d + 1))) := { ai | ∑ i, (ai.2 i).1 * dx i = ai.1 * d }
let F : s' → Away 𝒜 f := fun ai ↦ Away.mk 𝒜 hf ai.1.1.1 (∏ i, i ^ (ai.1.2 i).1)
(by convert SetLike.prod_pow_mem_graded _ _ _ _ fun i _ ↦ hxd i; exact ai.2.symm)
apply (Set.finite_range F).subset
rintro _ ⟨a, ai, hai, hai', rfl⟩
refine ⟨⟨⟨⟨a, ?_⟩, fun i ↦ ⟨ai i, (hai' i).trans_lt d.lt_succ_self⟩⟩, hai⟩, rfl⟩
rw [Nat.lt_succ, ← mul_le_mul_iff_of_pos_right hd, ← smul_eq_mul, ← hai, Finset.sum_mul]
simp_rw [smul_eq_mul, mul_comm _ d]
gcongr
exact hai' _ | 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 | Away.finiteType | null |
GradeZero.isNoetherianRing : IsNoetherianRing (𝒜 0) :=
isNoetherianRing_of_surjective
A (𝒜 0) (GradedRing.projZeroRingHom' 𝒜) (GradedRing.projZeroRingHom'_surjective 𝒜) | instance | RingTheory | [
"Mathlib.RingTheory.GradedAlgebra.Basic",
"Mathlib.RingTheory.Noetherian.Basic"
] | Mathlib/RingTheory/GradedAlgebra/Noetherian.lean | GradeZero.isNoetherianRing | If the internally graded ring `A` is Noetherian, then `𝒜 0` is a Noetherian ring. |
Ideal.IsHomogeneous.isPrime_of_homogeneous_mem_or_mem {I : Ideal A} (hI : I.IsHomogeneous 𝒜)
(I_ne_top : I ≠ ⊤)
(homogeneous_mem_or_mem :
∀ {x y : A}, IsHomogeneousElem 𝒜 x → IsHomogeneousElem 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I) :
Ideal.IsPrime I :=
⟨I_ne_top, by
intro x y hxy
by_contra! rid
obtain ⟨rid₁, rid₂⟩ := rid
classical
/-
The idea of the proof is the following :
since `x * y ∈ I` and `I` homogeneous, then `proj i (x * y) ∈ I` for any `i : ι`.
Then consider two sets `{i ∈ x.support | xᵢ ∉ I}` and `{j ∈ y.support | yⱼ ∉ J}`;
let `max₁, max₂` be the maximum of the two sets, then `proj (max₁ + max₂) (x * y) ∈ I`.
Then, `proj max₁ x ∉ I` and `proj max₂ j ∉ I`
but `proj i x ∈ I` for all `max₁ < i` and `proj j y ∈ I` for all `max₂ < j`.
` proj (max₁ + max₂) (x * y)`
`= ∑ {(i, j) ∈ supports | i + j = max₁ + max₂}, xᵢ * yⱼ`
`= proj max₁ x * proj max₂ y`
` + ∑ {(i, j) ∈ supports \ {(max₁, max₂)} | i + j = max₁ + max₂}, xᵢ * yⱼ`.
This is a contradiction, because both `proj (max₁ + max₂) (x * y) ∈ I` and the sum on the
right-hand side is in `I` however `proj max₁ x * proj max₂ y` is not in `I`.
-/
set set₁ := {i ∈ (decompose 𝒜 x).support | proj 𝒜 i x ∉ I} with set₁_eq
set set₂ := {i ∈ (decompose 𝒜 y).support | proj 𝒜 i y ∉ I} with set₂_eq
have nonempty :
∀ x : A, x ∉ I → {i ∈ (decompose 𝒜 x).support | proj 𝒜 i x ∉ I}.Nonempty := by
intro x hx
rw [filter_nonempty_iff]
contrapose! hx
simp_rw [proj_apply] at hx
rw [← sum_support_decompose 𝒜 x]
exact Ideal.sum_mem _ hx
set max₁ := set₁.max' (nonempty x rid₁)
set max₂ := set₂.max' (nonempty y rid₂)
have mem_max₁ : max₁ ∈ set₁ := max'_mem set₁ (nonempty x rid₁)
have mem_max₂ : max₂ ∈ set₂ := max'_mem set₂ (nonempty y rid₂)
replace hxy : proj 𝒜 (max₁ + max₂) (x * y) ∈ I := hI _ hxy
have mem_I : proj 𝒜 max₁ x * proj 𝒜 max₂ y ∈ I := by
set antidiag :=
{z ∈ (decompose 𝒜 x).support ×ˢ (decompose 𝒜 y).support | z.1 + z.2 = max₁ + max₂}
with ha
have mem_antidiag : (max₁, max₂) ∈ antidiag := by
simp only [antidiag, mem_filter, mem_product]
exact ⟨⟨mem_of_mem_filter _ mem_max₁, mem_of_mem_filter _ mem_max₂⟩, trivial⟩
have eq_add_sum :=
calc
proj 𝒜 (max₁ + max₂) (x * y) = ∑ ij ∈ antidiag, proj 𝒜 ij.1 x * proj 𝒜 ij.2 y := by
simp_rw [ha, proj_apply, DirectSum.decompose_mul, DirectSum.coe_mul_apply 𝒜]
_ =
... | theorem | RingTheory | [
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal"
] | Mathlib/RingTheory/GradedAlgebra/Radical.lean | Ideal.IsHomogeneous.isPrime_of_homogeneous_mem_or_mem | null |
Ideal.IsHomogeneous.isPrime_iff {I : Ideal A} (h : I.IsHomogeneous 𝒜) :
I.IsPrime ↔
I ≠ ⊤ ∧
∀ {x y : A},
IsHomogeneousElem 𝒜 x → IsHomogeneousElem 𝒜 y → x * y ∈ I → x ∈ I ∨ y ∈ I :=
⟨fun HI => ⟨HI.ne_top, fun _ _ hxy => Ideal.IsPrime.mem_or_mem HI hxy⟩,
fun ⟨I_ne_top, homogeneous_mem_or_mem⟩ =>
h.isPrime_of_homogeneous_mem_or_mem I_ne_top @homogeneous_mem_or_mem⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal"
] | Mathlib/RingTheory/GradedAlgebra/Radical.lean | Ideal.IsHomogeneous.isPrime_iff | null |
Ideal.IsPrime.homogeneousCore {I : Ideal A} (h : I.IsPrime) :
(I.homogeneousCore 𝒜).toIdeal.IsPrime := by
apply (Ideal.homogeneousCore 𝒜 I).isHomogeneous.isPrime_of_homogeneous_mem_or_mem
· exact ne_top_of_le_ne_top h.ne_top (Ideal.toIdeal_homogeneousCore_le 𝒜 I)
rintro x y hx hy hxy
have H := h.mem_or_mem (Ideal.toIdeal_homogeneousCore_le 𝒜 I hxy)
refine H.imp ?_ ?_
· exact Ideal.mem_homogeneousCore_of_homogeneous_of_mem hx
· exact Ideal.mem_homogeneousCore_of_homogeneous_of_mem hy | theorem | RingTheory | [
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal"
] | Mathlib/RingTheory/GradedAlgebra/Radical.lean | Ideal.IsPrime.homogeneousCore | null |
Ideal.IsHomogeneous.radical_eq {I : Ideal A} (hI : I.IsHomogeneous 𝒜) :
I.radical = InfSet.sInf { J | Ideal.IsHomogeneous 𝒜 J ∧ I ≤ J ∧ J.IsPrime } := by
rw [Ideal.radical_eq_sInf]
apply le_antisymm
· exact sInf_le_sInf fun J => And.right
· refine sInf_le_sInf_of_isCoinitialFor ?_
rintro J ⟨HJ₁, HJ₂⟩
refine ⟨(J.homogeneousCore 𝒜).toIdeal, ?_, J.toIdeal_homogeneousCore_le _⟩
refine ⟨HomogeneousIdeal.isHomogeneous _, ?_, HJ₂.homogeneousCore⟩
exact hI.toIdeal_homogeneousCore_eq_self.symm.trans_le (Ideal.homogeneousCore_mono _ HJ₁) | theorem | RingTheory | [
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal"
] | Mathlib/RingTheory/GradedAlgebra/Radical.lean | Ideal.IsHomogeneous.radical_eq | null |
Ideal.IsHomogeneous.radical {I : Ideal A} (h : I.IsHomogeneous 𝒜) :
I.radical.IsHomogeneous 𝒜 := by
rw [h.radical_eq]
exact Ideal.IsHomogeneous.sInf fun _ => And.left | theorem | RingTheory | [
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal"
] | Mathlib/RingTheory/GradedAlgebra/Radical.lean | Ideal.IsHomogeneous.radical | null |
HomogeneousIdeal.radical (I : HomogeneousIdeal 𝒜) : HomogeneousIdeal 𝒜 :=
⟨I.toIdeal.radical, I.isHomogeneous.radical⟩
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal"
] | Mathlib/RingTheory/GradedAlgebra/Radical.lean | HomogeneousIdeal.radical | The radical of a homogeneous ideal, as another homogeneous ideal. |
HomogeneousIdeal.coe_radical (I : HomogeneousIdeal 𝒜) :
I.radical.toIdeal = I.toIdeal.radical := rfl | theorem | RingTheory | [
"Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal"
] | Mathlib/RingTheory/GradedAlgebra/Radical.lean | HomogeneousIdeal.coe_radical | null |
@[simp]
coeff_smul' (r : R) (x : HahnSeries Γ V) : (r • x).coeff = r • x.coeff :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | coeff_smul' | null |
coeff_smul {r : R} {x : HahnSeries Γ V} {a : Γ} : (r • x).coeff a = r • x.coeff a :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | coeff_smul | null |
orderTop_smul_not_lt (r : R) (x : HahnSeries Γ V) : ¬ (r • x).orderTop < x.orderTop := by
by_cases hrx : r • x = 0
· rw [hrx, orderTop_zero]
exact not_top_lt
· simp only [orderTop_of_ne_zero hrx, orderTop_of_ne_zero <| right_ne_zero_of_smul hrx,
WithTop.coe_lt_coe]
exact Set.IsWF.min_of_subset_not_lt_min
(Function.support_smul_subset_right (fun _ => r) x.coeff) | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | orderTop_smul_not_lt | null |
order_smul_not_lt [Zero Γ] (r : R) (x : HahnSeries Γ V) (h : r • x ≠ 0) :
¬ (r • x).order < x.order := by
have hx : x ≠ 0 := right_ne_zero_of_smul h
simp_all only [order, dite_false]
exact Set.IsWF.min_of_subset_not_lt_min (Function.support_smul_subset_right (fun _ => r) x.coeff) | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | order_smul_not_lt | null |
le_order_smul {Γ} [Zero Γ] [LinearOrder Γ] (r : R) (x : HahnSeries Γ V) (h : r • x ≠ 0) :
x.order ≤ (r • x).order :=
le_of_not_gt (order_smul_not_lt r x h) | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | le_order_smul | null |
truncLT_smul [DecidableLT Γ] (c : Γ) (r : R) (x : HahnSeries Γ V) :
truncLT c (r • x) = r • truncLT c x := by ext; simp | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | truncLT_smul | null |
@[simp]
coeff_add' (x y : HahnSeries Γ R) : (x + y).coeff = x.coeff + y.coeff :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | coeff_add' | null |
coeff_add {x y : HahnSeries Γ R} {a : Γ} : (x + y).coeff a = x.coeff a + y.coeff a :=
rfl
@[simp] theorem single_add (a : Γ) (r s : R) : single a (r + s) = single a r + single a s := by
classical
ext : 1; exact Pi.single_add (f := fun _ => R) a r s | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | coeff_add | null |
coeff_nsmul {x : HahnSeries Γ R} {n : ℕ} : (n • x).coeff = n • x.coeff := coeff_smul' _ _
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | coeff_nsmul | null |
protected map_add [AddMonoid S] (f : R →+ S) {x y : HahnSeries Γ R} :
((x + y).map f : HahnSeries Γ S) = x.map f + y.map f := by
ext; simp | lemma | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | map_add | null |
@[simps -isSimp]
addOppositeEquiv : HahnSeries Γ Rᵃᵒᵖ ≃+ (HahnSeries Γ R)ᵃᵒᵖ where
toFun x := .op ⟨fun a ↦ (x.coeff a).unop, by convert x.isPWO_support; ext; simp⟩
invFun x := ⟨fun a ↦ .op (x.unop.coeff a), by convert x.unop.isPWO_support; ext; simp⟩
left_inv x := by simp
right_inv x := by
apply AddOpposite.unop_injective
simp
map_add' x y := by
apply AddOpposite.unop_injective
ext
simp
@[simp] | def | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | addOppositeEquiv | `addOppositeEquiv` is an additive monoid isomorphism between
Hahn series over `Γ` with coefficients in the opposite additive monoid `Rᵃᵒᵖ`
and the additive opposite of Hahn series over `Γ` with coefficients `R`. |
addOppositeEquiv_support (x : HahnSeries Γ Rᵃᵒᵖ) :
(addOppositeEquiv x).unop.support = x.support := by
ext
simp [addOppositeEquiv_apply]
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | addOppositeEquiv_support | null |
addOppositeEquiv_symm_support (x : (HahnSeries Γ R)ᵃᵒᵖ) :
(addOppositeEquiv.symm x).support = x.unop.support := by
rw [← addOppositeEquiv_support, AddEquiv.apply_symm_apply]
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | addOppositeEquiv_symm_support | null |
addOppositeEquiv_orderTop (x : HahnSeries Γ Rᵃᵒᵖ) :
(addOppositeEquiv x).unop.orderTop = x.orderTop := by
classical
simp only [orderTop,
addOppositeEquiv_support]
simp only [addOppositeEquiv_apply, AddOpposite.unop_op, mk_eq_zero]
simp_rw [HahnSeries.ext_iff, funext_iff]
simp only [Pi.zero_apply, AddOpposite.unop_eq_zero_iff, coeff_zero]
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | addOppositeEquiv_orderTop | null |
addOppositeEquiv_symm_orderTop (x : (HahnSeries Γ R)ᵃᵒᵖ) :
(addOppositeEquiv.symm x).orderTop = x.unop.orderTop := by
rw [← addOppositeEquiv_orderTop, AddEquiv.apply_symm_apply]
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | addOppositeEquiv_symm_orderTop | null |
addOppositeEquiv_leadingCoeff (x : HahnSeries Γ Rᵃᵒᵖ) :
(addOppositeEquiv x).unop.leadingCoeff = x.leadingCoeff.unop := by
classical
obtain rfl | hx := eq_or_ne x 0
· simp
simp only [ne_eq, AddOpposite.unop_eq_zero_iff, EmbeddingLike.map_eq_zero_iff, hx,
not_false_eq_true, leadingCoeff_of_ne_zero, addOppositeEquiv_orderTop]
simp [addOppositeEquiv]
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | addOppositeEquiv_leadingCoeff | null |
addOppositeEquiv_symm_leadingCoeff (x : (HahnSeries Γ R)ᵃᵒᵖ) :
(addOppositeEquiv.symm x).leadingCoeff = .op x.unop.leadingCoeff := by
apply AddOpposite.unop_injective
rw [← addOppositeEquiv_leadingCoeff, AddEquiv.apply_symm_apply, AddOpposite.unop_op] | lemma | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | addOppositeEquiv_symm_leadingCoeff | null |
support_add_subset {x y : HahnSeries Γ R} : support (x + y) ⊆ support x ∪ support y :=
fun a ha => by
rw [mem_support, coeff_add] at ha
rw [Set.mem_union, mem_support, mem_support]
contrapose! ha
rw [ha.1, ha.2, add_zero] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | support_add_subset | null |
protected min_le_min_add {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R} (hx : x ≠ 0)
(hy : y ≠ 0) (hxy : x + y ≠ 0) :
min (Set.IsWF.min x.isWF_support (support_nonempty_iff.2 hx))
(Set.IsWF.min y.isWF_support (support_nonempty_iff.2 hy)) ≤
Set.IsWF.min (x + y).isWF_support (support_nonempty_iff.2 hxy) := by
rw [← Set.IsWF.min_union]
exact Set.IsWF.min_le_min_of_subset (support_add_subset (x := x) (y := y)) | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | min_le_min_add | null |
min_orderTop_le_orderTop_add {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R} :
min x.orderTop y.orderTop ≤ (x + y).orderTop := by
by_cases hx : x = 0; · simp [hx]
by_cases hy : y = 0; · simp [hy]
by_cases hxy : x + y = 0; · simp [hxy]
rw [orderTop_of_ne_zero hx, orderTop_of_ne_zero hy, orderTop_of_ne_zero hxy, ← WithTop.coe_min,
WithTop.coe_le_coe]
exact HahnSeries.min_le_min_add hx hy hxy | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | min_orderTop_le_orderTop_add | null |
min_order_le_order_add {Γ} [Zero Γ] [LinearOrder Γ] {x y : HahnSeries Γ R}
(hxy : x + y ≠ 0) : min x.order y.order ≤ (x + y).order := by
by_cases hx : x = 0; · simp [hx]
by_cases hy : y = 0; · simp [hy]
rw [order_of_ne hx, order_of_ne hy, order_of_ne hxy]
exact HahnSeries.min_le_min_add hx hy hxy | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | min_order_le_order_add | null |
orderTop_add_eq_left {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R}
(hxy : x.orderTop < y.orderTop) : (x + y).orderTop = x.orderTop := by
have hx : x ≠ 0 := orderTop_ne_top.1 hxy.ne_top
let g : Γ := Set.IsWF.min x.isWF_support (support_nonempty_iff.2 hx)
have hcxyne : (x + y).coeff g ≠ 0 := by
rw [coeff_add, coeff_eq_zero_of_lt_orderTop (lt_of_eq_of_lt (orderTop_of_ne_zero hx).symm hxy),
add_zero]
exact coeff_orderTop_ne (orderTop_of_ne_zero hx)
have hxyx : (x + y).orderTop ≤ x.orderTop := by
rw [orderTop_of_ne_zero hx]
exact orderTop_le_of_coeff_ne_zero hcxyne
exact le_antisymm hxyx (le_of_eq_of_le (min_eq_left_of_lt hxy).symm min_orderTop_le_orderTop_add) | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | orderTop_add_eq_left | null |
orderTop_add_eq_right {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R}
(hxy : y.orderTop < x.orderTop) : (x + y).orderTop = y.orderTop := by
simpa [← map_add, ← AddOpposite.op_add, hxy] using orderTop_add_eq_left
(x := addOppositeEquiv.symm (.op y))
(y := addOppositeEquiv.symm (.op x)) | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | orderTop_add_eq_right | null |
leadingCoeff_add_eq_left {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R}
(hxy : x.orderTop < y.orderTop) : (x + y).leadingCoeff = x.leadingCoeff := by
have hx : x ≠ 0 := orderTop_ne_top.1 hxy.ne_top
have ho : (x + y).orderTop = x.orderTop := orderTop_add_eq_left hxy
by_cases h : x + y = 0
· rw [h, orderTop_zero] at ho
rw [h, orderTop_eq_top.mp ho.symm]
· simp_rw [leadingCoeff_of_ne_zero h, leadingCoeff_of_ne_zero hx, ho, coeff_add]
rw [coeff_eq_zero_of_lt_orderTop (x := y) (by simpa using hxy), add_zero] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | leadingCoeff_add_eq_left | null |
leadingCoeff_add_eq_right {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R}
(hxy : y.orderTop < x.orderTop) : (x + y).leadingCoeff = y.leadingCoeff := by
simpa [← map_add, ← AddOpposite.op_add, hxy] using leadingCoeff_add_eq_left
(x := addOppositeEquiv.symm (.op y))
(y := addOppositeEquiv.symm (.op x)) | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | leadingCoeff_add_eq_right | null |
ne_zero_of_eq_add_single [Zero Γ] {x y : HahnSeries Γ R}
(hxy : x = y + single x.order x.leadingCoeff) (hy : y ≠ 0) : x ≠ 0 := by
by_contra h
simp only [h, order_zero, leadingCoeff_zero, map_zero, add_zero] at hxy
exact hy hxy.symm | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | ne_zero_of_eq_add_single | null |
coeff_order_of_eq_add_single {R} [AddCancelCommMonoid R] [Zero Γ] {x y : HahnSeries Γ R}
(hxy : x = y + single x.order x.leadingCoeff) : y.coeff x.order = 0 := by
simpa [← leadingCoeff_eq] using congr(($hxy).coeff x.order) | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | coeff_order_of_eq_add_single | null |
order_lt_order_of_eq_add_single {R} {Γ} [LinearOrder Γ] [Zero Γ] [AddCancelCommMonoid R]
{x y : HahnSeries Γ R} (hxy : x = y + single x.order x.leadingCoeff) (hy : y ≠ 0) :
x.order < y.order := by
have : x.order ≠ y.order := by
intro h
have hyne : single y.order y.leadingCoeff ≠ 0 := single_ne_zero <| leadingCoeff_ne_zero.mpr hy
rw [leadingCoeff_eq, ← h, coeff_order_of_eq_add_single hxy, single_eq_zero] at hyne
exact hyne rfl
refine lt_of_le_of_ne ?_ this
simp only [order, ne_zero_of_eq_add_single hxy hy, ↓reduceDIte, hy]
have : y.support ⊆ x.support := by
intro g hg
by_cases hgx : g = x.order
· refine (mem_support x g).mpr ?_
have : x.coeff x.order ≠ 0 := coeff_order_ne_zero <| ne_zero_of_eq_add_single hxy hy
rwa [← hgx] at this
· have : x.coeff g = (y + (single x.order) x.leadingCoeff).coeff g := by rw [← hxy]
rw [coeff_add, coeff_single_of_ne hgx, add_zero] at this
simpa [this] using hg
exact Set.IsWF.min_le_min_of_subset this | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | order_lt_order_of_eq_add_single | null |
@[simps!]
single.addMonoidHom (a : Γ) : R →+ HahnSeries Γ R :=
{ single a with
map_add' := single_add _ } | def | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | single.addMonoidHom | `single` as an additive monoid/group homomorphism |
@[simps]
coeff.addMonoidHom (g : Γ) : HahnSeries Γ R →+ R where
toFun f := f.coeff g
map_zero' := coeff_zero
map_add' _ _ := coeff_add | def | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | coeff.addMonoidHom | `coeff g` as an additive monoid/group homomorphism |
embDomain_add (f : Γ ↪o Γ') (x y : HahnSeries Γ R) :
embDomain f (x + y) = embDomain f x + embDomain f y := by
ext g
by_cases hg : g ∈ Set.range f
· obtain ⟨a, rfl⟩ := hg
simp
· simp [embDomain_notin_range hg] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | embDomain_add | null |
truncLT_add [DecidableLT Γ] (c : Γ) (x y : HahnSeries Γ R) :
truncLT c (x + y) = truncLT c x + truncLT c y := by
ext i
by_cases h : i < c <;> simp [h] | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | truncLT_add | null |
@[simp]
coeff_sum {s : Finset α} {x : α → HahnSeries Γ R} (g : Γ) :
(∑ i ∈ s, x i).coeff g = ∑ i ∈ s, (x i).coeff g :=
cons_induction rfl (fun i s his hsum => by rw [sum_cons, sum_cons, coeff_add, hsum]) s | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | coeff_sum | null |
@[simp]
coeff_neg' (x : HahnSeries Γ R) : (-x).coeff = -x.coeff :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.BigOperators.Group.Finset.Basic",
"Mathlib.Algebra.Group.Pi.Lemmas",
"Mathlib.Algebra.Group.Support",
"Mathlib.Algebra.Module.Basic",
"Mathlib.Algebra.Module.LinearMap.Defs",
"Mathlib.Data.Finsupp.SMul",
"Mathlib.RingTheory.HahnSeries.Basic",
"Mathlib.Tactic.FastInstance"
] | Mathlib/RingTheory/HahnSeries/Addition.lean | coeff_neg' | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.