l3lab/ntp-mathlib huggingface dataset:
theorem map_alternatingFaceMapComplex {D : Type*} [Category D] [Preadditive D] (F : C ⥤ D)
    [F.Additive] :
    alternatingFaceMapComplex C ⋙ F.mapHomologicalComplex _ =
      (SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D := by
  

Proof state:
C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Functor.Additive F
⊢ alternatingFaceMapComplex C ⋙ Functor.mapHomologicalComplex F (ComplexShape.down ℕ) =
    (SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D

Next tactic:
apply CategoryTheory.Functor.ext
theorem map_alternatingFaceMapComplex {D : Type*} [Category D] [Preadditive D] (F : C ⥤ D)
    [F.Additive] :
    alternatingFaceMapComplex C ⋙ F.mapHomologicalComplex _ =
      (SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D := by
  apply CategoryTheory.Functor.ext
  · 

Proof state:
case h_map
C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Functor.Additive F
⊢ autoParam
    (∀ (X Y : SimplicialObject C) (f : X ⟶ Y),
      (alternatingFaceMapComplex C ⋙ Functor.mapHomologicalComplex F (ComplexShape.down ℕ)).map f =
        eqToHom (_ : ?F.obj X = ?G.obj X) ≫
          ((SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D).map f ≫
            eqToHom
              (_ :
                ((SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D).obj Y =
                  (alternatingFaceMapComplex C ⋙ Functor.mapHomologicalComplex F (ComplexShape.down ℕ)).obj Y))
    _auto✝

Next tactic:
intro X Y f
theorem map_alternatingFaceMapComplex {D : Type*} [Category D] [Preadditive D] (F : C ⥤ D)
    [F.Additive] :
    alternatingFaceMapComplex C ⋙ F.mapHomologicalComplex _ =
      (SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D := by
  apply CategoryTheory.Functor.ext
  · intro X Y f
    

Proof state:
case h_map
C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Functor.Additive F
X Y : SimplicialObject C
f : X ⟶ Y
⊢ (alternatingFaceMapComplex C ⋙ Functor.mapHomologicalComplex F (ComplexShape.down ℕ)).map f =
    eqToHom (_ : ?F.obj X = ?G.obj X) ≫
      ((SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D).map f ≫
        eqToHom
          (_ :
            ((SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D).obj Y =
              (alternatingFaceMapComplex C ⋙ Functor.mapHomologicalComplex F (ComplexShape.down ℕ)).obj Y)

Next tactic:
ext n
theorem map_alternatingFaceMapComplex {D : Type*} [Category D] [Preadditive D] (F : C ⥤ D)
    [F.Additive] :
    alternatingFaceMapComplex C ⋙ F.mapHomologicalComplex _ =
      (SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D := by
  apply CategoryTheory.Functor.ext
  · intro X Y f
    ext n
    

Proof state:
case h_map.h
C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Functor.Additive F
X Y : SimplicialObject C
f : X ⟶ Y
n : ℕ
⊢ HomologicalComplex.Hom.f ((alternatingFaceMapComplex C ⋙ Functor.mapHomologicalComplex F (ComplexShape.down ℕ)).map f)
      n =
    HomologicalComplex.Hom.f
      (eqToHom (_ : ?F.obj X = ?G.obj X) ≫
        ((SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D).map f ≫
          eqToHom
            (_ :
              ((SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D).obj Y =
                (alternatingFaceMapComplex C ⋙ Functor.mapHomologicalComplex F (ComplexShape.down ℕ)).obj Y))
      n

Next tactic:
simp only [Functor.comp_map, HomologicalComplex.comp_f, alternatingFaceMapComplex_map_f,
      Functor.mapHomologicalComplex_map_f, HomologicalComplex.eqToHom_f, eqToHom_refl, comp_id,
      id_comp, SimplicialObject.whiskering_obj_map_app]
theorem map_alternatingFaceMapComplex {D : Type*} [Category D] [Preadditive D] (F : C ⥤ D)
    [F.Additive] :
    alternatingFaceMapComplex C ⋙ F.mapHomologicalComplex _ =
      (SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D := by
  apply CategoryTheory.Functor.ext
  · intro X Y f
    ext n
    simp only [Functor.comp_map, HomologicalComplex.comp_f, alternatingFaceMapComplex_map_f,
      Functor.mapHomologicalComplex_map_f, HomologicalComplex.eqToHom_f, eqToHom_refl, comp_id,
      id_comp, SimplicialObject.whiskering_obj_map_app]
  · 

Proof state:
case h_obj
C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Functor.Additive F
⊢ ∀ (X : SimplicialObject C),
    (alternatingFaceMapComplex C ⋙ Functor.mapHomologicalComplex F (ComplexShape.down ℕ)).obj X =
      ((SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D).obj X

Next tactic:
intro X
theorem map_alternatingFaceMapComplex {D : Type*} [Category D] [Preadditive D] (F : C ⥤ D)
    [F.Additive] :
    alternatingFaceMapComplex C ⋙ F.mapHomologicalComplex _ =
      (SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D := by
  apply CategoryTheory.Functor.ext
  · intro X Y f
    ext n
    simp only [Functor.comp_map, HomologicalComplex.comp_f, alternatingFaceMapComplex_map_f,
      Functor.mapHomologicalComplex_map_f, HomologicalComplex.eqToHom_f, eqToHom_refl, comp_id,
      id_comp, SimplicialObject.whiskering_obj_map_app]
  · intro X
    

Proof state:
case h_obj
C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Functor.Additive F
X : SimplicialObject C
⊢ (alternatingFaceMapComplex C ⋙ Functor.mapHomologicalComplex F (ComplexShape.down ℕ)).obj X =
    ((SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D).obj X

Next tactic:
apply HomologicalComplex.ext
theorem map_alternatingFaceMapComplex {D : Type*} [Category D] [Preadditive D] (F : C ⥤ D)
    [F.Additive] :
    alternatingFaceMapComplex C ⋙ F.mapHomologicalComplex _ =
      (SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D := by
  apply CategoryTheory.Functor.ext
  · intro X Y f
    ext n
    simp only [Functor.comp_map, HomologicalComplex.comp_f, alternatingFaceMapComplex_map_f,
      Functor.mapHomologicalComplex_map_f, HomologicalComplex.eqToHom_f, eqToHom_refl, comp_id,
      id_comp, SimplicialObject.whiskering_obj_map_app]
  · intro X
    apply HomologicalComplex.ext
    · 

Proof state:
case h_obj.h_d
C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Functor.Additive F
X : SimplicialObject C
⊢ ∀ (i j : ℕ),
    ComplexShape.Rel (ComplexShape.down ℕ) i j →
      HomologicalComplex.d ((alternatingFaceMapComplex C ⋙ Functor.mapHomologicalComplex F (ComplexShape.down ℕ)).obj X)
            i j ≫
          eqToHom
            (_ :
              HomologicalComplex.X
                  ((alternatingFaceMapComplex C ⋙ Functor.mapHomologicalComplex F (ComplexShape.down ℕ)).obj X) j =
                HomologicalComplex.X (((SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D).obj X)
                  j) =
        eqToHom
            (_ :
              HomologicalComplex.X
                  ((alternatingFaceMapComplex C ⋙ Functor.mapHomologicalComplex F (ComplexShape.down ℕ)).obj X) i =
                HomologicalComplex.X (((SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D).obj X)
                  i) ≫
          HomologicalComplex.d (((SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D).obj X) i j

Next tactic:
rintro i j (rfl : j + 1 = i)
theorem map_alternatingFaceMapComplex {D : Type*} [Category D] [Preadditive D] (F : C ⥤ D)
    [F.Additive] :
    alternatingFaceMapComplex C ⋙ F.mapHomologicalComplex _ =
      (SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D := by
  apply CategoryTheory.Functor.ext
  · intro X Y f
    ext n
    simp only [Functor.comp_map, HomologicalComplex.comp_f, alternatingFaceMapComplex_map_f,
      Functor.mapHomologicalComplex_map_f, HomologicalComplex.eqToHom_f, eqToHom_refl, comp_id,
      id_comp, SimplicialObject.whiskering_obj_map_app]
  · intro X
    apply HomologicalComplex.ext
    · rintro i j (rfl : j + 1 = i)
      

Proof state:
case h_obj.h_d
C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Functor.Additive F
X : SimplicialObject C
j : ℕ
⊢ HomologicalComplex.d ((alternatingFaceMapComplex C ⋙ Functor.mapHomologicalComplex F (ComplexShape.down ℕ)).obj X)
        (j + 1) j ≫
      eqToHom
        (_ :
          HomologicalComplex.X
              ((alternatingFaceMapComplex C ⋙ Functor.mapHomologicalComplex F (ComplexShape.down ℕ)).obj X) j =
            HomologicalComplex.X (((SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D).obj X) j) =
    eqToHom
        (_ :
          HomologicalComplex.X
              ((alternatingFaceMapComplex C ⋙ Functor.mapHomologicalComplex F (ComplexShape.down ℕ)).obj X) (j + 1) =
            HomologicalComplex.X (((SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D).obj X)
              (j + 1)) ≫
      HomologicalComplex.d (((SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D).obj X) (j + 1) j

Next tactic:
dsimp only [Functor.comp_obj]
theorem map_alternatingFaceMapComplex {D : Type*} [Category D] [Preadditive D] (F : C ⥤ D)
    [F.Additive] :
    alternatingFaceMapComplex C ⋙ F.mapHomologicalComplex _ =
      (SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D := by
  apply CategoryTheory.Functor.ext
  · intro X Y f
    ext n
    simp only [Functor.comp_map, HomologicalComplex.comp_f, alternatingFaceMapComplex_map_f,
      Functor.mapHomologicalComplex_map_f, HomologicalComplex.eqToHom_f, eqToHom_refl, comp_id,
      id_comp, SimplicialObject.whiskering_obj_map_app]
  · intro X
    apply HomologicalComplex.ext
    · rintro i j (rfl : j + 1 = i)
      dsimp only [Functor.comp_obj]
      

Proof state:
case h_obj.h_d
C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Functor.Additive F
X : SimplicialObject C
j : ℕ
⊢ HomologicalComplex.d
        ((Functor.mapHomologicalComplex F (ComplexShape.down ℕ)).obj ((alternatingFaceMapComplex C).obj X)) (j + 1) j ≫
      eqToHom
        (_ :
          HomologicalComplex.X
              ((Functor.mapHomologicalComplex F (ComplexShape.down ℕ)).obj ((alternatingFaceMapComplex C).obj X)) j =
            HomologicalComplex.X ((alternatingFaceMapComplex D).obj (((SimplicialObject.whiskering C D).obj F).obj X))
              j) =
    eqToHom
        (_ :
          HomologicalComplex.X
              ((Functor.mapHomologicalComplex F (ComplexShape.down ℕ)).obj ((alternatingFaceMapComplex C).obj X))
              (j + 1) =
            HomologicalComplex.X ((alternatingFaceMapComplex D).obj (((SimplicialObject.whiskering C D).obj F).obj X))
              (j + 1)) ≫
      HomologicalComplex.d ((alternatingFaceMapComplex D).obj (((SimplicialObject.whiskering C D).obj F).obj X)) (j + 1)
        j

Next tactic:
simp only [Functor.mapHomologicalComplex_obj_d, alternatingFaceMapComplex_obj_d,
        eqToHom_refl, id_comp, comp_id, AlternatingFaceMapComplex.objD, Functor.map_sum,
        Functor.map_zsmul]
theorem map_alternatingFaceMapComplex {D : Type*} [Category D] [Preadditive D] (F : C ⥤ D)
    [F.Additive] :
    alternatingFaceMapComplex C ⋙ F.mapHomologicalComplex _ =
      (SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D := by
  apply CategoryTheory.Functor.ext
  · intro X Y f
    ext n
    simp only [Functor.comp_map, HomologicalComplex.comp_f, alternatingFaceMapComplex_map_f,
      Functor.mapHomologicalComplex_map_f, HomologicalComplex.eqToHom_f, eqToHom_refl, comp_id,
      id_comp, SimplicialObject.whiskering_obj_map_app]
  · intro X
    apply HomologicalComplex.ext
    · rintro i j (rfl : j + 1 = i)
      dsimp only [Functor.comp_obj]
      simp only [Functor.mapHomologicalComplex_obj_d, alternatingFaceMapComplex_obj_d,
        eqToHom_refl, id_comp, comp_id, AlternatingFaceMapComplex.objD, Functor.map_sum,
        Functor.map_zsmul]
      

Proof state:
case h_obj.h_d
C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Functor.Additive F
X : SimplicialObject C
j : ℕ
⊢ ∑ x : Fin (j + 2), (-1) ^ ↑x • F.map (SimplicialObject.δ X x) =
    ∑ i : Fin (j + 2), (-1) ^ ↑i • SimplicialObject.δ (((SimplicialObject.whiskering C D).obj F).obj X) i

Next tactic:
rfl
theorem map_alternatingFaceMapComplex {D : Type*} [Category D] [Preadditive D] (F : C ⥤ D)
    [F.Additive] :
    alternatingFaceMapComplex C ⋙ F.mapHomologicalComplex _ =
      (SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D := by
  apply CategoryTheory.Functor.ext
  · intro X Y f
    ext n
    simp only [Functor.comp_map, HomologicalComplex.comp_f, alternatingFaceMapComplex_map_f,
      Functor.mapHomologicalComplex_map_f, HomologicalComplex.eqToHom_f, eqToHom_refl, comp_id,
      id_comp, SimplicialObject.whiskering_obj_map_app]
  · intro X
    apply HomologicalComplex.ext
    · rintro i j (rfl : j + 1 = i)
      dsimp only [Functor.comp_obj]
      simp only [Functor.mapHomologicalComplex_obj_d, alternatingFaceMapComplex_obj_d,
        eqToHom_refl, id_comp, comp_id, AlternatingFaceMapComplex.objD, Functor.map_sum,
        Functor.map_zsmul]
      rfl
    · 

Proof state:
case h_obj.h_X
C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Functor.Additive F
X : SimplicialObject C
⊢ ((alternatingFaceMapComplex C ⋙ Functor.mapHomologicalComplex F (ComplexShape.down ℕ)).obj X).X =
    (((SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D).obj X).X

Next tactic:
ext n
theorem map_alternatingFaceMapComplex {D : Type*} [Category D] [Preadditive D] (F : C ⥤ D)
    [F.Additive] :
    alternatingFaceMapComplex C ⋙ F.mapHomologicalComplex _ =
      (SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D := by
  apply CategoryTheory.Functor.ext
  · intro X Y f
    ext n
    simp only [Functor.comp_map, HomologicalComplex.comp_f, alternatingFaceMapComplex_map_f,
      Functor.mapHomologicalComplex_map_f, HomologicalComplex.eqToHom_f, eqToHom_refl, comp_id,
      id_comp, SimplicialObject.whiskering_obj_map_app]
  · intro X
    apply HomologicalComplex.ext
    · rintro i j (rfl : j + 1 = i)
      dsimp only [Functor.comp_obj]
      simp only [Functor.mapHomologicalComplex_obj_d, alternatingFaceMapComplex_obj_d,
        eqToHom_refl, id_comp, comp_id, AlternatingFaceMapComplex.objD, Functor.map_sum,
        Functor.map_zsmul]
      rfl
    · ext n
      

Proof state:
case h_obj.h_X.h
C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Functor.Additive F
X : SimplicialObject C
n : ℕ
⊢ HomologicalComplex.X ((alternatingFaceMapComplex C ⋙ Functor.mapHomologicalComplex F (ComplexShape.down ℕ)).obj X) n =
    HomologicalComplex.X (((SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D).obj X) n

Next tactic:
rfl
theorem karoubi_alternatingFaceMapComplex_d (P : Karoubi (SimplicialObject C)) (n : ℕ) :
    ((AlternatingFaceMapComplex.obj (KaroubiFunctorCategoryEmbedding.obj P)).d (n + 1) n).f =
      P.p.app (op [n + 1]) ≫ (AlternatingFaceMapComplex.obj P.X).d (n + 1) n := by
  

Proof state:
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
P : Karoubi (SimplicialObject C)
n : ℕ
⊢ (HomologicalComplex.d (AlternatingFaceMapComplex.obj (KaroubiFunctorCategoryEmbedding.obj P)) (n + 1) n).f =
    P.p.app (op [n + 1]) ≫ HomologicalComplex.d (AlternatingFaceMapComplex.obj P.X) (n + 1) n

Next tactic:
dsimp
theorem karoubi_alternatingFaceMapComplex_d (P : Karoubi (SimplicialObject C)) (n : ℕ) :
    ((AlternatingFaceMapComplex.obj (KaroubiFunctorCategoryEmbedding.obj P)).d (n + 1) n).f =
      P.p.app (op [n + 1]) ≫ (AlternatingFaceMapComplex.obj P.X).d (n + 1) n := by
  dsimp
  

Proof state:
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
P : Karoubi (SimplicialObject C)
n : ℕ
⊢ (HomologicalComplex.d (AlternatingFaceMapComplex.obj (KaroubiFunctorCategoryEmbedding.obj P)) (n + 1) n).f =
    P.p.app (op [n + 1]) ≫ HomologicalComplex.d (AlternatingFaceMapComplex.obj P.X) (n + 1) n

Next tactic:
simp only [AlternatingFaceMapComplex.obj_d_eq, Karoubi.sum_hom, Preadditive.comp_sum,
    Karoubi.zsmul_hom, Preadditive.comp_zsmul]
theorem karoubi_alternatingFaceMapComplex_d (P : Karoubi (SimplicialObject C)) (n : ℕ) :
    ((AlternatingFaceMapComplex.obj (KaroubiFunctorCategoryEmbedding.obj P)).d (n + 1) n).f =
      P.p.app (op [n + 1]) ≫ (AlternatingFaceMapComplex.obj P.X).d (n + 1) n := by
  dsimp
  simp only [AlternatingFaceMapComplex.obj_d_eq, Karoubi.sum_hom, Preadditive.comp_sum,
    Karoubi.zsmul_hom, Preadditive.comp_zsmul]
  

Proof state:
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
P : Karoubi (SimplicialObject C)
n : ℕ
⊢ ∑ x : Fin (n + 2), (-1) ^ ↑x • (SimplicialObject.δ (KaroubiFunctorCategoryEmbedding.obj P) x).f =
    ∑ x : Fin (n + 2), (-1) ^ ↑x • P.p.app (op [n + 1]) ≫ SimplicialObject.δ P.X x

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

Proof state:
C : Type u_1
inst✝² : Category.{?u.196418, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasZeroObject C
X : SimplicialObject.Augmented C
⊢ (SimplicialObject.Augmented.drop ⋙ alternatingFaceMapComplex C).obj X ⟶
    (SimplicialObject.Augmented.point ⋙ ChainComplex.single₀ C).obj X

Next tactic:
refine' (ChainComplex.toSingle₀Equiv _ _).symm _
/-- 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 _
    

Proof state:
C : Type u_1
inst✝² : Category.{?u.196418, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasZeroObject C
X : SimplicialObject.Augmented C
⊢ { f // HomologicalComplex.d ((SimplicialObject.Augmented.drop ⋙ alternatingFaceMapComplex C).obj X) 1 0 ≫ f = 0 }

Next tactic:
refine' ⟨X.hom.app (op [0]), _⟩
/-- 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]), _⟩
    

Proof state:
C : Type u_1
inst✝² : Category.{?u.196418, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasZeroObject C
X : SimplicialObject.Augmented C
⊢ HomologicalComplex.d ((SimplicialObject.Augmented.drop ⋙ alternatingFaceMapComplex C).obj X) 1 0 ≫
      X.hom.app (op [0]) =
    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
    

Proof state:
C : Type u_1
inst✝² : Category.{?u.196418, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasZeroObject C
X : SimplicialObject.Augmented C
⊢ HomologicalComplex.d ((alternatingFaceMapComplex C).obj X.left) 1 0 ≫ X.hom.app (op [0]) = 0

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

Proof state:
C : Type u_1
inst✝² : Category.{?u.196418, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasZeroObject C
X : SimplicialObject.Augmented C
⊢ X.hom.app (op [0 + 1]) ≫ SimplicialObject.δ ((SimplicialObject.const C).obj X.right) 0 +
      -X.hom.app (op [0 + 1]) ≫ SimplicialObject.δ ((SimplicialObject.const C).obj X.right) 1 =
    0

Next tactic:
apply add_right_neg
/-- 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
    

Proof state:
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
⊢ (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 =
    (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

Next tactic:
apply HomologicalComplex.to_single_hom_ext