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 ⌀ |
|---|---|---|---|---|---|---|
powerSeriesFamily_of_not_orderTop_pos {x : HahnSeries Γ V} (hx : ¬ 0 < x.orderTop)
(f : PowerSeries R) :
powerSeriesFamily x f = powerSeriesFamily 0 f := by
ext n g
obtain rfl | hn := eq_or_ne n 0 <;> simp [*] | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Summable",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/HahnSeries/HEval.lean | powerSeriesFamily_of_not_orderTop_pos | null |
powerSeriesFamily_of_orderTop_pos {x : HahnSeries Γ V} (hx : 0 < x.orderTop)
(f : PowerSeries R) (n : ℕ) :
powerSeriesFamily x f n = f.coeff n • x ^ n := by
simp [hx] | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Summable",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/HahnSeries/HEval.lean | powerSeriesFamily_of_orderTop_pos | null |
powerSeriesFamily_hsum_zero (f : PowerSeries R) :
(powerSeriesFamily 0 f).hsum = f.constantCoeff • (1 : HahnSeries Γ V) := by
ext g
by_cases hg : g = 0
· simp only [hg, coeff_hsum]
rw [finsum_eq_single _ 0 (fun n hn ↦ by simp [hn])]
simp
· rw [coeff_hsum, finsum_eq_zero_of_forall_eq_zero
fun n ↦ (by by_cases hn : n = 0 <;> simp [hg, hn])]
simp [hg] | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Summable",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/HahnSeries/HEval.lean | powerSeriesFamily_hsum_zero | null |
powerSeriesFamily_add {x : HahnSeries Γ V} (f g : PowerSeries R) :
powerSeriesFamily x (f + g) = powerSeriesFamily x f + powerSeriesFamily x g := by
ext1 n
by_cases hx: 0 < x.orderTop <;> · simp [hx, add_smul] | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Summable",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/HahnSeries/HEval.lean | powerSeriesFamily_add | null |
powerSeriesFamily_smul {x : HahnSeries Γ V} (f : PowerSeries R) (r : R) :
powerSeriesFamily x (r • f) = HahnSeries.single (0 : Γ) r • powerSeriesFamily x f := by
ext1 n
simp [mul_smul] | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Summable",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/HahnSeries/HEval.lean | powerSeriesFamily_smul | null |
support_powerSeriesFamily_subset {x : HahnSeries Γ V} (a b : PowerSeries R) (g : Γ) :
((powerSeriesFamily x (a * b)).coeff g).support ⊆
(((powerSeriesFamily x a).mul (powerSeriesFamily x b)).coeff g).support.image
fun i => i.1 + i.2 := by
by_cases h : 0 < x.orderTop
· simp only [coeff_support, Set.Finite.toFinset_subset, support_subset_iff]
intro n hn
have he : ∃ c ∈ antidiagonal n, (PowerSeries.coeff c.1) a • (PowerSeries.coeff c.2) b •
((powers x) n).coeff g ≠ 0 := by
refine exists_ne_zero_of_sum_ne_zero ?_
simpa [PowerSeries.coeff_mul, sum_smul, mul_smul, h] using hn
simp only [powers_of_orderTop_pos h, mem_antidiagonal] at he
obtain ⟨c, hcn, hc⟩ := he
simp only [coe_image, Set.Finite.coe_toFinset, Set.mem_image]
use c
simp only [mul_toFun, smulFamily_toFun, Function.mem_support, hcn,
and_true]
rw [powers_of_orderTop_pos h c.1, powers_of_orderTop_pos h c.2, Algebra.smul_mul_assoc,
Algebra.mul_smul_comm, ← pow_add, hcn]
simp [hc]
· simp only [coeff_support, Set.Finite.toFinset_subset, support_subset_iff]
intro n hn
by_cases hz : n = 0
· have : g = 0 ∧ (a.constantCoeff * b.constantCoeff) • (1 : V) ≠ 0 := by
simpa [hz, h] using hn
simp only [coe_image, Set.mem_image]
use (0, 0)
simp [this.2, this.1, h, hz, smul_smul, mul_comm]
· simp [h, hz] at hn | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Summable",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/HahnSeries/HEval.lean | support_powerSeriesFamily_subset | null |
hsum_powerSeriesFamily_mul {x : HahnSeries Γ V} (a b : PowerSeries R) :
(powerSeriesFamily x (a * b)).hsum =
((powerSeriesFamily x a).mul (powerSeriesFamily x b)).hsum := by
by_cases h : 0 < x.orderTop;
· ext g
simp only [coeff_hsum_eq_sum, smulFamily_toFun, h, powers_of_orderTop_pos,
HahnSeries.coeff_smul, mul_toFun, Algebra.mul_smul_comm, Algebra.smul_mul_assoc]
rw [sum_subset (support_powerSeriesFamily_subset a b g)
(fun i hi his ↦ by simpa [h, PowerSeries.coeff_mul, sum_smul] using his)]
simp only [coeff_support, mul_toFun, smulFamily_toFun, Algebra.mul_smul_comm,
Algebra.smul_mul_assoc, HahnSeries.coeff_smul, PowerSeries.coeff_mul, sum_smul]
rw [sum_sigma']
refine (Finset.sum_of_injOn (fun x => ⟨x.1 + x.2, x⟩) (fun _ _ _ _ => by simp) ?_ ?_
(fun _ _ => by simp [smul_smul, mul_comm, pow_add])).symm
· intro ij hij
simp only [coe_sigma, coe_image, Set.mem_sigma_iff, Set.mem_image, Prod.exists, mem_coe,
mem_antidiagonal, and_true]
use ij.1, ij.2
simp_all
· intro i hi his
have hisc : ∀ j k : ℕ, ⟨j + k, (j, k)⟩ = i → (PowerSeries.coeff k) b •
(PowerSeries.coeff j a • (x ^ j * x ^ k).coeff g) = 0 := by
intro m n
contrapose!
simp only [powers_of_orderTop_pos h, Set.Finite.coe_toFinset, Set.mem_image,
Function.mem_support, ne_eq, Prod.exists, not_exists, not_and] at his
exact his m n
simp only [mem_sigma, mem_antidiagonal] at hi
rw [mul_comm ((PowerSeries.coeff i.snd.1) a), ← hi.2, mul_smul, pow_add]
exact hisc i.snd.1 i.snd.2 <| Sigma.eq hi.2 (by simp)
· simp only [h, not_false_eq_true, powerSeriesFamily_of_not_orderTop_pos,
powerSeriesFamily_hsum_zero, map_mul, hsum_mul]
rw [smul_mul_smul_comm, mul_one] | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Summable",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/HahnSeries/HEval.lean | hsum_powerSeriesFamily_mul | null |
@[simps]
heval : PowerSeries R →ₐ[R] HahnSeries Γ R where
toFun f := (powerSeriesFamily x f).hsum
map_one' := by
simp only [hsum, smulFamily_toFun, coeff_one, powers_toFun, ite_smul, one_smul, zero_smul]
ext g
simp only
rw [finsum_eq_single _ (0 : ℕ) (fun n hn => by simp [hn])]
simp
map_mul' a b := by
simp only [← hsum_mul, hsum_powerSeriesFamily_mul]
map_zero' := by
simp only [hsum, smulFamily_toFun, map_zero, zero_smul,
coeff_zero, finsum_zero, mk_eq_zero, Pi.zero_def]
map_add' a b := by
simp only [powerSeriesFamily_add, hsum_add]
commutes' r := by
simp only [algebraMap_eq]
ext g
simp only [coeff_hsum, smulFamily_toFun, coeff_C, powers_toFun, ite_smul, zero_smul]
rw [finsum_eq_single _ 0 fun n hn => by simp [hn]]
by_cases hg : g = 0 <;> simp [hg, Algebra.algebraMap_eq_smul_one] | def | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Summable",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/HahnSeries/HEval.lean | heval | The `R`-algebra homomorphism from `R[[X]]` to `HahnSeries Γ R` given by sending the power series
variable `X` to a positive order element `x` and extending to infinite sums. |
heval_mul {a b : PowerSeries R} :
heval x (a * b) = heval x a * heval x b :=
map_mul (heval x) a b | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Summable",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/HahnSeries/HEval.lean | heval_mul | null |
heval_C (r : R) : heval x (C r) = r • 1 := by
ext g
simp only [heval_apply, coeff_hsum, smulFamily_toFun, powers_toFun, HahnSeries.coeff_smul,
HahnSeries.coeff_one, smul_eq_mul, mul_ite, mul_one, mul_zero]
rw [finsum_eq_single _ 0 (fun n hn ↦ by simp [coeff_ne_zero_C hn])]
by_cases hg : g = 0 <;> simp | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Summable",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/HahnSeries/HEval.lean | heval_C | null |
heval_X (hx : 0 < x.orderTop) : heval x X = x := by
rw [X_eq, monomial_eq_mk, heval_apply, powerSeriesFamily, smulFamily]
simp only [coeff_mk, powers_toFun, hx, ↓reduceIte, ite_smul, one_smul, zero_smul]
ext g
rw [coeff_hsum, finsum_eq_single _ 1 (fun n hn ↦ by simp [hn])]
simp | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Summable",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/HahnSeries/HEval.lean | heval_X | null |
heval_unit (u : (PowerSeries R)ˣ) : IsUnit (heval x u) := by
refine isUnit_iff_exists_inv.mpr ?_
use heval x u.inv
rw [← heval_mul, Units.val_inv, map_one] | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Summable",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/HahnSeries/HEval.lean | heval_unit | null |
coeff_heval (f : PowerSeries R) (g : Γ) :
(heval x f).coeff g = ∑ᶠ n, ((powerSeriesFamily x f).coeff g) n := by
rw [heval_apply, coeff_hsum]
exact rfl | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Summable",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/HahnSeries/HEval.lean | coeff_heval | null |
coeff_heval_zero (f : PowerSeries R) :
(heval x f).coeff 0 = PowerSeries.constantCoeff f := by
rw [coeff_heval, finsum_eq_single (fun n => ((powerSeriesFamily x f).coeff 0) n) 0,
← PowerSeries.coeff_zero_eq_constantCoeff_apply]
· simp
· intro n hn
simp only [coeff_toFun, smulFamily_toFun, HahnSeries.coeff_smul, smul_eq_mul]
refine mul_eq_zero_of_right (coeff n f) (coeff_eq_zero_of_lt_orderTop ?_)
by_cases h : 0 < x.orderTop
· refine (lt_of_lt_of_le ((nsmul_pos_iff hn).mpr h) ?_)
simp [h, orderTop_nsmul_le_orderTop_pow]
· simp [h, hn] | theorem | RingTheory | [
"Mathlib.RingTheory.HahnSeries.Summable",
"Mathlib.RingTheory.PowerSeries.Basic"
] | Mathlib/RingTheory/HahnSeries/HEval.lean | coeff_heval_zero | null |
lt_iff (a b : Lex (HahnSeries Γ R)) :
a < b ↔ ∃ (i : Γ), (∀ (j : Γ), j < i → (ofLex a).coeff j = (ofLex b).coeff j)
∧ (ofLex a).coeff i < (ofLex b).coeff i := by rfl | theorem | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | lt_iff | null |
@[simp]
leadingCoeff_pos_iff {x : Lex (HahnSeries Γ R)} : 0 < (ofLex x).leadingCoeff ↔ 0 < x := by
rw [lt_iff]
constructor
· intro hpos
have hne : (ofLex x) ≠ 0 := leadingCoeff_ne_zero.mp hpos.ne.symm
have htop : (ofLex x).orderTop ≠ ⊤ := orderTop_ne_top.2 hne
refine ⟨(ofLex x).orderTop.untop htop, ?_, by simpa [coeff_untop_eq_leadingCoeff] using hpos⟩
intro j hj
simpa using (coeff_eq_zero_of_lt_orderTop ((WithTop.lt_untop_iff htop).mp hj)).symm
· intro ⟨i, hj, hi⟩
have horder : (ofLex x).orderTop = WithTop.some i := by
apply orderTop_eq_of_le
· simpa using hi.ne.symm
· intro g hg
contrapose! hg
simpa using (hj g hg).symm
have htop : (ofLex x).orderTop ≠ ⊤ := WithTop.ne_top_iff_exists.mpr ⟨i, horder.symm⟩
have hne : ofLex x ≠ 0 := orderTop_ne_top.1 htop
have horder' : (ofLex x).orderTop.untop htop = i := (WithTop.untop_eq_iff _).mpr horder
rw [leadingCoeff_of_ne_zero hne, horder']
simpa using hi | theorem | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | leadingCoeff_pos_iff | null |
leadingCoeff_nonneg_iff {x : Lex (HahnSeries Γ R)} :
0 ≤ (ofLex x).leadingCoeff ↔ 0 ≤ x := by
constructor
· intro h
obtain heq | hlt := h.eq_or_lt
· exact le_of_eq (leadingCoeff_eq_zero.mp heq.symm).symm
· exact (leadingCoeff_pos_iff.mp hlt).le
· intro h
obtain rfl | hlt := h.eq_or_lt
· simp
· exact (leadingCoeff_pos_iff.mpr hlt).le | theorem | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | leadingCoeff_nonneg_iff | null |
leadingCoeff_neg_iff {x : Lex (HahnSeries Γ R)} : (ofLex x).leadingCoeff < 0 ↔ x < 0 := by
simpa using (leadingCoeff_nonneg_iff (x := x)).not | theorem | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | leadingCoeff_neg_iff | null |
leadingCoeff_nonpos_iff {x : Lex (HahnSeries Γ R)} :
(ofLex x).leadingCoeff ≤ 0 ↔ x ≤ 0 := by
simp [← not_lt] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | leadingCoeff_nonpos_iff | null |
@[simp]
support_abs (x : Lex (HahnSeries Γ R)) : (ofLex |x|).support = (ofLex x).support := by
obtain hle | hge := le_total x 0
· rw [abs_eq_neg_self.mpr hle]
simp
· rw [abs_eq_self.mpr hge]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | support_abs | null |
orderTop_abs (x : Lex (HahnSeries Γ R)) : (ofLex |x|).orderTop = (ofLex x).orderTop := by
obtain hle | hge := le_total x 0
· rw [abs_eq_neg_self.mpr hle, ofLex_neg, orderTop_neg]
· rw [abs_eq_self.mpr hge] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | orderTop_abs | null |
order_abs [Zero Γ] (x : Lex (HahnSeries Γ R)) : (ofLex |x|).order = (ofLex x).order := by
obtain rfl | hne := eq_or_ne x 0
· simp
· have hne' : ofLex x ≠ 0 := hne
have habs : ofLex |x| ≠ 0 := by simpa using hne
apply WithTop.coe_injective
rw [order_eq_orderTop_of_ne_zero habs, order_eq_orderTop_of_ne_zero hne']
apply orderTop_abs | theorem | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | order_abs | null |
leadingCoeff_abs (x : Lex (HahnSeries Γ R)) :
(ofLex |x|).leadingCoeff = |(ofLex x).leadingCoeff| := by
obtain hlt | rfl | hgt := lt_trichotomy x 0
· obtain hlt' := leadingCoeff_neg_iff.mpr hlt
rw [abs_eq_neg_self.mpr hlt.le, abs_eq_neg_self.mpr hlt'.le, ofLex_neg, leadingCoeff_neg]
· simp
· obtain hgt' := leadingCoeff_pos_iff.mpr hgt
rw [abs_eq_self.mpr hgt.le, abs_eq_self.mpr hgt'.le] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | leadingCoeff_abs | null |
abs_lt_abs_of_orderTop_ofLex {x y : Lex (HahnSeries Γ R)}
(h : (ofLex y).orderTop < (ofLex x).orderTop) : |x| < |y| := by
rw [← orderTop_abs x, ← orderTop_abs y] at h
refine (lt_iff _ _).mpr ⟨(ofLex |y|).orderTop.untop h.ne_top, ?_, ?_⟩
· simp +contextual [-orderTop_abs, coeff_eq_zero_of_lt_orderTop, h.trans']
· simpa [-orderTop_abs, coeff_eq_zero_of_lt_orderTop, coeff_untop_eq_leadingCoeff, h]
using h.ne_top | theorem | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | abs_lt_abs_of_orderTop_ofLex | null |
archimedeanClassMk_le_archimedeanClassMk_iff_of_orderTop_ofLex {x y : Lex (HahnSeries Γ R)}
(h : (ofLex x).orderTop = (ofLex y).orderTop) :
ArchimedeanClass.mk x ≤ .mk y ↔
ArchimedeanClass.mk (ofLex x).leadingCoeff ≤ .mk (ofLex y).leadingCoeff := by
simp_rw [ArchimedeanClass.mk_le_mk]
obtain rfl | hy := eq_or_ne y 0
· -- special case: both `x` and `y` are zero
simp_all
have hx : x ≠ 0 := by simpa using orderTop_ne_top.1 <| h ▸ orderTop_ne_top.2 (by simpa using hy)
have h' : (ofLex |x|).orderTop = (ofLex |y|).orderTop := by simpa using h
constructor
· -- `mk x ≤ mk y → mk x.leadingCoeff ≤ mk y.leadingCoeff`
intro ⟨n, hn⟩
refine ⟨n + 1, ?_⟩
have hn' : |y| < (n + 1) • |x| :=
lt_of_le_of_lt hn <| nsmul_lt_nsmul_left (by simpa using hx) (by simp)
obtain ⟨j, hj, hi⟩ := (lt_iff _ _).mp hn'
simp_rw [ofLex_smul, coeff_smul] at hj hi
simp_rw [← leadingCoeff_abs]
rw [leadingCoeff_of_ne_zero (by simpa using hy), leadingCoeff_of_ne_zero (by simpa using hx)]
simp_rw [← h']
obtain hjlt | hjeq | hjgt := lt_trichotomy (WithTop.some j) (ofLex |x|).orderTop
· -- impossible case: `x` and `y` differ before their leading coefficients
have hjlt' : j < (ofLex |y|).orderTop := h'.symm ▸ hjlt
simp [coeff_eq_zero_of_lt_orderTop hjlt, coeff_eq_zero_of_lt_orderTop hjlt'] at hi
· convert hi.le <;> exact (WithTop.untop_eq_iff _).mpr hjeq.symm
· exact (hj _ ((WithTop.untop_lt_iff _).mpr hjgt)).le
· -- `mk x.leadingCoeff ≤ mk y.leadingCoeff → mk x ≤ mk y`
intro ⟨n, hn⟩
refine ⟨n + 1, ((lt_iff _ _).mpr ?_).le⟩
refine ⟨(ofLex x).orderTop.untop (by simpa using hx), ?_, ?_⟩
· -- all coefficients before the leading coefficient are zero
intro j hj
trans 0
· apply coeff_eq_zero_of_lt_orderTop
simpa [← h] using hj
· suffices (ofLex |x|).coeff j = 0 by simp [this]
apply coeff_eq_zero_of_lt_orderTop
simpa using hj
rw [ofLex_smul, coeff_smul]
suffices |(ofLex y).leadingCoeff| < (n + 1) • |(ofLex x).leadingCoeff| by
simp_rw [← leadingCoeff_abs] at this
rw [leadingCoeff_of_ne_zero (by simpa using hy), leadingCoeff_of_ne_zero (by simpa using hx)]
at this
convert this using 3 <;> simp [h]
refine lt_of_le_of_lt hn <| nsmul_lt_nsmul_left ?_ (by simp)
rwa [abs_pos, leadingCoeff_ne_zero] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | archimedeanClassMk_le_archimedeanClassMk_iff_of_orderTop_ofLex | null |
archimedeanClassMk_le_archimedeanClassMk_iff {x y : Lex (HahnSeries Γ R)} :
ArchimedeanClass.mk x ≤ .mk y ↔
(ofLex x).orderTop < (ofLex y).orderTop ∨
(ofLex x).orderTop = (ofLex y).orderTop ∧
ArchimedeanClass.mk (ofLex x).leadingCoeff ≤ .mk (ofLex y).leadingCoeff := by
obtain hlt | heq | hgt := lt_trichotomy (ofLex x).orderTop (ofLex y).orderTop
· -- when `x`'s order is less than `y`'s, this reduces to abs_lt_abs_of_orderTop_ofLex
simpa [ArchimedeanClass.mk_le_mk, hlt] using
⟨1, by simpa using (abs_lt_abs_of_orderTop_ofLex hlt).le⟩
· -- when `x` and `y` have the same order, this reduces to
simpa [heq] using archimedeanClassMk_le_archimedeanClassMk_iff_of_orderTop_ofLex heq
simp_rw [ArchimedeanClass.mk_le_mk]
refine ⟨?_, by simp [hgt.not_gt, hgt.ne']⟩
intro ⟨n, hn⟩
contrapose! hn
rw [← abs_nsmul]
have hgt' : (ofLex y).orderTop < (ofLex (n • x)).orderTop := by
apply lt_of_lt_of_le hgt
simpa using orderTop_smul_not_lt n (ofLex x)
exact abs_lt_abs_of_orderTop_ofLex hgt' | theorem | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | archimedeanClassMk_le_archimedeanClassMk_iff | null |
archimedeanClassMk_eq_archimedeanClassMk_iff {x y : Lex (HahnSeries Γ R)} :
ArchimedeanClass.mk x = ArchimedeanClass.mk y ↔
(ofLex x).orderTop = (ofLex y).orderTop ∧
ArchimedeanClass.mk (ofLex x).leadingCoeff = ArchimedeanClass.mk (ofLex y).leadingCoeff := by
rw [le_antisymm_iff, archimedeanClassMk_le_archimedeanClassMk_iff,
archimedeanClassMk_le_archimedeanClassMk_iff]
constructor
· simpa +contextual [or_imp, ne_of_gt, le_of_lt] using fun _ ↦ le_antisymm
· intro ⟨horder, hcoeff⟩
exact ⟨.inr ⟨horder, hcoeff.le⟩, .inr ⟨horder.symm, hcoeff.ge⟩⟩
variable (Γ R) in | theorem | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | archimedeanClassMk_eq_archimedeanClassMk_iff | null |
noncomputable finiteArchimedeanClassOrderHomLex :
FiniteArchimedeanClass (Lex (HahnSeries Γ R)) →o Γ ×ₗ FiniteArchimedeanClass R :=
FiniteArchimedeanClass.liftOrderHom
(fun ⟨x, hx⟩ ↦ toLex
⟨(ofLex x).orderTop.untop (by simp [orderTop_of_ne_zero (show ofLex x ≠ 0 by exact hx)]),
FiniteArchimedeanClass.mk (ofLex x).leadingCoeff (leadingCoeff_ne_zero.mpr hx)⟩)
fun ⟨a, ha⟩ ⟨b, hb⟩ h ↦ by
rw [Prod.Lex.le_iff]
simp only [ofLex_toLex]
rw [FiniteArchimedeanClass.mk_le_mk] at ⊢ h
rw [WithTop.untop_eq_iff]
simpa using archimedeanClassMk_le_archimedeanClassMk_iff.mp h
variable (Γ R) in | def | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | finiteArchimedeanClassOrderHomLex | Finite archimedean classes of `Lex (HahnSeries Γ R)` decompose into lexicographical pairs
of `order` and the finite archimedean class of `leadingCoeff`. |
noncomputable finiteArchimedeanClassOrderHomInvLex :
Γ ×ₗ FiniteArchimedeanClass R →o FiniteArchimedeanClass (Lex (HahnSeries Γ R)) where
toFun x := (ofLex x).2.liftOrderHom
(fun a ↦ FiniteArchimedeanClass.mk (toLex (single (ofLex x).1 a.val)) (by
simpa using a.prop))
fun ⟨a, ha⟩ ⟨b, hb⟩ h ↦ by
rw [FiniteArchimedeanClass.mk_le_mk, archimedeanClassMk_le_archimedeanClassMk_iff]
simpa [ha, hb] using h
monotone' a b := a.rec fun (ao, ac) ↦ b.rec fun (bo, bc) h ↦ by
obtain h | ⟨rfl, hle⟩ := Prod.Lex.le_iff.mp h
· induction ac using FiniteArchimedeanClass.ind with | mk a ha
induction bc using FiniteArchimedeanClass.ind with | mk b hb
simp only [ne_eq, ofLex_toLex, FiniteArchimedeanClass.liftOrderHom_mk]
rw [FiniteArchimedeanClass.mk_le_mk, archimedeanClassMk_le_archimedeanClassMk_iff]
exact .inl (by simpa [ha, hb] using h)
· exact OrderHom.monotone _ hle
variable (Γ R) in | def | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | finiteArchimedeanClassOrderHomInvLex | The inverse of `finiteArchimedeanClassOrderHomLex`. |
noncomputable finiteArchimedeanClassOrderIsoLex :
FiniteArchimedeanClass (Lex (HahnSeries Γ R)) ≃o Γ ×ₗ FiniteArchimedeanClass R := by
apply OrderIso.ofHomInv (finiteArchimedeanClassOrderHomLex Γ R)
(finiteArchimedeanClassOrderHomInvLex Γ R)
· ext x
cases x with | h x
obtain ⟨order, coeff⟩ := x
induction coeff using FiniteArchimedeanClass.ind with | mk a ha
simp [finiteArchimedeanClassOrderHomLex, finiteArchimedeanClassOrderHomInvLex, ha]
· ext x
induction x using FiniteArchimedeanClass.ind with | mk a ha
simp [finiteArchimedeanClassOrderHomLex, finiteArchimedeanClassOrderHomInvLex,
archimedeanClassMk_eq_archimedeanClassMk_iff, ha]
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | finiteArchimedeanClassOrderIsoLex | The correspondence between finite archimedean classes of `Lex (HahnSeries Γ R)`
and lexicographical pairs of `HahnSeries.orderTop` and the finite archimedean class of
`HahnSeries.leadingCoeff`. |
finiteArchimedeanClassOrderIsoLex_apply_fst {x : Lex (HahnSeries Γ R)} (h : x ≠ 0) :
(ofLex (finiteArchimedeanClassOrderIsoLex Γ R (FiniteArchimedeanClass.mk x h))).1 =
(ofLex x).orderTop := by
simp [finiteArchimedeanClassOrderIsoLex, finiteArchimedeanClassOrderHomLex]
@[simp] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | finiteArchimedeanClassOrderIsoLex_apply_fst | null |
finiteArchimedeanClassOrderIsoLex_apply_snd {x : Lex (HahnSeries Γ R)} (h : x ≠ 0) :
(ofLex (finiteArchimedeanClassOrderIsoLex Γ R (FiniteArchimedeanClass.mk x h))).2.val =
ArchimedeanClass.mk (ofLex x).leadingCoeff := by
simp [finiteArchimedeanClassOrderIsoLex, finiteArchimedeanClassOrderHomLex] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | finiteArchimedeanClassOrderIsoLex_apply_snd | null |
noncomputable finiteArchimedeanClassOrderIso :
FiniteArchimedeanClass (Lex (HahnSeries Γ R)) ≃o Γ :=
have : Unique (FiniteArchimedeanClass R) := (nonempty_unique _).some
(finiteArchimedeanClassOrderIsoLex Γ R).trans (Prod.Lex.prodUnique _ _)
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | finiteArchimedeanClassOrderIso | For `Archimedean` coefficients, there is a correspondence between finite
archimedean classes and `HahnSeries.orderTop` without the top element. |
finiteArchimedeanClassOrderIso_apply {x : Lex (HahnSeries Γ R)} (h : x ≠ 0) :
finiteArchimedeanClassOrderIso Γ R (FiniteArchimedeanClass.mk x h) = (ofLex x).orderTop := by
simp [finiteArchimedeanClassOrderIso]
variable (Γ R) in | theorem | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | finiteArchimedeanClassOrderIso_apply | null |
noncomputable archimedeanClassOrderIsoWithTop :
ArchimedeanClass (Lex (HahnSeries Γ R)) ≃o WithTop Γ :=
(FiniteArchimedeanClass.withTopOrderIso _).symm.trans
(finiteArchimedeanClassOrderIso _ _).withTopCongr
@[simp] | def | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | archimedeanClassOrderIsoWithTop | For `Archimedean` coefficients, there is a correspondence between
archimedean classes (with top) and `HahnSeries.orderTop`. |
archimedeanClassOrderIsoWithTop_apply (x : Lex (HahnSeries Γ R)) :
archimedeanClassOrderIsoWithTop Γ R (ArchimedeanClass.mk x) = (ofLex x).orderTop := by
unfold archimedeanClassOrderIsoWithTop
obtain rfl | h := eq_or_ne x 0 <;>
simp [FiniteArchimedeanClass.withTopOrderIso_symm_apply, *] | theorem | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | archimedeanClassOrderIsoWithTop_apply | null |
@[simps]
noncomputable
embDomainOrderEmbedding [Zero R] : Lex (HahnSeries Γ R) ↪o Lex (HahnSeries Γ' R) where
toFun a := toLex (embDomain f (ofLex a))
inj' := toLex.injective.comp (embDomain_injective.comp (ofLex.injective))
map_rel_iff' {a b} := by
simp_rw [le_iff_lt_or_eq, lt_iff]
simp only [Function.Embedding.coeFn_mk, ofLex_toLex, EmbeddingLike.apply_eq_iff_eq]
constructor
· rintro (⟨i, hj, hi⟩ | heq)
· have himem : i ∈ Set.range f := by
contrapose! hi
simp [embDomain_notin_range hi]
obtain ⟨k, rfl⟩ := himem
refine Or.inl ⟨k, fun j hjk ↦ ?_, by simpa using hi⟩
simpa using hj (f j) (f.lt_iff_lt.mpr hjk)
· exact Or.inr <| embDomain_injective.comp (ofLex.injective) heq
· rintro (⟨i, hj, hi⟩ | rfl)
· refine Or.inl ⟨f i, fun k hki ↦ ?_, by simpa using hi⟩
by_cases hkmem : k ∈ Set.range f
· obtain ⟨j', rfl⟩ := hkmem
simpa using hj _ <| f.lt_iff_lt.mp hki
· simp_rw [embDomain_notin_range hkmem]
· simp | def | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | embDomainOrderEmbedding | `HahnSeries.embDomain` as an `OrderEmbedding`. |
@[simps]
noncomputable
embDomainOrderAddMonoidHom [AddMonoid R] : Lex (HahnSeries Γ R) →+o Lex (HahnSeries Γ' R) where
__ := (embDomainOrderEmbedding f).toOrderHom
map_zero' := by simp
map_add' := by simp [embDomainOrderEmbedding, embDomain_add] | def | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | embDomainOrderAddMonoidHom | `HahnSeries.embDomain` as an `OrderAddMonoidHom`. |
embDomainOrderAddMonoidHom_injective [AddMonoid R] :
Function.Injective (embDomainOrderAddMonoidHom f (R := R)) :=
(embDomainOrderEmbedding f).injective | theorem | RingTheory | [
"Mathlib.Algebra.Order.Archimedean.Class",
"Mathlib.Order.Hom.Lex",
"Mathlib.Order.PiLex",
"Mathlib.RingTheory.HahnSeries.Addition"
] | Mathlib/RingTheory/HahnSeries/Lex.lean | embDomainOrderAddMonoidHom_injective | null |
@[simp]
coeff_one [Zero R] [One R] {a : Γ} :
(1 : HahnSeries Γ R).coeff a = if a = 0 then 1 else 0 :=
coeff_single
@[simp] theorem single_zero_one [Zero R] [One R] : single (0 : Γ) (1 : R) = 1 := 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 | coeff_one | null |
single_zero_natCast [Zero R] [NatCast R] (n : ℕ) : single (0 : Γ) (n : R) = n := 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 | single_zero_natCast | null |
single_zero_intCast [Zero R] [IntCast R] (z : ℤ) : single (0 : Γ) (z : R) = z := 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 | single_zero_intCast | null |
single_zero_nnratCast [Zero R] [NNRatCast R] (q : ℚ≥0) : single (0 : Γ) (q : R) = q := 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 | single_zero_nnratCast | null |
single_zero_ratCast [Zero R] [RatCast R] (q : ℚ) : single (0 : Γ) (q : R) = q := 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 | single_zero_ratCast | null |
single_zero_ofNat [Zero R] [NatCast R] (n : ℕ) [n.AtLeastTwo] :
single (0 : Γ) (ofNat(n) : R) = ofNat(n) := rfl
@[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 | single_zero_ofNat | null |
support_one [MulZeroOneClass R] [Nontrivial R] : support (1 : HahnSeries Γ R) = {0} :=
support_single_of_ne one_ne_zero
@[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 | support_one | null |
orderTop_one [MulZeroOneClass R] [Nontrivial R] : orderTop (1 : HahnSeries Γ R) = 0 := by
rw [← single_zero_one, orderTop_single one_ne_zero, WithTop.coe_eq_zero]
@[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 | orderTop_one | null |
order_one [MulZeroOneClass R] : order (1 : HahnSeries Γ R) = 0 := by
cases subsingleton_or_nontrivial R
· rw [Subsingleton.elim (1 : HahnSeries Γ R) 0, order_zero]
· exact order_single one_ne_zero
@[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 | order_one | null |
leadingCoeff_one [MulZeroOneClass R] : (1 : HahnSeries Γ R).leadingCoeff = 1 := by
simp [leadingCoeff_eq]
@[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 | leadingCoeff_one | null |
protected map_one [MonoidWithZero R] [MonoidWithZero S] (f : R →*₀ S) :
(1 : HahnSeries Γ R).map f = (1 : HahnSeries Γ S) :=
HahnSeries.map_single (a := (0 : Γ)) f.toZeroHom |>.trans <| congrArg _ <| f.map_one | lemma | 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_one | null |
@[nolint unusedArguments]
HahnModule (Γ R V : Type*) [PartialOrder Γ] [Zero V] [SMul R V] :=
HahnSeries Γ V | 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 | HahnModule | We introduce a type alias for `HahnSeries` in order to work with scalar multiplication by
series. If we wrote a `SMul (HahnSeries Γ R) (HahnSeries Γ V)` instance, then when
`V = HahnSeries Γ R`, we would have two different actions of `HahnSeries Γ R` on `HahnSeries Γ V`.
See `Mathlib/Algebra/Polynomial/Module.lean` for more discussion on this problem. |
of (R : Type*) [SMul R V] : HahnSeries Γ V ≃ HahnModule Γ R V :=
Equiv.refl _ | 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 | of | The casting function to the type synonym. |
@[elab_as_elim]
rec {motive : HahnModule Γ R V → Sort*} (h : ∀ x : HahnSeries Γ V, motive (of R x)) :
∀ x, motive x :=
fun x => h <| (of R).symm x
@[ext] | 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 | rec | Recursion principle to reduce a result about the synonym to the original type. |
ext (x y : HahnModule Γ R V) (h : ((of R).symm x).coeff = ((of R).symm y).coeff) : x = y :=
(of R).symm.injective <| HahnSeries.coeff_inj.1 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 | ext | null |
instAddCommMonoid : AddCommMonoid (HahnModule Γ R V) :=
inferInstanceAs <| AddCommMonoid (HahnSeries Γ V) | instance | 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 | instAddCommMonoid | null |
instBaseSMul {V} [Monoid R] [AddMonoid V] [DistribMulAction R V] :
SMul R (HahnModule Γ R V) :=
inferInstanceAs <| SMul R (HahnSeries Γ V)
@[simp] theorem of_zero : of R (0 : HahnSeries Γ V) = 0 := rfl
@[simp] theorem of_add (x y : HahnSeries Γ V) : of R (x + y) = of R x + of R y := rfl
@[simp] theorem of_symm_zero : (of R).symm (0 : HahnModule Γ R V) = 0 := rfl
@[simp] theorem of_symm_add (x y : HahnModule Γ R V) :
(of R).symm (x + y) = (of R).symm x + (of R).symm y := rfl
variable [PartialOrder Γ'] [VAdd Γ Γ'] [IsOrderedCancelVAdd Γ Γ'] | instance | 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 | instBaseSMul | null |
instSMul [Zero R] : SMul (HahnSeries Γ R) (HahnModule Γ' R V) where
smul x y := (of R) {
coeff := fun a =>
∑ ij ∈ VAddAntidiagonal x.isPWO_support ((of R).symm y).isPWO_support a,
x.coeff ij.fst • ((of R).symm y).coeff ij.snd
isPWO_support' :=
haveI h :
{ a : Γ' |
(∑ ij ∈ VAddAntidiagonal x.isPWO_support ((of R).symm y).isPWO_support a,
x.coeff ij.fst • ((of R).symm y).coeff ij.snd) ≠ 0 } ⊆
{ a : Γ' | (VAddAntidiagonal x.isPWO_support
((of R).symm y).isPWO_support a).Nonempty } := by
intro a ha
contrapose! ha
simp [not_nonempty_iff_eq_empty.1 ha]
isPWO_support_vaddAntidiagonal.mono h } | instance | 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 | instSMul | null |
coeff_smul [Zero R] (x : HahnSeries Γ R) (y : HahnModule Γ' R V) (a : Γ') :
((of R).symm <| x • y).coeff a =
∑ ij ∈ VAddAntidiagonal x.isPWO_support ((of R).symm y).isPWO_support a,
x.coeff ij.fst • ((of R).symm y).coeff ij.snd :=
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 | coeff_smul | null |
instBaseSMulZeroClass [SMulZeroClass R V] :
SMulZeroClass R (HahnModule Γ R V) :=
inferInstanceAs <| SMulZeroClass R (HahnSeries Γ V)
@[simp] theorem of_smul [SMulZeroClass R V] (r : R) (x : HahnSeries Γ V) :
(of R) (r • x) = r • (of R) x := rfl
@[simp] theorem of_symm_smul [SMulZeroClass R V] (r : R) (x : HahnModule Γ R V) :
(of R).symm (r • x) = r • (of R).symm x := rfl
variable [Zero R] | instance | 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 | instBaseSMulZeroClass | null |
instSMulZeroClass [SMulZeroClass R V] :
SMulZeroClass (HahnSeries Γ R) (HahnModule Γ' R V) where
smul_zero x := by
ext
simp [coeff_smul] | instance | 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 | instSMulZeroClass | null |
coeff_smul_right [SMulZeroClass R V] {x : HahnSeries Γ R} {y : HahnModule Γ' R V} {a : Γ'}
{s : Set Γ'} (hs : s.IsPWO) (hys : ((of R).symm y).support ⊆ s) :
((of R).symm <| x • y).coeff a =
∑ ij ∈ VAddAntidiagonal x.isPWO_support hs a,
x.coeff ij.fst • ((of R).symm y).coeff ij.snd := by
classical
rw [coeff_smul]
apply sum_subset_zero_on_sdiff (vaddAntidiagonal_mono_right hys) _ fun _ _ => rfl
intro b hb
simp only [not_and, mem_sdiff, mem_vaddAntidiagonal, HahnSeries.mem_support, not_imp_not] at hb
rw [hb.2 hb.1.1 hb.1.2.2, smul_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 | coeff_smul_right | null |
coeff_smul_left [SMulWithZero R V] {x : HahnSeries Γ R}
{y : HahnModule Γ' R V} {a : Γ'} {s : Set Γ}
(hs : s.IsPWO) (hxs : x.support ⊆ s) :
((of R).symm <| x • y).coeff a =
∑ ij ∈ VAddAntidiagonal hs ((of R).symm y).isPWO_support a,
x.coeff ij.fst • ((of R).symm y).coeff ij.snd := by
classical
rw [coeff_smul]
apply sum_subset_zero_on_sdiff (vaddAntidiagonal_mono_left hxs) _ fun _ _ => rfl
intro b hb
simp only [not_and', mem_sdiff, mem_vaddAntidiagonal, HahnSeries.mem_support, not_ne_iff] at hb
rw [hb.2 ⟨hb.1.2.1, hb.1.2.2⟩, zero_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 | coeff_smul_left | null |
smul_add [Zero R] [DistribSMul R V] (x : HahnSeries Γ R) (y z : HahnModule Γ' R V) :
x • (y + z) = x • y + x • z := by
ext k
have hwf := ((of R).symm y).isPWO_support.union ((of R).symm z).isPWO_support
rw [coeff_smul_right hwf, of_symm_add]
· simp_all only [HahnSeries.coeff_add', Pi.add_apply, of_symm_add]
rw [coeff_smul_right hwf Set.subset_union_right,
coeff_smul_right hwf Set.subset_union_left]
simp_all [sum_add_distrib]
· intro b
simp_all only [Set.isPWO_union, HahnSeries.isPWO_support, and_self, of_symm_add,
HahnSeries.coeff_add', Pi.add_apply, ne_eq, Set.mem_union, HahnSeries.mem_support]
contrapose!
intro h
rw [h.1, h.2, add_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 | smul_add | null |
instDistribSMul [MonoidWithZero R] [DistribSMul R V] : DistribSMul (HahnSeries Γ R)
(HahnModule Γ' R V) where
smul_add := smul_add | instance | 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 | instDistribSMul | null |
add_smul [AddCommMonoid R] [SMulWithZero R V] {x y : HahnSeries Γ R}
{z : HahnModule Γ' R V} (h : ∀ (r s : R) (u : V), (r + s) • u = r • u + s • u) :
(x + y) • z = x • z + y • z := by
ext a
have hwf := x.isPWO_support.union y.isPWO_support
rw [coeff_smul_left hwf, HahnSeries.coeff_add', of_symm_add]
· simp_all only [Pi.add_apply, HahnSeries.coeff_add']
rw [coeff_smul_left hwf Set.subset_union_right,
coeff_smul_left hwf Set.subset_union_left]
simp only [sum_add_distrib]
· intro b
simp_all only [Set.isPWO_union, HahnSeries.isPWO_support, and_self, HahnSeries.mem_support,
HahnSeries.coeff_add, ne_eq, Set.mem_union]
contrapose!
intro h
rw [h.1, h.2, add_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 | add_smul | null |
coeff_single_smul_vadd [MulZeroClass R] [SMulWithZero R V] {r : R} {x : HahnModule Γ' R V}
{a : Γ'} {b : Γ} :
((of R).symm (HahnSeries.single b r • x)).coeff (b +ᵥ a) = r • ((of R).symm x).coeff a := by
by_cases hr : r = 0
· simp_all only [map_zero, zero_smul, coeff_smul, HahnSeries.support_zero, HahnSeries.coeff_zero,
sum_const_zero]
simp only [hr, coeff_smul, coeff_smul, HahnSeries.support_single_of_ne, ne_eq, not_false_iff]
by_cases hx : ((of R).symm x).coeff a = 0
· simp only [hx, smul_zero]
rw [sum_congr _ fun _ _ => rfl, sum_empty]
ext ⟨a1, a2⟩
simp only [notMem_empty, not_and, Set.mem_singleton_iff,
mem_vaddAntidiagonal, iff_false]
rintro rfl h2 h1
rw [IsCancelVAdd.left_cancel a1 a2 a h1] at h2
exact h2 hx
trans ∑ ij ∈ {(b, a)},
(HahnSeries.single b r).coeff ij.fst • ((of R).symm x).coeff ij.snd
· apply sum_congr _ fun _ _ => rfl
ext ⟨a1, a2⟩
simp only [Set.mem_singleton_iff, Prod.mk_inj, mem_vaddAntidiagonal, mem_singleton]
constructor
· rintro ⟨rfl, _, h1⟩
exact ⟨rfl, IsCancelVAdd.left_cancel a1 a2 a h1⟩
· rintro ⟨rfl, rfl⟩
exact ⟨rfl, by exact hx, rfl⟩
· 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 | coeff_single_smul_vadd | null |
coeff_single_zero_smul {Γ} [AddCommMonoid Γ] [PartialOrder Γ] [AddAction Γ Γ']
[IsOrderedCancelVAdd Γ Γ'] [MulZeroClass R] [SMulWithZero R V] {r : R}
{x : HahnModule Γ' R V} {a : Γ'} :
((of R).symm ((HahnSeries.single 0 r : HahnSeries Γ R) • x)).coeff a =
r • ((of R).symm x).coeff a := by
nth_rw 1 [← zero_vadd Γ a]
exact coeff_single_smul_vadd
@[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 | coeff_single_zero_smul | null |
single_zero_smul_eq_smul (Γ) [AddCommMonoid Γ] [PartialOrder Γ] [AddAction Γ Γ']
[IsOrderedCancelVAdd Γ Γ'] [MulZeroClass R] [SMulWithZero R V] {r : R}
{x : HahnModule Γ' R V} :
(HahnSeries.single (0 : Γ) r) • x = r • x := by
ext
exact coeff_single_zero_smul
@[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 | single_zero_smul_eq_smul | null |
zero_smul' [Zero R] [SMulWithZero R V] {x : HahnModule Γ' R V} :
(0 : HahnSeries Γ R) • x = 0 := by
ext
simp [coeff_smul]
@[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 | zero_smul' | null |
one_smul' {Γ} [AddCommMonoid Γ] [PartialOrder Γ] [AddAction Γ Γ'] [IsOrderedCancelVAdd Γ Γ']
[MonoidWithZero R] [MulActionWithZero R V] {x : HahnModule Γ' R V} :
(1 : HahnSeries Γ R) • x = x := by
ext g
exact coeff_single_zero_smul.trans (one_smul R (x.coeff g)) | 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 | one_smul' | null |
support_smul_subset_vadd_support' [MulZeroClass R] [SMulWithZero R V] {x : HahnSeries Γ R}
{y : HahnModule Γ' R V} :
((of R).symm (x • y)).support ⊆ x.support +ᵥ ((of R).symm y).support := by
apply Set.Subset.trans (fun x hx => _) support_vaddAntidiagonal_subset_vadd
· exact x.isPWO_support
· exact y.isPWO_support
intro x hx
contrapose! hx
simp only [Set.mem_setOf_eq, not_nonempty_iff_eq_empty] at hx
simp [hx, coeff_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 | support_smul_subset_vadd_support' | null |
support_smul_subset_vadd_support [MulZeroClass R] [SMulWithZero R V] {x : HahnSeries Γ R}
{y : HahnModule Γ' R V} :
((of R).symm (x • y)).support ⊆ x.support +ᵥ ((of R).symm y).support := by
exact support_smul_subset_vadd_support' | 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 | support_smul_subset_vadd_support | null |
orderTop_vAdd_le_orderTop_smul {Γ Γ'} [LinearOrder Γ] [LinearOrder Γ'] [VAdd Γ Γ']
[IsOrderedCancelVAdd Γ Γ'] [MulZeroClass R] [SMulWithZero R V] {x : HahnSeries Γ R}
[VAdd (WithTop Γ) (WithTop Γ')] {y : HahnModule Γ' R V}
(h : ∀ (γ : Γ) (γ' : Γ'), γ +ᵥ γ' = (γ : WithTop Γ) +ᵥ (γ' : WithTop Γ')) :
x.orderTop +ᵥ ((of R).symm y).orderTop ≤ ((of R).symm (x • y)).orderTop := by
by_cases hx : x = 0; · simp_all
by_cases hy : y = 0; · simp_all
have hhy : ((of R).symm y) ≠ 0 := hy
rw [HahnSeries.orderTop_of_ne_zero hx, HahnSeries.orderTop_of_ne_zero hhy, ← h,
← Set.IsWF.min_vadd]
by_cases hxy : (of R).symm (x • y) = 0
· rw [hxy, HahnSeries.orderTop_zero]
exact OrderTop.le_top (α := WithTop Γ') _
· rw [HahnSeries.orderTop_of_ne_zero hxy, WithTop.coe_le_coe]
exact Set.IsWF.min_le_min_of_subset support_smul_subset_vadd_support | 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 | orderTop_vAdd_le_orderTop_smul | null |
coeff_smul_order_add_order {Γ}
[AddCommMonoid Γ] [LinearOrder Γ] [IsOrderedCancelAddMonoid Γ] [Zero R]
[SMulWithZero R V] (x : HahnSeries Γ R) (y : HahnModule Γ R V) :
((of R).symm (x • y)).coeff (x.order + ((of R).symm y).order) =
x.leadingCoeff • ((of R).symm y).leadingCoeff := by
by_cases hx : x = (0 : HahnSeries Γ R); · simp [HahnSeries.coeff_zero, hx]
by_cases hy : (of R).symm y = 0; · simp [hy, coeff_smul]
rw [HahnSeries.order_of_ne hx, HahnSeries.order_of_ne hy, coeff_smul,
HahnSeries.leadingCoeff_of_ne_zero hx, HahnSeries.leadingCoeff_of_ne_zero hy, ← vadd_eq_add,
Finset.vaddAntidiagonal_min_vadd_min, Finset.sum_singleton]
simp [HahnSeries.orderTop, hx, hy] | 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 | coeff_smul_order_add_order | null |
of_symm_smul_of_eq_mul [NonUnitalNonAssocSemiring R] {x y : HahnSeries Γ R} :
(HahnModule.of R).symm (x • HahnModule.of R y) = x * y := 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 | of_symm_smul_of_eq_mul | null |
coeff_mul [NonUnitalNonAssocSemiring R] {x y : HahnSeries Γ R} {a : Γ} :
(x * y).coeff a =
∑ ij ∈ addAntidiagonal x.isPWO_support y.isPWO_support a, x.coeff ij.fst * y.coeff ij.snd :=
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 | coeff_mul | null |
protected map_mul [NonUnitalNonAssocSemiring R] [NonUnitalNonAssocSemiring S] (f : R →ₙ+* S)
{x y : HahnSeries Γ R} : (x * y).map f = (x.map f : HahnSeries Γ S) * (y.map f) := by
ext
simp only [map_coeff, coeff_mul, map_sum, map_mul]
refine Eq.symm (sum_subset (fun gh hgh => ?_) (fun gh hgh hz => ?_))
· simp_all only [mem_addAntidiagonal, mem_support, map_coeff, ne_eq, and_true]
exact ⟨fun h => hgh.1 (map_zero f ▸ congrArg f h), fun h => hgh.2.1 (map_zero f ▸ congrArg f h)⟩
· simp_all only [mem_addAntidiagonal, mem_support, ne_eq, map_coeff, and_true,
not_and, not_not]
by_cases h : f (x.coeff gh.1) = 0
· exact mul_eq_zero_of_left h (f (y.coeff gh.2))
· exact mul_eq_zero_of_right (f (x.coeff gh.1)) (hz h) | lemma | 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_mul | null |
coeff_mul_left' [NonUnitalNonAssocSemiring R] {x y : HahnSeries Γ R} {a : Γ} {s : Set Γ}
(hs : s.IsPWO) (hxs : x.support ⊆ s) :
(x * y).coeff a =
∑ ij ∈ addAntidiagonal hs y.isPWO_support a, x.coeff ij.fst * y.coeff ij.snd :=
HahnModule.coeff_smul_left hs hxs | 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 | coeff_mul_left' | null |
coeff_mul_right' [NonUnitalNonAssocSemiring R] {x y : HahnSeries Γ R} {a : Γ} {s : Set Γ}
(hs : s.IsPWO) (hys : y.support ⊆ s) :
(x * y).coeff a =
∑ ij ∈ addAntidiagonal x.isPWO_support hs a, x.coeff ij.fst * y.coeff ij.snd :=
HahnModule.coeff_smul_right hs hys | 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 | coeff_mul_right' | null |
coeff_single_mul_add [NonUnitalNonAssocSemiring R] {r : R} {x : HahnSeries Γ R} {a : Γ}
{b : Γ} : (single b r * x).coeff (a + b) = r * x.coeff a := by
rw [← of_symm_smul_of_eq_mul, add_comm, ← vadd_eq_add]
exact HahnModule.coeff_single_smul_vadd | 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 | coeff_single_mul_add | null |
coeff_mul_single_add [NonUnitalNonAssocSemiring R] {r : R} {x : HahnSeries Γ R} {a : Γ}
{b : Γ} : (x * single b r).coeff (a + b) = x.coeff a * r := by
by_cases hr : r = 0
· simp [hr, coeff_mul]
simp only [hr, coeff_mul, support_single_of_ne, Ne, not_false_iff]
by_cases hx : x.coeff a = 0
· simp only [hx, zero_mul]
rw [sum_congr _ fun _ _ => rfl, sum_empty]
ext ⟨a1, a2⟩
simp only [notMem_empty, not_and, Set.mem_singleton_iff,
mem_addAntidiagonal, iff_false]
rintro h2 rfl h1
rw [← add_right_cancel h1] at hx
exact h2 hx
trans ∑ ij ∈ {(a, b)}, x.coeff ij.fst * (single b r).coeff ij.snd
· apply sum_congr _ fun _ _ => rfl
ext ⟨a1, a2⟩
simp only [Set.mem_singleton_iff, Prod.mk_inj, mem_addAntidiagonal, mem_singleton]
constructor
· rintro ⟨_, rfl, h1⟩
exact ⟨add_right_cancel h1, rfl⟩
· rintro ⟨rfl, rfl⟩
simp [hx]
· simp
@[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 | coeff_mul_single_add | null |
coeff_mul_single_zero [NonUnitalNonAssocSemiring R] {r : R} {x : HahnSeries Γ R} {a : Γ} :
(x * single 0 r).coeff a = x.coeff a * r := by rw [← add_zero a, coeff_mul_single_add, add_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 | coeff_mul_single_zero | null |
coeff_single_zero_mul [NonUnitalNonAssocSemiring R] {r : R} {x : HahnSeries Γ R} {a : Γ} :
((single 0 r : HahnSeries Γ R) * x).coeff a = r * x.coeff a := by
rw [← add_zero a, coeff_single_mul_add, add_zero]
@[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 | coeff_single_zero_mul | null |
single_zero_mul_eq_smul [Semiring R] {r : R} {x : HahnSeries Γ R} :
single 0 r * x = r • x := by
ext
exact coeff_single_zero_mul | 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 | single_zero_mul_eq_smul | null |
support_mul_subset_add_support [NonUnitalNonAssocSemiring R] {x y : HahnSeries Γ R} :
support (x * y) ⊆ support x + support y := by
rw [← of_symm_smul_of_eq_mul, ← vadd_eq_add]
exact HahnModule.support_smul_subset_vadd_support | 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 | support_mul_subset_add_support | null |
coeff_mul_order_add_order (x y : HahnSeries Γ R) :
(x * y).coeff (x.order + y.order) = x.leadingCoeff * y.leadingCoeff := by
simp only [← of_symm_smul_of_eq_mul]
exact HahnModule.coeff_smul_order_add_order x y | 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 | coeff_mul_order_add_order | null |
orderTop_add_le_mul {x y : HahnSeries Γ R} :
x.orderTop + y.orderTop ≤ (x * y).orderTop := by
rw [← smul_eq_mul]
exact HahnModule.orderTop_vAdd_le_orderTop_smul fun i j ↦ 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 | orderTop_add_le_mul | null |
order_mul_of_nonzero {x y : HahnSeries Γ R}
(h : x.leadingCoeff * y.leadingCoeff ≠ 0) : (x * y).order = x.order + y.order := by
have hx : x.leadingCoeff ≠ 0 := by aesop
have hy : y.leadingCoeff ≠ 0 := by aesop
have hxy : (x * y).coeff (x.order + y.order) ≠ 0 :=
ne_of_eq_of_ne (coeff_mul_order_add_order x y) h
refine le_antisymm (order_le_of_coeff_ne_zero
(Eq.mpr (congrArg (fun _a ↦ _a ≠ 0) (coeff_mul_order_add_order x y)) h)) ?_
rw [order_of_ne <| leadingCoeff_ne_zero.mp hx, order_of_ne <| leadingCoeff_ne_zero.mp hy,
order_of_ne <| ne_zero_of_coeff_ne_zero hxy, ← Set.IsWF.min_add]
exact Set.IsWF.min_le_min_of_subset support_mul_subset_add_support | 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_mul_of_nonzero | null |
order_single_mul_of_isRegular {g : Γ} {r : R} (hr : IsRegular r)
{x : HahnSeries Γ R} (hx : x ≠ 0) : (((single g) r) * x).order = g + x.order := by
obtain _ | _ := subsingleton_or_nontrivial R
· exact (hx <| Subsingleton.eq_zero x).elim
have hrx : ((single g) r).leadingCoeff * x.leadingCoeff ≠ 0 := by
rwa [leadingCoeff_of_single, ne_eq, hr.left.mul_left_eq_zero_iff, leadingCoeff_eq_zero]
rw [order_mul_of_nonzero hrx, order_single <| IsRegular.ne_zero hr] | 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_single_mul_of_isRegular | null |
private mul_assoc' [NonUnitalSemiring R] (x y z : HahnSeries Γ R) :
x * y * z = x * (y * z) := by
ext b
rw [coeff_mul_left' (x.isPWO_support.add y.isPWO_support) support_mul_subset_add_support,
coeff_mul_right' (y.isPWO_support.add z.isPWO_support) support_mul_subset_add_support]
simp only [coeff_mul, sum_mul, mul_sum, sum_sigma']
apply Finset.sum_nbij' (fun ⟨⟨_i, j⟩, ⟨k, l⟩⟩ ↦ ⟨(k, l + j), (l, j)⟩)
(fun ⟨⟨i, _j⟩, ⟨k, l⟩⟩ ↦ ⟨(i + k, l), (i, k)⟩) <;>
aesop (add safe Set.add_mem_add) (add simp [add_assoc, mul_assoc]) | 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 | mul_assoc' | null |
orderTop_nsmul_le_orderTop_pow {Γ}
[AddCommMonoid Γ] [LinearOrder Γ] [IsOrderedCancelAddMonoid Γ]
[Semiring R] {x : HahnSeries Γ R} {n : ℕ} : n • x.orderTop ≤ (x ^ n).orderTop := by
induction n with
| zero =>
simp only [zero_smul, pow_zero]
by_cases h : (0 : R) = 1
· simp [subsingleton_iff_zero_eq_one.mp h]
· simp [nontrivial_of_ne 0 1 h]
| succ n ih =>
rw [add_nsmul, pow_add]
calc
n • x.orderTop + 1 • x.orderTop ≤ (x ^ n).orderTop + 1 • x.orderTop :=
add_le_add_right ih (1 • x.orderTop)
(x ^ n).orderTop + 1 • x.orderTop = (x ^ n).orderTop + x.orderTop := by rw [one_nsmul]
(x ^ n).orderTop + x.orderTop ≤ (x ^ n * x).orderTop := orderTop_add_le_mul
(x ^ n * x).orderTop ≤ (x ^ n * x ^ 1).orderTop := by rw [pow_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 | orderTop_nsmul_le_orderTop_pow | null |
private mul_smul' [Semiring R] [Module R V] (x y : HahnSeries Γ R)
(z : HahnModule Γ' R V) : (x * y) • z = x • (y • z) := by
ext b
rw [coeff_smul_left (x.isPWO_support.add y.isPWO_support)
HahnSeries.support_mul_subset_add_support, coeff_smul_right
(y.isPWO_support.vadd ((of R).symm z).isPWO_support) support_smul_subset_vadd_support]
simp only [HahnSeries.coeff_mul, coeff_smul, sum_smul, smul_sum, sum_sigma']
apply Finset.sum_nbij' (fun ⟨⟨_i, j⟩, ⟨k, l⟩⟩ ↦ ⟨(k, l +ᵥ j), (l, j)⟩)
(fun ⟨⟨i, _j⟩, ⟨k, l⟩⟩ ↦ ⟨(i + k, l), (i, k)⟩) <;>
aesop (add safe [Set.vadd_mem_vadd, Set.add_mem_add]) (add simp [add_vadd, mul_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 | mul_smul' | null |
instBaseModule [Semiring R] [Module R V] : Module R (HahnModule Γ' R V) :=
inferInstanceAs <| Module R (HahnSeries Γ' V) | instance | 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 | instBaseModule | null |
instModule [Semiring R] [Module R V] : Module (HahnSeries Γ R)
(HahnModule Γ' R V) := {
inferInstanceAs (DistribSMul (HahnSeries Γ R) (HahnModule Γ' R V)) with
mul_smul := mul_smul'
one_smul := fun _ => one_smul'
add_smul := fun _ _ _ => add_smul Module.add_smul
zero_smul := fun _ => zero_smul' } | instance | 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 | instModule | null |
SMulCommClass [CommSemiring R] [Module R V] :
SMulCommClass R (HahnSeries Γ R) (HahnModule Γ' R V) where
smul_comm r x y := by
rw [← single_zero_smul_eq_smul Γ, ← mul_smul', mul_comm, mul_smul', single_zero_smul_eq_smul Γ] | instance | 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 | SMulCommClass | null |
instNoZeroSMulDivisors {Γ} [AddCommMonoid Γ] [LinearOrder Γ] [IsOrderedCancelAddMonoid Γ]
[Zero R] [SMulWithZero R V] [NoZeroSMulDivisors R V] :
NoZeroSMulDivisors (HahnSeries Γ R) (HahnModule Γ R V) where
eq_zero_or_eq_zero_of_smul_eq_zero {x y} hxy := by
contrapose! hxy
simp only [ne_eq]
rw [HahnModule.ext_iff, funext_iff, not_forall]
refine ⟨x.order + ((of R).symm y).order, ?_⟩
rw [coeff_smul_order_add_order x y, of_symm_zero, HahnSeries.coeff_zero, smul_eq_zero, not_or]
constructor
· exact HahnSeries.leadingCoeff_ne_zero.mpr hxy.1
· exact HahnSeries.leadingCoeff_ne_zero.mpr hxy.2 | instance | 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 | instNoZeroSMulDivisors | null |
@[simp]
order_mul {Γ} [AddCommMonoid Γ] [LinearOrder Γ] [IsOrderedCancelAddMonoid Γ]
[NonUnitalNonAssocSemiring R]
[NoZeroDivisors R] {x y : HahnSeries Γ R} (hx : x ≠ 0) (hy : y ≠ 0) :
(x * y).order = x.order + y.order := by
apply le_antisymm
· apply order_le_of_coeff_ne_zero
rw [coeff_mul_order_add_order x y]
exact mul_ne_zero (leadingCoeff_ne_zero.mpr hx) (leadingCoeff_ne_zero.mpr hy)
· rw [order_of_ne hx, order_of_ne hy, order_of_ne (mul_ne_zero hx hy), ← Set.IsWF.min_add]
exact Set.IsWF.min_le_min_of_subset support_mul_subset_add_support
@[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 | order_mul | null |
order_pow {Γ} [AddCommMonoid Γ] [LinearOrder Γ] [IsOrderedCancelAddMonoid Γ]
[Semiring R] [NoZeroDivisors R]
(x : HahnSeries Γ R) (n : ℕ) : (x ^ n).order = n • x.order := by
induction n with
| zero => simp
| succ h IH =>
rcases eq_or_ne x 0 with (rfl | hx); · simp
rw [pow_succ, order_mul (pow_ne_zero _ hx) hx, succ_nsmul, IH] | 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_pow | null |
@[simp]
single_mul_single {a b : Γ} {r s : R} :
single a r * single b s = single (a + b) (r * s) := by
ext x
by_cases h : x = a + b
· rw [h, coeff_mul_single_add]
simp
· rw [coeff_single_of_ne h, coeff_mul, sum_eq_zero]
simp_rw [mem_addAntidiagonal]
rintro ⟨y, z⟩ ⟨hy, hz, rfl⟩
rw [eq_of_mem_support_single hy, eq_of_mem_support_single hz] at h
exact (h rfl).elim | 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 | single_mul_single | null |
@[simp]
single_pow (a : Γ) (n : ℕ) (r : R) : single a r ^ n = single (n • a) (r ^ n) := by
induction n with
| zero => ext; simp only [pow_zero, coeff_one, zero_smul, coeff_single]
| succ n IH => rw [pow_succ, pow_succ, IH, single_mul_single, succ_nsmul] | 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 | single_pow | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.