File: Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean

full_name: FormalMultilinearSeries
code: /-- A formal multilinear series over a field `𝕜`, from `E` to `F`, is given by a family of
multilinear maps from `E^n` to `F` for all `n`. -/
@[nolint unusedArguments]
def FormalMultilinearSeries (𝕜 : Type*) (E : Type*) (F : Type*) [Ring 𝕜] [AddCommGroup E]
    [Module 𝕜 E] [TopologicalSpace E] [TopologicalAddGroup E] [ContinuousConstSMul 𝕜 E]
    [AddCommGroup F] [Module 𝕜 F] [TopologicalSpace F] [TopologicalAddGroup F]
    [ContinuousConstSMul 𝕜 F] 
goal: Type (max (max u_3 u_2) 0)

full_name: instAddCommGroupFormalMultilinearSeries
code: instance : AddCommGroup (FormalMultilinearSeries 𝕜 E F) 
goal: AddCommGroup (FormalMultilinearSeries 𝕜 E F)

full_name: instInhabitedFormalMultilinearSeries
code: instance : Inhabited (FormalMultilinearSeries 𝕜 E F) 
goal: Inhabited (FormalMultilinearSeries 𝕜 E F)

full_name: instModuleFormalMultilinearSeriesOfContinuousConstSMulOfSMulCommClass
code: instance (𝕜') [Semiring 𝕜'] [Module 𝕜' F] [ContinuousConstSMul 𝕜' F] [SMulCommClass 𝕜 𝕜' F] :
    Module 𝕜' (FormalMultilinearSeries 𝕜 E F) 
goal: Module 𝕜' (FormalMultilinearSeries 𝕜 E F)

full_name: FormalMultilinearSeries.zero_apply
code: @[simp, nolint simpNF]
theorem zero_apply (n : ℕ) : (0 : FormalMultilinearSeries 𝕜 E F) n = 0 
goal: 0 n = 0

full_name: FormalMultilinearSeries.neg_apply
code: @[simp]
theorem neg_apply (f : FormalMultilinearSeries 𝕜 E F) (n : ℕ) : (-f) n = - f n 
goal: (-f) n = -f n

full_name: FormalMultilinearSeries.ext
code: @[ext]
protected theorem ext {p q : FormalMultilinearSeries 𝕜 E F} (h : ∀ n, p n = q n) : p = q 
goal: p = q

full_name: FormalMultilinearSeries.ext_iff
code: protected theorem ext_iff {p q : FormalMultilinearSeries 𝕜 E F} : p = q ↔ ∀ n, p n = q n 
goal: p = q ↔ ∀ (n : ℕ), p n = q n

full_name: FormalMultilinearSeries.ne_iff
code: protected theorem ne_iff {p q : FormalMultilinearSeries 𝕜 E F} : p ≠ q ↔ ∃ n, p n ≠ q n 
goal: p ≠ q ↔ ∃ n, p n ≠ q n

full_name: FormalMultilinearSeries.prod
code: /-- Cartesian product of two formal multilinear series (with the same field `𝕜` and the same source
space, but possibly different target spaces). -/
def prod (p : FormalMultilinearSeries 𝕜 E F) (q : FormalMultilinearSeries 𝕜 E G) :
    FormalMultilinearSeries 𝕜 E (F × G)
  
goal: FormalMultilinearSeries 𝕜 E (F × G)

full_name: FormalMultilinearSeries.removeZero
code: /-- Killing the zeroth coefficient in a formal multilinear series -/
def removeZero (p : FormalMultilinearSeries 𝕜 E F) : FormalMultilinearSeries 𝕜 E F
  
goal: FormalMultilinearSeries 𝕜 E F

full_name: FormalMultilinearSeries.removeZero_coeff_zero
code: @[simp]
theorem removeZero_coeff_zero (p : FormalMultilinearSeries 𝕜 E F) : p.removeZero 0 = 0 
goal: p.removeZero 0 = 0

full_name: FormalMultilinearSeries.removeZero_coeff_succ
code: @[simp]
theorem removeZero_coeff_succ (p : FormalMultilinearSeries 𝕜 E F) (n : ℕ) :
    p.removeZero (n + 1) = p (n + 1) 
goal: p.removeZero (n + 1) = p (n + 1)

full_name: FormalMultilinearSeries.removeZero_of_pos
code: theorem removeZero_of_pos (p : FormalMultilinearSeries 𝕜 E F) {n : ℕ} (h : 0 < n) :
    p.removeZero n = p n 
goal: p.removeZero n = p n

full_name: FormalMultilinearSeries.congr
code: /-- Convenience congruence lemma stating in a dependent setting that, if the arguments to a formal
multilinear series are equal, then the values are also equal. -/
theorem congr (p : FormalMultilinearSeries 𝕜 E F) {m n : ℕ} {v : Fin m → E} {w : Fin n → E}
    (h1 : m = n) (h2 : ∀ (i : ℕ) (him : i < m) (hin : i < n), v ⟨i, him⟩ = w ⟨i, hin⟩) :
    p m v = p n w 
goal: (p m) v = (p n) w

full_name: FormalMultilinearSeries.compContinuousLinearMap
code: /-- Composing each term `pₙ` in a formal multilinear series with `(u, ..., u)` where `u` is a fixed
continuous linear map, gives a new formal multilinear series `p.compContinuousLinearMap u`. -/
def compContinuousLinearMap (p : FormalMultilinearSeries 𝕜 F G) (u : E →L[𝕜] F) :
    FormalMultilinearSeries 𝕜 E G 
goal: FormalMultilinearSeries 𝕜 E G

full_name: FormalMultilinearSeries.compContinuousLinearMap_apply
code: @[simp]
theorem compContinuousLinearMap_apply (p : FormalMultilinearSeries 𝕜 F G) (u : E →L[𝕜] F) (n : ℕ)
    (v : Fin n → E) : (p.compContinuousLinearMap u) n v = p n (u ∘ v) 
goal: (p.compContinuousLinearMap u n) v = (p n) (⇑u ∘ v)

full_name: FormalMultilinearSeries.restrictScalars
code: /-- Reinterpret a formal `𝕜'`-multilinear series as a formal `𝕜`-multilinear series. -/
@[simp]
protected def restrictScalars (p : FormalMultilinearSeries 𝕜' E F) :
    FormalMultilinearSeries 𝕜 E F 
goal: FormalMultilinearSeries 𝕜 E F

full_name: FormalMultilinearSeries.shift
code: /-- Forgetting the zeroth term in a formal multilinear series, and interpreting the following terms
as multilinear maps into `E →L[𝕜] F`. If `p` is the Taylor series (`HasFTaylorSeriesUpTo`) of a
function, then `p.shift` is the Taylor series of the derivative of the function. Note that the
`p.sum` of a Taylor series `p` does not give the original function; for a formal multilinear
series that sums to the derivative of `p.sum`, see `HasFPowerSeriesOnBall.fderiv`. -/
def shift : FormalMultilinearSeries 𝕜 E (E →L[𝕜] F) 
goal: FormalMultilinearSeries 𝕜 E (E →L[𝕜] F)

full_name: FormalMultilinearSeries.unshift
code: /-- Adding a zeroth term to a formal multilinear series taking values in `E →L[𝕜] F`. This
corresponds to starting from a Taylor series (`HasFTaylorSeriesUpTo`) for the derivative of a
function, and building a Taylor series for the function itself. -/
def unshift (q : FormalMultilinearSeries 𝕜 E (E →L[𝕜] F)) (z : F) : FormalMultilinearSeries 𝕜 E F
  
goal: FormalMultilinearSeries 𝕜 E F

full_name: ContinuousLinearMap.compFormalMultilinearSeries
code: /-- Composing each term `pₙ` in a formal multilinear series with a continuous linear map `f` on the
left gives a new formal multilinear series `f.compFormalMultilinearSeries p` whose general term
is `f ∘ pₙ`. -/
def compFormalMultilinearSeries (f : F →L[𝕜] G) (p : FormalMultilinearSeries 𝕜 E F) :
    FormalMultilinearSeries 𝕜 E G 
goal: FormalMultilinearSeries 𝕜 E G

full_name: ContinuousLinearMap.compFormalMultilinearSeries_apply
code: @[simp]
theorem compFormalMultilinearSeries_apply (f : F →L[𝕜] G) (p : FormalMultilinearSeries 𝕜 E F)
    (n : ℕ) : (f.compFormalMultilinearSeries p) n = f.compContinuousMultilinearMap (p n) 
goal: f.compFormalMultilinearSeries p n = f.compContinuousMultilinearMap (p n)

full_name: ContinuousLinearMap.compFormalMultilinearSeries_apply'
code: theorem compFormalMultilinearSeries_apply' (f : F →L[𝕜] G) (p : FormalMultilinearSeries 𝕜 E F)
    (n : ℕ) (v : Fin n → E) : (f.compFormalMultilinearSeries p) n v = f (p n v) 
goal: (f.compFormalMultilinearSeries p n) v = f ((p n) v)

full_name: ContinuousMultilinearMap.toFormalMultilinearSeries
code: /-- Realize a ContinuousMultilinearMap on `∀ i : ι, E i` as the evaluation of a
FormalMultilinearSeries by choosing an arbitrary identification `ι ≃ Fin (Fintype.card ι)`. -/
noncomputable def toFormalMultilinearSeries : FormalMultilinearSeries 𝕜 (∀ i, E i) F 
goal: FormalMultilinearSeries 𝕜 ((i : ι) → E i) F

full_name: FormalMultilinearSeries.order
code: /-- The index of the first non-zero coefficient in `p` (or `0` if all coefficients are zero). This
  is the order of the isolated zero of an analytic function `f` at a point if `p` is the Taylor
  series of `f` at that point. -/
noncomputable def order (p : FormalMultilinearSeries 𝕜 E F) : ℕ 
goal: ℕ

full_name: FormalMultilinearSeries.order_zero
code: @[simp]
theorem order_zero : (0 : FormalMultilinearSeries 𝕜 E F).order = 0 
goal: FormalMultilinearSeries.order 0 = 0

full_name: FormalMultilinearSeries.ne_zero_of_order_ne_zero
code: theorem ne_zero_of_order_ne_zero (hp : p.order ≠ 0) : p ≠ 0 
goal: p ≠ 0

full_name: FormalMultilinearSeries.order_eq_find
code: theorem order_eq_find [DecidablePred fun n => p n ≠ 0] (hp : ∃ n, p n ≠ 0) :
    p.order = Nat.find hp 
goal: p.order = Nat.find hp

full_name: FormalMultilinearSeries.order_eq_find'
code: theorem order_eq_find' [DecidablePred fun n => p n ≠ 0] (hp : p ≠ 0) :
    p.order = Nat.find (FormalMultilinearSeries.ne_iff.mp hp) 
goal: p.order = Nat.find ⋯

full_name: FormalMultilinearSeries.order_eq_zero_iff'
code: theorem order_eq_zero_iff' : p.order = 0 ↔ p = 0 ∨ p 0 ≠ 0 
goal: p.order = 0 ↔ p = 0 ∨ p 0 ≠ 0

full_name: FormalMultilinearSeries.order_eq_zero_iff
code: theorem order_eq_zero_iff (hp : p ≠ 0) : p.order = 0 ↔ p 0 ≠ 0 
goal: p.order = 0 ↔ p 0 ≠ 0

full_name: FormalMultilinearSeries.apply_order_ne_zero
code: theorem apply_order_ne_zero (hp : p ≠ 0) : p p.order ≠ 0 
goal: p p.order ≠ 0

full_name: FormalMultilinearSeries.apply_order_ne_zero'
code: theorem apply_order_ne_zero' (hp : p.order ≠ 0) : p p.order ≠ 0 
goal: p p.order ≠ 0

full_name: FormalMultilinearSeries.apply_eq_zero_of_lt_order
code: theorem apply_eq_zero_of_lt_order (hp : n < p.order) : p n = 0 
goal: p n = 0

full_name: FormalMultilinearSeries.coeff
code: /-- The `n`th coefficient of `p` when seen as a power series. -/
def coeff (p : FormalMultilinearSeries 𝕜 𝕜 E) (n : ℕ) : E 
goal: E

full_name: FormalMultilinearSeries.mkPiRing_coeff_eq
code: theorem mkPiRing_coeff_eq (p : FormalMultilinearSeries 𝕜 𝕜 E) (n : ℕ) :
    ContinuousMultilinearMap.mkPiRing 𝕜 (Fin n) (p.coeff n) = p n 
goal: ContinuousMultilinearMap.mkPiRing 𝕜 (Fin n) (p.coeff n) = p n

full_name: FormalMultilinearSeries.apply_eq_prod_smul_coeff
code: @[simp]
theorem apply_eq_prod_smul_coeff : p n y = (∏ i, y i) • p.coeff n 
goal: (p n) y = (∏ i : Fin n, y i) • p.coeff n

full_name: FormalMultilinearSeries.coeff_eq_zero
code: theorem coeff_eq_zero : p.coeff n = 0 ↔ p n = 0 
goal: p.coeff n = 0 ↔ p n = 0

full_name: FormalMultilinearSeries.apply_eq_pow_smul_coeff
code: theorem apply_eq_pow_smul_coeff : (p n fun _ => z) = z ^ n • p.coeff n 
goal: ((p n) fun x => z) = z ^ n • p.coeff n

full_name: FormalMultilinearSeries.norm_apply_eq_norm_coef
code: @[simp]
theorem norm_apply_eq_norm_coef : ‖p n‖ = ‖coeff p n‖ 
goal: ‖p n‖ = ‖p.coeff n‖

full_name: FormalMultilinearSeries.fslope
code: /-- The formal counterpart of `dslope`, corresponding to the expansion of `(f z - f 0) / z`. If `f`
has `p` as a power series, then `dslope f` has `fslope p` as a power series. -/
noncomputable def fslope (p : FormalMultilinearSeries 𝕜 𝕜 E) : FormalMultilinearSeries 𝕜 𝕜 E 
goal: FormalMultilinearSeries 𝕜 𝕜 E

full_name: FormalMultilinearSeries.coeff_fslope
code: @[simp]
theorem coeff_fslope : p.fslope.coeff n = p.coeff (n + 1) 
goal: p.fslope.coeff n = p.coeff (n + 1)

full_name: FormalMultilinearSeries.coeff_iterate_fslope
code: @[simp]
theorem coeff_iterate_fslope (k n : ℕ) : (fslope^[k] p).coeff n = p.coeff (n + k) 
goal: (FormalMultilinearSeries.fslope^[k] p).coeff n = p.coeff (n + k)

full_name: constFormalMultilinearSeries
code: /-- The formal multilinear series where all terms of positive degree are equal to zero, and the term
of degree zero is `c`. It is the power series expansion of the constant function equal to `c`
everywhere. -/
def constFormalMultilinearSeries (𝕜 : Type*) [NontriviallyNormedField 𝕜] (E : Type*)
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] [ContinuousConstSMul 𝕜 E] [TopologicalAddGroup E]
    {F : Type*} [NormedAddCommGroup F] [TopologicalAddGroup F] [NormedSpace 𝕜 F]
    [ContinuousConstSMul 𝕜 F] (c : F) : FormalMultilinearSeries 𝕜 E F
  
goal: FormalMultilinearSeries 𝕜 E F

full_name: constFormalMultilinearSeries_apply
code: @[simp]
theorem constFormalMultilinearSeries_apply [NontriviallyNormedField 𝕜] [NormedAddCommGroup E]
    [NormedAddCommGroup F] [NormedSpace 𝕜 E] [NormedSpace 𝕜 F] {c : F} {n : ℕ} (hn : n ≠ 0) :
    constFormalMultilinearSeries 𝕜 E c n = 0 
goal: constFormalMultilinearSeries 𝕜 E c n = 0

full_name: constFormalMultilinearSeries_zero
code: @[simp]
lemma constFormalMultilinearSeries_zero [NontriviallyNormedField 𝕜] [NormedAddCommGroup E ]
    [NormedAddCommGroup F] [NormedSpace 𝕜 E] [NormedSpace 𝕜 F] :
    constFormalMultilinearSeries 𝕜 E (0 : F) = 0 
goal: constFormalMultilinearSeries 𝕜 E 0 = 0

full_name: ContinuousLinearMap.fpowerSeries
code: /-- Formal power series of a continuous linear map `f : E →L[𝕜] F` at `x : E`:
`f y = f x + f (y - x)`. -/
def fpowerSeries (f : E →L[𝕜] F) (x : E) : FormalMultilinearSeries 𝕜 E F
  
goal: FormalMultilinearSeries 𝕜 E F

full_name: ContinuousLinearMap.fpowerSeries_apply_zero
code: theorem fpowerSeries_apply_zero (f : E →L[𝕜] F) (x : E) :
    f.fpowerSeries x 0 = ContinuousMultilinearMap.curry0 𝕜 _ (f x) 
goal: f.fpowerSeries x 0 = ContinuousMultilinearMap.curry0 𝕜 E (f x)

full_name: ContinuousLinearMap.fpowerSeries_apply_one
code: theorem fpowerSeries_apply_one (f : E →L[𝕜] F) (x : E) :
    f.fpowerSeries x 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm f 
goal: f.fpowerSeries x 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm f

full_name: ContinuousLinearMap.fpowerSeries_apply_add_two
code: theorem fpowerSeries_apply_add_two (f : E →L[𝕜] F) (x : E) (n : ℕ) : f.fpowerSeries x (n + 2) = 0 
goal: f.fpowerSeries x (n + 2) = 0