/-- Summing the series `p.changeOrigin x` at a point `y` gives back `p (x + y)`. -/
theorem changeOrigin_eval (h : (‖x‖₊ + ‖y‖₊ : ℝ≥0∞) < p.radius) :
    (p.changeOrigin x).sum y = p.sum (x + y) := by
  have radius_pos : 0 < p.radius := lt_of_le_of_lt (zero_le _) h
  have x_mem_ball : x ∈ EMetric.ball (0 : E) p.radius :=
    mem_emetric_ball_zero_iff.2 ((le_add_right le_rfl).trans_lt h)
  have y_mem_ball : y ∈ EMetric.ball (0 : E) (p.changeOrigin x).radius := by
    refine' mem_emetric_ball_zero_iff.2 (lt_of_lt_of_le _ p.changeOrigin_radius)
    rwa [lt_tsub_iff_right, add_comm]
  have x_add_y_mem_ball : x + y ∈ EMetric.ball (0 : E) p.radius := by
    refine' mem_emetric_ball_zero_iff.2 (lt_of_le_of_lt _ h)
    exact mod_cast nnnorm_add_le x y
  set f : (Σk l : ℕ, { s : Finset (Fin (k + l)) // s.card = l }) → F := fun s =>
    p.changeOriginSeriesTerm s.1 s.2.1 s.2.2 s.2.2.2 (fun _ => x) fun _ => y
  have hsf : Summable f := by
    refine' .of_nnnorm_bounded _ (p.changeOriginSeries_summable_aux₁ h) _
    rintro ⟨k, l, s, hs⟩
    dsimp only [Subtype.coe_mk]
    exact p.nnnorm_changeOriginSeriesTerm_apply_le _ _ _ _ _ _
  have hf : HasSum f ((p.changeOrigin x).sum y) := by
    refine' HasSum.sigma_of_hasSum ((p.changeOrigin x).summable y_mem_ball).hasSum (fun k => _) hsf
    · dsimp only
      refine' ContinuousMultilinearMap.hasSum_eval _ _
      have := (p.hasFPowerSeriesOnBall_changeOrigin k radius_pos).hasSum x_mem_ball
      rw [zero_add] at this
      refine' HasSum.sigma_of_hasSum this (fun l => _) _
      · simp only [changeOriginSeries, ContinuousMultilinearMap.sum_apply]
        apply hasSum_fintype
      · refine' .of_nnnorm_bounded _
          (p.changeOriginSeries_summable_aux₂ (mem_emetric_ball_zero_iff.1 x_mem_ball) k) fun s => _
        refine' (ContinuousMultilinearMap.le_op_nnnorm _ _).trans_eq _
        simp
  refine' hf.unique (changeOriginIndexEquiv.symm.hasSum_iff.1 _)
  refine' HasSum.sigma_of_hasSum
    (p.hasSum x_add_y_mem_ball) (fun n => _) (changeOriginIndexEquiv.symm.summable_iff.2 hsf)
  erw [(p n).map_add_univ (fun _ => x) fun _ => y]
  -- porting note: added explicit function
  convert hasSum_fintype (fun c : Finset (Fin n) => f (changeOriginIndexEquiv.symm ⟨n, c⟩))
  rename_i s _
  dsimp only [changeOriginSeriesTerm, (· ∘ ·), changeOriginIndexEquiv_symm_apply_fst,
    changeOriginIndexEquiv_symm_apply_snd_fst, changeOriginIndexEquiv_symm_apply_snd_snd_coe]
  rw [ContinuousMultilinearMap.curryFinFinset_apply_const]
  have : ∀ (m) (hm : n = m), p n (s.piecewise (fun _ => x) fun _ => y) =
      p m ((s.map (Fin.castIso hm).toEquiv.toEmbedding).piecewise (fun _ => x) fun _ => y) := by
    rintro m rfl
    simp (config := { unfoldPartialApp := true }) [Finset.piecewise]
  

Proof state:
case h.e'_6.a
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
inst✝ : CompleteSpace F
p : FormalMultilinearSeries 𝕜 E F
x y : E
r R : ℝ≥0
h : ↑‖x‖₊ + ↑‖y‖₊ < radius p
radius_pos : 0 < radius p
x_mem_ball : x ∈ EMetric.ball 0 (radius p)
y_mem_ball : y ∈ EMetric.ball 0 (radius (changeOrigin p x))
x_add_y_mem_ball : x + y ∈ EMetric.ball 0 (radius p)
f : (k : ℕ) × (l : ℕ) × { s // Finset.card s = l } → F :=
  fun s =>
    ((changeOriginSeriesTerm p s.fst s.snd.fst ↑s.snd.snd (_ : Finset.card ↑s.snd.snd = s.snd.fst)) fun x_1 => x)
      fun x => y
hsf : Summable f
hf : HasSum f (FormalMultilinearSeries.sum (changeOrigin p x) y)
n : ℕ
s : Finset (Fin n)
a✝ : s ∈ Finset.univ
this :
  ∀ (m : ℕ) (hm : n = m),
    (p n) (Finset.piecewise s (fun x_1 => x) fun x => y) =
      (p m) (Finset.piecewise (Finset.map (Equiv.toEmbedding (Fin.castIso hm).toEquiv) s) (fun x_1 => x) fun x => y)
⊢ (p n) (Finset.piecewise s (fun x_1 => x) fun x => y) =
    (p (n - Finset.card s + Finset.card s))
      (Finset.piecewise
        (Finset.map
          (Equiv.toEmbedding
            (Fin.castIso
                (_ :
                  { fst := n, snd := s }.fst =
                    { fst := n, snd := s }.fst - Finset.card { fst := n, snd := s }.snd +
                      Finset.card { fst := n, snd := s }.snd)).toEquiv)
          s)
        (fun x_1 => x) fun x => y)

Next tactic:
apply this