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 ⌀ |
|---|---|---|---|---|---|---|
@[simps]
C : R →+* HahnSeries Γ R where
toFun := single 0
map_zero' := single_eq_zero
map_one' := rfl
map_add' x y := by
ext a
by_cases h : a = 0 <;> simp [h]
map_mul' x y := by rw [single_mul_single, zero_add] | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.GroupWithZero.Regular",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Finset.MulAntidiagonal",
"Mathlib.Data.Finset.SMulAntidiagonal",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Multiplication.lean | C | `C a` is the constant Hahn Series `a`. `C` is provided as a ring homomorphism. |
C_zero : C (0 : R) = (0 : HahnSeries Γ R) :=
C.map_zero | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.GroupWithZero.Regular",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Finset.MulAntidiagonal",
"Mathlib.Data.Finset.SMulAntidiagonal",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Multiplication.lean | C_zero | null |
C_one : C (1 : R) = (1 : HahnSeries Γ R) :=
C.map_one | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.GroupWithZero.Regular",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Finset.MulAntidiagonal",
"Mathlib.Data.Finset.SMulAntidiagonal",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Multiplication.lean | C_one | null |
map_C [NonAssocSemiring S] (a : R) (f : R →+* S) :
((C a).map f : HahnSeries Γ S) = C (f a) := by
ext g
by_cases h : g = 0 <;> simp [h] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.GroupWithZero.Regular",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Finset.MulAntidiagonal",
"Mathlib.Data.Finset.SMulAntidiagonal",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Multiplication.lean | map_C | null |
C_injective : Function.Injective (C : R → HahnSeries Γ R) := by
intro r s rs
rw [HahnSeries.ext_iff, funext_iff] at rs
have h := rs 0
rwa [C_apply, coeff_single_same, C_apply, coeff_single_same] at h | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.GroupWithZero.Regular",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Finset.MulAntidiagonal",
"Mathlib.Data.Finset.SMulAntidiagonal",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Multiplication.lean | C_injective | null |
C_ne_zero {r : R} (h : r ≠ 0) : (C r : HahnSeries Γ R) ≠ 0 :=
C_injective.ne_iff' C_zero |>.mpr h | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.GroupWithZero.Regular",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Finset.MulAntidiagonal",
"Mathlib.Data.Finset.SMulAntidiagonal",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Multiplication.lean | C_ne_zero | null |
order_C {r : R} : order (C r : HahnSeries Γ R) = 0 := by
by_cases h : r = 0
· rw [h, C_zero, order_zero]
· exact order_single h | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.GroupWithZero.Regular",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Finset.MulAntidiagonal",
"Mathlib.Data.Finset.SMulAntidiagonal",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Multiplication.lean | order_C | null |
C_mul_eq_smul {r : R} {x : HahnSeries Γ R} : C r * x = r • x :=
single_zero_mul_eq_smul | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.GroupWithZero.Regular",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Finset.MulAntidiagonal",
"Mathlib.Data.Finset.SMulAntidiagonal",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Multiplication.lean | C_mul_eq_smul | null |
embDomain_mul [NonUnitalNonAssocSemiring R] (f : Γ ↪o Γ')
(hf : ∀ x y, f (x + y) = f x + f y) (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 ⟨g, rfl⟩ := hg
simp only [coeff_mul, embDomain_coeff]
trans
∑ ij ∈
(addAntidiagonal x.isPWO_support y.isPWO_support g).map
(f.toEmbedding.prodMap f.toEmbedding),
(embDomain f x).coeff ij.1 * (embDomain f y).coeff ij.2
· simp
apply sum_subset
· rintro ⟨i, j⟩ hij
simp only [mem_map, mem_addAntidiagonal,
Function.Embedding.coe_prodMap, mem_support, Prod.exists] at hij
obtain ⟨i, j, ⟨hx, hy, rfl⟩, rfl, rfl⟩ := hij
simp [hx, hy, hf]
· rintro ⟨_, _⟩ h1 h2
contrapose! h2
obtain ⟨i, _, rfl⟩ := support_embDomain_subset (ne_zero_and_ne_zero_of_mul h2).1
obtain ⟨j, _, rfl⟩ := support_embDomain_subset (ne_zero_and_ne_zero_of_mul h2).2
simp only [mem_map, mem_addAntidiagonal,
Function.Embedding.coe_prodMap, mem_support, Prod.exists]
simp only [mem_addAntidiagonal, embDomain_coeff, mem_support, ← hf,
OrderEmbedding.eq_iff_eq] at h1
exact ⟨i, j, h1, rfl⟩
· rw [embDomain_notin_range hg, eq_comm]
contrapose! hg
obtain ⟨_, hi, _, hj, rfl⟩ := support_mul_subset_add_support ((mem_support _ _).2 hg)
obtain ⟨i, _, rfl⟩ := support_embDomain_subset hi
obtain ⟨j, _, rfl⟩ := support_embDomain_subset hj
exact ⟨i + j, hf i j⟩
omit [IsOrderedCancelAddMonoid Γ] [IsOrderedCancelAddMonoid Γ'] in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.GroupWithZero.Regular",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Finset.MulAntidiagonal",
"Mathlib.Data.Finset.SMulAntidiagonal",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Multiplication.lean | embDomain_mul | null |
embDomain_one [NonAssocSemiring R] (f : Γ ↪o Γ') (hf : f 0 = 0) :
embDomain f (1 : HahnSeries Γ R) = (1 : HahnSeries Γ' R) :=
embDomain_single.trans <| hf.symm ▸ rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.GroupWithZero.Regular",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Finset.MulAntidiagonal",
"Mathlib.Data.Finset.SMulAntidiagonal",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Multiplication.lean | embDomain_one | null |
@[simps]
embDomainRingHom [NonAssocSemiring R] (f : Γ →+ Γ') (hfi : Function.Injective f)
(hf : ∀ g g' : Γ, f g ≤ f g' ↔ g ≤ g') : HahnSeries Γ R →+* HahnSeries Γ' R where
toFun := embDomain ⟨⟨f, hfi⟩, hf _ _⟩
map_one' := embDomain_one _ f.map_zero
map_mul' := embDomain_mul _ f.map_add
map_zero' := embDomain_zero
map_add' := embDomain_add _ | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.GroupWithZero.Regular",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Finset.MulAntidiagonal",
"Mathlib.Data.Finset.SMulAntidiagonal",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Multiplication.lean | embDomainRingHom | Extending the domain of Hahn series is a ring homomorphism. |
embDomainRingHom_C [NonAssocSemiring R] {f : Γ →+ Γ'} {hfi : Function.Injective f}
{hf : ∀ g g' : Γ, f g ≤ f g' ↔ g ≤ g'} {r : R} : embDomainRingHom f hfi hf (C r) = C r :=
embDomain_single.trans (by simp) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.GroupWithZero.Regular",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Finset.MulAntidiagonal",
"Mathlib.Data.Finset.SMulAntidiagonal",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Multiplication.lean | embDomainRingHom_C | null |
C_eq_algebraMap : C = algebraMap R (HahnSeries Γ R) :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.GroupWithZero.Regular",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Finset.MulAntidiagonal",
"Mathlib.Data.Finset.SMulAntidiagonal",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Multiplication.lean | C_eq_algebraMap | null |
algebraMap_apply {r : R} : algebraMap R (HahnSeries Γ A) r = C (algebraMap R A r) :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.GroupWithZero.Regular",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Finset.MulAntidiagonal",
"Mathlib.Data.Finset.SMulAntidiagonal",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Multiplication.lean | algebraMap_apply | null |
@[simps!]
embDomainAlgHom (f : Γ →+ Γ') (hfi : Function.Injective f)
(hf : ∀ g g' : Γ, f g ≤ f g' ↔ g ≤ g') : HahnSeries Γ A →ₐ[R] HahnSeries Γ' A :=
{ embDomainRingHom f hfi hf with commutes' := fun _ => embDomainRingHom_C (hf := hf) } | def | RingTheory | [
"Mathlib.Algebra.Algebra.Subalgebra.Lattice",
"Mathlib.Algebra.GroupWithZero.Regular",
"Mathlib.Algebra.Module.BigOperators",
"Mathlib.Data.Finset.MulAntidiagonal",
"Mathlib.Data.Finset.SMulAntidiagonal",
"Mathlib.GroupTheory.GroupAction.Ring",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Multiplication.lean | embDomainAlgHom | Extending the domain of Hahn series is an algebra homomorphism. |
@[simps]
toPowerSeries : HahnSeries ℕ R ≃+* PowerSeries R where
toFun f := PowerSeries.mk f.coeff
invFun f := ⟨fun n => PowerSeries.coeff n f, .of_linearOrder _⟩
left_inv f := by
ext
simp
right_inv f := by
ext
simp
map_add' f g := by
ext
simp
map_mul' f g := by
ext n
simp only [PowerSeries.coeff_mul, PowerSeries.coeff_mk, coeff_mul]
classical
refine (sum_filter_ne_zero _).symm.trans <| (sum_congr ?_ fun _ _ ↦ rfl).trans <|
sum_filter_ne_zero _
ext m
simp only [mem_antidiagonal, mem_addAntidiagonal, and_congr_left_iff, mem_filter,
mem_support]
rintro h
rw [and_iff_right (left_ne_zero_of_mul h), and_iff_right (right_ne_zero_of_mul h)] | def | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.Data.Finsupp.PWO"
] | Mathlib/RingTheory/HahnSeries/PowerSeries.lean | toPowerSeries | The ring `HahnSeries ℕ R` is isomorphic to `PowerSeries R`. |
coeff_toPowerSeries {f : HahnSeries ℕ R} {n : ℕ} :
PowerSeries.coeff n (toPowerSeries f) = f.coeff n :=
PowerSeries.coeff_mk _ _ | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.Data.Finsupp.PWO"
] | Mathlib/RingTheory/HahnSeries/PowerSeries.lean | coeff_toPowerSeries | null |
coeff_toPowerSeries_symm {f : PowerSeries R} {n : ℕ} :
(HahnSeries.toPowerSeries.symm f).coeff n = PowerSeries.coeff n f :=
rfl
variable (Γ R) [Semiring Γ] [PartialOrder Γ] [IsStrictOrderedRing Γ] | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.Data.Finsupp.PWO"
] | Mathlib/RingTheory/HahnSeries/PowerSeries.lean | coeff_toPowerSeries_symm | null |
ofPowerSeries : PowerSeries R →+* HahnSeries Γ R :=
(HahnSeries.embDomainRingHom (Nat.castAddMonoidHom Γ) Nat.strictMono_cast.injective fun _ _ =>
Nat.cast_le).comp
(RingEquiv.toRingHom toPowerSeries.symm)
variable {Γ} {R} | def | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.Data.Finsupp.PWO"
] | Mathlib/RingTheory/HahnSeries/PowerSeries.lean | ofPowerSeries | Casts a power series as a Hahn series with coefficients from a `StrictOrderedSemiring`. |
ofPowerSeries_injective : Function.Injective (ofPowerSeries Γ R) :=
embDomain_injective.comp toPowerSeries.symm.injective | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.Data.Finsupp.PWO"
] | Mathlib/RingTheory/HahnSeries/PowerSeries.lean | ofPowerSeries_injective | null |
ofPowerSeries_apply (x : PowerSeries R) :
ofPowerSeries Γ R x =
HahnSeries.embDomain
⟨⟨((↑) : ℕ → Γ), Nat.strictMono_cast.injective⟩, by
simp only [Function.Embedding.coeFn_mk]
exact Nat.cast_le⟩
(toPowerSeries.symm x) :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.Data.Finsupp.PWO"
] | Mathlib/RingTheory/HahnSeries/PowerSeries.lean | ofPowerSeries_apply | null |
ofPowerSeries_apply_coeff (x : PowerSeries R) (n : ℕ) :
(ofPowerSeries Γ R x).coeff n = PowerSeries.coeff n x := by simp [ofPowerSeries_apply]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.Data.Finsupp.PWO"
] | Mathlib/RingTheory/HahnSeries/PowerSeries.lean | ofPowerSeries_apply_coeff | null |
ofPowerSeries_C (r : R) : ofPowerSeries Γ R (PowerSeries.C r) = HahnSeries.C r := by
ext n
simp only [ofPowerSeries_apply, C, RingHom.coe_mk, MonoidHom.coe_mk, OneHom.coe_mk,
coeff_single]
split_ifs with hn
· subst hn
convert embDomain_coeff (a := 0) <;> simp
· rw [embDomain_notin_image_support]
simp only [not_exists, Set.mem_image, toPowerSeries_symm_apply_coeff, mem_support,
PowerSeries.coeff_C]
intro
simp +contextual [Ne.symm hn]
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.Data.Finsupp.PWO"
] | Mathlib/RingTheory/HahnSeries/PowerSeries.lean | ofPowerSeries_C | null |
ofPowerSeries_X : ofPowerSeries Γ R PowerSeries.X = single 1 1 := by
ext n
simp only [coeff_single, ofPowerSeries_apply]
split_ifs with hn
· rw [hn]
convert embDomain_coeff (a := 1) <;> simp
· rw [embDomain_notin_image_support]
simp only [not_exists, Set.mem_image, toPowerSeries_symm_apply_coeff, mem_support,
PowerSeries.coeff_X]
intro
simp +contextual [Ne.symm hn] | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.Data.Finsupp.PWO"
] | Mathlib/RingTheory/HahnSeries/PowerSeries.lean | ofPowerSeries_X | null |
ofPowerSeries_X_pow {R} [Semiring R] (n : ℕ) :
ofPowerSeries Γ R (PowerSeries.X ^ n) = single (n : Γ) 1 := by
simp | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.Data.Finsupp.PWO"
] | Mathlib/RingTheory/HahnSeries/PowerSeries.lean | ofPowerSeries_X_pow | null |
@[simps]
toMvPowerSeries {σ : Type*} [Finite σ] : HahnSeries (σ →₀ ℕ) R ≃+* MvPowerSeries σ R where
toFun f := f.coeff
invFun f := ⟨(f : (σ →₀ ℕ) → R), Finsupp.isPWO _⟩
left_inv f := by
ext
simp
right_inv f := by
ext
simp
map_add' f g := by
ext
simp
map_mul' f g := by
ext n
classical
change (f * g).coeff n = _
simp_rw [coeff_mul]
refine (sum_filter_ne_zero _).symm.trans <| (sum_congr ?_ fun _ _ ↦ rfl).trans <|
sum_filter_ne_zero _
ext m
simp only [and_congr_left_iff, mem_addAntidiagonal, mem_filter, mem_support,
Finset.mem_antidiagonal]
rintro h
rw [and_iff_right (left_ne_zero_of_mul h), and_iff_right (right_ne_zero_of_mul h)]
variable {σ : Type*} [Finite σ] | def | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.Data.Finsupp.PWO"
] | Mathlib/RingTheory/HahnSeries/PowerSeries.lean | toMvPowerSeries | The ring `HahnSeries (σ →₀ ℕ) R` is isomorphic to `MvPowerSeries σ R` for a `Finite` `σ`.
We take the index set of the hahn series to be `Finsupp` rather than `pi`,
even though we assume `Finite σ` as this is more natural for alignment with `MvPowerSeries`.
After importing `Mathlib/Algebra/Order/Pi.lean` the ring `HahnSeries (σ → ℕ) R` could be constructed
instead. |
@[simps!]
toPowerSeriesAlg : HahnSeries ℕ A ≃ₐ[R] PowerSeries A :=
{ toPowerSeries with
commutes' := fun r => by
ext n
cases n <;> simp [algebraMap_apply, PowerSeries.algebraMap_apply] }
variable (Γ) [Semiring Γ] [PartialOrder Γ] [IsStrictOrderedRing Γ] | def | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.Data.Finsupp.PWO"
] | Mathlib/RingTheory/HahnSeries/PowerSeries.lean | toPowerSeriesAlg | If R has no zero divisors and `σ` is finite,
then `HahnSeries (σ →₀ ℕ) R` has no zero divisors -/
instance [NoZeroDivisors R] : NoZeroDivisors (HahnSeries (σ →₀ ℕ) R) :=
toMvPowerSeries.toMulEquiv.noZeroDivisors (A := HahnSeries (σ →₀ ℕ) R) (MvPowerSeries σ R)
theorem coeff_toMvPowerSeries {f : HahnSeries (σ →₀ ℕ) R} {n : σ →₀ ℕ} :
MvPowerSeries.coeff n (toMvPowerSeries f) = f.coeff n :=
rfl
theorem coeff_toMvPowerSeries_symm {f : MvPowerSeries σ R} {n : σ →₀ ℕ} :
(HahnSeries.toMvPowerSeries.symm f).coeff n = MvPowerSeries.coeff n f :=
rfl
end Semiring
section Algebra
variable (R) [CommSemiring R] {A : Type*} [Semiring A] [Algebra R A]
/-- The `R`-algebra `HahnSeries ℕ A` is isomorphic to `PowerSeries A`. |
@[simps!]
ofPowerSeriesAlg : PowerSeries A →ₐ[R] HahnSeries Γ A :=
(HahnSeries.embDomainAlgHom (Nat.castAddMonoidHom Γ) Nat.strictMono_cast.injective fun _ _ =>
Nat.cast_le).comp
(AlgEquiv.toAlgHom (toPowerSeriesAlg R).symm) | def | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.Data.Finsupp.PWO"
] | Mathlib/RingTheory/HahnSeries/PowerSeries.lean | ofPowerSeriesAlg | Casting a power series as a Hahn series with coefficients from a `StrictOrderedSemiring`
is an algebra homomorphism. |
powerSeriesAlgebra {S : Type*} [CommSemiring S] [Algebra S (PowerSeries R)] :
Algebra S (HahnSeries Γ R) :=
RingHom.toAlgebra <| (ofPowerSeries Γ R).comp (algebraMap S (PowerSeries R))
variable {R}
variable {S : Type*} [CommSemiring S] [Algebra S (PowerSeries R)] | instance | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.Data.Finsupp.PWO"
] | Mathlib/RingTheory/HahnSeries/PowerSeries.lean | powerSeriesAlgebra | null |
algebraMap_apply' (x : S) :
algebraMap S (HahnSeries Γ R) x = ofPowerSeries Γ R (algebraMap S (PowerSeries R) x) :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.Data.Finsupp.PWO"
] | Mathlib/RingTheory/HahnSeries/PowerSeries.lean | algebraMap_apply' | null |
_root_.Polynomial.algebraMap_hahnSeries_apply (f : R[X]) :
algebraMap R[X] (HahnSeries Γ R) f = ofPowerSeries Γ R f :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.Data.Finsupp.PWO"
] | Mathlib/RingTheory/HahnSeries/PowerSeries.lean | _root_.Polynomial.algebraMap_hahnSeries_apply | null |
_root_.Polynomial.algebraMap_hahnSeries_injective :
Function.Injective (algebraMap R[X] (HahnSeries Γ R)) :=
ofPowerSeries_injective.comp (Polynomial.coe_injective R) | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.RingTheory.PowerSeries.Basic",
"Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors",
"Mathlib.Data.Finsupp.PWO"
] | Mathlib/RingTheory/HahnSeries/PowerSeries.lean | _root_.Polynomial.algebraMap_hahnSeries_injective | null |
SummableFamily (Γ) (R) [PartialOrder Γ] [AddCommMonoid R] (α : Type*) where
/-- A parametrized family of Hahn series. -/
toFun : α → HahnSeries Γ R
isPWO_iUnion_support' : Set.IsPWO (⋃ a : α, (toFun a).support)
finite_co_support' : ∀ g : Γ, { a | (toFun a).coeff g ≠ 0 }.Finite | structure | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | SummableFamily | A family of Hahn series whose formal coefficient-wise sum is a Hahn series. For each
coefficient of the sum to be well-defined, we require that only finitely many series are nonzero at
any given coefficient. For the formal sum to be a Hahn series, we require that the union of the
supports of the constituent series is partially well-ordered. |
@[simp]
coe_mk (toFun : α → HahnSeries Γ R) (h1 h2) :
(⟨toFun, h1, h2⟩ : SummableFamily Γ R α) = toFun :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | coe_mk | null |
isPWO_iUnion_support (s : SummableFamily Γ R α) : Set.IsPWO (⋃ a : α, (s a).support) :=
s.isPWO_iUnion_support' | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | isPWO_iUnion_support | null |
finite_co_support (s : SummableFamily Γ R α) (g : Γ) :
(Function.support fun a => (s a).coeff g).Finite :=
s.finite_co_support' g | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | finite_co_support | null |
coe_injective : @Function.Injective (SummableFamily Γ R α) (α → HahnSeries Γ R) (⇑) :=
DFunLike.coe_injective
@[ext] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | coe_injective | null |
ext {s t : SummableFamily Γ R α} (h : ∀ a : α, s a = t a) : s = t :=
DFunLike.ext s t h | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | ext | null |
@[simp]
coe_add (s t : SummableFamily Γ R α) : ⇑(s + t) = s + t :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | coe_add | null |
add_apply {s t : SummableFamily Γ R α} {a : α} : (s + t) a = s a + t a :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | add_apply | null |
coe_zero : ((0 : SummableFamily Γ R α) : α → HahnSeries Γ R) = 0 :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | coe_zero | null |
zero_apply {a : α} : (0 : SummableFamily Γ R α) a = 0 :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | zero_apply | null |
@[simp]
coe_smul' (m : M) (s : SummableFamily Γ R α) : ⇑(m • s) = m • s :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | coe_smul' | null |
smul_apply' (m : M) (s : SummableFamily Γ R α) (a : α) : (m • s) a = m • s a :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | smul_apply' | null |
@[simps]
coeff (s : SummableFamily Γ R α) (g : Γ) : α →₀ R where
support := (s.finite_co_support g).toFinset
toFun a := (s a).coeff g
mem_support_toFun a := by simp
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | coeff | The coefficient function of a summable family, as a finsupp on the parameter type. |
coeff_def (s : SummableFamily Γ R α) (a : α) (g : Γ) : s.coeff g a = (s a).coeff g :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | coeff_def | null |
hsum (s : SummableFamily Γ R α) : HahnSeries Γ R where
coeff g := ∑ᶠ i, (s i).coeff g
isPWO_support' :=
s.isPWO_iUnion_support.mono fun g => by
contrapose
rw [Set.mem_iUnion, not_exists, Function.mem_support, Classical.not_not]
simp_rw [mem_support, Classical.not_not]
intro h
rw [finsum_congr h, finsum_zero]
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | hsum | The infinite sum of a `SummableFamily` of Hahn series. |
coeff_hsum {s : SummableFamily Γ R α} {g : Γ} : s.hsum.coeff g = ∑ᶠ i, (s i).coeff g :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | coeff_hsum | null |
hsum_zero : (0 : SummableFamily Γ R α).hsum = 0 := by
ext
simp | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | hsum_zero | null |
support_hsum_subset {s : SummableFamily Γ R α} : s.hsum.support ⊆ ⋃ a : α, (s a).support :=
fun g hg => by
rw [mem_support, coeff_hsum, finsum_eq_sum _ (s.finite_co_support _)] at hg
obtain ⟨a, _, h2⟩ := exists_ne_zero_of_sum_ne_zero hg
rw [Set.mem_iUnion]
exact ⟨a, h2⟩
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | support_hsum_subset | null |
hsum_add {s t : SummableFamily Γ R α} : (s + t).hsum = s.hsum + t.hsum := by
ext g
simp only [coeff_hsum, coeff_add, add_apply]
exact finsum_add_distrib (s.finite_co_support _) (t.finite_co_support _) | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | hsum_add | null |
coeff_hsum_eq_sum_of_subset {s : SummableFamily Γ R α} {g : Γ} {t : Finset α}
(h : { a | (s a).coeff g ≠ 0 } ⊆ t) : s.hsum.coeff g = ∑ i ∈ t, (s i).coeff g := by
simp only [coeff_hsum, finsum_eq_sum _ (s.finite_co_support _)]
exact sum_subset (Set.Finite.toFinset_subset.mpr h) (by simp) | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | coeff_hsum_eq_sum_of_subset | null |
coeff_hsum_eq_sum {s : SummableFamily Γ R α} {g : Γ} :
s.hsum.coeff g = ∑ i ∈ (s.coeff g).support, (s i).coeff g := by
simp only [coeff_hsum, finsum_eq_sum _ (s.finite_co_support _), coeff_support] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | coeff_hsum_eq_sum | null |
@[simps]
single {ι} [DecidableEq ι] (i : ι) (x : HahnSeries Γ R) : SummableFamily Γ R ι where
toFun := Pi.single i x
isPWO_iUnion_support' := by
have : (Pi.single (M := fun _ ↦ HahnSeries Γ R) i x i).support.IsPWO := by simp
refine this.mono <| Set.iUnion_subset fun a => ?_
obtain rfl | ha := eq_or_ne a i
· rfl
· simp [ha]
finite_co_support' g := (Set.finite_singleton i).subset fun j => by
obtain rfl | ha := eq_or_ne j i <;> simp [*]
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | single | The summable family made of a single Hahn series. |
hsum_single {ι} [DecidableEq ι] (i : ι) (x : HahnSeries Γ R) : (single i x).hsum = x := by
ext g
rw [coeff_hsum, finsum_eq_single _ i, single_toFun, Pi.single_eq_same]
simp +contextual | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | hsum_single | null |
@[simps]
const (ι) [Finite ι] (x : HahnSeries Γ R) : SummableFamily Γ R ι where
toFun _ := x
isPWO_iUnion_support' := by
cases isEmpty_or_nonempty ι
· simp
· exact Eq.mpr (congrArg (fun s ↦ s.IsPWO) (Set.iUnion_const x.support)) x.isPWO_support
finite_co_support' g := Set.toFinite {a | ((fun _ ↦ x) a).coeff g ≠ 0}
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | const | The summable family made of a constant Hahn series. |
hsum_unique {ι} [Unique ι] (x : SummableFamily Γ R ι) : x.hsum = x default := by
ext g
simp only [coeff_hsum, finsum_unique] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | hsum_unique | null |
@[simps]
Equiv (e : α ≃ β) (s : SummableFamily Γ R α) : SummableFamily Γ R β where
toFun b := s (e.symm b)
isPWO_iUnion_support' := by
refine Set.IsPWO.mono s.isPWO_iUnion_support fun g => ?_
simp only [Set.mem_iUnion, mem_support, ne_eq, forall_exists_index]
exact fun b hg => Exists.intro (e.symm b) hg
finite_co_support' g :=
(Equiv.set_finite_iff e.subtypeEquivOfSubtype').mp <| s.finite_co_support' g
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | Equiv | A summable family induced by an equivalence of the parametrizing type. |
hsum_equiv (e : α ≃ β) (s : SummableFamily Γ R α) : (Equiv e s).hsum = s.hsum := by
ext g
simp only [coeff_hsum, Equiv_toFun]
exact finsum_eq_of_bijective e.symm (Equiv.bijective e.symm) fun x => rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | hsum_equiv | null |
@[simps]
smulFamily [AddCommMonoid V] [SMulWithZero R V] (f : α → R) (s : SummableFamily Γ V α) :
SummableFamily Γ V α where
toFun a := (f a) • s a
isPWO_iUnion_support' := by
refine Set.IsPWO.mono s.isPWO_iUnion_support fun g hg => ?_
simp_all only [Set.mem_iUnion, mem_support, coeff_smul, ne_eq]
obtain ⟨i, hi⟩ := hg
exact Exists.intro i <| right_ne_zero_of_smul hi
finite_co_support' g := by
refine Set.Finite.subset (s.finite_co_support g) fun i hi => ?_
simp_all only [coeff_smul, ne_eq, Set.mem_setOf_eq, Function.mem_support]
exact right_ne_zero_of_smul hi | def | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | smulFamily | The summable family given by multiplying every series in a summable family by a scalar. |
hsum_smulFamily [AddCommMonoid V] [SMulWithZero R V] (f : α → R)
(s : SummableFamily Γ V α) (g : Γ) :
(smulFamily f s).hsum.coeff g = ∑ᶠ i, (f i) • ((s i).coeff g) :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | hsum_smulFamily | null |
@[simp]
coe_neg (s : SummableFamily Γ R α) : ⇑(-s) = -s :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | coe_neg | null |
neg_apply : (-s) a = -s a :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | neg_apply | null |
@[simp]
coe_sub (s t : SummableFamily Γ R α) : ⇑(s - t) = s - t :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | coe_sub | null |
sub_apply : (s - t) a = s a - t a :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | sub_apply | null |
smul_support_subset_prod (s : SummableFamily Γ R α)
(t : SummableFamily Γ' V β) (gh : Γ × Γ') :
(Function.support fun (i : α × β) ↦ (s i.1).coeff gh.1 • (t i.2).coeff gh.2) ⊆
((s.finite_co_support' gh.1).prod (t.finite_co_support' gh.2)).toFinset := by
intro _ hab
simp_all only [Function.mem_support, ne_eq, Set.Finite.coe_toFinset, Set.mem_prod,
Set.mem_setOf_eq]
exact ⟨left_ne_zero_of_smul hab, right_ne_zero_of_smul hab⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | smul_support_subset_prod | null |
smul_support_finite (s : SummableFamily Γ R α)
(t : SummableFamily Γ' V β) (gh : Γ × Γ') :
(Function.support fun (i : α × β) ↦ (s i.1).coeff gh.1 • (t i.2).coeff gh.2).Finite :=
Set.Finite.subset (Set.toFinite ((s.finite_co_support' gh.1).prod
(t.finite_co_support' gh.2)).toFinset) (smul_support_subset_prod s t gh)
variable [VAdd Γ Γ'] [IsOrderedCancelVAdd Γ Γ']
open HahnModule | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | smul_support_finite | null |
isPWO_iUnion_support_prod_smul {s : α → HahnSeries Γ R} {t : β → HahnSeries Γ' V}
(hs : (⋃ a, (s a).support).IsPWO) (ht : (⋃ b, (t b).support).IsPWO) :
(⋃ (a : α × β), ((fun a ↦ (of R).symm
((s a.1) • (of R) (t a.2))) a).support).IsPWO := by
apply (hs.vadd ht).mono
have hsupp : ∀ ab : α × β, support ((fun ab ↦ (of R).symm (s ab.1 • (of R) (t ab.2))) ab) ⊆
(s ab.1).support +ᵥ (t ab.2).support := by
intro ab
refine Set.Subset.trans (fun x hx => ?_) (support_vaddAntidiagonal_subset_vadd
(hs := (s ab.1).isPWO_support) (ht := (t ab.2).isPWO_support))
contrapose! hx
simp only [Set.mem_setOf_eq, not_nonempty_iff_eq_empty] at hx
rw [mem_support, not_not, HahnModule.coeff_smul, hx, sum_empty]
refine Set.Subset.trans (Set.iUnion_mono fun a => (hsupp a)) ?_
simp_all only [Set.iUnion_subset_iff, Prod.forall]
exact fun a b => Set.vadd_subset_vadd (Set.subset_iUnion_of_subset a fun x y ↦ y)
(Set.subset_iUnion_of_subset b fun x y ↦ y) | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | isPWO_iUnion_support_prod_smul | null |
finite_co_support_prod_smul (s : SummableFamily Γ R α)
(t : SummableFamily Γ' V β) (g : Γ') :
Finite {(ab : α × β) |
((fun (ab : α × β) ↦ (of R).symm (s ab.1 • (of R) (t ab.2))) ab).coeff g ≠ 0} := by
apply ((VAddAntidiagonal s.isPWO_iUnion_support t.isPWO_iUnion_support g).finite_toSet.biUnion'
(fun gh _ => smul_support_finite s t gh)).subset _
exact fun ab hab => by
simp only [ne_eq, Set.mem_setOf_eq] at hab
obtain ⟨ij, hij⟩ := Finset.exists_ne_zero_of_sum_ne_zero hab
simp only [mem_coe, mem_vaddAntidiagonal, Set.mem_iUnion, mem_support, ne_eq,
Function.mem_support, exists_prop, Prod.exists]
exact ⟨ij.1, ij.2, ⟨⟨ab.1, left_ne_zero_of_smul hij.2⟩, ⟨ab.2, right_ne_zero_of_smul hij.2⟩,
((mem_vaddAntidiagonal _ _ _).mp hij.1).2.2⟩, hij.2⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | finite_co_support_prod_smul | null |
@[simps]
smul (s : SummableFamily Γ R α) (t : SummableFamily Γ' V β) : SummableFamily Γ' V (α × β) where
toFun ab := (of R).symm (s (ab.1) • ((of R) (t (ab.2))))
isPWO_iUnion_support' :=
isPWO_iUnion_support_prod_smul s.isPWO_iUnion_support t.isPWO_iUnion_support
finite_co_support' g := finite_co_support_prod_smul s t g | def | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | smul | An elementwise scalar multiplication of one summable family on another. |
sum_vAddAntidiagonal_eq (s : SummableFamily Γ R α) (t : SummableFamily Γ' V β) (g : Γ')
(a : α × β) :
∑ x ∈ VAddAntidiagonal (s a.1).isPWO_support' (t a.2).isPWO_support' g, (s a.1).coeff x.1 •
(t a.2).coeff x.2 = ∑ x ∈ VAddAntidiagonal s.isPWO_iUnion_support' t.isPWO_iUnion_support' g,
(s a.1).coeff x.1 • (t a.2).coeff x.2 := by
refine sum_subset (fun gh hgh => ?_) fun gh hgh h => ?_
· simp_all only [mem_vaddAntidiagonal, Function.mem_support, Set.mem_iUnion, mem_support]
exact ⟨Exists.intro a.1 hgh.1, Exists.intro a.2 hgh.2.1, trivial⟩
· by_cases hs : (s a.1).coeff gh.1 = 0
· exact smul_eq_zero_of_left hs ((t a.2).coeff gh.2)
· simp_all | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | sum_vAddAntidiagonal_eq | null |
coeff_smul {R} {V} [Semiring R] [AddCommMonoid V] [Module R V]
(s : SummableFamily Γ R α) (t : SummableFamily Γ' V β) (g : Γ') :
(smul s t).hsum.coeff g = ∑ gh ∈ VAddAntidiagonal s.isPWO_iUnion_support
t.isPWO_iUnion_support g, (s.hsum.coeff gh.1) • (t.hsum.coeff gh.2) := by
rw [coeff_hsum]
simp only [coeff_hsum_eq_sum, smul_toFun, HahnModule.coeff_smul, Equiv.symm_apply_apply]
simp_rw [sum_vAddAntidiagonal_eq, Finset.smul_sum, Finset.sum_smul]
rw [← sum_finsum_comm _ _ <| fun gh _ => smul_support_finite s t gh]
refine sum_congr rfl fun gh _ => ?_
rw [finsum_eq_sum _ (smul_support_finite s t gh), ← sum_product_right']
refine sum_subset (fun ab hab => ?_) (fun ab _ hab => by simp_all)
have hsupp := smul_support_subset_prod s t gh
simp_all only [mem_vaddAntidiagonal, Set.mem_iUnion, mem_support, ne_eq, Set.Finite.mem_toFinset,
Function.mem_support, Set.Finite.coe_toFinset, support_subset_iff, Set.mem_prod,
Set.mem_setOf_eq, Prod.forall, coeff_support, mem_product]
exact hsupp ab.1 ab.2 hab | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | coeff_smul | null |
smul_hsum {R} {V} [Semiring R] [AddCommMonoid V] [Module R V]
(s : SummableFamily Γ R α) (t : SummableFamily Γ' V β) :
(smul s t).hsum = (of R).symm (s.hsum • (of R) (t.hsum)) := by
ext g
rw [coeff_smul s t g, HahnModule.coeff_smul, Equiv.symm_apply_apply]
refine Eq.symm (sum_of_injOn (fun a ↦ a) (fun _ _ _ _ h ↦ h) (fun _ hgh => ?_)
(fun gh _ hgh => ?_) fun _ _ => by simp)
· simp_all only [mem_coe, mem_vaddAntidiagonal, mem_support, ne_eq, Set.mem_iUnion, and_true]
constructor
· rw [coeff_hsum_eq_sum] at hgh
have h' := Finset.exists_ne_zero_of_sum_ne_zero hgh.1
simpa using h'
· by_contra hi
simp_all
· simp only [Set.image_id', mem_coe, mem_vaddAntidiagonal, mem_support, ne_eq, not_and] at hgh
by_cases h : s.hsum.coeff gh.1 = 0
· exact smul_eq_zero_of_left h (t.hsum.coeff gh.2)
· simp_all | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | smul_hsum | null |
smul_eq {x : HahnSeries Γ R} {t : SummableFamily Γ' V β} :
x • t = Equiv (Equiv.punitProd β) (smul (const Unit x) t) :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | smul_eq | null |
smul_apply {x : HahnSeries Γ R} {s : SummableFamily Γ' V α} {a : α} :
(x • s) a = (of R).symm (x • of R (s a)) :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | smul_apply | null |
hsum_smul_module {R} {V} [Semiring R] [AddCommMonoid V] [Module R V] {x : HahnSeries Γ R}
{s : SummableFamily Γ' V α} :
(x • s).hsum = (of R).symm (x • of R s.hsum) := by
rw [smul_eq, hsum_equiv, smul_hsum, hsum_unique, const_toFun] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | hsum_smul_module | null |
hsum_smul {x : HahnSeries Γ R} {s : SummableFamily Γ R α} :
(x • s).hsum = x * s.hsum := by
rw [hsum_smul_module, of_symm_smul_of_eq_mul] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | hsum_smul | null |
@[simps]
lsum : SummableFamily Γ R α →ₗ[HahnSeries Γ R] HahnSeries Γ R where
toFun := hsum
map_add' _ _ := hsum_add
map_smul' _ _ := hsum_smul
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | lsum | The summation of a `summable_family` as a `LinearMap`. |
hsum_sub {R : Type*} [Ring R] {s t : SummableFamily Γ R α} :
(s - t).hsum = s.hsum - t.hsum := by
rw [← lsum_apply, LinearMap.map_sub, lsum_apply, lsum_apply] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | hsum_sub | null |
isPWO_iUnion_support_prod_mul {s : α → HahnSeries Γ R} {t : β → HahnSeries Γ R}
(hs : (⋃ a, (s a).support).IsPWO) (ht : (⋃ b, (t b).support).IsPWO) :
(⋃ (a : α × β), ((fun a ↦ ((s a.1) * (t a.2))) a).support).IsPWO :=
isPWO_iUnion_support_prod_smul hs ht | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | isPWO_iUnion_support_prod_mul | null |
finite_co_support_prod_mul (s : SummableFamily Γ R α)
(t : SummableFamily Γ R β) (g : Γ) :
Finite {(a : α × β) | ((fun (a : α × β) ↦ (s a.1 * t a.2)) a).coeff g ≠ 0} :=
finite_co_support_prod_smul s t g | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | finite_co_support_prod_mul | null |
@[simps]
mul (s : SummableFamily Γ R α) (t : SummableFamily Γ R β) :
(SummableFamily Γ R (α × β)) where
toFun a := s (a.1) * t (a.2)
isPWO_iUnion_support' :=
isPWO_iUnion_support_prod_mul s.isPWO_iUnion_support t.isPWO_iUnion_support
finite_co_support' g := finite_co_support_prod_mul s t g | def | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | mul | A summable family given by pointwise multiplication of a pair of summable families. |
mul_eq_smul (s : SummableFamily Γ R α) (t : SummableFamily Γ R β) :
mul s t = smul s t :=
rfl | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | mul_eq_smul | null |
coeff_hsum_mul (s : SummableFamily Γ R α) (t : SummableFamily Γ R β) (g : Γ) :
(mul s t).hsum.coeff g = ∑ gh ∈ addAntidiagonal s.isPWO_iUnion_support
t.isPWO_iUnion_support g, (s.hsum.coeff gh.1) * (t.hsum.coeff gh.2) := by
simp_rw [← smul_eq_mul, mul_eq_smul]
exact coeff_smul s t g | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | coeff_hsum_mul | null |
hsum_mul (s : SummableFamily Γ R α) (t : SummableFamily Γ R β) :
(mul s t).hsum = s.hsum * t.hsum := by
rw [← smul_eq_mul, mul_eq_smul]
exact smul_hsum s t | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | hsum_mul | null |
ofFinsupp (f : α →₀ HahnSeries Γ R) : SummableFamily Γ R α where
toFun := f
isPWO_iUnion_support' := by
apply (f.support.isPWO_bUnion.2 fun a _ => (f a).isPWO_support).mono
refine Set.iUnion_subset_iff.2 fun a g hg => ?_
have haf : a ∈ f.support := by
rw [Finsupp.mem_support_iff, ← support_nonempty_iff]
exact ⟨g, hg⟩
exact Set.mem_biUnion haf hg
finite_co_support' g := by
refine f.support.finite_toSet.subset fun a ha => ?_
simp only [mem_coe, Finsupp.mem_support_iff, Ne]
contrapose! ha
simp [ha]
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | ofFinsupp | A family with only finitely many nonzero elements is summable. |
coe_ofFinsupp {f : α →₀ HahnSeries Γ R} : ⇑(SummableFamily.ofFinsupp f) = f :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | coe_ofFinsupp | null |
hsum_ofFinsupp {f : α →₀ HahnSeries Γ R} : (ofFinsupp f).hsum = f.sum fun _ => id := by
ext g
simp only [coeff_hsum, coe_ofFinsupp, Finsupp.sum]
simp_rw [← coeff.addMonoidHom_apply, id]
rw [map_sum, finsum_eq_sum_of_support_subset]
intro x h
simp only [mem_coe, Finsupp.mem_support_iff, Ne]
contrapose! h
simp [h] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | hsum_ofFinsupp | null |
embDomain (s : SummableFamily Γ R α) (f : α ↪ β) : SummableFamily Γ R β where
toFun b := if h : b ∈ Set.range f then s (Classical.choose h) else 0
isPWO_iUnion_support' := by
refine s.isPWO_iUnion_support.mono (Set.iUnion_subset fun b g h => ?_)
by_cases hb : b ∈ Set.range f
· rw [dif_pos hb] at h
exact Set.mem_iUnion.2 ⟨Classical.choose hb, h⟩
· simp [-Set.mem_range, dif_neg hb] at h
finite_co_support' g :=
((s.finite_co_support g).image f).subset
(by
intro b h
by_cases hb : b ∈ Set.range f
· simp only [Ne, Set.mem_setOf_eq, dif_pos hb] at h
exact ⟨Classical.choose hb, h, Classical.choose_spec hb⟩
· simp only [Ne, Set.mem_setOf_eq, dif_neg hb, coeff_zero, not_true_eq_false] at h)
variable (s : SummableFamily Γ R α) (f : α ↪ β) {a : α} {b : β}
open Classical in | def | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | embDomain | A summable family can be reindexed by an embedding without changing its sum. |
embDomain_apply :
s.embDomain f b = if h : b ∈ Set.range f then s (Classical.choose h) else 0 :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | embDomain_apply | null |
embDomain_image : s.embDomain f (f a) = s a := by
rw [embDomain_apply, dif_pos (Set.mem_range_self a)]
exact congr rfl (f.injective (Classical.choose_spec (Set.mem_range_self a)))
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | embDomain_image | null |
embDomain_notin_range (h : b ∉ Set.range f) : s.embDomain f b = 0 := by
rw [embDomain_apply, dif_neg h]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | embDomain_notin_range | null |
hsum_embDomain : (s.embDomain f).hsum = s.hsum := by
classical
ext g
simp only [coeff_hsum, embDomain_apply, apply_dite HahnSeries.coeff, dite_apply, coeff_zero]
exact finsum_emb_domain f fun a => (s a).coeff g | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | hsum_embDomain | null |
support_pow_subset_closure [AddCommMonoid Γ] [PartialOrder Γ] [IsOrderedCancelAddMonoid Γ]
[Semiring R] (x : HahnSeries Γ R)
(n : ℕ) : support (x ^ n) ⊆ AddSubmonoid.closure (support x) := by
intro g hn
induction n generalizing g with
| zero =>
simp only [pow_zero, mem_support, coeff_one, ne_eq, ite_eq_right_iff, Classical.not_imp] at hn
simp only [hn, SetLike.mem_coe]
exact AddSubmonoid.zero_mem _
| succ n ih =>
obtain ⟨i, hi, j, hj, rfl⟩ := support_mul_subset_add_support hn
exact SetLike.mem_coe.2 (AddSubmonoid.add_mem _ (ih hi) (AddSubmonoid.subset_closure hj)) | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | support_pow_subset_closure | null |
isPWO_iUnion_support_powers [AddCommMonoid Γ] [LinearOrder Γ] [IsOrderedCancelAddMonoid Γ]
[Semiring R]
{x : HahnSeries Γ R} (hx : 0 ≤ x.order) :
(⋃ n : ℕ, (x ^ n).support).IsPWO :=
(x.isPWO_support'.addSubmonoid_closure
fun _ hg => le_trans hx (order_le_of_coeff_ne_zero (Function.mem_support.mp hg))).mono
(Set.iUnion_subset fun n => support_pow_subset_closure x n) | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | isPWO_iUnion_support_powers | null |
co_support_zero [AddCommMonoid Γ] [PartialOrder Γ] [IsOrderedCancelAddMonoid Γ]
[Semiring R] (g : Γ) :
{a | ¬((0 : HahnSeries Γ R) ^ a).coeff g = 0} ⊆ {0} := by
simp only [Set.subset_singleton_iff, Set.mem_setOf_eq]
intro n hn
by_contra h'
simp_all only [ne_eq, not_false_eq_true, zero_pow, coeff_zero, not_true_eq_false]
variable [AddCommMonoid Γ] [LinearOrder Γ] [IsOrderedCancelAddMonoid Γ] [CommRing R] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | co_support_zero | null |
pow_finite_co_support {x : HahnSeries Γ R} (hx : 0 < x.orderTop) (g : Γ) :
Set.Finite {a | ((fun n ↦ x ^ n) a).coeff g ≠ 0} := by
have hpwo : Set.IsPWO (⋃ n, support (x ^ n)) :=
isPWO_iUnion_support_powers (zero_le_orderTop_iff.mp <| le_of_lt hx)
by_cases h0 : x = 0; · exact h0 ▸ Set.Finite.subset (Set.finite_singleton 0) (co_support_zero g)
by_cases hg : g ∈ ⋃ n : ℕ, { g | (x ^ n).coeff g ≠ 0 }
swap; · exact Set.finite_empty.subset fun n hn => hg (Set.mem_iUnion.2 ⟨n, hn⟩)
apply hpwo.isWF.induction hg
intro y ys hy
refine ((((addAntidiagonal x.isPWO_support hpwo y).finite_toSet.biUnion
fun ij hij => hy ij.snd (mem_addAntidiagonal.1 (mem_coe.1 hij)).2.1 ?_).image Nat.succ).union
(Set.finite_singleton 0)).subset ?_
· obtain ⟨hi, _, rfl⟩ := mem_addAntidiagonal.1 (mem_coe.1 hij)
exact lt_add_of_pos_left ij.2 <| lt_of_lt_of_le ((zero_lt_orderTop_iff h0).mp hx) <|
order_le_of_coeff_ne_zero <| Function.mem_support.mp hi
· rintro (_ | n) hn
· exact Set.mem_union_right _ (Set.mem_singleton 0)
· obtain ⟨i, hi, j, hj, rfl⟩ := support_mul_subset_add_support hn
refine Set.mem_union_left _ ⟨n, Set.mem_iUnion.2 ⟨⟨j, i⟩, Set.mem_iUnion.2 ⟨?_, hi⟩⟩, rfl⟩
simp only [mem_coe, mem_addAntidiagonal, mem_support, ne_eq, Set.mem_iUnion]
exact ⟨hj, ⟨n, hi⟩, add_comm j i⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | pow_finite_co_support | null |
@[simps]
powers (x : HahnSeries Γ R) : SummableFamily Γ R ℕ where
toFun n := (if 0 < x.orderTop then x else 0) ^ n
isPWO_iUnion_support' := by
by_cases h : 0 < x.orderTop
· simp only [h, ↓reduceIte]
exact isPWO_iUnion_support_powers (zero_le_orderTop_iff.mp <| le_of_lt h)
· simp only [h, ↓reduceIte]
apply isPWO_iUnion_support_powers
rw [order_zero]
finite_co_support' g := by
by_cases h : 0 < x.orderTop
· simp only [h, ↓reduceIte]
exact pow_finite_co_support h g
· simp only [h, ↓reduceIte]
exact pow_finite_co_support (orderTop_zero (R := R) (Γ := Γ) ▸ WithTop.top_pos) g | def | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | powers | A summable family of powers of a Hahn series `x`. If `x` has non-positive `orderTop`, then
return a junk value given by pretending `x = 0`. |
powers_of_orderTop_pos {x : HahnSeries Γ R} (hx : 0 < x.orderTop) (n : ℕ) :
powers x n = x ^ n := by
simp [hx] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | powers_of_orderTop_pos | null |
powers_of_not_orderTop_pos {x : HahnSeries Γ R} (hx : ¬ 0 < x.orderTop) :
powers x = .single 0 1 := by
ext a
obtain rfl | ha := eq_or_ne a 0 <;> simp [powers, *]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Ring.Action.Rat",
"Mathlib.RingTheory.HahnSeries.Multiplication",
"Mathlib.Data.Rat.Cast.Lemmas"
] | Mathlib/RingTheory/HahnSeries/Summable.lean | powers_of_not_orderTop_pos | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.