ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- SimplicialObject.Splitting.ofIso_N
@[simps]
def ofIso (e : X ≅ Y) : Splitting Y 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : CategoryTheory.SimplicialObject C} (s : SimplicialObject.Splitting X) (e : X ≅ Y)
Goal: ∀ (a : ℕ), (s.ofIso e).N a = s.N a
-- SimplicialObject.Splitting.ofIso_ι
@[simps]
def ofIso (e : X ≅ Y) : Splitting Y 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : CategoryTheory.SimplicialObject C} (s : SimplicialObject.Splitting X) (e : X ≅ Y) (n : ℕ)
Goal: (s.ofIso e).ι n = s.ι n ≫ e.hom.app (Opposite.op [n])
-- SimplicialObject.Splitting.ofIso_isColimit'
@[simps]
def ofIso (e : X ≅ Y) : Splitting Y 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : CategoryTheory.SimplicialObject C} (s : SimplicialObject.Splitting X) (e : X ≅ Y) (Δ : SimplexCategoryᵒᵖ)
Goal: (s.ofIso e).isColimit' Δ = (s.isColimit Δ).ofIsoColimit (CategoryTheory.Limits.Cofan.ext (e.app Δ) ⋯)
-- SimplicialObject.Splitting.cofan_inj_epi_naturality
@[reassoc]
theorem cofan_inj_epi_naturality {Δ₁ Δ₂ : SimplexCategoryᵒᵖ} (A : IndexSet Δ₁) (p : Δ₁ ⟶ Δ₂)
    [Epi p.unop] : (s.cofan Δ₁).inj A ≫ X.map p = (s.cofan Δ₂).inj (A.epiComp p) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X : CategoryTheory.SimplicialObject C} (s : SimplicialObject.Splitting X) {Δ₁ Δ₂ : SimplexCategoryᵒᵖ} (A : SimplicialObject.Splitting.IndexSet Δ₁) (p : Δ₁ ⟶ Δ₂) [CategoryTheory.Epi p.unop]
