Theorem: groupCohomology.resolution.actionDiagonalSucc_inv_apply
File: Mathlib/RepresentationTheory/GroupCohomology/Resolution.lean

tactic: revert g
state_before: k G✝ : Type u
inst✝² : CommRing k
n✝ : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
n : ℕ
g : G
f : Fin n → G
⊢ (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
state_after: k G✝ : Type u
inst✝² : CommRing k
n✝ : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
n : ℕ
f : Fin n → G
⊢ ∀ (g : G), (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f

tactic: induction' n with n hn
state_before: k G✝ : Type u
inst✝² : CommRing k
n✝ : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
n : ℕ
f : Fin n → G
⊢ ∀ (g : G), (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
state_after: case zero
k G✝ : Type u
inst✝² : CommRing k
n : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
f : Fin 0 → G
⊢ ∀ (g : G), (actionDiagonalSucc G 0).inv.hom (g, f) = g • partialProd f

case succ
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), (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
f : Fin (n + 1) → G
⊢ ∀ (g : G), (actionDiagonalSucc G (n + 1)).inv.hom (g, f) = g • partialProd f

tactic: intro g
state_before: case zero
k G✝ : Type u
inst✝² : CommRing k
n : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
f : Fin 0 → G
⊢ ∀ (g : G), (actionDiagonalSucc G 0).inv.hom (g, f) = g • partialProd f
state_after: case zero
k G✝ : Type u
inst✝² : CommRing k
n : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
f : Fin 0 → G
g : G
⊢ (actionDiagonalSucc G 0).inv.hom (g, f) = g • partialProd f

tactic: funext (x : Fin 1)
state_before: case zero
k G✝ : Type u
inst✝² : CommRing k
n : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
f : Fin 0 → G
g : G
⊢ (actionDiagonalSucc G 0).inv.hom (g, f) = g • partialProd f
state_after: case zero.h
k G✝ : Type u
inst✝² : CommRing k
n : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
f : Fin 0 → G
g : G
x : Fin 1
⊢ (actionDiagonalSucc G 0).inv.hom (g, f) x = (g • partialProd f) x

tactic: simp only [Subsingleton.elim x 0, Pi.smul_apply, Fin.partialProd_zero, smul_eq_mul, mul_one]
state_before: case zero.h
k G✝ : Type u
inst✝² : CommRing k
n : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
f : Fin 0 → G
g : G
x : Fin 1
⊢ (actionDiagonalSucc G 0).inv.hom (g, f) x = (g • partialProd f) x
state_after: case zero.h
k G✝ : Type u
inst✝² : CommRing k
n : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
f : Fin 0 → G
g : G
x : Fin 1
⊢ (actionDiagonalSucc G 0).inv.hom (g, f) 0 = g

tactic: rfl
state_before: case zero.h
k G✝ : Type u
inst✝² : CommRing k
n : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
f : Fin 0 → G
g : G
x : Fin 1
⊢ (actionDiagonalSucc G 0).inv.hom (g, f) 0 = g
state_after: no goals

tactic: intro g
state_before: case succ
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), (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
f : Fin (n + 1) → G
⊢ ∀ (g : G), (actionDiagonalSucc G (n + 1)).inv.hom (g, f) = g • partialProd f
state_after: case succ
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), (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
f : Fin (n + 1) → G
g : G
⊢ (actionDiagonalSucc G (n + 1)).inv.hom (g, f) = g • partialProd f

tactic: funext x
state_before: case succ
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), (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
f : Fin (n + 1) → G
g : G
⊢ (actionDiagonalSucc G (n + 1)).inv.hom (g, f) = g • partialProd f
state_after: case succ.h
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), (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
f : Fin (n + 1) → G
g : G
x : Fin (n + 1 + 1)
⊢ (actionDiagonalSucc G (n + 1)).inv.hom (g, f) x = (g • partialProd f) x

tactic: dsimp [actionDiagonalSucc]
state_before: case succ.h
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), (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
f : Fin (n + 1) → G
g : G
x : Fin (n + 1 + 1)
⊢ (actionDiagonalSucc G (n + 1)).inv.hom (g, f) x = (g • partialProd f) x
state_after: case succ.h
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), (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
f : Fin (n + 1) → G
g : G
x : Fin (n + 1 + 1)
⊢ (Equiv.piFinSuccAbove (fun a => G) 0).symm
      (g,
        (actionDiagonalSucc G n).inv.hom
          ((FunctorCategoryEquivalence.inverse.obj
                (FunctorCategoryEquivalence.functor.obj (leftRegular G) ⊗
                  FunctorCategoryEquivalence.functor.obj { V := Fin n → G, ρ := 1 })).ρ
            g ((Equiv.piFinSuccAbove (fun x => G) 0) f)))
      x =
    g * partialProd f x

tactic: erw [hn, Equiv.piFinSuccAbove_symm_apply]
state_before: case succ.h
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), (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
f : Fin (n + 1) → G
g : G
x : Fin (n + 1 + 1)
⊢ (Equiv.piFinSuccAbove (fun a => G) 0).symm
      (g,
        (actionDiagonalSucc G n).inv.hom
          ((FunctorCategoryEquivalence.inverse.obj
                (FunctorCategoryEquivalence.functor.obj (leftRegular G) ⊗
                  FunctorCategoryEquivalence.functor.obj { V := Fin n → G, ρ := 1 })).ρ
            g ((Equiv.piFinSuccAbove (fun x => G) 0) f)))
      x =
    g * partialProd f x
state_after: case succ.h
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), (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
f : Fin (n + 1) → G
g : G
x : Fin (n + 1 + 1)
⊢ (fun f => Fin.insertNth 0 f.1 f.2)
      (g,
        (Limits.BinaryFan.mk
                ((ChosenFiniteProducts.product ((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)
                ((ChosenFiniteProducts.product ((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)).fst
            ((Equiv.piFinSuccAbove (fun x => G) 0) f) •
          partialProd
            ((Limits.BinaryFan.mk
                  ((ChosenFiniteProducts.product
                              ((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)
                  ((ChosenFiniteProducts.product
                              ((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)).snd
              ((Equiv.piFinSuccAbove (fun x => G) 0) f)))
      x =
    g * partialProd f x

tactic: refine Fin.cases ?_ (fun i => ?_) x
state_before: case succ.h
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), (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
f : Fin (n + 1) → G
g : G
x : Fin (n + 1 + 1)
⊢ (fun f => Fin.insertNth 0 f.1 f.2)
      (g,
        (Limits.BinaryFan.mk
                ((ChosenFiniteProducts.product ((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)
                ((ChosenFiniteProducts.product ((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)).fst
            ((Equiv.piFinSuccAbove (fun x => G) 0) f) •
          partialProd
            ((Limits.BinaryFan.mk
                  ((ChosenFiniteProducts.product
                              ((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)
                  ((ChosenFiniteProducts.product
                              ((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)).snd
              ((Equiv.piFinSuccAbove (fun x => G) 0) f)))
      x =
    g * partialProd f x
state_after: case succ.h.refine_1
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), (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
f : Fin (n + 1) → G
g : G
x : Fin (n + 1 + 1)
⊢ (fun f => Fin.insertNth 0 f.1 f.2)
      (g,
        (Limits.BinaryFan.mk
                ((ChosenFiniteProducts.product ((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)
                ((ChosenFiniteProducts.product ((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)).fst
            ((Equiv.piFinSuccAbove (fun x => G) 0) f) •
          partialProd
            ((Limits.BinaryFan.mk
                  ((ChosenFiniteProducts.product
                              ((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)
                  ((ChosenFiniteProducts.product
                              ((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)).snd
              ((Equiv.piFinSuccAbove (fun x => G) 0) f)))
      0 =
    g * partialProd f 0

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), (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
f : Fin (n + 1) → G
g : G
x : Fin (n + 1 + 1)
i : Fin (n + 1)
⊢ (fun f => Fin.insertNth 0 f.1 f.2)
      (g,
        (Limits.BinaryFan.mk
                ((ChosenFiniteProducts.product ((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)
                ((ChosenFiniteProducts.product ((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)).fst
            ((Equiv.piFinSuccAbove (fun x => G) 0) f) •
          partialProd
            ((Limits.BinaryFan.mk
                  ((ChosenFiniteProducts.product
                              ((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)
                  ((ChosenFiniteProducts.product
                              ((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)).snd
              ((Equiv.piFinSuccAbove (fun x => G) 0) f)))
      i.succ =
    g * partialProd f i.succ

tactic: simp only [Fin.insertNth_zero, Fin.cons_zero, Fin.partialProd_zero, mul_one]
state_before: case succ.h.refine_1
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), (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
f : Fin (n + 1) → G
g : G
x : Fin (n + 1 + 1)
⊢ (fun f => Fin.insertNth 0 f.1 f.2)
      (g,
        (Limits.BinaryFan.mk
                ((ChosenFiniteProducts.product ((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)
                ((ChosenFiniteProducts.product ((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)).fst
            ((Equiv.piFinSuccAbove (fun x => G) 0) f) •
          partialProd
            ((Limits.BinaryFan.mk
                  ((ChosenFiniteProducts.product
                              ((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)
                  ((ChosenFiniteProducts.product
                              ((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)).snd
              ((Equiv.piFinSuccAbove (fun x => G) 0) f)))
      0 =
    g * partialProd f 0
state_after: no goals

tactic: simp only [Fin.cons_succ, Pi.smul_apply, smul_eq_mul, Fin.partialProd_succ', ← mul_assoc]
state_before: 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), (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
f : Fin (n + 1) → G
g : G
x : Fin (n + 1 + 1)
i : Fin (n + 1)
⊢ (fun f => Fin.insertNth 0 f.1 f.2)
      (g,
        (Limits.BinaryFan.mk
                ((ChosenFiniteProducts.product ((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)
                ((ChosenFiniteProducts.product ((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)).fst
            ((Equiv.piFinSuccAbove (fun x => G) 0) f) •
          partialProd
            ((Limits.BinaryFan.mk
                  ((ChosenFiniteProducts.product
                              ((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)
                  ((ChosenFiniteProducts.product
                              ((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)).snd
              ((Equiv.piFinSuccAbove (fun x => G) 0) f)))
      i.succ =
    g * partialProd f i.succ
state_after: 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), (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
f : Fin (n + 1) → G
g : G
x : Fin (n + 1 + 1)
i : Fin (n + 1)
⊢ Fin.insertNth 0 g
      ((Limits.BinaryFan.mk
              ((ChosenFiniteProducts.product ((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)
              ((ChosenFiniteProducts.product ((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)).fst
          ((Equiv.piFinSuccAbove (fun x => G) 0) f) •
        partialProd
          ((Limits.BinaryFan.mk
                ((ChosenFiniteProducts.product ((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)
                ((ChosenFiniteProducts.product ((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)).snd
            ((Equiv.piFinSuccAbove (fun x => G) 0) f)))
      i.succ =
    g * f 0 * partialProd (Fin.tail f) i

tactic: rfl
state_before: 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), (actionDiagonalSucc G n).inv.hom (g, f) = g • partialProd f
f : Fin (n + 1) → G
g : G
x : Fin (n + 1 + 1)
i : Fin (n + 1)
⊢ Fin.insertNth 0 g
      ((Limits.BinaryFan.mk
              ((ChosenFiniteProducts.product ((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)
              ((ChosenFiniteProducts.product ((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)).fst
          ((Equiv.piFinSuccAbove (fun x => G) 0) f) •
        partialProd
          ((Limits.BinaryFan.mk
                ((ChosenFiniteProducts.product ((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)
                ((ChosenFiniteProducts.product ((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)).snd
            ((Equiv.piFinSuccAbove (fun x => G) 0) f)))
      i.succ =
    g * f 0 * partialProd (Fin.tail f) i
state_after: no goals