File: Mathlib/RingTheory/HahnSeries/Summable.lean

full_name: HahnSeries.isPWO_iUnion_support_powers
code: theorem isPWO_iUnion_support_powers [LinearOrderedCancelAddCommMonoid Γ] [Ring R] [IsDomain R]
    {x : HahnSeries Γ R} (hx : 0 < x.orderTop) : (⋃ n : ℕ, (x ^ n).support).IsPWO 
goal: (⋃ n, (x ^ n).support).IsPWO

full_name: HahnSeries.SummableFamily
code: /-- 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. -/
structure SummableFamily (α : 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
goal: Type (max (max u_1 u_2) u_3)

full_name: HahnSeries.SummableFamily.isPWO_iUnion_support'
code: /-- 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. -/
structure SummableFamily (α : 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
goal: (⋃ a, (self.toFun a).support).IsPWO

full_name: HahnSeries.SummableFamily.toFun
code: /-- 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. -/
structure SummableFamily (α : 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
goal: α → HahnSeries Γ R

full_name: HahnSeries.SummableFamily.finite_co_support'
code: /-- 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. -/
structure SummableFamily (α : 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
goal: {a | (self.toFun a).coeff g ≠ 0}.Finite

full_name: HahnSeries.SummableFamily.instFunLike
code: instance : FunLike (SummableFamily Γ R α) α (HahnSeries Γ R) 
goal: FunLike (HahnSeries.SummableFamily Γ R α) α (HahnSeries Γ R)

full_name: HahnSeries.SummableFamily.isPWO_iUnion_support
code: theorem isPWO_iUnion_support (s : SummableFamily Γ R α) : Set.IsPWO (⋃ a : α, (s a).support) 
goal: (⋃ a, (s a).support).IsPWO

full_name: HahnSeries.SummableFamily.finite_co_support
code: theorem finite_co_support (s : SummableFamily Γ R α) (g : Γ) :
    (Function.support fun a => (s a).coeff g).Finite 
goal: (Function.support fun a => (s a).coeff g).Finite

full_name: HahnSeries.SummableFamily.coe_injective
code: theorem coe_injective : @Function.Injective (SummableFamily Γ R α) (α → HahnSeries Γ R) (⇑) 
goal: Function.Injective DFunLike.coe

full_name: HahnSeries.SummableFamily.ext
code: @[ext]
theorem ext {s t : SummableFamily Γ R α} (h : ∀ a : α, s a = t a) : s = t 
goal: s = t

full_name: HahnSeries.SummableFamily.instAdd
code: instance : Add (SummableFamily Γ R α) 
goal: Add (HahnSeries.SummableFamily Γ R α)

full_name: HahnSeries.SummableFamily.instZero
code: instance : Zero (SummableFamily Γ R α) 
goal: Zero (HahnSeries.SummableFamily Γ R α)

full_name: HahnSeries.SummableFamily.instInhabited
code: instance : Inhabited (SummableFamily Γ R α) 
goal: Inhabited (HahnSeries.SummableFamily Γ R α)

full_name: HahnSeries.SummableFamily.coe_add
code: @[simp]
theorem coe_add {s t : SummableFamily Γ R α} : ⇑(s + t) = s + t 
goal: ⇑(s + t) = ⇑s + ⇑t

full_name: HahnSeries.SummableFamily.add_apply
code: theorem add_apply {s t : SummableFamily Γ R α} {a : α} : (s + t) a = s a + t a 
goal: (s + t) a = s a + t a

full_name: HahnSeries.SummableFamily.coe_zero
code: @[simp]
theorem coe_zero : ((0 : SummableFamily Γ R α) : α → HahnSeries Γ R) = 0 
goal: ⇑0 = 0

full_name: HahnSeries.SummableFamily.zero_apply
code: theorem zero_apply {a : α} : (0 : SummableFamily Γ R α) a = 0 
goal: 0 a = 0

full_name: HahnSeries.SummableFamily.instAddCommMonoid
code: instance : AddCommMonoid (SummableFamily Γ R α) 
goal: AddCommMonoid (HahnSeries.SummableFamily Γ R α)

full_name: HahnSeries.SummableFamily.hsum
code: /-- The infinite sum of a `SummableFamily` of Hahn series. -/
def hsum (s : SummableFamily Γ R α) : HahnSeries Γ R 
goal: HahnSeries Γ R

full_name: HahnSeries.SummableFamily.hsum_coeff
code: @[simp]
theorem hsum_coeff {s : SummableFamily Γ R α} {g : Γ} : s.hsum.coeff g = ∑ᶠ i, (s i).coeff g 
goal: s.hsum.coeff g = ∑ᶠ (i : α), (s i).coeff g

full_name: HahnSeries.SummableFamily.support_hsum_subset
code: theorem support_hsum_subset {s : SummableFamily Γ R α} : s.hsum.support ⊆ ⋃ a : α, (s a).support 
goal: s.hsum.support ⊆ ⋃ a, (s a).support

full_name: HahnSeries.SummableFamily.hsum_add
code: @[simp]
theorem hsum_add {s t : SummableFamily Γ R α} : (s + t).hsum = s.hsum + t.hsum 
goal: (s + t).hsum = s.hsum + t.hsum

full_name: HahnSeries.SummableFamily.instNeg
code: instance : Neg (SummableFamily Γ R α) 
goal: Neg (HahnSeries.SummableFamily Γ R α)

full_name: HahnSeries.SummableFamily.instAddCommGroup
code: instance : AddCommGroup (SummableFamily Γ R α) 
goal: AddCommGroup (HahnSeries.SummableFamily Γ R α)

full_name: HahnSeries.SummableFamily.coe_neg
code: @[simp]
theorem coe_neg : ⇑(-s) = -s 
goal: ⇑(-s) = -⇑s

full_name: HahnSeries.SummableFamily.neg_apply
code: theorem neg_apply : (-s) a = -s a 
goal: (-s) a = -s a

full_name: HahnSeries.SummableFamily.coe_sub
code: @[simp]
theorem coe_sub : ⇑(s - t) = s - t 
goal: ⇑(s - t) = ⇑s - ⇑t

full_name: HahnSeries.SummableFamily.sub_apply
code: theorem sub_apply : (s - t) a = s a - t a 
goal: (s - t) a = s a - t a

full_name: HahnSeries.SummableFamily.instSMul
code: instance : SMul (HahnSeries Γ R) (SummableFamily Γ R α) 
goal: SMul (HahnSeries Γ R) (HahnSeries.SummableFamily Γ R α)

full_name: HahnSeries.SummableFamily.smul_apply
code: @[simp]
theorem smul_apply {x : HahnSeries Γ R} {s : SummableFamily Γ R α} {a : α} : (x • s) a = x * s a 
goal: (x • s) a = x * s a

full_name: HahnSeries.SummableFamily.instModule
code: instance : Module (HahnSeries Γ R) (SummableFamily Γ R α) 
goal: Module (HahnSeries Γ R) (HahnSeries.SummableFamily Γ R α)

full_name: HahnSeries.SummableFamily.hsum_smul
code: @[simp]
theorem hsum_smul {x : HahnSeries Γ R} {s : SummableFamily Γ R α} : (x • s).hsum = x * s.hsum 
goal: (x • s).hsum = x * s.hsum

full_name: HahnSeries.SummableFamily.lsum_apply
code: /-- The summation of a `summable_family` as a `LinearMap`. -/
@[simps]
def lsum : SummableFamily Γ R α →ₗ[HahnSeries Γ R] HahnSeries Γ R 
goal: HahnSeries.SummableFamily.lsum s = s.hsum

full_name: HahnSeries.SummableFamily.lsum
code: /-- The summation of a `summable_family` as a `LinearMap`. -/
@[simps]
def lsum : SummableFamily Γ R α →ₗ[HahnSeries Γ R] HahnSeries Γ R 
goal: HahnSeries.SummableFamily Γ R α →ₗ[HahnSeries Γ R] HahnSeries Γ R

full_name: HahnSeries.SummableFamily.hsum_sub
code: @[simp]
theorem hsum_sub {R : Type*} [Ring R] {s t : SummableFamily Γ R α} :
    (s - t).hsum = s.hsum - t.hsum 
goal: (s - t).hsum = s.hsum - t.hsum

full_name: HahnSeries.SummableFamily.ofFinsupp
code: /-- A family with only finitely many nonzero elements is summable. -/
def ofFinsupp (f : α →₀ HahnSeries Γ R) : SummableFamily Γ R α 
goal: HahnSeries.SummableFamily Γ R α

full_name: HahnSeries.SummableFamily.coe_ofFinsupp
code: @[simp]
theorem coe_ofFinsupp {f : α →₀ HahnSeries Γ R} : ⇑(SummableFamily.ofFinsupp f) = f 
goal: ⇑(HahnSeries.SummableFamily.ofFinsupp f) = ⇑f

full_name: HahnSeries.SummableFamily.hsum_ofFinsupp
code: @[simp]
theorem hsum_ofFinsupp {f : α →₀ HahnSeries Γ R} : (ofFinsupp f).hsum = f.sum fun _ => id 
goal: (HahnSeries.SummableFamily.ofFinsupp f).hsum = f.sum fun x => id

full_name: HahnSeries.SummableFamily.embDomain
code: /-- A summable family can be reindexed by an embedding without changing its sum. -/
def embDomain (s : SummableFamily Γ R α) (f : α ↪ β) : SummableFamily Γ R β 
goal: HahnSeries.SummableFamily Γ R β

full_name: HahnSeries.SummableFamily.embDomain_apply
code: theorem embDomain_apply :
    s.embDomain f b = if h : b ∈ Set.range f then s (Classical.choose h) else 0 
goal: (s.embDomain f) b = if h : b ∈ Set.range ⇑f then s (Classical.choose h) else 0

full_name: HahnSeries.SummableFamily.embDomain_image
code: @[simp]
theorem embDomain_image : s.embDomain f (f a) = s a 
goal: (s.embDomain f) (f a) = s a

full_name: HahnSeries.SummableFamily.embDomain_notin_range
code: @[simp]
theorem embDomain_notin_range (h : b ∉ Set.range f) : s.embDomain f b = 0 
goal: (s.embDomain f) b = 0

full_name: HahnSeries.SummableFamily.hsum_embDomain
code: @[simp]
theorem hsum_embDomain : (s.embDomain f).hsum = s.hsum 
goal: (s.embDomain f).hsum = s.hsum

full_name: HahnSeries.SummableFamily.powers
code: /-- The powers of an element of positive valuation form a summable family. -/
def powers (x : HahnSeries Γ R) (hx : 0 < x.orderTop) : SummableFamily Γ R ℕ 
goal: HahnSeries.SummableFamily Γ R ℕ

full_name: HahnSeries.SummableFamily.coe_powers
code: @[simp]
theorem coe_powers : ⇑(powers x hx) = HPow.hPow x 
goal: ⇑(HahnSeries.SummableFamily.powers x hx) = HPow.hPow x

full_name: HahnSeries.SummableFamily.embDomain_succ_smul_powers
code: theorem embDomain_succ_smul_powers :
    (x • powers x hx).embDomain ⟨Nat.succ, Nat.succ_injective⟩ =
      powers x hx - ofFinsupp (Finsupp.single 0 1) 
goal: (x • HahnSeries.SummableFamily.powers x hx).embDomain { toFun := Nat.succ, inj' := Nat.succ_injective } =
  HahnSeries.SummableFamily.powers x hx - HahnSeries.SummableFamily.ofFinsupp (Finsupp.single 0 1)

full_name: HahnSeries.SummableFamily.one_sub_self_mul_hsum_powers
code: theorem one_sub_self_mul_hsum_powers : (1 - x) * (powers x hx).hsum = 1 
goal: (1 - x) * (HahnSeries.SummableFamily.powers x hx).hsum = 1

full_name: HahnSeries.unit_aux
code: theorem unit_aux (x : HahnSeries Γ R) {r : R} (hr : r * x.leadingCoeff = 1) :
    0 < (1 - single (-x.order) r * x).orderTop 
goal: 0 < (1 - (HahnSeries.single (-x.order)) r * x).orderTop

full_name: HahnSeries.isUnit_iff
code: theorem isUnit_iff {x : HahnSeries Γ R} : IsUnit x ↔ IsUnit (x.leadingCoeff) 
goal: IsUnit x ↔ IsUnit x.leadingCoeff

full_name: HahnSeries.instField
code: instance instField [Field R] : Field (HahnSeries Γ R) 
goal: Field (HahnSeries Γ R)