Goal: (s.cofan Δ₁).inj A ≫ X.map p = (s.cofan Δ₂).inj (A.epiComp p)
-- SimplicialObject.Split.mk'_s
@[simps]
def mk' {X : SimplicialObject C} (s : Splitting X) : Split C 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X : CategoryTheory.SimplicialObject C} (s : SimplicialObject.Splitting X)
Goal: (SimplicialObject.Split.mk' s).s = s
-- SimplicialObject.Split.mk'_X
@[simps]
def mk' {X : SimplicialObject C} (s : Splitting X) : Split C 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X : CategoryTheory.SimplicialObject C} (s : SimplicialObject.Splitting X)
Goal: (SimplicialObject.Split.mk' s).X = X
-- SimplicialObject.Split.Hom.comm
structure Hom (S₁ S₂ : Split C) where
    F : S₁.X ⟶ S₂.X
    f : ∀ n : ℕ, S₁.s.N n ⟶ S₂.s.N n
  comm : ∀ n : ℕ, S₁.s.ι n ≫ F.app (op [n]) = f n ≫ S₂.s.ι n := by aesop_cat
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {S₁ S₂ : SimplicialObject.Split C} (self : S₁.Hom S₂) (n : ℕ)
Goal: S₁.s.ι n ≫ self.F.app (Opposite.op [n]) = self.f n ≫ S₂.s.ι n
-- SimplicialObject.Split.Hom.ext
@[ext]
theorem Hom.ext {S₁ S₂ : Split C} (Φ₁ Φ₂ : Hom S₁ S₂) (h : ∀ n : ℕ, Φ₁.f n = Φ₂.f n) : Φ₁ = Φ₂ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {S₁ S₂ : SimplicialObject.Split C} (Φ₁ Φ₂ : S₁.Hom S₂) (h : ∀ (n : ℕ), Φ₁.f n = Φ₂.f n)
Goal: Φ₁ = Φ₂
-- SimplicialObject.Split.hom_ext
@[ext]
theorem hom_ext {S₁ S₂ : Split C} (Φ₁ Φ₂ : S₁ ⟶ S₂) (h : ∀ n : ℕ, Φ₁.f n = Φ₂.f n) : Φ₁ = Φ₂ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {S₁ S₂ : SimplicialObject.Split C} (Φ₁ Φ₂ : S₁ ⟶ S₂) (h : ∀ (n : ℕ), Φ₁.f n = Φ₂.f n)
Goal: Φ₁ = Φ₂
-- SimplicialObject.Split.congr_F
theorem congr_F {S₁ S₂ : Split C} {Φ₁ Φ₂ : S₁ ⟶ S₂} (h : Φ₁ = Φ₂) : Φ₁.f = Φ₂.f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {S₁ S₂ : SimplicialObject.Split C} {Φ₁ Φ₂ : S₁ ⟶ S₂} (h : Φ₁ = Φ₂)
Goal: Φ₁.f = Φ₂.f
-- SimplicialObject.Split.congr_f
theorem congr_f {S₁ S₂ : Split C} {Φ₁ Φ₂ : S₁ ⟶ S₂} (h : Φ₁ = Φ₂) (n : ℕ) : Φ₁.f n = Φ₂.f n 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {S₁ S₂ : SimplicialObject.Split C} {Φ₁ Φ₂ : S₁ ⟶ S₂} (h : Φ₁ = Φ₂) (n : ℕ)
Goal: Φ₁.f n = Φ₂.f n
-- SimplicialObject.Split.id_F
@[simp]
theorem id_F (S : Split C) : (𝟙 S : S ⟶ S).F = 𝟙 S.X 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (S : SimplicialObject.Split C)
Goal: (𝟙 S).F = 𝟙 S.X
-- SimplicialObject.Split.id_f
@[simp]
theorem id_f (S : Split C) (n : ℕ) : (𝟙 S : S ⟶ S).f n = 𝟙 (S.s.N n) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (S : SimplicialObject.Split C) (n : ℕ)
Goal: (𝟙 S).f n = 𝟙 (S.s.N n)
-- SimplicialObject.Split.comp_F
@[simp]
theorem comp_F {S₁ S₂ S₃ : Split C} (Φ₁₂ : S₁ ⟶ S₂) (Φ₂₃ : S₂ ⟶ S₃) :
    (Φ₁₂ ≫ Φ₂₃).F = Φ₁₂.F ≫ Φ₂₃.F 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {S₁ S₂ S₃ : SimplicialObject.Split C} (Φ₁₂ : S₁ ⟶ S₂) (Φ₂₃ : S₂ ⟶ S₃)
Goal: (Φ₁₂ ≫ Φ₂₃).F = Φ₁₂.F ≫ Φ₂₃.F
-- SimplicialObject.Split.comp_f
@[simp]
theorem comp_f {S₁ S₂ S₃ : Split C} (Φ₁₂ : S₁ ⟶ S₂) (Φ₂₃ : S₂ ⟶ S₃) (n : ℕ) :
    (Φ₁₂ ≫ Φ₂₃).f n = Φ₁₂.f n ≫ Φ₂₃.f n 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {S₁ S₂ S₃ : SimplicialObject.Split C} (Φ₁₂ : S₁ ⟶ S₂) (Φ₂₃ : S₂ ⟶ S₃) (n : ℕ)
Goal: (Φ₁₂ ≫ Φ₂₃).f n = Φ₁₂.f n ≫ Φ₂₃.f n
-- SimplicialObject.Split.cofan_inj_naturality_symm
@[reassoc (attr := simp 1100)]
theorem cofan_inj_naturality_symm {S₁ S₂ : Split C} (Φ : S₁ ⟶ S₂) {Δ : SimplexCategoryᵒᵖ}
    (A : Splitting.IndexSet Δ) :
    (S₁.s.cofan Δ).inj A ≫ Φ.F.app Δ = Φ.f A.1.unop.len ≫ (S₂.s.cofan Δ).inj A 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {S₁ S₂ : SimplicialObject.Split C} (Φ : S₁ ⟶ S₂) {Δ : SimplexCategoryᵒᵖ} (A : SimplicialObject.Splitting.IndexSet Δ)
Goal: (S₁.s.cofan Δ).inj A ≫ Φ.F.app Δ = Φ.f (Opposite.unop A.fst).len ≫ (S₂.s.cofan Δ).inj A
-- SimplicialObject.Split.forget_obj
@[simps]
def forget : Split C ⥤ SimplicialObject C 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (S : SimplicialObject.Split C)
Goal: (SimplicialObject.Split.forget C).obj S = S.X
-- SimplicialObject.Split.forget_map
@[simps]
def forget : Split C ⥤ SimplicialObject C 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C]
Goal: ∀ {X Y : SimplicialObject.Split C} (Φ : X ⟶ Y), (SimplicialObject.Split.forget C).map Φ = Φ.F
-- SimplicialObject.Split.evalN_map
@[simps]
def evalN (n : ℕ) : Split C ⥤ C 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (n : ℕ)
Goal: ∀ {X Y : SimplicialObject.Split C} (Φ : X ⟶ Y), (SimplicialObject.Split.evalN C n).map Φ = Φ.f n
-- SimplicialObject.Split.evalN_obj
@[simps]
def evalN (n : ℕ) : Split C ⥤ C 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (n : ℕ) (S : SimplicialObject.Split C)
Goal: (SimplicialObject.Split.evalN C n).obj S = S.s.N n
-- SimplicialObject.Split.natTransCofanInj_app
@[simps]
def natTransCofanInj {Δ : SimplexCategoryᵒᵖ} (A : Splitting.IndexSet Δ) :
    evalN C A.1.unop.len ⟶ forget C ⋙ (evaluation SimplexCategoryᵒᵖ C).obj Δ 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] {Δ : SimplexCategoryᵒᵖ} (A : SimplicialObject.Splitting.IndexSet Δ) (S : SimplicialObject.Split C)
