File: Mathlib/RingTheory/HahnSeries/PowerSeries.lean

full_name: HahnSeries.toPowerSeries_apply
code: /-- The ring `HahnSeries ℕ R` is isomorphic to `PowerSeries R`. -/
@[simps]
def toPowerSeries : HahnSeries ℕ R ≃+* PowerSeries R 
goal: HahnSeries.toPowerSeries f = PowerSeries.mk f.coeff

full_name: HahnSeries.toPowerSeries
code: /-- The ring `HahnSeries ℕ R` is isomorphic to `PowerSeries R`. -/
@[simps]
def toPowerSeries : HahnSeries ℕ R ≃+* PowerSeries R 
goal: HahnSeries ℕ R ≃+* PowerSeries R

full_name: HahnSeries.toPowerSeries_symm_apply_coeff
code: /-- The ring `HahnSeries ℕ R` is isomorphic to `PowerSeries R`. -/
@[simps]
def toPowerSeries : HahnSeries ℕ R ≃+* PowerSeries R 
goal: (HahnSeries.toPowerSeries.symm f).coeff n = (PowerSeries.coeff R n) f

full_name: HahnSeries.coeff_toPowerSeries
code: theorem coeff_toPowerSeries {f : HahnSeries ℕ R} {n : ℕ} :
    PowerSeries.coeff R n (toPowerSeries f) = f.coeff n 
goal: (PowerSeries.coeff R n) (HahnSeries.toPowerSeries f) = f.coeff n

full_name: HahnSeries.coeff_toPowerSeries_symm
code: theorem coeff_toPowerSeries_symm {f : PowerSeries R} {n : ℕ} :
    (HahnSeries.toPowerSeries.symm f).coeff n = PowerSeries.coeff R n f 
goal: (HahnSeries.toPowerSeries.symm f).coeff n = (PowerSeries.coeff R n) f

full_name: HahnSeries.ofPowerSeries
code: /-- Casts a power series as a Hahn series with coefficients from a `StrictOrderedSemiring`. -/
def ofPowerSeries : PowerSeries R →+* HahnSeries Γ R 
goal: PowerSeries R →+* HahnSeries Γ R

full_name: HahnSeries.ofPowerSeries_injective
code: theorem ofPowerSeries_injective : Function.Injective (ofPowerSeries Γ R) 
goal: Function.Injective ⇑(HahnSeries.ofPowerSeries Γ R)

full_name: HahnSeries.ofPowerSeries_apply
code: theorem 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) 
goal: (HahnSeries.ofPowerSeries Γ R) x =
  HahnSeries.embDomain { toFun := Nat.cast, inj' := ⋯, map_rel_iff' := ⋯ } (HahnSeries.toPowerSeries.symm x)

full_name: HahnSeries.ofPowerSeries_apply_coeff
code: theorem ofPowerSeries_apply_coeff (x : PowerSeries R) (n : ℕ) :
    (ofPowerSeries Γ R x).coeff n = PowerSeries.coeff R n x 
goal: ((HahnSeries.ofPowerSeries Γ R) x).coeff ↑n = (PowerSeries.coeff R n) x

full_name: HahnSeries.ofPowerSeries_C
code: @[simp]
theorem ofPowerSeries_C (r : R) : ofPowerSeries Γ R (PowerSeries.C R r) = HahnSeries.C r 
goal: (HahnSeries.ofPowerSeries Γ R) ((PowerSeries.C R) r) = HahnSeries.C r

full_name: HahnSeries.ofPowerSeries_X
code: @[simp]
theorem ofPowerSeries_X : ofPowerSeries Γ R PowerSeries.X = single 1 1 
goal: (HahnSeries.ofPowerSeries Γ R) PowerSeries.X = (HahnSeries.single 1) 1

full_name: HahnSeries.ofPowerSeries_X_pow
code: theorem ofPowerSeries_X_pow {R} [Semiring R] (n : ℕ) :
    ofPowerSeries Γ R (PowerSeries.X ^ n) = single (n : Γ) 1 
goal: (HahnSeries.ofPowerSeries Γ R) (PowerSeries.X ^ n) = (HahnSeries.single ↑n) 1

full_name: HahnSeries.toMvPowerSeries
code: /-- 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 `Algebra.Order.Pi` the ring `HahnSeries (σ → ℕ) R` could be constructed instead.
 -/
@[simps]
def toMvPowerSeries {σ : Type*} [Finite σ] : HahnSeries (σ →₀ ℕ) R ≃+* MvPowerSeries σ R 
goal: HahnSeries (σ →₀ ℕ) R ≃+* MvPowerSeries σ R

full_name: HahnSeries.toMvPowerSeries_apply
code: /-- 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 `Algebra.Order.Pi` the ring `HahnSeries (σ → ℕ) R` could be constructed instead.
 -/
@[simps]
def toMvPowerSeries {σ : Type*} [Finite σ] : HahnSeries (σ →₀ ℕ) R ≃+* MvPowerSeries σ R 
goal: ∀ (a : σ →₀ ℕ), HahnSeries.toMvPowerSeries f a = f.coeff a

