Theorem: FormalMultilinearSeries.leftInv_comp
File: Mathlib/Analysis/Analytic/Inverse.lean

tactic: ext (n v)
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
⊢ (p.leftInv i).comp p = id 𝕜 E
state_after: case h.H
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n : ℕ
v : Fin n → E
⊢ ((p.leftInv i).comp p n) v = (id 𝕜 E n) v

tactic: simp only [leftInv_coeff_zero, ContinuousMultilinearMap.zero_apply, id_apply_ne_one, Ne,
  not_false_iff, zero_ne_one, comp_coeff_zero']
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n : ℕ
v : Fin 0 → E
⊢ ((p.leftInv i).comp p 0) v = (id 𝕜 E 0) v
state_after: no goals

tactic: simp only [leftInv_coeff_one, comp_coeff_one, h, id_apply_one, ContinuousLinearEquiv.coe_apply,
  ContinuousLinearEquiv.symm_apply_apply, continuousMultilinearCurryFin1_symm_apply]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n : ℕ
v : Fin 1 → E
⊢ ((p.leftInv i).comp p 1) v = (id 𝕜 E 1) v
state_after: no goals

tactic: have B :
  Disjoint ({c | Composition.length c < n + 2} : Set (Composition (n + 2))).toFinset
    {Composition.ones (n + 2)} := by
  simp [Set.mem_toFinset (s := {c | Composition.length c < n + 2})]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
⊢ ((p.leftInv i).comp p (n + 2)) v = (id 𝕜 E (n + 2)) v
state_after: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
⊢ ((p.leftInv i).comp p (n + 2)) v = (id 𝕜 E (n + 2)) v

tactic: have C :
  ((p.leftInv i (Composition.ones (n + 2)).length)
      fun j : Fin (Composition.ones n.succ.succ).length =>
      p 1 fun _ => v ((Fin.castLE (Composition.length_le _)) j)) =
    p.leftInv i (n + 2) fun j : Fin (n + 2) => p 1 fun _ => v j := by
  apply FormalMultilinearSeries.congr _ (Composition.ones_length _) fun j hj1 hj2 => ?_
  exact FormalMultilinearSeries.congr _ rfl fun k _ _ => by congr
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
⊢ ((p.leftInv i).comp p (n + 2)) v = (id 𝕜 E (n + 2)) v
state_after: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
C :
  ((p.leftInv i (Composition.ones (n + 2)).length) fun j => (p 1) fun x => v (Fin.castLE ⋯ j)) =
    (p.leftInv i (n + 2)) fun j => (p 1) fun x => v j
⊢ ((p.leftInv i).comp p (n + 2)) v = (id 𝕜 E (n + 2)) v

tactic: have D :
  (p.leftInv i (n + 2) fun j : Fin (n + 2) => p 1 fun _ => v j) =
    -∑ c ∈ {c : Composition (n + 2) | c.length < n + 2}.toFinset,
        (p.leftInv i c.length) (p.applyComposition c v) := by
  simp only [leftInv, ContinuousMultilinearMap.neg_apply, neg_inj,
    ContinuousMultilinearMap.sum_apply]
  convert
    (sum_toFinset_eq_subtype
      (fun c : Composition (n + 2) => c.length < n + 2)
      (fun c : Composition (n + 2) =>
      (ContinuousMultilinearMap.compAlongComposition
        (p.compContinuousLinearMap (i.symm : F →L[𝕜] E)) c (p.leftInv i c.length))
        fun j : Fin (n + 2) => p 1 fun _ : Fin 1 => v j)).symm.trans
      _
  simp only [compContinuousLinearMap_applyComposition,
    ContinuousMultilinearMap.compAlongComposition_apply]
  congr
  ext c
  congr
  ext k
  simp [h, Function.comp]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
C :
  ((p.leftInv i (Composition.ones (n + 2)).length) fun j => (p 1) fun x => v (Fin.castLE ⋯ j)) =
    (p.leftInv i (n + 2)) fun j => (p 1) fun x => v j
⊢ ((p.leftInv i).comp p (n + 2)) v = (id 𝕜 E (n + 2)) v
state_after: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
C :
  ((p.leftInv i (Composition.ones (n + 2)).length) fun j => (p 1) fun x => v (Fin.castLE ⋯ j)) =
    (p.leftInv i (n + 2)) fun j => (p 1) fun x => v j
D :
  ((p.leftInv i (n + 2)) fun j => (p 1) fun x => v j) =
    -∑ c ∈ {c | c.length < n + 2}.toFinset, (p.leftInv i c.length) (p.applyComposition c v)
⊢ ((p.leftInv i).comp p (n + 2)) v = (id 𝕜 E (n + 2)) v

tactic: simp [FormalMultilinearSeries.comp, show n + 2 ≠ 1 by omega, A, Finset.sum_union B,
  applyComposition_ones, C, D, -Set.toFinset_setOf]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
C :
  ((p.leftInv i (Composition.ones (n + 2)).length) fun j => (p 1) fun x => v (Fin.castLE ⋯ j)) =
    (p.leftInv i (n + 2)) fun j => (p 1) fun x => v j
D :
  ((p.leftInv i (n + 2)) fun j => (p 1) fun x => v j) =
    -∑ c ∈ {c | c.length < n + 2}.toFinset, (p.leftInv i c.length) (p.applyComposition c v)
⊢ ((p.leftInv i).comp p (n + 2)) v = (id 𝕜 E (n + 2)) v
state_after: no goals

tactic: refine Subset.antisymm (fun c _ => ?_) (subset_univ _)
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
⊢ univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
state_after: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
c : Composition (n + 2)
x✝ : c ∈ univ
⊢ c ∈ {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}

tactic: by_cases h : c.length < n + 2
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
c : Composition (n + 2)
x✝ : c ∈ univ
⊢ c ∈ {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
state_after: case pos
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h✝ : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
c : Composition (n + 2)
x✝ : c ∈ univ
h : c.length < n + 2
⊢ c ∈ {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}

case neg
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h✝ : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
c : Composition (n + 2)
x✝ : c ∈ univ
h : ¬c.length < n + 2
⊢ c ∈ {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}

tactic: simp [h, Set.mem_toFinset (s := {c | Composition.length c < n + 2})]
state_before: case pos
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h✝ : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
c : Composition (n + 2)
x✝ : c ∈ univ
h : c.length < n + 2
⊢ c ∈ {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
state_after: no goals

tactic: simp [Composition.eq_ones_iff_le_length.2 (not_lt.1 h)]
state_before: case neg
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h✝ : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
c : Composition (n + 2)
x✝ : c ∈ univ
h : ¬c.length < n + 2
⊢ c ∈ {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
state_after: no goals

tactic: simp [Set.mem_toFinset (s := {c | Composition.length c < n + 2})]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
⊢ Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
state_after: no goals

tactic: apply FormalMultilinearSeries.congr _ (Composition.ones_length _) fun j hj1 hj2 => ?_
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
⊢ ((p.leftInv i (Composition.ones (n + 2)).length) fun j => (p 1) fun x => v (Fin.castLE ⋯ j)) =
    (p.leftInv i (n + 2)) fun j => (p 1) fun x => v j
state_after: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
j : ℕ
hj1 : j < (Composition.ones (n + 2)).length
hj2 : j < n + 2
⊢ ((p 1) fun x => v (Fin.castLE ⋯ ⟨j, hj1⟩)) = (p 1) fun x => v ⟨j, hj2⟩

tactic: exact FormalMultilinearSeries.congr _ rfl fun k _ _ => by congr
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
j : ℕ
hj1 : j < (Composition.ones (n + 2)).length
hj2 : j < n + 2
⊢ ((p 1) fun x => v (Fin.castLE ⋯ ⟨j, hj1⟩)) = (p 1) fun x => v ⟨j, hj2⟩
state_after: no goals

tactic: congr
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
j : ℕ
hj1 : j < (Composition.ones (n + 2)).length
hj2 : j < n + 2
k : ℕ
x✝¹ x✝ : k < 1
⊢ v (Fin.castLE ⋯ ⟨j, hj1⟩) = v ⟨j, hj2⟩
state_after: no goals

tactic: simp only [leftInv, ContinuousMultilinearMap.neg_apply, neg_inj,
  ContinuousMultilinearMap.sum_apply]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
C :
  ((p.leftInv i (Composition.ones (n + 2)).length) fun j => (p 1) fun x => v (Fin.castLE ⋯ j)) =
    (p.leftInv i (n + 2)) fun j => (p 1) fun x => v j
⊢ ((p.leftInv i (n + 2)) fun j => (p 1) fun x => v j) =
    -∑ c ∈ {c | c.length < n + 2}.toFinset, (p.leftInv i c.length) (p.applyComposition c v)
state_after: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
C :
  ((p.leftInv i (Composition.ones (n + 2)).length) fun j => (p 1) fun x => v (Fin.castLE ⋯ j)) =
    (p.leftInv i (n + 2)) fun j => (p 1) fun x => v j
⊢ (∑ a : { c // c.length < n + 2 },
      (ContinuousMultilinearMap.compAlongComposition (p.compContinuousLinearMap ↑i.symm) (↑a) (p.leftInv i (↑a).length))
        fun j => (p 1) fun x => v j) =
    ∑ x ∈ {c | c.length < n + 2}.toFinset, (p.leftInv i x.length) (p.applyComposition x v)

tactic: convert
  (sum_toFinset_eq_subtype
    (fun c : Composition (n + 2) => c.length < n + 2)
    (fun c : Composition (n + 2) =>
    (ContinuousMultilinearMap.compAlongComposition
      (p.compContinuousLinearMap (i.symm : F →L[𝕜] E)) c (p.leftInv i c.length))
      fun j : Fin (n + 2) => p 1 fun _ : Fin 1 => v j)).symm.trans
    _
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
C :
  ((p.leftInv i (Composition.ones (n + 2)).length) fun j => (p 1) fun x => v (Fin.castLE ⋯ j)) =
    (p.leftInv i (n + 2)) fun j => (p 1) fun x => v j
⊢ (∑ a : { c // c.length < n + 2 },
      (ContinuousMultilinearMap.compAlongComposition (p.compContinuousLinearMap ↑i.symm) (↑a) (p.leftInv i (↑a).length))
        fun j => (p 1) fun x => v j) =
    ∑ x ∈ {c | c.length < n + 2}.toFinset, (p.leftInv i x.length) (p.applyComposition x v)
state_after: case convert_2
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
C :
  ((p.leftInv i (Composition.ones (n + 2)).length) fun j => (p 1) fun x => v (Fin.castLE ⋯ j)) =
    (p.leftInv i (n + 2)) fun j => (p 1) fun x => v j
⊢ (∑ a ∈ {x | x.length < n + 2}.toFinset,
      (ContinuousMultilinearMap.compAlongComposition (p.compContinuousLinearMap ↑i.symm) a (p.leftInv i a.length))
        fun j => (p 1) fun x => v j) =
    ∑ x ∈ {c | c.length < n + 2}.toFinset, (p.leftInv i x.length) (p.applyComposition x v)

tactic: simp only [compContinuousLinearMap_applyComposition,
  ContinuousMultilinearMap.compAlongComposition_apply]
state_before: case convert_2
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
C :
  ((p.leftInv i (Composition.ones (n + 2)).length) fun j => (p 1) fun x => v (Fin.castLE ⋯ j)) =
    (p.leftInv i (n + 2)) fun j => (p 1) fun x => v j
⊢ (∑ a ∈ {x | x.length < n + 2}.toFinset,
      (ContinuousMultilinearMap.compAlongComposition (p.compContinuousLinearMap ↑i.symm) a (p.leftInv i a.length))
        fun j => (p 1) fun x => v j) =
    ∑ x ∈ {c | c.length < n + 2}.toFinset, (p.leftInv i x.length) (p.applyComposition x v)
state_after: case convert_2
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
C :
  ((p.leftInv i (Composition.ones (n + 2)).length) fun j => (p 1) fun x => v (Fin.castLE ⋯ j)) =
    (p.leftInv i (n + 2)) fun j => (p 1) fun x => v j
⊢ ∑ x ∈ {x | x.length < n + 2}.toFinset,
      (p.leftInv i x.length) (p.applyComposition x (⇑↑i.symm ∘ fun j => (p 1) fun x => v j)) =
    ∑ x ∈ {x | x.length < n + 2}.toFinset, (p.leftInv i x.length) (p.applyComposition x v)

tactic: congr
state_before: case convert_2
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
C :
  ((p.leftInv i (Composition.ones (n + 2)).length) fun j => (p 1) fun x => v (Fin.castLE ⋯ j)) =
    (p.leftInv i (n + 2)) fun j => (p 1) fun x => v j
⊢ ∑ x ∈ {x | x.length < n + 2}.toFinset,
      (p.leftInv i x.length) (p.applyComposition x (⇑↑i.symm ∘ fun j => (p 1) fun x => v j)) =
    ∑ x ∈ {x | x.length < n + 2}.toFinset, (p.leftInv i x.length) (p.applyComposition x v)
state_after: case convert_2.e_f
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
C :
  ((p.leftInv i (Composition.ones (n + 2)).length) fun j => (p 1) fun x => v (Fin.castLE ⋯ j)) =
    (p.leftInv i (n + 2)) fun j => (p 1) fun x => v j
⊢ (fun x => (p.leftInv i x.length) (p.applyComposition x (⇑↑i.symm ∘ fun j => (p 1) fun x => v j))) = fun x =>
    (p.leftInv i x.length) (p.applyComposition x v)

tactic: ext c
state_before: case convert_2.e_f
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
C :
  ((p.leftInv i (Composition.ones (n + 2)).length) fun j => (p 1) fun x => v (Fin.castLE ⋯ j)) =
    (p.leftInv i (n + 2)) fun j => (p 1) fun x => v j
⊢ (fun x => (p.leftInv i x.length) (p.applyComposition x (⇑↑i.symm ∘ fun j => (p 1) fun x => v j))) = fun x =>
    (p.leftInv i x.length) (p.applyComposition x v)
state_after: case convert_2.e_f.h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
C :
  ((p.leftInv i (Composition.ones (n + 2)).length) fun j => (p 1) fun x => v (Fin.castLE ⋯ j)) =
    (p.leftInv i (n + 2)) fun j => (p 1) fun x => v j
c : Composition (n + 2)
⊢ (p.leftInv i c.length) (p.applyComposition c (⇑↑i.symm ∘ fun j => (p 1) fun x => v j)) =
    (p.leftInv i c.length) (p.applyComposition c v)

tactic: congr
state_before: case convert_2.e_f.h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
C :
  ((p.leftInv i (Composition.ones (n + 2)).length) fun j => (p 1) fun x => v (Fin.castLE ⋯ j)) =
    (p.leftInv i (n + 2)) fun j => (p 1) fun x => v j
c : Composition (n + 2)
⊢ (p.leftInv i c.length) (p.applyComposition c (⇑↑i.symm ∘ fun j => (p 1) fun x => v j)) =
    (p.leftInv i c.length) (p.applyComposition c v)
state_after: case convert_2.e_f.h.h.e_6.h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
C :
  ((p.leftInv i (Composition.ones (n + 2)).length) fun j => (p 1) fun x => v (Fin.castLE ⋯ j)) =
    (p.leftInv i (n + 2)) fun j => (p 1) fun x => v j
c : Composition (n + 2)
⊢ p.applyComposition c (⇑↑i.symm ∘ fun j => (p 1) fun x => v j) = p.applyComposition c v

tactic: ext k
state_before: case convert_2.e_f.h.h.e_6.h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
C :
  ((p.leftInv i (Composition.ones (n + 2)).length) fun j => (p 1) fun x => v (Fin.castLE ⋯ j)) =
    (p.leftInv i (n + 2)) fun j => (p 1) fun x => v j
c : Composition (n + 2)
⊢ p.applyComposition c (⇑↑i.symm ∘ fun j => (p 1) fun x => v j) = p.applyComposition c v
state_after: case convert_2.e_f.h.h.e_6.h.h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
C :
  ((p.leftInv i (Composition.ones (n + 2)).length) fun j => (p 1) fun x => v (Fin.castLE ⋯ j)) =
    (p.leftInv i (n + 2)) fun j => (p 1) fun x => v j
c : Composition (n + 2)
k : Fin c.length
⊢ p.applyComposition c (⇑↑i.symm ∘ fun j => (p 1) fun x => v j) k = p.applyComposition c v k

tactic: simp [h, Function.comp]
state_before: case convert_2.e_f.h.h.e_6.h.h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
C :
  ((p.leftInv i (Composition.ones (n + 2)).length) fun j => (p 1) fun x => v (Fin.castLE ⋯ j)) =
    (p.leftInv i (n + 2)) fun j => (p 1) fun x => v j
c : Composition (n + 2)
k : Fin c.length
⊢ p.applyComposition c (⇑↑i.symm ∘ fun j => (p 1) fun x => v j) k = p.applyComposition c v k
state_after: no goals

tactic: omega
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
n✝ n : ℕ
v : Fin (n + 2) → E
A : univ = {c | c.length < n + 2}.toFinset ∪ {Composition.ones (n + 2)}
B : Disjoint {c | c.length < n + 2}.toFinset {Composition.ones (n + 2)}
C :
  ((p.leftInv i (Composition.ones (n + 2)).length) fun j => (p 1) fun x => v (Fin.castLE ⋯ j)) =
    (p.leftInv i (n + 2)) fun j => (p 1) fun x => v j
D :
  ((p.leftInv i (n + 2)) fun j => (p 1) fun x => v j) =
    -∑ c ∈ {c | c.length < n + 2}.toFinset, (p.leftInv i c.length) (p.applyComposition c v)
⊢ n + 2 ≠ 1
state_after: no goals