Goal: (SimplicialObject.Split.natTransCofanInj C A).app S = (S.s.cofan Δ).inj A
-- AlgebraicTopology.AlternatingFaceMapComplex.d_squared
theorem d_squared (n : ℕ) : objD X (n + 1) ≫ objD X n = 0 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] (X : CategoryTheory.SimplicialObject C) (n : ℕ)
Goal: AlgebraicTopology.AlternatingFaceMapComplex.objD X (n + 1) ≫ AlgebraicTopology.AlternatingFaceMapComplex.objD X n = 0
-- AlgebraicTopology.AlternatingFaceMapComplex.obj_X
@[simp]
theorem obj_X (X : SimplicialObject C) (n : ℕ) : (AlternatingFaceMapComplex.obj X).X n = X _[n] 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] (X : CategoryTheory.SimplicialObject C) (n : ℕ)
Goal: (AlgebraicTopology.AlternatingFaceMapComplex.obj X).X n = X _[n]
-- AlgebraicTopology.AlternatingFaceMapComplex.obj_d_eq
@[simp]
theorem obj_d_eq (X : SimplicialObject C) (n : ℕ) :
    (AlternatingFaceMapComplex.obj X).d (n + 1) n
      = ∑ i : Fin (n + 2), (-1 : ℤ) ^ (i : ℕ) • X.δ i 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] (X : CategoryTheory.SimplicialObject C) (n : ℕ)
Goal: (AlgebraicTopology.AlternatingFaceMapComplex.obj X).d (n + 1) n = ∑ i : Fin (n + 2), (-1) ^ ↑i • X.δ i
-- AlgebraicTopology.AlternatingFaceMapComplex.map_f
@[simp]
theorem map_f (f : X ⟶ Y) (n : ℕ) : (map f).f n = f.app (op [n]) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] {X Y : CategoryTheory.SimplicialObject C} (f : X ⟶ Y) (n : ℕ)
Goal: (AlgebraicTopology.AlternatingFaceMapComplex.map f).f n = f.app (Opposite.op [n])
-- AlgebraicTopology.alternatingFaceMapComplex_obj_X
@[simp]
theorem alternatingFaceMapComplex_obj_X (X : SimplicialObject C) (n : ℕ) :
    ((alternatingFaceMapComplex C).obj X).X n = X _[n] 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] (X : CategoryTheory.SimplicialObject C) (n : ℕ)