full_name: HahnSeries.toMvPowerSeries_symm_apply_coeff
code: /-- 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 `Algebra.Order.Pi` the ring `HahnSeries (σ → ℕ) R` could be constructed instead.
 -/
@[simps]
def toMvPowerSeries {σ : Type*} [Finite σ] : HahnSeries (σ →₀ ℕ) R ≃+* MvPowerSeries σ R 
goal: (HahnSeries.toMvPowerSeries.symm f).coeff = f

full_name: HahnSeries.coeff_toMvPowerSeries
code: theorem coeff_toMvPowerSeries {f : HahnSeries (σ →₀ ℕ) R} {n : σ →₀ ℕ} :
    MvPowerSeries.coeff R n (toMvPowerSeries f) = f.coeff n 
goal: (MvPowerSeries.coeff R n) (HahnSeries.toMvPowerSeries f) = f.coeff n

full_name: HahnSeries.coeff_toMvPowerSeries_symm
code: theorem coeff_toMvPowerSeries_symm {f : MvPowerSeries σ R} {n : σ →₀ ℕ} :
    (HahnSeries.toMvPowerSeries.symm f).coeff n = MvPowerSeries.coeff R n f 
goal: (HahnSeries.toMvPowerSeries.symm f).coeff n = (MvPowerSeries.coeff R n) f

full_name: HahnSeries.toPowerSeriesAlg
code: /-- The `R`-algebra `HahnSeries ℕ A` is isomorphic to `PowerSeries A`. -/
@[simps!]
def toPowerSeriesAlg : HahnSeries ℕ A ≃ₐ[R] PowerSeries A 
goal: HahnSeries ℕ A ≃ₐ[R] PowerSeries A

full_name: HahnSeries.toPowerSeriesAlg_symm_apply_coeff
code: /-- The `R`-algebra `HahnSeries ℕ A` is isomorphic to `PowerSeries A`. -/
@[simps!]
def toPowerSeriesAlg : HahnSeries ℕ A ≃ₐ[R] PowerSeries A 
goal: ((HahnSeries.toPowerSeriesAlg R).symm f).coeff n = (PowerSeries.coeff A n) f

full_name: HahnSeries.toPowerSeriesAlg_apply
code: /-- The `R`-algebra `HahnSeries ℕ A` is isomorphic to `PowerSeries A`. -/
@[simps!]
def toPowerSeriesAlg : HahnSeries ℕ A ≃ₐ[R] PowerSeries A 
goal: (HahnSeries.toPowerSeriesAlg R) f = PowerSeries.mk f.coeff

full_name: HahnSeries.ofPowerSeriesAlg
code: /-- Casting a power series as a Hahn series with coefficients from a `StrictOrderedSemiring`
  is an algebra homomorphism. -/
@[simps!]
def ofPowerSeriesAlg : PowerSeries A →ₐ[R] HahnSeries Γ A 
goal: PowerSeries A →ₐ[R] HahnSeries Γ A

full_name: HahnSeries.ofPowerSeriesAlg_apply_coeff
code: /-- Casting a power series as a Hahn series with coefficients from a `StrictOrderedSemiring`
  is an algebra homomorphism. -/
@[simps!]
def ofPowerSeriesAlg : PowerSeries A →ₐ[R] HahnSeries Γ A 
goal: ∀ (a : PowerSeries A) (b : Γ),
  ((HahnSeries.ofPowerSeriesAlg Γ R) a).coeff b =
    if h : ∃ x, ¬(PowerSeries.coeff A x) a = 0 ∧ ↑x = b then (PowerSeries.coeff A (Classical.choose ⋯)) a else 0

full_name: HahnSeries.powerSeriesAlgebra
code: instance powerSeriesAlgebra {S : Type*} [CommSemiring S] [Algebra S (PowerSeries R)] :
    Algebra S (HahnSeries Γ R) 
goal: Algebra S (HahnSeries Γ R)

full_name: HahnSeries.algebraMap_apply'
code: theorem algebraMap_apply' (x : S) :
    algebraMap S (HahnSeries Γ R) x = ofPowerSeries Γ R (algebraMap S (PowerSeries R) x) 
goal: (algebraMap S (HahnSeries Γ R)) x = (HahnSeries.ofPowerSeries Γ R) ((algebraMap S (PowerSeries R)) x)

full_name: Polynomial.algebraMap_hahnSeries_apply
code: @[simp]
theorem _root_.Polynomial.algebraMap_hahnSeries_apply (f : R[X]) :
    algebraMap R[X] (HahnSeries Γ R) f = ofPowerSeries Γ R f 
goal: (algebraMap R[X] (HahnSeries Γ R)) f = (HahnSeries.ofPowerSeries Γ R) ↑f

full_name: Polynomial.algebraMap_hahnSeries_injective
code: theorem _root_.Polynomial.algebraMap_hahnSeries_injective :
    Function.Injective (algebraMap R[X] (HahnSeries Γ R)) 
goal: Function.Injective ⇑(algebraMap R[X] (HahnSeries Γ R))