l3lab/ntp-mathlib huggingface dataset:
/-- The natural transformation which gives the augmentation of the alternating face map
complex attached to an augmented simplicial object. -/
def ε [Limits.HasZeroObject C] :
    SimplicialObject.Augmented.drop ⋙ AlgebraicTopology.alternatingFaceMapComplex C ⟶
      SimplicialObject.Augmented.point ⋙ ChainComplex.single₀ C where
  app X := by
    refine' (ChainComplex.toSingle₀Equiv _ _).symm _
    refine' ⟨X.hom.app (op [0]), _⟩
    dsimp
    rw [alternatingFaceMapComplex_obj_d, objD, Fin.sum_univ_two, Fin.val_zero,
      pow_zero, one_smul, Fin.val_one, pow_one, neg_smul, one_smul, add_comp,
      neg_comp, SimplicialObject.δ_naturality, SimplicialObject.δ_naturality]
    apply add_right_neg
  naturality X Y f := by
    apply HomologicalComplex.to_single_hom_ext
    

Proof state:
case hfg
C : Type u_1
inst✝² : Category.{?u.196418, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasZeroObject C
X Y : SimplicialObject.Augmented C
f : X ⟶ Y
⊢ HomologicalComplex.Hom.f
      ((SimplicialObject.Augmented.drop ⋙ alternatingFaceMapComplex C).map f ≫
        (fun X =>
            (ChainComplex.toSingle₀Equiv ((SimplicialObject.Augmented.drop ⋙ alternatingFaceMapComplex C).obj X)
                  (SimplicialObject.Augmented.point.obj X)).symm
              { val := X.hom.app (op [0]),
                property :=
                  (_ :
                    HomologicalComplex.d ((SimplicialObject.Augmented.drop ⋙ alternatingFaceMapComplex C).obj X) 1 0 ≫
                        X.hom.app (op [0]) =
                      0) })
          Y)
      0 =
    HomologicalComplex.Hom.f
      ((fun X =>
            (ChainComplex.toSingle₀Equiv ((SimplicialObject.Augmented.drop ⋙ alternatingFaceMapComplex C).obj X)
                  (SimplicialObject.Augmented.point.obj X)).symm
              { val := X.hom.app (op [0]),
                property :=
                  (_ :
                    HomologicalComplex.d ((SimplicialObject.Augmented.drop ⋙ alternatingFaceMapComplex C).obj X) 1 0 ≫
                        X.hom.app (op [0]) =
                      0) })
          X ≫
        (SimplicialObject.Augmented.point ⋙ ChainComplex.single₀ C).map f)
      0

Next tactic:
dsimp
/-- The natural transformation which gives the augmentation of the alternating face map
complex attached to an augmented simplicial object. -/
def ε [Limits.HasZeroObject C] :
    SimplicialObject.Augmented.drop ⋙ AlgebraicTopology.alternatingFaceMapComplex C ⟶
      SimplicialObject.Augmented.point ⋙ ChainComplex.single₀ C where
  app X := by
    refine' (ChainComplex.toSingle₀Equiv _ _).symm _
    refine' ⟨X.hom.app (op [0]), _⟩
    dsimp
    rw [alternatingFaceMapComplex_obj_d, objD, Fin.sum_univ_two, Fin.val_zero,
      pow_zero, one_smul, Fin.val_one, pow_one, neg_smul, one_smul, add_comp,
      neg_comp, SimplicialObject.δ_naturality, SimplicialObject.δ_naturality]
    apply add_right_neg
  naturality X Y f := by
    apply HomologicalComplex.to_single_hom_ext
    dsimp
    

Proof state:
case hfg
C : Type u_1
inst✝² : Category.{?u.196418, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasZeroObject C
X Y : SimplicialObject.Augmented C
f : X ⟶ Y
⊢ f.left.app (op [0]) ≫
      HomologicalComplex.Hom.f
        ((ChainComplex.toSingle₀Equiv ((alternatingFaceMapComplex C).obj Y.left) Y.right).symm
          { val := Y.hom.app (op [0]),
            property :=
              (_ : HomologicalComplex.d ((alternatingFaceMapComplex C).obj Y.left) 1 0 ≫ Y.hom.app (op [0]) = 0) })
        0 =
    HomologicalComplex.Hom.f
        ((ChainComplex.toSingle₀Equiv ((alternatingFaceMapComplex C).obj X.left) X.right).symm
          { val := X.hom.app (op [0]),
            property :=
              (_ : HomologicalComplex.d ((alternatingFaceMapComplex C).obj X.left) 1 0 ≫ X.hom.app (op [0]) = 0) })
        0 ≫
      HomologicalComplex.Hom.f ((ChainComplex.single₀ C).map f.right) 0

Next tactic:
erw [ChainComplex.toSingle₀Equiv_symm_apply_f_zero,
      ChainComplex.toSingle₀Equiv_symm_apply_f_zero]
/-- The natural transformation which gives the augmentation of the alternating face map
complex attached to an augmented simplicial object. -/
def ε [Limits.HasZeroObject C] :
    SimplicialObject.Augmented.drop ⋙ AlgebraicTopology.alternatingFaceMapComplex C ⟶
      SimplicialObject.Augmented.point ⋙ ChainComplex.single₀ C where
  app X := by
    refine' (ChainComplex.toSingle₀Equiv _ _).symm _
    refine' ⟨X.hom.app (op [0]), _⟩
    dsimp
    rw [alternatingFaceMapComplex_obj_d, objD, Fin.sum_univ_two, Fin.val_zero,
      pow_zero, one_smul, Fin.val_one, pow_one, neg_smul, one_smul, add_comp,
      neg_comp, SimplicialObject.δ_naturality, SimplicialObject.δ_naturality]
    apply add_right_neg
  naturality X Y f := by
    apply HomologicalComplex.to_single_hom_ext
    dsimp
    erw [ChainComplex.toSingle₀Equiv_symm_apply_f_zero,
      ChainComplex.toSingle₀Equiv_symm_apply_f_zero]
    

Proof state:
case hfg
C : Type u_1
inst✝² : Category.{?u.196418, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasZeroObject C
X Y : SimplicialObject.Augmented C
f : X ⟶ Y
⊢ f.left.app (op [0]) ≫ Y.hom.app (op [0]) =
    X.hom.app (op [0]) ≫ HomologicalComplex.Hom.f ((ChainComplex.single₀ C).map f.right) 0

Next tactic:
simp only [ChainComplex.single₀_map_f_zero]
/-- The natural transformation which gives the augmentation of the alternating face map
complex attached to an augmented simplicial object. -/
def ε [Limits.HasZeroObject C] :
    SimplicialObject.Augmented.drop ⋙ AlgebraicTopology.alternatingFaceMapComplex C ⟶
      SimplicialObject.Augmented.point ⋙ ChainComplex.single₀ C where
  app X := by
    refine' (ChainComplex.toSingle₀Equiv _ _).symm _
    refine' ⟨X.hom.app (op [0]), _⟩
    dsimp
    rw [alternatingFaceMapComplex_obj_d, objD, Fin.sum_univ_two, Fin.val_zero,
      pow_zero, one_smul, Fin.val_one, pow_one, neg_smul, one_smul, add_comp,
      neg_comp, SimplicialObject.δ_naturality, SimplicialObject.δ_naturality]
    apply add_right_neg
  naturality X Y f := by
    apply HomologicalComplex.to_single_hom_ext
    dsimp
    erw [ChainComplex.toSingle₀Equiv_symm_apply_f_zero,
      ChainComplex.toSingle₀Equiv_symm_apply_f_zero]
    simp only [ChainComplex.single₀_map_f_zero]
    

Proof state:
case hfg
C : Type u_1
inst✝² : Category.{?u.196418, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasZeroObject C
X Y : SimplicialObject.Augmented C
f : X ⟶ Y
⊢ f.left.app (op [0]) ≫ Y.hom.app (op [0]) = X.hom.app (op [0]) ≫ f.right

Next tactic:
exact congr_app f.w _
/-- The inclusion map of the Moore complex in the alternating face map complex -/
def inclusionOfMooreComplexMap (X : SimplicialObject A) :
    (normalizedMooreComplex A).obj X ⟶ (alternatingFaceMapComplex A).obj X := by
  

Proof state:
C : Type u_1
inst✝³ : Category.{?u.242416, u_1} C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category.{?u.242438, u_2} A
inst✝ : Abelian A
X : SimplicialObject A
⊢ (normalizedMooreComplex A).obj X ⟶ (alternatingFaceMapComplex A).obj X

Next tactic:
dsimp only [normalizedMooreComplex, NormalizedMooreComplex.obj,
    alternatingFaceMapComplex, AlternatingFaceMapComplex.obj]
/-- The inclusion map of the Moore complex in the alternating face map complex -/
def inclusionOfMooreComplexMap (X : SimplicialObject A) :
    (normalizedMooreComplex A).obj X ⟶ (alternatingFaceMapComplex A).obj X := by
  dsimp only [normalizedMooreComplex, NormalizedMooreComplex.obj,
    alternatingFaceMapComplex, AlternatingFaceMapComplex.obj]
  

Proof state:
C : Type u_1
inst✝³ : Category.{?u.242416, u_1} C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category.{?u.242438, u_2} A
inst✝ : Abelian A
X : SimplicialObject A
⊢ ChainComplex.of (fun n => underlying.obj (NormalizedMooreComplex.objX X n)) (NormalizedMooreComplex.objD X)
      (_ : ∀ (n : ℕ), NormalizedMooreComplex.objD X (n + 1) ≫ NormalizedMooreComplex.objD X n = 0) ⟶
    ChainComplex.of (fun n => X.obj (op [n])) (AlternatingFaceMapComplex.objD X)
      (_ : ∀ (n : ℕ), AlternatingFaceMapComplex.objD X (n + 1) ≫ AlternatingFaceMapComplex.objD X n = 0)

Next tactic:
apply ChainComplex.ofHom _ _ _ _ _ _ (fun n => (NormalizedMooreComplex.objX X n).arrow)
/-- The inclusion map of the Moore complex in the alternating face map complex -/
def inclusionOfMooreComplexMap (X : SimplicialObject A) :
    (normalizedMooreComplex A).obj X ⟶ (alternatingFaceMapComplex A).obj X := by
  dsimp only [normalizedMooreComplex, NormalizedMooreComplex.obj,
    alternatingFaceMapComplex, AlternatingFaceMapComplex.obj]
  apply ChainComplex.ofHom _ _ _ _ _ _ (fun n => (NormalizedMooreComplex.objX X n).arrow)
  /- we have to show the compatibility of the differentials on the alternating
           face map complex with those defined on the normalized Moore complex:
           we first get rid of the terms of the alternating sum that are obviously
           zero on the normalized_Moore_complex -/
  

Proof state:
C : Type u_1
inst✝³ : Category.{?u.242416, u_1} C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category.{?u.242438, u_2} A
inst✝ : Abelian A
X : SimplicialObject A
⊢ ∀ (i : ℕ),
    arrow (NormalizedMooreComplex.objX X (i + 1)) ≫ AlternatingFaceMapComplex.objD X i =
      NormalizedMooreComplex.objD X i ≫ arrow (NormalizedMooreComplex.objX X i)

Next tactic:
intro i
/-- The inclusion map of the Moore complex in the alternating face map complex -/
def inclusionOfMooreComplexMap (X : SimplicialObject A) :
    (normalizedMooreComplex A).obj X ⟶ (alternatingFaceMapComplex A).obj X := by
  dsimp only [normalizedMooreComplex, NormalizedMooreComplex.obj,
    alternatingFaceMapComplex, AlternatingFaceMapComplex.obj]
  apply ChainComplex.ofHom _ _ _ _ _ _ (fun n => (NormalizedMooreComplex.objX X n).arrow)
  /- we have to show the compatibility of the differentials on the alternating
           face map complex with those defined on the normalized Moore complex:
           we first get rid of the terms of the alternating sum that are obviously
           zero on the normalized_Moore_complex -/
  intro i
  

Proof state:
C : Type u_1
inst✝³ : Category.{?u.242416, u_1} C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category.{?u.242438, u_2} A
inst✝ : Abelian A
X : SimplicialObject A
i : ℕ
⊢ arrow (NormalizedMooreComplex.objX X (i + 1)) ≫ AlternatingFaceMapComplex.objD X i =
    NormalizedMooreComplex.objD X i ≫ arrow (NormalizedMooreComplex.objX X i)

Next tactic:
simp only [AlternatingFaceMapComplex.objD, comp_sum]
/-- The inclusion map of the Moore complex in the alternating face map complex -/
def inclusionOfMooreComplexMap (X : SimplicialObject A) :
    (normalizedMooreComplex A).obj X ⟶ (alternatingFaceMapComplex A).obj X := by
  dsimp only [normalizedMooreComplex, NormalizedMooreComplex.obj,
    alternatingFaceMapComplex, AlternatingFaceMapComplex.obj]
  apply ChainComplex.ofHom _ _ _ _ _ _ (fun n => (NormalizedMooreComplex.objX X n).arrow)
  /- we have to show the compatibility of the differentials on the alternating
           face map complex with those defined on the normalized Moore complex:
           we first get rid of the terms of the alternating sum that are obviously
           zero on the normalized_Moore_complex -/
  intro i
  simp only [AlternatingFaceMapComplex.objD, comp_sum]
  

Proof state:
C : Type u_1
inst✝³ : Category.{?u.242416, u_1} C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category.{?u.242438, u_2} A
inst✝ : Abelian A
X : SimplicialObject A
i : ℕ
⊢ ∑ j : Fin (i + 2), arrow (NormalizedMooreComplex.objX X (i + 1)) ≫ ((-1) ^ ↑j • SimplicialObject.δ X j) =
    NormalizedMooreComplex.objD X i ≫ arrow (NormalizedMooreComplex.objX X i)

Next tactic:
rw [Fin.sum_univ_succ, Fintype.sum_eq_zero]
/-- The inclusion map of the Moore complex in the alternating face map complex -/
def inclusionOfMooreComplexMap (X : SimplicialObject A) :
    (normalizedMooreComplex A).obj X ⟶ (alternatingFaceMapComplex A).obj X := by
  dsimp only [normalizedMooreComplex, NormalizedMooreComplex.obj,
    alternatingFaceMapComplex, AlternatingFaceMapComplex.obj]
  apply ChainComplex.ofHom _ _ _ _ _ _ (fun n => (NormalizedMooreComplex.objX X n).arrow)
  /- we have to show the compatibility of the differentials on the alternating
           face map complex with those defined on the normalized Moore complex:
           we first get rid of the terms of the alternating sum that are obviously
           zero on the normalized_Moore_complex -/
  intro i
  simp only [AlternatingFaceMapComplex.objD, comp_sum]
  rw [Fin.sum_univ_succ, Fintype.sum_eq_zero]
  

Proof state:
C : Type u_1
inst✝³ : Category.{?u.242416, u_1} C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category.{?u.242438, u_2} A
inst✝ : Abelian A
X : SimplicialObject A
i : ℕ
⊢ arrow (NormalizedMooreComplex.objX X (i + 1)) ≫ ((-1) ^ ↑0 • SimplicialObject.δ X 0) + 0 =
    NormalizedMooreComplex.objD X i ≫ arrow (NormalizedMooreComplex.objX X i)
case h
C : Type u_1
inst✝³ : Category.{?u.242416, u_1} C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category.{?u.242438, u_2} A
inst✝ : Abelian A
X : SimplicialObject A
i : ℕ
⊢ ∀ (a : Fin (i + 1)),
    arrow (NormalizedMooreComplex.objX X (i + 1)) ≫ ((-1) ^ ↑(Fin.succ a) • SimplicialObject.δ X (Fin.succ a)) = 0

Next tactic:
swap
/-- The inclusion map of the Moore complex in the alternating face map complex -/
def inclusionOfMooreComplexMap (X : SimplicialObject A) :
    (normalizedMooreComplex A).obj X ⟶ (alternatingFaceMapComplex A).obj X := by
  dsimp only [normalizedMooreComplex, NormalizedMooreComplex.obj,
    alternatingFaceMapComplex, AlternatingFaceMapComplex.obj]
  apply ChainComplex.ofHom _ _ _ _ _ _ (fun n => (NormalizedMooreComplex.objX X n).arrow)
  /- we have to show the compatibility of the differentials on the alternating
           face map complex with those defined on the normalized Moore complex:
           we first get rid of the terms of the alternating sum that are obviously
           zero on the normalized_Moore_complex -/
  intro i
  simp only [AlternatingFaceMapComplex.objD, comp_sum]
  rw [Fin.sum_univ_succ, Fintype.sum_eq_zero]
  swap
  · 

Proof state:
case h
C : Type u_1
inst✝³ : Category.{?u.242416, u_1} C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category.{?u.242438, u_2} A
inst✝ : Abelian A
X : SimplicialObject A
i : ℕ
⊢ ∀ (a : Fin (i + 1)),
    arrow (NormalizedMooreComplex.objX X (i + 1)) ≫ ((-1) ^ ↑(Fin.succ a) • SimplicialObject.δ X (Fin.succ a)) = 0

Next tactic:
intro j
/-- The inclusion map of the Moore complex in the alternating face map complex -/
def inclusionOfMooreComplexMap (X : SimplicialObject A) :
    (normalizedMooreComplex A).obj X ⟶ (alternatingFaceMapComplex A).obj X := by
  dsimp only [normalizedMooreComplex, NormalizedMooreComplex.obj,
    alternatingFaceMapComplex, AlternatingFaceMapComplex.obj]
  apply ChainComplex.ofHom _ _ _ _ _ _ (fun n => (NormalizedMooreComplex.objX X n).arrow)
  /- we have to show the compatibility of the differentials on the alternating
           face map complex with those defined on the normalized Moore complex:
           we first get rid of the terms of the alternating sum that are obviously
           zero on the normalized_Moore_complex -/
  intro i
  simp only [AlternatingFaceMapComplex.objD, comp_sum]
  rw [Fin.sum_univ_succ, Fintype.sum_eq_zero]
  swap
  · intro j
    

Proof state:
case h
C : Type u_1
inst✝³ : Category.{?u.242416, u_1} C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category.{?u.242438, u_2} A
inst✝ : Abelian A
X : SimplicialObject A
i : ℕ
j : Fin (i + 1)
⊢ arrow (NormalizedMooreComplex.objX X (i + 1)) ≫ ((-1) ^ ↑(Fin.succ j) • SimplicialObject.δ X (Fin.succ j)) = 0

Next tactic:
rw [NormalizedMooreComplex.objX, comp_zsmul,
      ← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ _ (Finset.mem_univ j)),
      Category.assoc, kernelSubobject_arrow_comp, comp_zero, smul_zero]
/-- The inclusion map of the Moore complex in the alternating face map complex -/
def inclusionOfMooreComplexMap (X : SimplicialObject A) :
    (normalizedMooreComplex A).obj X ⟶ (alternatingFaceMapComplex A).obj X := by
  dsimp only [normalizedMooreComplex, NormalizedMooreComplex.obj,
    alternatingFaceMapComplex, AlternatingFaceMapComplex.obj]
  apply ChainComplex.ofHom _ _ _ _ _ _ (fun n => (NormalizedMooreComplex.objX X n).arrow)
  /- we have to show the compatibility of the differentials on the alternating
           face map complex with those defined on the normalized Moore complex:
           we first get rid of the terms of the alternating sum that are obviously
           zero on the normalized_Moore_complex -/
  intro i
  simp only [AlternatingFaceMapComplex.objD, comp_sum]
  rw [Fin.sum_univ_succ, Fintype.sum_eq_zero]
  swap
  · intro j
    rw [NormalizedMooreComplex.objX, comp_zsmul,
      ← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ _ (Finset.mem_univ j)),
      Category.assoc, kernelSubobject_arrow_comp, comp_zero, smul_zero]
  -- finally, we study the remaining term which is induced by X.δ 0
  

Proof state:
C : Type u_1
inst✝³ : Category.{?u.242416, u_1} C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category.{?u.242438, u_2} A
inst✝ : Abelian A
X : SimplicialObject A
i : ℕ
⊢ arrow (NormalizedMooreComplex.objX X (i + 1)) ≫ ((-1) ^ ↑0 • SimplicialObject.δ X 0) + 0 =
    NormalizedMooreComplex.objD X i ≫ arrow (NormalizedMooreComplex.objX X i)

Next tactic:
rw [add_zero, Fin.val_zero, pow_zero, one_zsmul]
/-- The inclusion map of the Moore complex in the alternating face map complex -/
def inclusionOfMooreComplexMap (X : SimplicialObject A) :
    (normalizedMooreComplex A).obj X ⟶ (alternatingFaceMapComplex A).obj X := by
  dsimp only [normalizedMooreComplex, NormalizedMooreComplex.obj,
    alternatingFaceMapComplex, AlternatingFaceMapComplex.obj]
  apply ChainComplex.ofHom _ _ _ _ _ _ (fun n => (NormalizedMooreComplex.objX X n).arrow)
  /- we have to show the compatibility of the differentials on the alternating
           face map complex with those defined on the normalized Moore complex:
           we first get rid of the terms of the alternating sum that are obviously
           zero on the normalized_Moore_complex -/
  intro i
  simp only [AlternatingFaceMapComplex.objD, comp_sum]
  rw [Fin.sum_univ_succ, Fintype.sum_eq_zero]
  swap
  · intro j
    rw [NormalizedMooreComplex.objX, comp_zsmul,
      ← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ _ (Finset.mem_univ j)),
      Category.assoc, kernelSubobject_arrow_comp, comp_zero, smul_zero]
  -- finally, we study the remaining term which is induced by X.δ 0
  rw [add_zero, Fin.val_zero, pow_zero, one_zsmul]
  

Proof state:
C : Type u_1
inst✝³ : Category.{?u.242416, u_1} C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category.{?u.242438, u_2} A
inst✝ : Abelian A
X : SimplicialObject A
i : ℕ
⊢ arrow (NormalizedMooreComplex.objX X (i + 1)) ≫ SimplicialObject.δ X 0 =
    NormalizedMooreComplex.objD X i ≫ arrow (NormalizedMooreComplex.objX X i)

Next tactic:
dsimp [NormalizedMooreComplex.objD, NormalizedMooreComplex.objX]
/-- The inclusion map of the Moore complex in the alternating face map complex -/
def inclusionOfMooreComplexMap (X : SimplicialObject A) :
    (normalizedMooreComplex A).obj X ⟶ (alternatingFaceMapComplex A).obj X := by
  dsimp only [normalizedMooreComplex, NormalizedMooreComplex.obj,
    alternatingFaceMapComplex, AlternatingFaceMapComplex.obj]
  apply ChainComplex.ofHom _ _ _ _ _ _ (fun n => (NormalizedMooreComplex.objX X n).arrow)
  /- we have to show the compatibility of the differentials on the alternating
           face map complex with those defined on the normalized Moore complex:
           we first get rid of the terms of the alternating sum that are obviously
           zero on the normalized_Moore_complex -/
  intro i
  simp only [AlternatingFaceMapComplex.objD, comp_sum]
  rw [Fin.sum_univ_succ, Fintype.sum_eq_zero]
  swap
  · intro j
    rw [NormalizedMooreComplex.objX, comp_zsmul,
      ← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ _ (Finset.mem_univ j)),
      Category.assoc, kernelSubobject_arrow_comp, comp_zero, smul_zero]
  -- finally, we study the remaining term which is induced by X.δ 0
  rw [add_zero, Fin.val_zero, pow_zero, one_zsmul]
  dsimp [NormalizedMooreComplex.objD, NormalizedMooreComplex.objX]
  