Goal: ((AlgebraicTopology.alternatingFaceMapComplex C).obj X).X n = X _[n]
-- AlgebraicTopology.alternatingFaceMapComplex_obj_d
@[simp]
theorem alternatingFaceMapComplex_obj_d (X : SimplicialObject C) (n : ℕ) :
    ((alternatingFaceMapComplex C).obj X).d (n + 1) n = AlternatingFaceMapComplex.objD X n 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] (X : CategoryTheory.SimplicialObject C) (n : ℕ)
Goal: ((AlgebraicTopology.alternatingFaceMapComplex C).obj X).d (n + 1) n =
  AlgebraicTopology.AlternatingFaceMapComplex.objD X n
-- AlgebraicTopology.alternatingFaceMapComplex_map_f
@[simp]
theorem alternatingFaceMapComplex_map_f {X Y : SimplicialObject C} (f : X ⟶ Y) (n : ℕ) :
    ((alternatingFaceMapComplex C).map f).f n = f.app (op [n]) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] {X Y : CategoryTheory.SimplicialObject C} (f : X ⟶ Y) (n : ℕ)
Goal: ((AlgebraicTopology.alternatingFaceMapComplex C).map f).f n = f.app (Opposite.op [n])
-- AlgebraicTopology.map_alternatingFaceMapComplex
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 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Preadditive C] {D : Type u_2} [CategoryTheory.Category.{u_3, u_2} D] [CategoryTheory.Preadditive D] (F : C ⥤ D) [F.Additive]
Goal: AlgebraicTopology.alternatingFaceMapComplex C ⋙ F.mapHomologicalComplex (ComplexShape.down ℕ) =
  (CategoryTheory.SimplicialObject.whiskering C D).obj F ⋙ AlgebraicTopology.alternatingFaceMapComplex D
-- AlgebraicTopology.karoubi_alternatingFaceMapComplex_d
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 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] (P : CategoryTheory.Idempotents.Karoubi (CategoryTheory.SimplicialObject C)) (n : ℕ)
Goal: ((AlgebraicTopology.AlternatingFaceMapComplex.obj (CategoryTheory.Idempotents.KaroubiFunctorCategoryEmbedding.obj P)).d
      (n + 1) n).f =
  P.p.app (Opposite.op [n + 1]) ≫ (AlgebraicTopology.AlternatingFaceMapComplex.obj P.X).d (n + 1) n
-- AlgebraicTopology.AlternatingFaceMapComplex.ε_app_f_zero
@[simp]
lemma ε_app_f_zero [Limits.HasZeroObject C] (X : SimplicialObject.Augmented C) :
    (ε.app X).f 0 = X.hom.app (op [0]) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasZeroObject C] (X : CategoryTheory.SimplicialObject.Augmented C)
Goal: (AlgebraicTopology.AlternatingFaceMapComplex.ε.app X).f 0 = X.hom.app (Opposite.op [0])
-- AlgebraicTopology.AlternatingFaceMapComplex.ε_app_f_succ
@[simp]
lemma ε_app_f_succ [Limits.HasZeroObject C] (X : SimplicialObject.Augmented C) (n : ℕ) :
    (ε.app X).f (n + 1) = 0 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasZeroObject C] (X : CategoryTheory.SimplicialObject.Augmented C) (n : ℕ)
Goal: (AlgebraicTopology.AlternatingFaceMapComplex.ε.app X).f (n + 1) = 0
-- AlgebraicTopology.inclusionOfMooreComplexMap_f
@[simp]
theorem inclusionOfMooreComplexMap_f (X : SimplicialObject A) (n : ℕ) :
    (inclusionOfMooreComplexMap X).f n = (NormalizedMooreComplex.objX X n).arrow 
