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 ⌀ |
|---|---|---|---|---|---|---|
coeff_neg {x : HahnSeries Γ R} {a : Γ} : (-x).coeff a = -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_neg | null |
@[simp]
coeff_sub' (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_sub' | null |
coeff_sub {x y : HahnSeries Γ R} {a : Γ} : (x - y).coeff a = x.coeff a - y.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_sub | null |
@[simp]
single_sub (a : Γ) (r s : R) : single a (r - s) = single a r - single a s :=
map_sub (single.addMonoidHom a) _ _
@[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 | single_sub | null |
single_neg (a : Γ) (r : R) : single a (-r) = -single a r :=
map_neg (single.addMonoidHom a) _
@[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 | single_neg | null |
support_neg {x : HahnSeries Γ R} : (-x).support = x.support := by
ext
simp
@[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 | support_neg | null |
protected map_neg [AddGroup S] (f : R →+ S) {x : HahnSeries Γ R} :
((-x).map f : HahnSeries Γ S) = -(x.map f) := by
ext; simp
@[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_neg | null |
orderTop_neg {x : HahnSeries Γ R} : (-x).orderTop = x.orderTop := by
classical simp only [orderTop, support_neg, neg_eq_zero]
@[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 | orderTop_neg | null |
order_neg [Zero Γ] {f : HahnSeries Γ R} : (-f).order = f.order := by
classical
by_cases hf : f = 0
· simp only [hf, neg_zero]
simp only [order, support_neg, neg_eq_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 | order_neg | null |
leadingCoeff_neg {x : HahnSeries Γ R} : (-x).leadingCoeff = -x.leadingCoeff := by
obtain rfl | hx := eq_or_ne x 0 <;> simp [leadingCoeff_of_ne_zero, *]
@[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 | leadingCoeff_neg | null |
protected map_sub [AddGroup 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_sub | null |
min_orderTop_le_orderTop_sub {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R} :
min x.orderTop y.orderTop ≤ (x - y).orderTop := by
rw [sub_eq_add_neg, ← orderTop_neg (x := y)]
exact 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 | min_orderTop_le_orderTop_sub | null |
orderTop_sub {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R}
(hxy : x.orderTop < y.orderTop) : (x - y).orderTop = x.orderTop := by
rw [sub_eq_add_neg]
rw [← orderTop_neg (x := y)] at hxy
exact orderTop_add_eq_left 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 | orderTop_sub | null |
leadingCoeff_sub {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R}
(hxy : x.orderTop < y.orderTop) : (x - y).leadingCoeff = x.leadingCoeff := by
rw [sub_eq_add_neg]
rw [← orderTop_neg (x := y)] at hxy
exact leadingCoeff_add_eq_left 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 | leadingCoeff_sub | null |
@[simps]
single.linearMap (a : Γ) : V →ₗ[R] HahnSeries Γ V :=
{ single.addMonoidHom a with
map_smul' := fun r s => by
ext b
by_cases h : b = a <;> simp [h] } | 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.linearMap | `single` as a linear map |
@[simps]
coeff.linearMap (g : Γ) : HahnSeries Γ V →ₗ[R] V :=
{ coeff.addMonoidHom g with map_smul' := fun _ _ => rfl }
@[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 | coeff.linearMap | `coeff g` as a linear map |
protected map_smul [AddCommMonoid U] [Module R U] (f : U →ₗ[R] V) {r : R}
{x : HahnSeries Γ U} : (r • x).map f = r • ((x.map f) : HahnSeries Γ V) := 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_smul | null |
ofFinsuppLinearMap : (Γ →₀ V) →ₗ[R] HahnSeries Γ V where
toFun := ofFinsupp
map_add' _ _ := by
ext
simp
map_smul' _ _ := by
ext
simp
variable (R) in
@[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 | ofFinsuppLinearMap | `ofFinsupp` as a linear map. |
coeff_ofFinsuppLinearMap (f : Γ →₀ V) (a : Γ) :
(ofFinsuppLinearMap R f).coeff a = f 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_ofFinsuppLinearMap | null |
embDomain_smul (f : Γ ↪o Γ') (r : R) (x : HahnSeries Γ R) :
embDomain f (r • x) = r • embDomain f x := 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_smul | null |
@[simps]
embDomainLinearMap (f : Γ ↪o Γ') : HahnSeries Γ R →ₗ[R] HahnSeries Γ' R where
toFun := embDomain f
map_add' := embDomain_add f
map_smul' := embDomain_smul f | 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 | embDomainLinearMap | Extending the domain of Hahn series is a linear map. |
truncLTLinearMap [DecidableLT Γ] (c : Γ) : HahnSeries Γ V →ₗ[R] HahnSeries Γ V where
toFun := truncLT c
map_add' := truncLT_add c
map_smul' := truncLT_smul c
variable (R) in
@[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 | truncLTLinearMap | `HahnSeries.truncLT` as a linear map. |
coe_truncLTLinearMap [DecidableLT Γ] (c : Γ) :
(truncLTLinearMap R c : HahnSeries Γ V → HahnSeries Γ V) = truncLT c := by 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 | coe_truncLTLinearMap | null |
@[ext]
HahnSeries (Γ : Type*) (R : Type*) [PartialOrder Γ] [Zero R] where
/-- The coefficient function of a Hahn Series. -/
coeff : Γ → R
isPWO_support' : (Function.support coeff).IsPWO
variable {Γ Γ' R S : Type*} | structure | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | HahnSeries | If `Γ` is linearly ordered and `R` has zero, then `HahnSeries Γ R` consists of
formal series over `Γ` with coefficients in `R`, whose supports are well-founded. |
coeff_injective : Injective (coeff : HahnSeries Γ R → Γ → R) :=
fun _ _ => HahnSeries.ext
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | coeff_injective | null |
coeff_inj {x y : HahnSeries Γ R} : x.coeff = y.coeff ↔ x = y :=
coeff_injective.eq_iff | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | coeff_inj | null |
@[simps]
map [Zero S] (x : HahnSeries Γ R) {F : Type*} [FunLike F R S] [ZeroHomClass F R S] (f : F) :
HahnSeries Γ S where
coeff g := f (x.coeff g)
isPWO_support' := x.isPWO_support.mono <| Function.support_comp_subset (ZeroHomClass.map_zero f) _
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | map | The support of a Hahn series is just the set of indices whose coefficients are nonzero.
Notably, it is well-founded. -/
nonrec def support (x : HahnSeries Γ R) : Set Γ :=
support x.coeff
@[simp]
theorem isPWO_support (x : HahnSeries Γ R) : x.support.IsPWO :=
x.isPWO_support'
@[simp]
theorem isWF_support (x : HahnSeries Γ R) : x.support.IsWF :=
x.isPWO_support.isWF
@[simp]
theorem mem_support (x : HahnSeries Γ R) (a : Γ) : a ∈ x.support ↔ x.coeff a ≠ 0 :=
Iff.refl _
instance : Zero (HahnSeries Γ R) :=
⟨{ coeff := 0
isPWO_support' := by simp }⟩
instance : Inhabited (HahnSeries Γ R) :=
⟨0⟩
instance [Subsingleton R] : Subsingleton (HahnSeries Γ R) :=
⟨fun _ _ => HahnSeries.ext (by subsingleton)⟩
theorem coeff_zero' : (0 : HahnSeries Γ R).coeff = 0 :=
rfl
@[simp]
theorem coeff_zero {a : Γ} : (0 : HahnSeries Γ R).coeff a = 0 :=
rfl
@[simp]
theorem coeff_fun_eq_zero_iff {x : HahnSeries Γ R} : x.coeff = 0 ↔ x = 0 :=
coeff_injective.eq_iff' rfl
theorem ne_zero_of_coeff_ne_zero {x : HahnSeries Γ R} {g : Γ} (h : x.coeff g ≠ 0) : x ≠ 0 :=
mt (fun x0 => (x0.symm ▸ coeff_zero : x.coeff g = 0)) h
@[simp]
theorem support_zero : support (0 : HahnSeries Γ R) = ∅ :=
Function.support_zero
@[simp]
nonrec theorem support_nonempty_iff {x : HahnSeries Γ R} : x.support.Nonempty ↔ x ≠ 0 := by
rw [support, support_nonempty_iff, Ne, coeff_fun_eq_zero_iff]
@[simp]
theorem support_eq_empty_iff {x : HahnSeries Γ R} : x.support = ∅ ↔ x = 0 :=
Function.support_eq_empty_iff.trans coeff_fun_eq_zero_iff
/-- The map of Hahn series induced by applying a zero-preserving map to each coefficient. |
protected map_zero [Zero S] (f : ZeroHom R S) :
(0 : HahnSeries Γ R).map f = 0 := by
ext; simp | lemma | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | map_zero | null |
ofIterate [PartialOrder Γ'] (x : HahnSeries Γ (HahnSeries Γ' R)) :
HahnSeries (Γ ×ₗ Γ') R where
coeff := fun g => coeff (coeff x g.1) g.2
isPWO_support' := by
refine Set.PartiallyWellOrderedOn.subsetProdLex ?_ ?_
· refine Set.IsPWO.mono x.isPWO_support' ?_
simp_rw [Set.image_subset_iff, support_subset_iff, Set.mem_preimage, Function.mem_support]
exact fun _ ↦ ne_zero_of_coeff_ne_zero
· exact fun a => by simpa [Function.mem_support, ne_eq] using (x.coeff a).isPWO_support'
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | ofIterate | Change a HahnSeries with coefficients in HahnSeries to a HahnSeries on the Lex product. |
mk_eq_zero (f : Γ → R) (h) : HahnSeries.mk f h = 0 ↔ f = 0 := by
simp_rw [HahnSeries.ext_iff, funext_iff, coeff_zero, Pi.zero_apply] | lemma | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | mk_eq_zero | null |
toIterate [PartialOrder Γ'] (x : HahnSeries (Γ ×ₗ Γ') R) :
HahnSeries Γ (HahnSeries Γ' R) where
coeff := fun g => {
coeff := fun g' => coeff x (g, g')
isPWO_support' := Set.PartiallyWellOrderedOn.fiberProdLex x.isPWO_support' g
}
isPWO_support' := by
have h₁ : (Function.support fun g => HahnSeries.mk (fun g' => x.coeff (g, g'))
(Set.PartiallyWellOrderedOn.fiberProdLex x.isPWO_support' g)) = Function.support
fun g => fun g' => x.coeff (g, g') := by
simp only [Function.support, ne_eq, mk_eq_zero]
rw [h₁, Function.support_fun_curry x.coeff]
exact Set.PartiallyWellOrderedOn.imageProdLex x.isPWO_support' | def | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | toIterate | Change a Hahn series on a lex product to a Hahn series with coefficients in a Hahn series. |
@[simps]
iterateEquiv [PartialOrder Γ'] :
HahnSeries Γ (HahnSeries Γ' R) ≃ HahnSeries (Γ ×ₗ Γ') R where
toFun := ofIterate
invFun := toIterate
left_inv := congrFun rfl
right_inv := congrFun rfl
open Classical in | def | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | iterateEquiv | The equivalence between iterated Hahn series and Hahn series on the lex product. |
single (a : Γ) : ZeroHom R (HahnSeries Γ R) where
toFun r :=
{ coeff := Pi.single a r
isPWO_support' := (Set.isPWO_singleton a).mono Pi.support_single_subset }
map_zero' := HahnSeries.ext (Pi.single_zero _)
variable {a b : Γ} {r : R}
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | single | `single a r` is the Hahn series which has coefficient `r` at `a` and zero otherwise. |
coeff_single_same (a : Γ) (r : R) : (single a r).coeff a = r := by
classical exact Pi.single_eq_same (M := fun _ => R) a r
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | coeff_single_same | null |
coeff_single_of_ne (h : b ≠ a) : (single a r).coeff b = 0 := by
classical exact Pi.single_eq_of_ne (M := fun _ => R) h r
open Classical in | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | coeff_single_of_ne | null |
coeff_single : (single a r).coeff b = if b = a then r else 0 := by
split_ifs with h <;> simp [h]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | coeff_single | null |
support_single_of_ne (h : r ≠ 0) : support (single a r) = {a} := by
classical exact Pi.support_single_of_ne h | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | support_single_of_ne | null |
support_single_subset : support (single a r) ⊆ {a} := by
classical exact Pi.support_single_subset | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | support_single_subset | null |
eq_of_mem_support_single {b : Γ} (h : b ∈ support (single a r)) : b = a :=
support_single_subset h | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | eq_of_mem_support_single | null |
single_eq_zero : single a (0 : R) = 0 :=
(single a).map_zero | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | single_eq_zero | null |
single_injective (a : Γ) : Function.Injective (single a : R → HahnSeries Γ R) :=
fun r s rs => by rw [← coeff_single_same a r, ← coeff_single_same a s, rs] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | single_injective | null |
single_ne_zero (h : r ≠ 0) : single a r ≠ 0 := fun con =>
h (single_injective a (con.trans single_eq_zero.symm))
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | single_ne_zero | null |
single_eq_zero_iff {a : Γ} {r : R} : single a r = 0 ↔ r = 0 :=
map_eq_zero_iff _ <| single_injective a
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | single_eq_zero_iff | null |
protected map_single [Zero S] (f : ZeroHom R S) : (single a r).map f = single a (f r) := by
ext g
by_cases h : g = a <;> simp [h] | lemma | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | map_single | null |
orderTop (x : HahnSeries Γ R) : WithTop Γ :=
if h : x = 0 then ⊤ else x.isWF_support.min (support_nonempty_iff.2 h)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | orderTop | The orderTop of a Hahn series `x` is a minimal element of `WithTop Γ` where `x` has a nonzero
coefficient if `x ≠ 0`, and is `⊤` when `x = 0`. |
orderTop_zero : orderTop (0 : HahnSeries Γ R) = ⊤ :=
dif_pos rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | orderTop_zero | null |
orderTop_of_subsingleton [Subsingleton R] : x.orderTop = ⊤ :=
(Subsingleton.eq_zero x) ▸ orderTop_zero
@[deprecated (since := "2025-08-19")] alias orderTop_of_Subsingleton := orderTop_of_subsingleton | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | orderTop_of_subsingleton | null |
orderTop_of_ne_zero (hx : x ≠ 0) :
orderTop x = x.isWF_support.min (support_nonempty_iff.2 hx) :=
dif_neg hx
@[deprecated (since := "2025-08-19")] alias orderTop_of_ne := orderTop_of_ne_zero
@[simp] lemma orderTop_eq_top : orderTop x = ⊤ ↔ x = 0 := by simp [orderTop]
@[simp] lemma orderTop_lt_top : orderTop x < ⊤ ↔ x ≠ 0 := by simp [lt_top_iff_ne_top] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | orderTop_of_ne_zero | null |
orderTop_ne_top : orderTop x ≠ ⊤ ↔ x ≠ 0 := orderTop_eq_top.not
@[deprecated (since := "2025-08-19")] alias orderTop_eq_top_iff := orderTop_eq_top
@[deprecated orderTop_ne_top (since := "2025-08-19")] | lemma | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | orderTop_ne_top | null |
ne_zero_iff_orderTop : x ≠ 0 ↔ orderTop x ≠ ⊤ := orderTop_ne_top.symm | lemma | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | ne_zero_iff_orderTop | null |
orderTop_eq_of_le {x : HahnSeries Γ R} {g : Γ} (hg : g ∈ x.support)
(hx : ∀ g' ∈ x.support, g ≤ g') : orderTop x = g := by
rw [orderTop_of_ne_zero <| support_nonempty_iff.mp <| Set.nonempty_of_mem hg,
x.isWF_support.min_eq_of_le hg hx] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | orderTop_eq_of_le | null |
untop_orderTop_of_ne_zero {x : HahnSeries Γ R} (hx : x ≠ 0) :
WithTop.untop x.orderTop (orderTop_ne_top.2 hx) =
x.isWF_support.min (support_nonempty_iff.2 hx) :=
WithTop.coe_inj.mp ((WithTop.coe_untop (orderTop x) (orderTop_ne_top.2 hx)).trans
(orderTop_of_ne_zero hx)) | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | untop_orderTop_of_ne_zero | null |
coeff_orderTop_ne {x : HahnSeries Γ R} {g : Γ} (hg : x.orderTop = g) :
x.coeff g ≠ 0 := by
have h : orderTop x ≠ ⊤ := by simp_all only [ne_eq, WithTop.coe_ne_top, not_false_eq_true]
have hx : x ≠ 0 := orderTop_ne_top.1 h
rw [orderTop_of_ne_zero hx, WithTop.coe_eq_coe] at hg
rw [← hg]
exact x.isWF_support.min_mem (support_nonempty_iff.2 hx) | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | coeff_orderTop_ne | null |
orderTop_le_of_coeff_ne_zero {Γ} [LinearOrder Γ] {x : HahnSeries Γ R}
{g : Γ} (h : x.coeff g ≠ 0) : x.orderTop ≤ g := by
rw [orderTop_of_ne_zero (ne_zero_of_coeff_ne_zero h), WithTop.coe_le_coe]
exact Set.IsWF.min_le _ _ ((mem_support _ _).2 h)
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | orderTop_le_of_coeff_ne_zero | null |
orderTop_single (h : r ≠ 0) : (single a r).orderTop = a :=
(orderTop_of_ne_zero (single_ne_zero h)).trans
(WithTop.coe_inj.mpr (support_single_subset
((single a r).isWF_support.min_mem (support_nonempty_iff.2 (single_ne_zero h))))) | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | orderTop_single | null |
orderTop_single_le : a ≤ (single a r).orderTop := by
by_cases hr : r = 0
· simp only [hr, map_zero, orderTop_zero, le_top]
· rw [orderTop_single hr] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | orderTop_single_le | null |
lt_orderTop_single {g g' : Γ} (hgg' : g < g') : g < (single g' r).orderTop :=
lt_of_lt_of_le (WithTop.coe_lt_coe.mpr hgg') orderTop_single_le | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | lt_orderTop_single | null |
coeff_eq_zero_of_lt_orderTop {x : HahnSeries Γ R} {i : Γ} (hi : i < x.orderTop) :
x.coeff i = 0 := by
rcases eq_or_ne x 0 with (rfl | hx)
· exact coeff_zero
contrapose! hi
rw [← mem_support] at hi
rw [orderTop_of_ne_zero hx, WithTop.coe_lt_coe]
exact Set.IsWF.not_lt_min _ _ hi
open Classical in | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | coeff_eq_zero_of_lt_orderTop | null |
leadingCoeff (x : HahnSeries Γ R) : R := x.orderTop.recTopCoe 0 x.coeff
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | leadingCoeff | A leading coefficient of a Hahn series is the coefficient of a lowest-order nonzero term, or
zero if the series vanishes. |
leadingCoeff_zero : leadingCoeff (0 : HahnSeries Γ R) = 0 := by simp [leadingCoeff] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | leadingCoeff_zero | null |
leadingCoeff_of_ne_zero {x : HahnSeries Γ R} (hx : x ≠ 0) :
x.leadingCoeff = x.coeff (x.orderTop.untop <| orderTop_ne_top.2 hx) := by
simp [leadingCoeff, orderTop, hx]
@[deprecated (since := "2025-08-19")] alias leadingCoeff_of_ne := leadingCoeff_of_ne_zero
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | leadingCoeff_of_ne_zero | null |
leadingCoeff_eq_zero {x : HahnSeries Γ R} : x.leadingCoeff = 0 ↔ x = 0 := by
obtain rfl | hx := eq_or_ne x 0 <;> simp [leadingCoeff_of_ne_zero, coeff_orderTop_ne, *] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | leadingCoeff_eq_zero | null |
leadingCoeff_ne_zero {x : HahnSeries Γ R} : x.leadingCoeff ≠ 0 ↔ x ≠ 0 :=
leadingCoeff_eq_zero.not
@[deprecated (since := "2025-08-19")] alias leadingCoeff_eq_iff := leadingCoeff_eq_zero
@[deprecated (since := "2025-08-19")] alias leadingCoeff_ne_iff := leadingCoeff_ne_zero
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | leadingCoeff_ne_zero | null |
leadingCoeff_of_single {a : Γ} {r : R} : leadingCoeff (single a r) = r := by
by_cases h : r = 0 <;> simp [leadingCoeff, h] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | leadingCoeff_of_single | null |
coeff_untop_eq_leadingCoeff {x : HahnSeries Γ R} (hx) :
x.coeff (x.orderTop.untop hx) = x.leadingCoeff := by
rw [orderTop_ne_top] at hx
rw [leadingCoeff_of_ne_zero hx, (WithTop.untop_eq_iff _).mpr (orderTop_of_ne_zero hx)]
variable [Zero Γ]
open Classical in | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | coeff_untop_eq_leadingCoeff | null |
order (x : HahnSeries Γ R) : Γ :=
if h : x = 0 then 0 else x.isWF_support.min (support_nonempty_iff.2 h)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | order | The order of a nonzero Hahn series `x` is a minimal element of `Γ` where `x` has a
nonzero coefficient, the order of 0 is 0. |
order_zero : order (0 : HahnSeries Γ R) = 0 :=
dif_pos rfl | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | order_zero | null |
order_of_ne {x : HahnSeries Γ R} (hx : x ≠ 0) :
order x = x.isWF_support.min (support_nonempty_iff.2 hx) :=
dif_neg hx | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | order_of_ne | null |
order_eq_orderTop_of_ne_zero (hx : x ≠ 0) : order x = orderTop x := by
rw [order_of_ne hx, orderTop_of_ne_zero hx]
@[deprecated (since := "2025-08-19")] alias order_eq_orderTop_of_ne := order_eq_orderTop_of_ne_zero | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | order_eq_orderTop_of_ne_zero | null |
coeff_order_ne_zero {x : HahnSeries Γ R} (hx : x ≠ 0) : x.coeff x.order ≠ 0 := by
rw [order_of_ne hx]
exact x.isWF_support.min_mem (support_nonempty_iff.2 hx) | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | coeff_order_ne_zero | null |
order_le_of_coeff_ne_zero {Γ} [Zero Γ] [LinearOrder Γ] {x : HahnSeries Γ R}
{g : Γ} (h : x.coeff g ≠ 0) : x.order ≤ g :=
le_trans (le_of_eq (order_of_ne (ne_zero_of_coeff_ne_zero h)))
(Set.IsWF.min_le _ _ ((mem_support _ _).2 h))
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | order_le_of_coeff_ne_zero | null |
order_single (h : r ≠ 0) : (single a r).order = a :=
(order_of_ne (single_ne_zero h)).trans
(support_single_subset
((single a r).isWF_support.min_mem (support_nonempty_iff.2 (single_ne_zero h)))) | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | order_single | null |
coeff_eq_zero_of_lt_order {x : HahnSeries Γ R} {i : Γ} (hi : i < x.order) :
x.coeff i = 0 := by
rcases eq_or_ne x 0 with (rfl | hx)
· simp
contrapose! hi
rw [← mem_support] at hi
rw [order_of_ne hx]
exact Set.IsWF.not_lt_min _ _ hi | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | coeff_eq_zero_of_lt_order | null |
zero_lt_orderTop_iff {x : HahnSeries Γ R} (hx : x ≠ 0) :
0 < x.orderTop ↔ 0 < x.order := by
simp_all [orderTop_of_ne_zero hx, order_of_ne hx] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | zero_lt_orderTop_iff | null |
zero_lt_orderTop_of_order {x : HahnSeries Γ R} (hx : 0 < x.order) : 0 < x.orderTop := by
by_cases h : x = 0
· simp_all only [order_zero, lt_self_iff_false]
· exact (zero_lt_orderTop_iff h).mpr hx | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | zero_lt_orderTop_of_order | null |
zero_le_orderTop_iff {x : HahnSeries Γ R} : 0 ≤ x.orderTop ↔ 0 ≤ x.order := by
by_cases h : x = 0
· simp_all
· simp_all [order_of_ne h, orderTop_of_ne_zero h] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | zero_le_orderTop_iff | null |
leadingCoeff_eq {x : HahnSeries Γ R} : x.leadingCoeff = x.coeff x.order := by
by_cases h : x = 0
· rw [h, leadingCoeff_zero, coeff_zero]
· simp [leadingCoeff_of_ne_zero, orderTop_of_ne_zero, order_of_ne, h] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | leadingCoeff_eq | null |
ofFinsupp : ZeroHom (Γ →₀ R) (HahnSeries Γ R) where
toFun f := { coeff := f, isPWO_support' := f.finite_support.isPWO }
map_zero' := by simp
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | ofFinsupp | Create a `HahnSeries` with a `Finsupp` as coefficients. |
coeff_ofFinsupp (f : Γ →₀ R) (a : Γ) : (ofFinsupp f).coeff a = f a := rfl | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | coeff_ofFinsupp | null |
embDomain (f : Γ ↪o Γ') : HahnSeries Γ R → HahnSeries Γ' R := fun x =>
{ coeff := fun b : Γ' => if h : b ∈ f '' x.support then x.coeff (Classical.choose h) else 0
isPWO_support' :=
(x.isPWO_support.image_of_monotone f.monotone).mono fun b hb => by
contrapose! hb
rw [Function.mem_support, dif_neg hb, Classical.not_not] }
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | embDomain | Extends the domain of a `HahnSeries` by an `OrderEmbedding`. |
embDomain_coeff {f : Γ ↪o Γ'} {x : HahnSeries Γ R} {a : Γ} :
(embDomain f x).coeff (f a) = x.coeff a := by
rw [embDomain]
dsimp only
by_cases ha : a ∈ x.support
· rw [dif_pos (Set.mem_image_of_mem f ha)]
exact congr rfl (f.injective (Classical.choose_spec (Set.mem_image_of_mem f ha)).2)
· rw [dif_neg, Classical.not_not.1 fun c => ha ((mem_support _ _).2 c)]
contrapose! ha
obtain ⟨b, hb1, hb2⟩ := (Set.mem_image _ _ _).1 ha
rwa [f.injective hb2] at hb1
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | embDomain_coeff | null |
embDomain_mk_coeff {f : Γ → Γ'} (hfi : Function.Injective f)
(hf : ∀ g g' : Γ, f g ≤ f g' ↔ g ≤ g') {x : HahnSeries Γ R} {a : Γ} :
(embDomain ⟨⟨f, hfi⟩, hf _ _⟩ x).coeff (f a) = x.coeff a :=
embDomain_coeff | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | embDomain_mk_coeff | null |
embDomain_notin_image_support {f : Γ ↪o Γ'} {x : HahnSeries Γ R} {b : Γ'}
(hb : b ∉ f '' x.support) : (embDomain f x).coeff b = 0 :=
dif_neg hb | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | embDomain_notin_image_support | null |
support_embDomain_subset {f : Γ ↪o Γ'} {x : HahnSeries Γ R} :
support (embDomain f x) ⊆ f '' x.support := by
intro g hg
contrapose! hg
rw [mem_support, embDomain_notin_image_support hg, Classical.not_not] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | support_embDomain_subset | null |
embDomain_notin_range {f : Γ ↪o Γ'} {x : HahnSeries Γ R} {b : Γ'} (hb : b ∉ Set.range f) :
(embDomain f x).coeff b = 0 :=
embDomain_notin_image_support fun con => hb (Set.image_subset_range _ _ con)
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | embDomain_notin_range | null |
embDomain_zero {f : Γ ↪o Γ'} : embDomain f (0 : HahnSeries Γ R) = 0 := by
ext
simp [embDomain_notin_image_support]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | embDomain_zero | null |
embDomain_single {f : Γ ↪o Γ'} {g : Γ} {r : R} :
embDomain f (single g r) = single (f g) r := by
ext g'
by_cases h : g' = f g
· simp [h]
rw [embDomain_notin_image_support, coeff_single_of_ne h]
by_cases hr : r = 0
· simp [hr]
rwa [support_single_of_ne hr, Set.image_singleton, Set.mem_singleton_iff] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | embDomain_single | null |
embDomain_injective {f : Γ ↪o Γ'} :
Function.Injective (embDomain f : HahnSeries Γ R → HahnSeries Γ' R) := fun x y xy => by
ext g
rw [HahnSeries.ext_iff, funext_iff] at xy
have xyg := xy (f g)
rwa [embDomain_coeff, embDomain_coeff] at xyg
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | embDomain_injective | null |
orderTop_embDomain {Γ : Type*} [LinearOrder Γ] {f : Γ ↪o Γ'} {x : HahnSeries Γ R} :
(embDomain f x).orderTop = WithTop.map f x.orderTop := by
obtain rfl | hx := eq_or_ne x 0
· simp
rw [← WithTop.coe_untop x.orderTop (by simpa using hx), WithTop.map_coe]
apply orderTop_eq_of_le
· simpa using coeff_orderTop_ne (by simp)
intro y hy
obtain ⟨z, hz, rfl⟩ :=
(Set.mem_image _ _ _).mp <| Set.mem_of_subset_of_mem support_embDomain_subset hy
rw [OrderEmbedding.le_iff_le, WithTop.untop_le_iff]
apply orderTop_le_of_coeff_ne_zero
simpa using hz | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | orderTop_embDomain | null |
forallLTEqZero_supp_BddBelow (f : Γ → R) (n : Γ) (hn : ∀ (m : Γ), m < n → f m = 0) :
BddBelow (Function.support f) := by
simp only [BddBelow, Set.Nonempty, lowerBounds]
use n
intro m hm
rw [Function.mem_support, ne_eq] at hm
exact not_lt.mp (mt (hn m) hm) | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | forallLTEqZero_supp_BddBelow | null |
BddBelow_zero [Nonempty Γ] : BddBelow (Function.support (0 : Γ → R)) := by
simp only [Function.support_zero, bddBelow_empty]
variable [LocallyFiniteOrder Γ] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | BddBelow_zero | null |
suppBddBelow_supp_PWO (f : Γ → R) (hf : BddBelow (Function.support f)) :
(Function.support f).IsPWO :=
hf.isWF.isPWO | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | suppBddBelow_supp_PWO | null |
@[simps]
ofSuppBddBelow (f : Γ → R) (hf : BddBelow (Function.support f)) : HahnSeries Γ R where
coeff := f
isPWO_support' := suppBddBelow_supp_PWO f hf
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | ofSuppBddBelow | Construct a Hahn series from any function whose support is bounded below. |
zero_ofSuppBddBelow [Nonempty Γ] : ofSuppBddBelow 0 BddBelow_zero = (0 : HahnSeries Γ R) :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | zero_ofSuppBddBelow | null |
order_ofForallLtEqZero [Zero Γ] (f : Γ → R) (hf : f ≠ 0) (n : Γ)
(hn : ∀ (m : Γ), m < n → f m = 0) :
n ≤ order (ofSuppBddBelow f (forallLTEqZero_supp_BddBelow f n hn)) := by
dsimp only [order]
by_cases h : ofSuppBddBelow f (forallLTEqZero_supp_BddBelow f n hn) = 0
cases h
· exact (hf rfl).elim
simp_all only [dite_false]
rw [Set.IsWF.le_min_iff]
intro m hm
rw [HahnSeries.support, Function.mem_support, ne_eq] at hm
exact not_lt.mp (mt (hn m) hm) | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | order_ofForallLtEqZero | null |
truncLT [PartialOrder Γ] [DecidableLT Γ] (c : Γ) :
ZeroHom (HahnSeries Γ R) (HahnSeries Γ R) where
toFun x :=
{ coeff i := if i < c then x.coeff i else 0
isPWO_support' := Set.IsPWO.mono x.isPWO_support (by simp) }
map_zero' := by ext; simp
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | truncLT | Zeroes out coefficients of a `HahnSeries` at indices not less than `c`. |
protected coeff_truncLT [PartialOrder Γ] [DecidableLT Γ]
(c : Γ) (x : HahnSeries Γ R) (i : Γ) :
(truncLT c x).coeff i = if i < c then x.coeff i else 0 := rfl | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | coeff_truncLT | null |
coeff_truncLT_of_lt [PartialOrder Γ] [DecidableLT Γ]
{c i : Γ} (h : i < c) (x : HahnSeries Γ R) : (truncLT c x).coeff i = x.coeff i := by
simp [h] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | coeff_truncLT_of_lt | null |
coeff_truncLT_of_le [LinearOrder Γ]
{c i : Γ} (h : c ≤ i) (x : HahnSeries Γ R) :
(truncLT c x).coeff i = 0 := by
simp [h] | theorem | RingTheory | [
"Mathlib.Algebra.Notation.Support",
"Mathlib.Algebra.Order.Monoid.Unbundled.WithTop",
"Mathlib.Data.Finsupp.Defs",
"Mathlib.Order.WellFoundedSet"
] | Mathlib/RingTheory/HahnSeries/Basic.lean | coeff_truncLT_of_le | null |
powerSeriesFamily (x : HahnSeries Γ V) (f : PowerSeries R) : SummableFamily Γ V ℕ :=
smulFamily (fun n => f.coeff n) (powers x) | abbrev | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Summable",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/HahnSeries/HEval.lean | powerSeriesFamily | A summable family given by scalar multiples of powers of a positive order Hahn series.
The scalar multiples are given by the coefficients of a power series. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.