l3lab/ntp-mathlib huggingface dataset:
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
  

Proof state:
k G✝ : Type u
inst✝² : CommRing k
n✝ : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
n : ℕ
g : G
f : Fin n → G
⊢ Hom.hom (actionDiagonalSucc G n).inv (g, f) = g • partialProd f

Next tactic:
revert g
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
  

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

Next tactic:
induction' n with n hn
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
  · 

Proof state:
case zero
k G✝ : Type u
inst✝² : CommRing k
n : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
f : Fin Nat.zero → G
⊢ ∀ (g : G), Hom.hom (actionDiagonalSucc G Nat.zero).inv (g, f) = g • partialProd f

Next tactic:
intro g
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
    

Proof state:
case zero
k G✝ : Type u
inst✝² : CommRing k
n : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
f : Fin Nat.zero → G
g : G
⊢ Hom.hom (actionDiagonalSucc G Nat.zero).inv (g, f) = g • partialProd f

Next tactic:
funext (x : Fin 1)
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)
    

Proof state:
case zero.h
k G✝ : Type u
inst✝² : CommRing k
n : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
f : Fin Nat.zero → G
g : G
x : Fin 1
⊢ Hom.hom (actionDiagonalSucc G Nat.zero).inv (g, f) x = (g • partialProd f) x

Next tactic:
simp only [Subsingleton.elim x 0, Pi.smul_apply, Fin.partialProd_zero, smul_eq_mul, mul_one]
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]
    

Proof state:
case zero.h
k G✝ : Type u
inst✝² : CommRing k
n : ℕ
inst✝¹ : Group G✝
G : Type u
inst✝ : Group G
f : Fin Nat.zero → G
g : G
x : Fin 1
⊢ Hom.hom (actionDiagonalSucc G Nat.zero).inv (g, f) 0 = g

Next tactic:
rfl
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
  · 

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

Next tactic:
intro g
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] -/
    

Proof state:
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), Hom.hom (actionDiagonalSucc G n).inv (g, f) = g • partialProd f
f : Fin (Nat.succ n) → G
g : G
⊢ Hom.hom (actionDiagonalSucc G (Nat.succ n)).inv (g, f) = g • partialProd f

Next tactic:
funext x
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
    

Proof state:
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), 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)
⊢ Hom.hom (actionDiagonalSucc G (Nat.succ n)).inv (g, f) x = (g • partialProd f) x

Next tactic:
dsimp [actionDiagonalSucc]
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]
    