Arguments: {A : Type u_2} [CategoryTheory.Category.{u_3, u_2} A] [CategoryTheory.Abelian A] (X : CategoryTheory.SimplicialObject A) (n : ℕ)
Goal: (AlgebraicTopology.inclusionOfMooreComplexMap X).f n = (AlgebraicTopology.NormalizedMooreComplex.objX X n).arrow
-- AlgebraicTopology.inclusionOfMooreComplex_app
@[simps]
def inclusionOfMooreComplex : normalizedMooreComplex A ⟶ alternatingFaceMapComplex A 
Arguments: (A : Type u_2) [CategoryTheory.Category.{u_3, u_2} A] [CategoryTheory.Abelian A] (X : CategoryTheory.SimplicialObject A)
Goal: (AlgebraicTopology.inclusionOfMooreComplex A).app X = AlgebraicTopology.inclusionOfMooreComplexMap X
-- AlgebraicTopology.AlternatingCofaceMapComplex.d_eq_unop_d
theorem d_eq_unop_d (n : ℕ) :
    objD X n =
      (AlternatingFaceMapComplex.objD ((cosimplicialSimplicialEquiv C).functor.obj (op X))
          n).unop 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] (X : CategoryTheory.CosimplicialObject C) (n : ℕ)
Goal: AlgebraicTopology.AlternatingCofaceMapComplex.objD X n =
  (AlgebraicTopology.AlternatingFaceMapComplex.objD
      ((CategoryTheory.cosimplicialSimplicialEquiv C).functor.obj (Opposite.op X)) n).unop
-- AlgebraicTopology.AlternatingCofaceMapComplex.d_squared
theorem d_squared (n : ℕ) : objD X n ≫ objD X (n + 1) = 0 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] (X : CategoryTheory.CosimplicialObject C) (n : ℕ)
Goal: AlgebraicTopology.AlternatingCofaceMapComplex.objD X n ≫ AlgebraicTopology.AlternatingCofaceMapComplex.objD X (n + 1) =
  0
-- AlgebraicTopology.alternatingCofaceMapComplex_obj
@[simps]
def alternatingCofaceMapComplex : CosimplicialObject C ⥤ CochainComplex C ℕ 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] (X : CategoryTheory.CosimplicialObject C)
Goal: (AlgebraicTopology.alternatingCofaceMapComplex C).obj X = AlgebraicTopology.AlternatingCofaceMapComplex.obj X
-- AlgebraicTopology.alternatingCofaceMapComplex_map
@[simps]
def alternatingCofaceMapComplex : CosimplicialObject C ⥤ CochainComplex C ℕ 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C]
Goal: ∀ {X Y : CategoryTheory.CosimplicialObject C} (f : X ⟶ Y),
  (AlgebraicTopology.alternatingCofaceMapComplex C).map f = AlgebraicTopology.AlternatingCofaceMapComplex.map f
-- CategoryTheory.Abelian.DoldKan.comparisonN_hom_app_f
@[simps!]
def comparisonN : (N : SimplicialObject A ⥤ _) ≅ Idempotents.DoldKan.N 
Arguments: {A : Type u_1} [CategoryTheory.Category.{u_2, u_1} A] [CategoryTheory.Abelian A] (X : CategoryTheory.SimplicialObject A) (i : ℕ)
Goal: (CategoryTheory.Abelian.DoldKan.comparisonN.hom.app X).f i =
  ((CategoryTheory.Idempotents.toKaroubiEquivalence (ChainComplex A ℕ)).unitIso.hom.app
          (CategoryTheory.Abelian.DoldKan.N.obj X)).f
      i ≫
    ((CategoryTheory.Idempotents.toKaroubiEquivalence (ChainComplex A ℕ)).inverse.map
          ((AlgebraicTopology.DoldKan.N₁_iso_normalizedMooreComplex_comp_toKaroubi A).inv.app X)).f
      i
