theorem actionDiagonalSucc_inv_apply {G : Type u} [Group G] {n : ℕ} (g : G) (f : Fin n → G) :
    (actionDiagonalSucc G n).inv.hom (g, f) = (g • Fin.partialProd f : Fin (n + 1) → G) := by
  revert g
  induction' n with n hn
  · intro g
    funext (x : Fin 1)
    simp only [Subsingleton.elim x 0, Pi.smul_apply, Fin.partialProd_zero, smul_eq_mul, mul_one]
    rfl
  · intro g
/- Porting note: broken proof was
    ext
    dsimp only [actionDiagonalSucc]
    simp only [Iso.trans_inv, comp_hom, hn, diagonalSucc_inv_hom, types_comp_apply, tensorIso_inv,
      Iso.refl_inv, Action.tensorHom, id_hom, tensor_apply, types_id_apply,
      leftRegularTensorIso_inv_hom, tensor_rho, leftRegular_ρ_apply, Pi.smul_apply, smul_eq_mul]
    refine' Fin.cases _ _ x
    · simp only [Fin.cons_zero, Fin.partialProd_zero, mul_one]
    · intro i
      simpa only [Fin.cons_succ, Pi.smul_apply, smul_eq_mul, Fin.partialProd_succ', mul_assoc] -/
    funext x
    dsimp [actionDiagonalSucc]
    erw [hn, Equiv.piFinSuccAbove_symm_apply]
    refine' Fin.cases _ (fun i => _) x
    · simp only [Fin.insertNth_zero, Fin.cons_zero, Fin.partialProd_zero, mul_one]
    · 

Proof state:
case succ.h.refine'_2
k G✝ : Type u
inst✝² : CommRing k
n✝ : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
n : ℕ
hn : ∀ (f : Fin n → G) (g : G), Hom.hom (actionDiagonalSucc G n).inv (g, f) = g • partialProd f
f : Fin (Nat.succ n) → G
g : G
x : Fin (Nat.succ n + 1)
i : Fin (n + 1)
⊢ (fun f => Fin.insertNth 0 f.1 f.2)
      (g,
        Limits.BinaryFan.fst
            (Limits.BinaryFan.mk
              ((Limits.Types.binaryProductLimitCone
                          ((FunctorCategoryEquivalence.functor.obj (leftRegular G)).obj PUnit.unit)
                          ((FunctorCategoryEquivalence.functor.obj { V := Fin n → G, ρ := 1 }).obj
                            PUnit.unit)).cone.π.app
                  { as := Limits.WalkingPair.left } ≫
                (FunctorCategoryEquivalence.functor.obj (leftRegular G)).map g)
              ((Limits.Types.binaryProductLimitCone
                          ((FunctorCategoryEquivalence.functor.obj (leftRegular G)).obj PUnit.unit)
                          ((FunctorCategoryEquivalence.functor.obj { V := Fin n → G, ρ := 1 }).obj
                            PUnit.unit)).cone.π.app
                  { as := Limits.WalkingPair.right } ≫
                (FunctorCategoryEquivalence.functor.obj { V := Fin n → G, ρ := 1 }).map g))
            ((Equiv.piFinSuccAbove (fun x => G) 0) f) •
          partialProd
            (Limits.BinaryFan.snd
              (Limits.BinaryFan.mk
                ((Limits.Types.binaryProductLimitCone
                            ((FunctorCategoryEquivalence.functor.obj (leftRegular G)).obj PUnit.unit)
                            ((FunctorCategoryEquivalence.functor.obj { V := Fin n → G, ρ := 1 }).obj
                              PUnit.unit)).cone.π.app
                    { as := Limits.WalkingPair.left } ≫
                  (FunctorCategoryEquivalence.functor.obj (leftRegular G)).map g)
                ((Limits.Types.binaryProductLimitCone
                            ((FunctorCategoryEquivalence.functor.obj (leftRegular G)).obj PUnit.unit)
                            ((FunctorCategoryEquivalence.functor.obj { V := Fin n → G, ρ := 1 }).obj
                              PUnit.unit)).cone.π.app
                    { as := Limits.WalkingPair.right } ≫
                  (FunctorCategoryEquivalence.functor.obj { V := Fin n → G, ρ := 1 }).map g))
              ((Equiv.piFinSuccAbove (fun x => G) 0) f)))
      (Fin.succ i) =
    g * partialProd f (Fin.succ i)

Next tactic:
simp only [Fin.cons_succ, Pi.smul_apply, smul_eq_mul, Fin.partialProd_succ', ← mul_assoc]