Proof state:
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), 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)
⊢ (Equiv.piFinSuccAbove (fun a => G) 0).symm
      (g,
        Hom.hom (actionDiagonalSucc G n).inv
          ((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

Next tactic:
erw [hn, Equiv.piFinSuccAbove_symm_apply]
theorem diagonalSucc_hom_single (f : Gⁿ⁺¹) (a : k) :
    (diagonalSucc k G n).hom.hom (single f a) =
      single (f 0) 1 ⊗ₜ single (fun i => (f (Fin.castSucc i))⁻¹ * f i.succ) a := by
/- Porting note: broken proof was
  dsimp only [diagonalSucc]
  simpa only [Iso.trans_hom, Iso.symm_hom, Action.comp_hom, ModuleCat.comp_def,
    LinearMap.comp_apply, Functor.mapIso_hom,
    linearization_map_hom_single (actionDiagonalSucc G n).hom f a, asIso_inv,
    linearization_μ_inv_hom, actionDiagonalSucc_hom_apply, finsuppTensorFinsupp',
    LinearEquiv.trans_symm, lcongr_symm, LinearEquiv.trans_apply, lcongr_single,
    TensorProduct.lid_symm_apply, finsuppTensorFinsupp_symm_single, LinearEquiv.coe_toLinearMap] -/
  

Proof state:
k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
f : Fin (n + 1) → G
a : k
⊢ ((diagonalSucc k G n).hom.hom fun₀ | f => a) =
    (fun₀ | f 0 => 1) ⊗ₜ[k] fun₀ | fun i => (f (Fin.castSucc i))⁻¹ * f (Fin.succ i) => a

Next tactic:
change (𝟙 ((linearization k G).1.obj (Action.leftRegular G)).V
      ⊗ (linearizationTrivialIso k G (Fin n → G)).hom.hom)
    ((inv ((linearization k G).μ (Action.leftRegular G) { V := Fin n → G, ρ := 1 })).hom
      ((lmapDomain k k (actionDiagonalSucc G n).hom.hom) (single f a))) = _
theorem diagonalSucc_hom_single (f : Gⁿ⁺¹) (a : k) :
    (diagonalSucc k G n).hom.hom (single f a) =
      single (f 0) 1 ⊗ₜ single (fun i => (f (Fin.castSucc i))⁻¹ * f i.succ) a := by
/- Porting note: broken proof was
  dsimp only [diagonalSucc]
  simpa only [Iso.trans_hom, Iso.symm_hom, Action.comp_hom, ModuleCat.comp_def,
    LinearMap.comp_apply, Functor.mapIso_hom,
    linearization_map_hom_single (actionDiagonalSucc G n).hom f a, asIso_inv,
    linearization_μ_inv_hom, actionDiagonalSucc_hom_apply, finsuppTensorFinsupp',
    LinearEquiv.trans_symm, lcongr_symm, LinearEquiv.trans_apply, lcongr_single,
    TensorProduct.lid_symm_apply, finsuppTensorFinsupp_symm_single, LinearEquiv.coe_toLinearMap] -/
  change (𝟙 ((linearization k G).1.obj (Action.leftRegular G)).V
      ⊗ (linearizationTrivialIso k G (Fin n → G)).hom.hom)
    ((inv ((linearization k G).μ (Action.leftRegular G) { V := Fin n → G, ρ := 1 })).hom
      ((lmapDomain k k (actionDiagonalSucc G n).hom.hom) (single f a))) = _
  

Proof state:
k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
f : Fin (n + 1) → G
a : k
⊢ (𝟙 ((linearization k G).toLaxMonoidalFunctor.toFunctor.obj (Action.leftRegular G)).V ⊗
        (linearizationTrivialIso k G (Fin n → G)).hom.hom)
      ((inv
            (LaxMonoidalFunctor.μ (linearization k G).toLaxMonoidalFunctor (Action.leftRegular G)
              { V := Fin n → G, ρ := 1 })).hom
        ((lmapDomain k k (actionDiagonalSucc G n).hom.hom) fun₀ | f => a)) =
    (fun₀ | f 0 => 1) ⊗ₜ[k] fun₀ | fun i => (f (Fin.castSucc i))⁻¹ * f (Fin.succ i) => a

Next tactic:
simp only [CategoryTheory.Functor.map_id, linearization_μ_inv_hom]
theorem diagonalSucc_hom_single (f : Gⁿ⁺¹) (a : k) :
    (diagonalSucc k G n).hom.hom (single f a) =
      single (f 0) 1 ⊗ₜ single (fun i => (f (Fin.castSucc i))⁻¹ * f i.succ) a := by
/- Porting note: broken proof was
  dsimp only [diagonalSucc]
  simpa only [Iso.trans_hom, Iso.symm_hom, Action.comp_hom, ModuleCat.comp_def,
    LinearMap.comp_apply, Functor.mapIso_hom,
    linearization_map_hom_single (actionDiagonalSucc G n).hom f a, asIso_inv,
    linearization_μ_inv_hom, actionDiagonalSucc_hom_apply, finsuppTensorFinsupp',
    LinearEquiv.trans_symm, lcongr_symm, LinearEquiv.trans_apply, lcongr_single,
    TensorProduct.lid_symm_apply, finsuppTensorFinsupp_symm_single, LinearEquiv.coe_toLinearMap] -/
  change (𝟙 ((linearization k G).1.obj (Action.leftRegular G)).V
      ⊗ (linearizationTrivialIso k G (Fin n → G)).hom.hom)
    ((inv ((linearization k G).μ (Action.leftRegular G) { V := Fin n → G, ρ := 1 })).hom
      ((lmapDomain k k (actionDiagonalSucc G n).hom.hom) (single f a))) = _
  simp only [CategoryTheory.Functor.map_id, linearization_μ_inv_hom]
  -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
  

Proof state:
k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
f : Fin (n + 1) → G
a : k
⊢ (𝟙 ((linearization k G).toLaxMonoidalFunctor.toFunctor.obj (Action.leftRegular G)).V ⊗
        (linearizationTrivialIso k G (Fin n → G)).hom.hom)
      (↑(LinearEquiv.symm (finsuppTensorFinsupp' k (Action.leftRegular G).V (Fin n → G)))
        ((lmapDomain k k (actionDiagonalSucc G n).hom.hom) fun₀ | f => a)) =
    (fun₀ | f 0 => 1) ⊗ₜ[k] fun₀ | fun i => (f (Fin.castSucc i))⁻¹ * f (Fin.succ i) => a

Next tactic:
erw [lmapDomain_apply, mapDomain_single, LinearEquiv.coe_toLinearMap, finsuppTensorFinsupp',
    LinearEquiv.trans_symm, LinearEquiv.trans_apply, lcongr_symm, Equiv.refl_symm]
theorem diagonalSucc_hom_single (f : Gⁿ⁺¹) (a : k) :
    (diagonalSucc k G n).hom.hom (single f a) =
      single (f 0) 1 ⊗ₜ single (fun i => (f (Fin.castSucc i))⁻¹ * f i.succ) a := by
/- Porting note: broken proof was
  dsimp only [diagonalSucc]
  simpa only [Iso.trans_hom, Iso.symm_hom, Action.comp_hom, ModuleCat.comp_def,
    LinearMap.comp_apply, Functor.mapIso_hom,
    linearization_map_hom_single (actionDiagonalSucc G n).hom f a, asIso_inv,
    linearization_μ_inv_hom, actionDiagonalSucc_hom_apply, finsuppTensorFinsupp',
    LinearEquiv.trans_symm, lcongr_symm, LinearEquiv.trans_apply, lcongr_single,
    TensorProduct.lid_symm_apply, finsuppTensorFinsupp_symm_single, LinearEquiv.coe_toLinearMap] -/
  change (𝟙 ((linearization k G).1.obj (Action.leftRegular G)).V
      ⊗ (linearizationTrivialIso k G (Fin n → G)).hom.hom)
    ((inv ((linearization k G).μ (Action.leftRegular G) { V := Fin n → G, ρ := 1 })).hom
      ((lmapDomain k k (actionDiagonalSucc G n).hom.hom) (single f a))) = _
  simp only [CategoryTheory.Functor.map_id, linearization_μ_inv_hom]
  -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
  erw [lmapDomain_apply, mapDomain_single, LinearEquiv.coe_toLinearMap, finsuppTensorFinsupp',
    LinearEquiv.trans_symm, LinearEquiv.trans_apply, lcongr_symm, Equiv.refl_symm]
  

Proof state:
k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
f : Fin (n + 1) → G
a : k
⊢ (𝟙 ((linearization k G).toLaxMonoidalFunctor.toFunctor.obj (Action.leftRegular G)).V ⊗
        (linearizationTrivialIso k G (Fin n → G)).hom.hom)
      ((LinearEquiv.symm (finsuppTensorFinsupp k k k (Action.leftRegular G).V (Fin n → G)))
        ((lcongr (Equiv.refl ((Action.leftRegular G).V × (Fin n → G))) (LinearEquiv.symm (TensorProduct.lid k k)))
          fun₀ | Action.Hom.hom (actionDiagonalSucc G n).hom f => a)) =
    (fun₀ | f 0 => 1) ⊗ₜ[k] fun₀ | fun i => (f (Fin.castSucc i))⁻¹ * f (Fin.succ i) => a

Next tactic:
erw [lcongr_single]
theorem diagonalSucc_hom_single (f : Gⁿ⁺¹) (a : k) :
    (diagonalSucc k G n).hom.hom (single f a) =
      single (f 0) 1 ⊗ₜ single (fun i => (f (Fin.castSucc i))⁻¹ * f i.succ) a := by
/- Porting note: broken proof was
  dsimp only [diagonalSucc]
  simpa only [Iso.trans_hom, Iso.symm_hom, Action.comp_hom, ModuleCat.comp_def,
    LinearMap.comp_apply, Functor.mapIso_hom,
    linearization_map_hom_single (actionDiagonalSucc G n).hom f a, asIso_inv,
    linearization_μ_inv_hom, actionDiagonalSucc_hom_apply, finsuppTensorFinsupp',
    LinearEquiv.trans_symm, lcongr_symm, LinearEquiv.trans_apply, lcongr_single,
    TensorProduct.lid_symm_apply, finsuppTensorFinsupp_symm_single, LinearEquiv.coe_toLinearMap] -/
  change (𝟙 ((linearization k G).1.obj (Action.leftRegular G)).V
      ⊗ (linearizationTrivialIso k G (Fin n → G)).hom.hom)
    ((inv ((linearization k G).μ (Action.leftRegular G) { V := Fin n → G, ρ := 1 })).hom
      ((lmapDomain k k (actionDiagonalSucc G n).hom.hom) (single f a))) = _
  simp only [CategoryTheory.Functor.map_id, linearization_μ_inv_hom]
  -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
  erw [lmapDomain_apply, mapDomain_single, LinearEquiv.coe_toLinearMap, finsuppTensorFinsupp',
    LinearEquiv.trans_symm, LinearEquiv.trans_apply, lcongr_symm, Equiv.refl_symm]
  erw [lcongr_single]
  

Proof state:
k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
f : Fin (n + 1) → G
a : k
⊢ (𝟙 ((linearization k G).toLaxMonoidalFunctor.toFunctor.obj (Action.leftRegular G)).V ⊗
        (linearizationTrivialIso k G (Fin n → G)).hom.hom)
      ((LinearEquiv.symm (finsuppTensorFinsupp k k k (Action.leftRegular G).V (Fin n → G)))
        fun₀
        | (Equiv.refl ((Action.leftRegular G).V × (Fin n → G))) (Action.Hom.hom (actionDiagonalSucc G n).hom f) =>
            (LinearEquiv.symm (TensorProduct.lid k k)) a) =
    (fun₀ | f 0 => 1) ⊗ₜ[k] fun₀ | fun i => (f (Fin.castSucc i))⁻¹ * f (Fin.succ i) => a

Next tactic:
rw [TensorProduct.lid_symm_apply, actionDiagonalSucc_hom_apply, finsuppTensorFinsupp_symm_single]
theorem diagonalSucc_hom_single (f : Gⁿ⁺¹) (a : k) :
    (diagonalSucc k G n).hom.hom (single f a) =
      single (f 0) 1 ⊗ₜ single (fun i => (f (Fin.castSucc i))⁻¹ * f i.succ) a := by
/- Porting note: broken proof was
  dsimp only [diagonalSucc]
  simpa only [Iso.trans_hom, Iso.symm_hom, Action.comp_hom, ModuleCat.comp_def,
    LinearMap.comp_apply, Functor.mapIso_hom,
    linearization_map_hom_single (actionDiagonalSucc G n).hom f a, asIso_inv,
    linearization_μ_inv_hom, actionDiagonalSucc_hom_apply, finsuppTensorFinsupp',
    LinearEquiv.trans_symm, lcongr_symm, LinearEquiv.trans_apply, lcongr_single,
    TensorProduct.lid_symm_apply, finsuppTensorFinsupp_symm_single, LinearEquiv.coe_toLinearMap] -/
  change (𝟙 ((linearization k G).1.obj (Action.leftRegular G)).V
      ⊗ (linearizationTrivialIso k G (Fin n → G)).hom.hom)
    ((inv ((linearization k G).μ (Action.leftRegular G) { V := Fin n → G, ρ := 1 })).hom
      ((lmapDomain k k (actionDiagonalSucc G n).hom.hom) (single f a))) = _
  simp only [CategoryTheory.Functor.map_id, linearization_μ_inv_hom]
  -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
  erw [lmapDomain_apply, mapDomain_single, LinearEquiv.coe_toLinearMap, finsuppTensorFinsupp',
    LinearEquiv.trans_symm, LinearEquiv.trans_apply, lcongr_symm, Equiv.refl_symm]
  erw [lcongr_single]
  rw [TensorProduct.lid_symm_apply, actionDiagonalSucc_hom_apply, finsuppTensorFinsupp_symm_single]
  

Proof state:
k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
f : Fin (n + 1) → G
a : k
⊢ (𝟙 ((linearization k G).toLaxMonoidalFunctor.toFunctor.obj (Action.leftRegular G)).V ⊗
        (linearizationTrivialIso k G (Fin n → G)).hom.hom)
      ((fun₀
          |
            ((Equiv.refl ((Action.leftRegular G).V × (Fin n → G)))
                  (f 0, fun i => (f (Fin.castSucc i))⁻¹ * f (Fin.succ i))).1 =>
              1) ⊗ₜ[k]
        fun₀
        |
          ((Equiv.refl ((Action.leftRegular G).V × (Fin n → G)))
                (f 0, fun i => (f (Fin.castSucc i))⁻¹ * f (Fin.succ i))).2 =>
            a) =
    (fun₀ | f 0 => 1) ⊗ₜ[k] fun₀ | fun i => (f (Fin.castSucc i))⁻¹ * f (Fin.succ i) => a

Next tactic:
rfl
theorem diagonalSucc_inv_single_single (g : G) (f : Gⁿ) (a b : k) :
    (diagonalSucc k G n).inv.hom (Finsupp.single g a ⊗ₜ Finsupp.single f b) =
      single (g • partialProd f) (a * b) := by
/- Porting note: broken proof was
  dsimp only [diagonalSucc]
  simp only [Iso.trans_inv, Iso.symm_inv, Iso.refl_inv, tensorIso_inv, Action.tensorHom,
    Action.comp_hom, ModuleCat.comp_def, LinearMap.comp_apply, asIso_hom, Functor.mapIso_inv,
    ModuleCat.MonoidalCategory.hom_apply, linearizationTrivialIso_inv_hom_apply,
    linearization_μ_hom, Action.id_hom ((linearization k G).obj _), actionDiagonalSucc_inv_apply,
    ModuleCat.id_apply, LinearEquiv.coe_toLinearMap,
    finsuppTensorFinsupp'_single_tmul_single k (Action.leftRegular G).V,
    linearization_map_hom_single (actionDiagonalSucc G n).inv (g, f) (a * b)] -/
  

Proof state:
k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
g : G
f : Fin n → G
a b : k
⊢ (diagonalSucc k G n).inv.hom ((fun₀ | g => a) ⊗ₜ[k] fun₀ | f => b) = fun₀ | g • partialProd f => a * b

Next tactic:
change mapDomain (actionDiagonalSucc G n).inv.hom
    (lcongr (Equiv.refl (G × (Fin n → G))) (TensorProduct.lid k k)
      (finsuppTensorFinsupp k k k G (Fin n → G) (single g a ⊗ₜ[k] single f b)))
    = single (g • partialProd f) (a * b)
theorem diagonalSucc_inv_single_single (g : G) (f : Gⁿ) (a b : k) :
    (diagonalSucc k G n).inv.hom (Finsupp.single g a ⊗ₜ Finsupp.single f b) =
      single (g • partialProd f) (a * b) := by
/- Porting note: broken proof was
  dsimp only [diagonalSucc]
  simp only [Iso.trans_inv, Iso.symm_inv, Iso.refl_inv, tensorIso_inv, Action.tensorHom,
    Action.comp_hom, ModuleCat.comp_def, LinearMap.comp_apply, asIso_hom, Functor.mapIso_inv,
    ModuleCat.MonoidalCategory.hom_apply, linearizationTrivialIso_inv_hom_apply,
    linearization_μ_hom, Action.id_hom ((linearization k G).obj _), actionDiagonalSucc_inv_apply,
    ModuleCat.id_apply, LinearEquiv.coe_toLinearMap,
    finsuppTensorFinsupp'_single_tmul_single k (Action.leftRegular G).V,
    linearization_map_hom_single (actionDiagonalSucc G n).inv (g, f) (a * b)] -/
  change mapDomain (actionDiagonalSucc G n).inv.hom
    (lcongr (Equiv.refl (G × (Fin n → G))) (TensorProduct.lid k k)
      (finsuppTensorFinsupp k k k G (Fin n → G) (single g a ⊗ₜ[k] single f b)))
    = single (g • partialProd f) (a * b)
  

Proof state:
k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
g : G
f : Fin n → G
a b : k
⊢ mapDomain (actionDiagonalSucc G n).inv.hom
      ((lcongr (Equiv.refl (G × (Fin n → G))) (TensorProduct.lid k k))
        ((finsuppTensorFinsupp k k k G (Fin n → G)) ((fun₀ | g => a) ⊗ₜ[k] fun₀ | f => b))) =
    fun₀ | g • partialProd f => a * b

Next tactic:
rw [finsuppTensorFinsupp_single, lcongr_single, mapDomain_single, Equiv.refl_apply,
    actionDiagonalSucc_inv_apply]
theorem diagonalSucc_inv_single_single (g : G) (f : Gⁿ) (a b : k) :
    (diagonalSucc k G n).inv.hom (Finsupp.single g a ⊗ₜ Finsupp.single f b) =
      single (g • partialProd f) (a * b) := by
/- Porting note: broken proof was
  dsimp only [diagonalSucc]
  simp only [Iso.trans_inv, Iso.symm_inv, Iso.refl_inv, tensorIso_inv, Action.tensorHom,
    Action.comp_hom, ModuleCat.comp_def, LinearMap.comp_apply, asIso_hom, Functor.mapIso_inv,
    ModuleCat.MonoidalCategory.hom_apply, linearizationTrivialIso_inv_hom_apply,
    linearization_μ_hom, Action.id_hom ((linearization k G).obj _), actionDiagonalSucc_inv_apply,
    ModuleCat.id_apply, LinearEquiv.coe_toLinearMap,
    finsuppTensorFinsupp'_single_tmul_single k (Action.leftRegular G).V,
    linearization_map_hom_single (actionDiagonalSucc G n).inv (g, f) (a * b)] -/
  change mapDomain (actionDiagonalSucc G n).inv.hom
    (lcongr (Equiv.refl (G × (Fin n → G))) (TensorProduct.lid k k)
      (finsuppTensorFinsupp k k k G (Fin n → G) (single g a ⊗ₜ[k] single f b)))
    = single (g • partialProd f) (a * b)
  rw [finsuppTensorFinsupp_single, lcongr_single, mapDomain_single, Equiv.refl_apply,
    actionDiagonalSucc_inv_apply]
  

Proof state:
k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
g : G
f : Fin n → G
a b : k
⊢ (fun₀ | g • partialProd f => (TensorProduct.lid k k) (a ⊗ₜ[k] b)) = fun₀ | g • partialProd f => a * b

Next tactic:
rfl
theorem diagonalSucc_inv_single_left (g : G) (f : Gⁿ →₀ k) (r : k) :
    (diagonalSucc k G n).inv.hom (Finsupp.single g r ⊗ₜ f) =
      Finsupp.lift (Gⁿ⁺¹ →₀ k) k Gⁿ (fun f => single (g • partialProd f) r) f := by
  

Proof state:
k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
g : G
f : (Fin n → G) →₀ k
r : k
⊢ (diagonalSucc k G n).inv.hom ((fun₀ | g => r) ⊗ₜ[k] f) =
    ((Finsupp.lift ((Fin (n + 1) → G) →₀ k) k (Fin n → G)) fun f => fun₀ | g • partialProd f => r) f

Next tactic:
refine' f.induction _ _