-- CategoryTheory.Abelian.DoldKan.comparisonN_inv_app_f
@[simps!]
def comparisonN : (N : SimplicialObject A ⥤ _) ≅ Idempotents.DoldKan.N 
Arguments: {A : Type u_1} [CategoryTheory.Category.{u_2, u_1} A] [CategoryTheory.Abelian A] (X : CategoryTheory.SimplicialObject A) (i : ℕ)
Goal: (CategoryTheory.Abelian.DoldKan.comparisonN.inv.app X).f i =
  ((CategoryTheory.Idempotents.toKaroubiEquivalence (ChainComplex A ℕ)).inverse.map
          ((AlgebraicTopology.DoldKan.N₁_iso_normalizedMooreComplex_comp_toKaroubi A).hom.app X)).f
      i ≫
    ((CategoryTheory.Idempotents.toKaroubiEquivalence (ChainComplex A ℕ)).unitIso.inv.app
          (CategoryTheory.Abelian.DoldKan.N.obj X)).f
      i
-- CategoryTheory.Abelian.DoldKan.equivalence_functor
@[simps! functor]
def equivalence : SimplicialObject A ≌ ChainComplex A ℕ 
Arguments: {A : Type u_1} [CategoryTheory.Category.{u_2, u_1} A] [CategoryTheory.Abelian A]
Goal: CategoryTheory.Abelian.DoldKan.equivalence.functor = CategoryTheory.Abelian.DoldKan.N
-- CategoryTheory.Abelian.DoldKan.equivalence_inverse
theorem equivalence_inverse : (equivalence : SimplicialObject A ≌ _).inverse = Γ 
Arguments: {A : Type u_1} [CategoryTheory.Category.{u_2, u_1} A] [CategoryTheory.Abelian A]
Goal: CategoryTheory.Abelian.DoldKan.equivalence.inverse = CategoryTheory.Abelian.DoldKan.Γ
-- FundamentalGroupoidFunctor.proj_map
@[simp]
theorem proj_map (i : I) (x₀ x₁ : πₓ (TopCat.of (∀ i, X i))) (p : x₀ ⟶ x₁) :
    (proj X i).map p = @Path.Homotopic.proj _ _ _ _ _ i p 
Arguments: {I : Type u} (X : I → TopCat) (i : I) (x₀ x₁ : ↑(π.obj (TopCat.of ((i : I) → ↑(X i))))) (p : x₀ ⟶ x₁)
Goal: (FundamentalGroupoidFunctor.proj X i).map p = Path.Homotopic.proj i p
-- FundamentalGroupoidFunctor.piToPiTop_obj_as
@[simps]
def piToPiTop : (∀ i, πₓ (X i)) ⥤ πₓ (TopCat.of (∀ i, X i)) 
Arguments: {I : Type u} (X : I → TopCat) (g : (i : I) → ↑(π.obj (X i))) (i : I)
Goal: ((FundamentalGroupoidFunctor.piToPiTop X).obj g).as i = (g i).as
-- FundamentalGroupoidFunctor.piToPiTop_map
@[simps]
def piToPiTop : (∀ i, πₓ (X i)) ⥤ πₓ (TopCat.of (∀ i, X i)) 
Arguments: {I : Type u} (X : I → TopCat)
Goal: ∀ {X_1 Y : (i : I) → ↑(π.obj (X i))} (p : X_1 ⟶ Y), (FundamentalGroupoidFunctor.piToPiTop X).map p = Path.Homotopic.pi p
-- FundamentalGroupoidFunctor.piIso_hom
@[simps]
def piIso : CategoryTheory.Grpd.of (∀ i : I, πₓ (X i)) ≅ πₓ (TopCat.of (∀ i, X i)) 
Arguments: {I : Type u} (X : I → TopCat)
Goal: (FundamentalGroupoidFunctor.piIso X).hom = FundamentalGroupoidFunctor.piToPiTop X
-- FundamentalGroupoidFunctor.piIso_inv
@[simps]
def piIso : CategoryTheory.Grpd.of (∀ i : I, πₓ (X i)) ≅ πₓ (TopCat.of (∀ i, X i)) 
Arguments: {I : Type u} (X : I → TopCat)
Goal: (FundamentalGroupoidFunctor.piIso X).inv = CategoryTheory.Functor.pi' (FundamentalGroupoidFunctor.proj X)
-- FundamentalGroupoidFunctor.coneDiscreteComp_obj_mapCone
theorem coneDiscreteComp_obj_mapCone :
    -- Porting note: check universe parameters here
    (coneDiscreteComp X).functor.obj (Functor.mapCone π (TopCat.piFan.{u,u} X)) =
      Limits.Fan.mk (πₓ (TopCat.of (∀ i, X i))) (proj X) 