Proof state:
C : Type u_1
inst✝³ : Category.{?u.242416, u_1} C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category.{?u.242438, u_2} A
inst✝ : Abelian A
X : SimplicialObject A
i : ℕ
⊢ arrow (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k))) ≫ SimplicialObject.δ X 0 =
    (match i with
      | 0 =>
        arrow (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k))) ≫
          SimplicialObject.δ X 0 ≫ inv (arrow ⊤)
      | Nat.succ n =>
        factorThru (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k)))
          (arrow (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k))) ≫
            SimplicialObject.δ X 0)
          (_ :
            Factors (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k)))
              (arrow (NormalizedMooreComplex.objX X (n + 1 + 1)) ≫ SimplicialObject.δ X 0))) ≫
      arrow
        (match i with
        | 0 => ⊤
        | Nat.succ n => Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k)))

Next tactic:
cases i
/-- The inclusion map of the Moore complex in the alternating face map complex -/
def inclusionOfMooreComplexMap (X : SimplicialObject A) :
    (normalizedMooreComplex A).obj X ⟶ (alternatingFaceMapComplex A).obj X := by
  dsimp only [normalizedMooreComplex, NormalizedMooreComplex.obj,
    alternatingFaceMapComplex, AlternatingFaceMapComplex.obj]
  apply ChainComplex.ofHom _ _ _ _ _ _ (fun n => (NormalizedMooreComplex.objX X n).arrow)
  /- we have to show the compatibility of the differentials on the alternating
           face map complex with those defined on the normalized Moore complex:
           we first get rid of the terms of the alternating sum that are obviously
           zero on the normalized_Moore_complex -/
  intro i
  simp only [AlternatingFaceMapComplex.objD, comp_sum]
  rw [Fin.sum_univ_succ, Fintype.sum_eq_zero]
  swap
  · intro j
    rw [NormalizedMooreComplex.objX, comp_zsmul,
      ← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ _ (Finset.mem_univ j)),
      Category.assoc, kernelSubobject_arrow_comp, comp_zero, smul_zero]
  -- finally, we study the remaining term which is induced by X.δ 0
  rw [add_zero, Fin.val_zero, pow_zero, one_zsmul]
  dsimp [NormalizedMooreComplex.objD, NormalizedMooreComplex.objX]
  cases i <;> 

Proof state:
case zero
C : Type u_1
inst✝³ : Category.{?u.242416, u_1} C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category.{?u.242438, u_2} A
inst✝ : Abelian A
X : SimplicialObject A
⊢ arrow (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k))) ≫ SimplicialObject.δ X 0 =
    (match Nat.zero with
      | 0 =>
        arrow (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k))) ≫
          SimplicialObject.δ X 0 ≫ inv (arrow ⊤)
      | Nat.succ n =>
        factorThru (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k)))
          (arrow (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k))) ≫
            SimplicialObject.δ X 0)
          (_ :
            Factors (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k)))
              (arrow (NormalizedMooreComplex.objX X (n + 1 + 1)) ≫ SimplicialObject.δ X 0))) ≫
      arrow
        (match Nat.zero with
        | 0 => ⊤
        | Nat.succ n => Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k)))

Next tactic:
simp