Arguments: {I : Type u} (X : I → TopCat)
Goal: (FundamentalGroupoidFunctor.coneDiscreteComp X).functor.obj (π.mapCone (TopCat.piFan X)) =
  CategoryTheory.Limits.Fan.mk (π.obj (TopCat.of ((i : I) → ↑(X i)))) (FundamentalGroupoidFunctor.proj X)
-- FundamentalGroupoidFunctor.projLeft_map
@[simp]
theorem projLeft_map (x₀ x₁ : πₓ (TopCat.of (A × B))) (p : x₀ ⟶ x₁) :
    (projLeft A B).map p = Path.Homotopic.projLeft p 
Arguments: (A B : TopCat) (x₀ x₁ : ↑(π.obj (TopCat.of (↑A × ↑B)))) (p : x₀ ⟶ x₁)
Goal: (FundamentalGroupoidFunctor.projLeft A B).map p = Path.Homotopic.projLeft p
-- FundamentalGroupoidFunctor.projRight_map
@[simp]
theorem projRight_map (x₀ x₁ : πₓ (TopCat.of (A × B))) (p : x₀ ⟶ x₁) :
    (projRight A B).map p = Path.Homotopic.projRight p 
Arguments: (A B : TopCat) (x₀ x₁ : ↑(π.obj (TopCat.of (↑A × ↑B)))) (p : x₀ ⟶ x₁)
Goal: (FundamentalGroupoidFunctor.projRight A B).map p = Path.Homotopic.projRight p
-- FundamentalGroupoidFunctor.prodToProdTop_obj
@[simps obj]
def prodToProdTop : πₓ A × πₓ B ⥤ πₓ (TopCat.of (A × B)) 
Arguments: (A B : TopCat) (g : ↑(π.obj A) × ↑(π.obj B))
Goal: (FundamentalGroupoidFunctor.prodToProdTop A B).obj g = { as := (g.1.as, g.2.as) }
-- FundamentalGroupoidFunctor.prodToProdTop_map
theorem prodToProdTop_map {x₀ x₁ : πₓ A} {y₀ y₁ : πₓ B} (p₀ : x₀ ⟶ x₁) (p₁ : y₀ ⟶ y₁) :
    (prodToProdTop A B).map (X := (x₀, y₀)) (Y := (x₁, y₁)) (p₀, p₁) =
      Path.Homotopic.prod p₀ p₁ 
Arguments: (A B : TopCat) {x₀ x₁ : ↑(π.obj A)} {y₀ y₁ : ↑(π.obj B)} (p₀ : x₀ ⟶ x₁) (p₁ : y₀ ⟶ y₁)
Goal: (FundamentalGroupoidFunctor.prodToProdTop A B).map (p₀, p₁) = Path.Homotopic.prod p₀ p₁
-- FundamentalGroupoidFunctor.prodIso_inv
@[simps]
def prodIso : CategoryTheory.Grpd.of (πₓ A × πₓ B) ≅ πₓ (TopCat.of (A × B)) 
Arguments: (A B : TopCat)
Goal: (FundamentalGroupoidFunctor.prodIso A B).inv =
  (FundamentalGroupoidFunctor.projLeft A B).prod' (FundamentalGroupoidFunctor.projRight A B)
-- FundamentalGroupoidFunctor.prodIso_hom
@[simps]
def prodIso : CategoryTheory.Grpd.of (πₓ A × πₓ B) ≅ πₓ (TopCat.of (A × B)) 
Arguments: (A B : TopCat)
Goal: (FundamentalGroupoidFunctor.prodIso A B).hom = FundamentalGroupoidFunctor.prodToProdTop A B
-- AlgebraicTopology.NormalizedMooreComplex.objX_zero
theorem objX_zero : objX X 0 = ⊤ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] (X : CategoryTheory.SimplicialObject C)
Goal: AlgebraicTopology.NormalizedMooreComplex.objX X 0 = ⊤
-- AlgebraicTopology.NormalizedMooreComplex.objX_add_one
theorem objX_add_one (n) :
    objX X (n + 1) = Finset.univ.inf fun k : Fin (n + 1) => kernelSubobject (X.δ k.succ) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] (X : CategoryTheory.SimplicialObject C) (n : ℕ)
Goal: AlgebraicTopology.NormalizedMooreComplex.objX X (n + 1) =
  Finset.univ.inf fun k => CategoryTheory.Limits.kernelSubobject (X.δ k.succ)
-- AlgebraicTopology.NormalizedMooreComplex.d_squared
theorem d_squared (n : ℕ) : objD X (n + 1) ≫ objD X n = 0 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] (X : CategoryTheory.SimplicialObject C) (n : ℕ)
Goal: AlgebraicTopology.NormalizedMooreComplex.objD X (n + 1) ≫ AlgebraicTopology.NormalizedMooreComplex.objD X n = 0
-- AlgebraicTopology.NormalizedMooreComplex.obj_X
@[simps!]
def obj (X : SimplicialObject C) : ChainComplex C ℕ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] (X : CategoryTheory.SimplicialObject C) (n : ℕ)
Goal: (AlgebraicTopology.NormalizedMooreComplex.obj X).X n =
  CategoryTheory.Subobject.underlying.obj (AlgebraicTopology.NormalizedMooreComplex.objX X n)
-- AlgebraicTopology.NormalizedMooreComplex.obj_d
@[simps!]
def obj (X : SimplicialObject C) : ChainComplex C ℕ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] (X : CategoryTheory.SimplicialObject C) (i j : ℕ)
Goal: (AlgebraicTopology.NormalizedMooreComplex.obj X).d i j =
  if h : i = j + 1 then
    CategoryTheory.eqToHom ⋯ ≫
      match j with
      | 0 =>
        (Finset.univ.inf fun k => CategoryTheory.Limits.kernelSubobject (X.δ k.succ)).arrow ≫
          X.δ 0 ≫ CategoryTheory.inv ⊤.arrow
      | n.succ =>
        (Finset.univ.inf fun k => CategoryTheory.Limits.kernelSubobject (X.δ k.succ)).factorThru
          ((Finset.univ.inf fun k => CategoryTheory.Limits.kernelSubobject (X.δ k.succ)).arrow ≫ X.δ 0) ⋯
  else 0
-- AlgebraicTopology.NormalizedMooreComplex.map_f
@[simps!]
def map (f : X ⟶ Y) : obj X ⟶ obj Y 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {X Y : CategoryTheory.SimplicialObject C} (f : X ⟶ Y) (n : ℕ)
Goal: (AlgebraicTopology.NormalizedMooreComplex.map f).f n =
  (AlgebraicTopology.NormalizedMooreComplex.objX Y n).factorThru
    ((AlgebraicTopology.NormalizedMooreComplex.objX X n).arrow ≫ f.app (Opposite.op (SimplexCategory.mk n))) ⋯
-- AlgebraicTopology.normalizedMooreComplex_map
@[simps]
def normalizedMooreComplex : SimplicialObject C ⥤ ChainComplex C ℕ 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C]
Goal: ∀ {X Y : CategoryTheory.SimplicialObject C} (f : X ⟶ Y),
  (AlgebraicTopology.normalizedMooreComplex C).map f = AlgebraicTopology.NormalizedMooreComplex.map f
-- AlgebraicTopology.normalizedMooreComplex_obj
@[simps]
def normalizedMooreComplex : SimplicialObject C ⥤ ChainComplex C ℕ 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] (X : CategoryTheory.SimplicialObject C)
Goal: (AlgebraicTopology.normalizedMooreComplex C).obj X = AlgebraicTopology.NormalizedMooreComplex.obj X