l3lab/ntp-mathlib huggingface dataset:
@[reassoc]
theorem Γ₀_obj_termwise_mapMono_comp_PInfty (X : SimplicialObject C) {Δ Δ' : SimplexCategory}
    (i : Δ ⟶ Δ') [Mono i] :
    Γ₀.Obj.Termwise.mapMono (AlternatingFaceMapComplex.obj X) i ≫ PInfty.f Δ.len =
      PInfty.f Δ'.len ≫ X.map i.op := by
  induction' Δ using SimplexCategory.rec with n
  induction' Δ' using SimplexCategory.rec with n'
  dsimp
  -- We start with the case `i` is an identity
  by_cases h : n = n'
  · subst h
    simp only [SimplexCategory.eq_id_of_mono i, Γ₀.Obj.Termwise.mapMono_id, op_id, X.map_id]
    dsimp
    simp only [id_comp, comp_id]
  by_cases hi : Isδ₀ i
  -- The case `i = δ 0`
  · have h' : n' = n + 1 := hi.left
    subst h'
    simp only [Γ₀.Obj.Termwise.mapMono_δ₀' _ i hi]
    dsimp
    rw [← PInfty.comm _ n, AlternatingFaceMapComplex.obj_d_eq]
    simp only [eq_self_iff_true, id_comp, if_true, Preadditive.comp_sum]
    rw [Finset.sum_eq_single (0 : Fin (n + 2))]
    rotate_left
    · intro b _ hb
      rw [Preadditive.comp_zsmul]
      erw [PInfty_comp_map_mono_eq_zero X (SimplexCategory.δ b) h
          (by
            rw [Isδ₀.iff]
            exact hb),
        zsmul_zero]
    · simp only [Finset.mem_univ, not_true, IsEmpty.forall_iff]
    · simp only [hi.eq_δ₀, Fin.val_zero, pow_zero, one_zsmul]
      rfl
  -- The case `i ≠ δ 0`
  · rw [Γ₀.Obj.Termwise.mapMono_eq_zero _ i _ hi, zero_comp]
    swap
    · by_contra h'
      exact h (congr_arg SimplexCategory.len h'.symm)
    rw [PInfty_comp_map_mono_eq_zero]
    · 

Proof state:
case neg.h₁
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
X : SimplicialObject C
n n' : ℕ
i : [n] ⟶ [n']
inst✝ : Mono i
h : ¬n = n'
hi : ¬Isδ₀ i
⊢ len [n] ≠ n'

Next tactic:
exact h
@[reassoc]
theorem Γ₀_obj_termwise_mapMono_comp_PInfty (X : SimplicialObject C) {Δ Δ' : SimplexCategory}
    (i : Δ ⟶ Δ') [Mono i] :
    Γ₀.Obj.Termwise.mapMono (AlternatingFaceMapComplex.obj X) i ≫ PInfty.f Δ.len =
      PInfty.f Δ'.len ≫ X.map i.op := by
  induction' Δ using SimplexCategory.rec with n
  induction' Δ' using SimplexCategory.rec with n'
  dsimp
  -- We start with the case `i` is an identity
  by_cases h : n = n'
  · subst h
    simp only [SimplexCategory.eq_id_of_mono i, Γ₀.Obj.Termwise.mapMono_id, op_id, X.map_id]
    dsimp
    simp only [id_comp, comp_id]
  by_cases hi : Isδ₀ i
  -- The case `i = δ 0`
  · have h' : n' = n + 1 := hi.left
    subst h'
    simp only [Γ₀.Obj.Termwise.mapMono_δ₀' _ i hi]
    dsimp
    rw [← PInfty.comm _ n, AlternatingFaceMapComplex.obj_d_eq]
    simp only [eq_self_iff_true, id_comp, if_true, Preadditive.comp_sum]
    rw [Finset.sum_eq_single (0 : Fin (n + 2))]
    rotate_left
    · intro b _ hb
      rw [Preadditive.comp_zsmul]
      erw [PInfty_comp_map_mono_eq_zero X (SimplexCategory.δ b) h
          (by
            rw [Isδ₀.iff]
            exact hb),
        zsmul_zero]
    · simp only [Finset.mem_univ, not_true, IsEmpty.forall_iff]
    · simp only [hi.eq_δ₀, Fin.val_zero, pow_zero, one_zsmul]
      rfl
  -- The case `i ≠ δ 0`
  · rw [Γ₀.Obj.Termwise.mapMono_eq_zero _ i _ hi, zero_comp]
    swap
    · by_contra h'
      exact h (congr_arg SimplexCategory.len h'.symm)
    rw [PInfty_comp_map_mono_eq_zero]
    · exact h
    · 

Proof state:
case neg.h₂
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
X : SimplicialObject C
n n' : ℕ
i : [n] ⟶ [n']
inst✝ : Mono i
h : ¬n = n'
hi : ¬Isδ₀ i
⊢ ¬Isδ₀ i

Next tactic:
by_contra h'
@[reassoc]
theorem Γ₀_obj_termwise_mapMono_comp_PInfty (X : SimplicialObject C) {Δ Δ' : SimplexCategory}
    (i : Δ ⟶ Δ') [Mono i] :
    Γ₀.Obj.Termwise.mapMono (AlternatingFaceMapComplex.obj X) i ≫ PInfty.f Δ.len =
      PInfty.f Δ'.len ≫ X.map i.op := by
  induction' Δ using SimplexCategory.rec with n
  induction' Δ' using SimplexCategory.rec with n'
  dsimp
  -- We start with the case `i` is an identity
  by_cases h : n = n'
  · subst h
    simp only [SimplexCategory.eq_id_of_mono i, Γ₀.Obj.Termwise.mapMono_id, op_id, X.map_id]
    dsimp
    simp only [id_comp, comp_id]
  by_cases hi : Isδ₀ i
  -- The case `i = δ 0`
  · have h' : n' = n + 1 := hi.left
    subst h'
    simp only [Γ₀.Obj.Termwise.mapMono_δ₀' _ i hi]
    dsimp
    rw [← PInfty.comm _ n, AlternatingFaceMapComplex.obj_d_eq]
    simp only [eq_self_iff_true, id_comp, if_true, Preadditive.comp_sum]
    rw [Finset.sum_eq_single (0 : Fin (n + 2))]
    rotate_left
    · intro b _ hb
      rw [Preadditive.comp_zsmul]
      erw [PInfty_comp_map_mono_eq_zero X (SimplexCategory.δ b) h
          (by
            rw [Isδ₀.iff]
            exact hb),
        zsmul_zero]
    · simp only [Finset.mem_univ, not_true, IsEmpty.forall_iff]
    · simp only [hi.eq_δ₀, Fin.val_zero, pow_zero, one_zsmul]
      rfl
  -- The case `i ≠ δ 0`
  · rw [Γ₀.Obj.Termwise.mapMono_eq_zero _ i _ hi, zero_comp]
    swap
    · by_contra h'
      exact h (congr_arg SimplexCategory.len h'.symm)
    rw [PInfty_comp_map_mono_eq_zero]
    · exact h
    · by_contra h'
      

Proof state:
case neg.h₂
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
X : SimplicialObject C
n n' : ℕ
i : [n] ⟶ [n']
inst✝ : Mono i
h : ¬n = n'
hi : ¬Isδ₀ i
h' : Isδ₀ i
⊢ False

Next tactic:
exact hi h'
/-- The natural transformation `N₁ ⋙ Γ₂ ⟶ toKaroubi (SimplicialObject C)`. -/
@[simps]
def natTrans : (N₁ : SimplicialObject C ⥤ _) ⋙ Γ₂ ⟶ toKaroubi _ where
  app X :=
    { f :=
        { app := fun Δ => (Γ₀.splitting K[X]).desc Δ fun A => PInfty.f A.1.unop.len ≫ X.map A.e.op
          naturality := fun Δ Δ' θ => by
            

Proof state:
C : Type u_1
inst✝² : Category.{?u.48241, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : SimplicialObject C
Δ Δ' : SimplexCategoryᵒᵖ
θ : Δ ⟶ Δ'
⊢ ((N₁ ⋙ Γ₂).obj X).X.map θ ≫
      (fun Δ =>
          Splitting.desc (Γ₀.splitting K[X]) Δ fun A =>
            HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫ X.map (Splitting.IndexSet.e A).op)
        Δ' =
    (fun Δ =>
          Splitting.desc (Γ₀.splitting K[X]) Δ fun A =>
            HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫ X.map (Splitting.IndexSet.e A).op)
        Δ ≫
      ((toKaroubi (SimplicialObject C)).obj X).X.map θ

Next tactic:
apply (Γ₀.splitting K[X]).hom_ext'
/-- The natural transformation `N₁ ⋙ Γ₂ ⟶ toKaroubi (SimplicialObject C)`. -/
@[simps]
def natTrans : (N₁ : SimplicialObject C ⥤ _) ⋙ Γ₂ ⟶ toKaroubi _ where
  app X :=
    { f :=
        { app := fun Δ => (Γ₀.splitting K[X]).desc Δ fun A => PInfty.f A.1.unop.len ≫ X.map A.e.op
          naturality := fun Δ Δ' θ => by
            apply (Γ₀.splitting K[X]).hom_ext'
            

Proof state:
case h
C : Type u_1
inst✝² : Category.{?u.48241, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : SimplicialObject C
Δ Δ' : SimplexCategoryᵒᵖ
θ : Δ ⟶ Δ'
⊢ ∀ (A : Splitting.IndexSet Δ),
    Splitting.ιSummand (Γ₀.splitting K[X]) A ≫
        ((N₁ ⋙ Γ₂).obj X).X.map θ ≫
          (fun Δ =>
              Splitting.desc (Γ₀.splitting K[X]) Δ fun A =>
                HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫ X.map (Splitting.IndexSet.e A).op)
            Δ' =
      Splitting.ιSummand (Γ₀.splitting K[X]) A ≫
        (fun Δ =>
              Splitting.desc (Γ₀.splitting K[X]) Δ fun A =>
                HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫ X.map (Splitting.IndexSet.e A).op)
            Δ ≫
          ((toKaroubi (SimplicialObject C)).obj X).X.map θ

Next tactic:
intro A
/-- The natural transformation `N₁ ⋙ Γ₂ ⟶ toKaroubi (SimplicialObject C)`. -/
@[simps]
def natTrans : (N₁ : SimplicialObject C ⥤ _) ⋙ Γ₂ ⟶ toKaroubi _ where
  app X :=
    { f :=
        { app := fun Δ => (Γ₀.splitting K[X]).desc Δ fun A => PInfty.f A.1.unop.len ≫ X.map A.e.op
          naturality := fun Δ Δ' θ => by
            apply (Γ₀.splitting K[X]).hom_ext'
            intro A
            

Proof state:
case h
C : Type u_1
inst✝² : Category.{?u.48241, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : SimplicialObject C
Δ Δ' : SimplexCategoryᵒᵖ
θ : Δ ⟶ Δ'
A : Splitting.IndexSet Δ
⊢ Splitting.ιSummand (Γ₀.splitting K[X]) A ≫
      ((N₁ ⋙ Γ₂).obj X).X.map θ ≫
        (fun Δ =>
            Splitting.desc (Γ₀.splitting K[X]) Δ fun A =>
              HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫ X.map (Splitting.IndexSet.e A).op)
          Δ' =
    Splitting.ιSummand (Γ₀.splitting K[X]) A ≫
      (fun Δ =>
            Splitting.desc (Γ₀.splitting K[X]) Δ fun A =>
              HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫ X.map (Splitting.IndexSet.e A).op)
          Δ ≫
        ((toKaroubi (SimplicialObject C)).obj X).X.map θ

Next tactic:
change _ ≫ (Γ₀.obj K[X]).map θ ≫ _ = _
/-- The natural transformation `N₁ ⋙ Γ₂ ⟶ toKaroubi (SimplicialObject C)`. -/
@[simps]
def natTrans : (N₁ : SimplicialObject C ⥤ _) ⋙ Γ₂ ⟶ toKaroubi _ where
  app X :=
    { f :=
        { app := fun Δ => (Γ₀.splitting K[X]).desc Δ fun A => PInfty.f A.1.unop.len ≫ X.map A.e.op
          naturality := fun Δ Δ' θ => by
            apply (Γ₀.splitting K[X]).hom_ext'
            intro A
            change _ ≫ (Γ₀.obj K[X]).map θ ≫ _ = _
            

Proof state:
case h
C : Type u_1
inst✝² : Category.{?u.48241, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : SimplicialObject C
Δ Δ' : SimplexCategoryᵒᵖ
θ : Δ ⟶ Δ'
A : Splitting.IndexSet Δ
⊢ Splitting.ιSummand (Γ₀.splitting K[X]) A ≫
      (Γ₀.obj K[X]).map θ ≫
        (fun Δ =>
            Splitting.desc (Γ₀.splitting K[X]) Δ fun A =>
              HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫ X.map (Splitting.IndexSet.e A).op)
          Δ' =
    Splitting.ιSummand (Γ₀.splitting K[X]) A ≫
      (fun Δ =>
            Splitting.desc (Γ₀.splitting K[X]) Δ fun A =>
              HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫ X.map (Splitting.IndexSet.e A).op)
          Δ ≫
        ((toKaroubi (SimplicialObject C)).obj X).X.map θ

Next tactic:
simp only [Splitting.ι_desc_assoc, assoc, Γ₀.Obj.map_on_summand'_assoc,
              Splitting.ι_desc]
/-- The natural transformation `N₁ ⋙ Γ₂ ⟶ toKaroubi (SimplicialObject C)`. -/
@[simps]
def natTrans : (N₁ : SimplicialObject C ⥤ _) ⋙ Γ₂ ⟶ toKaroubi _ where
  app X :=
    { f :=
        { app := fun Δ => (Γ₀.splitting K[X]).desc Δ fun A => PInfty.f A.1.unop.len ≫ X.map A.e.op
          naturality := fun Δ Δ' θ => by
            apply (Γ₀.splitting K[X]).hom_ext'
            intro A
            change _ ≫ (Γ₀.obj K[X]).map θ ≫ _ = _
            simp only [Splitting.ι_desc_assoc, assoc, Γ₀.Obj.map_on_summand'_assoc,
              Splitting.ι_desc]
            

Proof state:
case h
C : Type u_1
inst✝² : Category.{?u.48241, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : SimplicialObject C
Δ Δ' : SimplexCategoryᵒᵖ
θ : Δ ⟶ Δ'
A : Splitting.IndexSet Δ
⊢ Γ₀.Obj.Termwise.mapMono K[X] (image.ι (θ.unop ≫ Splitting.IndexSet.e A)) ≫
      HomologicalComplex.Hom.f PInfty (len (Splitting.IndexSet.pull A θ).fst.unop) ≫
        X.map (Splitting.IndexSet.e (Splitting.IndexSet.pull A θ)).op =
    HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫
      X.map (Splitting.IndexSet.e A).op ≫ ((toKaroubi (SimplicialObject C)).obj X).X.map θ

Next tactic:
erw [Γ₀_obj_termwise_mapMono_comp_PInfty_assoc X (image.ι (θ.unop ≫ A.e))]
/-- The natural transformation `N₁ ⋙ Γ₂ ⟶ toKaroubi (SimplicialObject C)`. -/
@[simps]
def natTrans : (N₁ : SimplicialObject C ⥤ _) ⋙ Γ₂ ⟶ toKaroubi _ where
  app X :=
    { f :=
        { app := fun Δ => (Γ₀.splitting K[X]).desc Δ fun A => PInfty.f A.1.unop.len ≫ X.map A.e.op
          naturality := fun Δ Δ' θ => by
            apply (Γ₀.splitting K[X]).hom_ext'
            intro A
            change _ ≫ (Γ₀.obj K[X]).map θ ≫ _ = _
            simp only [Splitting.ι_desc_assoc, assoc, Γ₀.Obj.map_on_summand'_assoc,
              Splitting.ι_desc]
            erw [Γ₀_obj_termwise_mapMono_comp_PInfty_assoc X (image.ι (θ.unop ≫ A.e))]
            

Proof state:
case h
C : Type u_1
inst✝² : Category.{?u.48241, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : SimplicialObject C
Δ Δ' : SimplexCategoryᵒᵖ
θ : Δ ⟶ Δ'
A : Splitting.IndexSet Δ
⊢ HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫
      X.map (image.ι (θ.unop ≫ Splitting.IndexSet.e A)).op ≫
        X.map (Splitting.IndexSet.e (Splitting.IndexSet.pull A θ)).op =
    HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫
      X.map (Splitting.IndexSet.e A).op ≫ ((toKaroubi (SimplicialObject C)).obj X).X.map θ

Next tactic:
dsimp only [toKaroubi]
/-- The natural transformation `N₁ ⋙ Γ₂ ⟶ toKaroubi (SimplicialObject C)`. -/
@[simps]
def natTrans : (N₁ : SimplicialObject C ⥤ _) ⋙ Γ₂ ⟶ toKaroubi _ where
  app X :=
    { f :=
        { app := fun Δ => (Γ₀.splitting K[X]).desc Δ fun A => PInfty.f A.1.unop.len ≫ X.map A.e.op
          naturality := fun Δ Δ' θ => by
            apply (Γ₀.splitting K[X]).hom_ext'
            intro A
            change _ ≫ (Γ₀.obj K[X]).map θ ≫ _ = _
            simp only [Splitting.ι_desc_assoc, assoc, Γ₀.Obj.map_on_summand'_assoc,
              Splitting.ι_desc]
            erw [Γ₀_obj_termwise_mapMono_comp_PInfty_assoc X (image.ι (θ.unop ≫ A.e))]
            dsimp only [toKaroubi]
            

Proof state:
case h
C : Type u_1
inst✝² : Category.{?u.48241, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : SimplicialObject C
Δ Δ' : SimplexCategoryᵒᵖ
θ : Δ ⟶ Δ'
A : Splitting.IndexSet Δ
⊢ HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫
      X.map (image.ι (θ.unop ≫ Splitting.IndexSet.e A)).op ≫
        X.map (Splitting.IndexSet.e (Splitting.IndexSet.pull A θ)).op =
    HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫ X.map (Splitting.IndexSet.e A).op ≫ X.map θ

Next tactic:
simp only [← X.map_comp]
/-- The natural transformation `N₁ ⋙ Γ₂ ⟶ toKaroubi (SimplicialObject C)`. -/
@[simps]
def natTrans : (N₁ : SimplicialObject C ⥤ _) ⋙ Γ₂ ⟶ toKaroubi _ where
  app X :=
    { f :=
        { app := fun Δ => (Γ₀.splitting K[X]).desc Δ fun A => PInfty.f A.1.unop.len ≫ X.map A.e.op
          naturality := fun Δ Δ' θ => by
            apply (Γ₀.splitting K[X]).hom_ext'
            intro A
            change _ ≫ (Γ₀.obj K[X]).map θ ≫ _ = _
            simp only [Splitting.ι_desc_assoc, assoc, Γ₀.Obj.map_on_summand'_assoc,
              Splitting.ι_desc]
            erw [Γ₀_obj_termwise_mapMono_comp_PInfty_assoc X (image.ι (θ.unop ≫ A.e))]
            dsimp only [toKaroubi]
            simp only [← X.map_comp]
            

Proof state:
case h
C : Type u_1
inst✝² : Category.{?u.48241, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : SimplicialObject C
Δ Δ' : SimplexCategoryᵒᵖ
θ : Δ ⟶ Δ'
A : Splitting.IndexSet Δ
⊢ HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫
      X.map ((image.ι (θ.unop ≫ Splitting.IndexSet.e A)).op ≫ (Splitting.IndexSet.e (Splitting.IndexSet.pull A θ)).op) =
    HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫ X.map ((Splitting.IndexSet.e A).op ≫ θ)

Next tactic:
congr 2
/-- The natural transformation `N₁ ⋙ Γ₂ ⟶ toKaroubi (SimplicialObject C)`. -/
@[simps]
def natTrans : (N₁ : SimplicialObject C ⥤ _) ⋙ Γ₂ ⟶ toKaroubi _ where
  app X :=
    { f :=
        { app := fun Δ => (Γ₀.splitting K[X]).desc Δ fun A => PInfty.f A.1.unop.len ≫ X.map A.e.op
          naturality := fun Δ Δ' θ => by
            apply (Γ₀.splitting K[X]).hom_ext'
            intro A
            change _ ≫ (Γ₀.obj K[X]).map θ ≫ _ = _
            simp only [Splitting.ι_desc_assoc, assoc, Γ₀.Obj.map_on_summand'_assoc,
              Splitting.ι_desc]
            erw [Γ₀_obj_termwise_mapMono_comp_PInfty_assoc X (image.ι (θ.unop ≫ A.e))]
            dsimp only [toKaroubi]
            simp only [← X.map_comp]
            congr 2
            

Proof state:
case h.e_a.e_a
C : Type u_1
inst✝² : Category.{?u.48241, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : SimplicialObject C
Δ Δ' : SimplexCategoryᵒᵖ
θ : Δ ⟶ Δ'
A : Splitting.IndexSet Δ
⊢ (image.ι (θ.unop ≫ Splitting.IndexSet.e A)).op ≫ (Splitting.IndexSet.e (Splitting.IndexSet.pull A θ)).op =
    (Splitting.IndexSet.e A).op ≫ θ

Next tactic:
simp only [eqToHom_refl, id_comp, comp_id, ← op_comp]
/-- The natural transformation `N₁ ⋙ Γ₂ ⟶ toKaroubi (SimplicialObject C)`. -/
@[simps]
def natTrans : (N₁ : SimplicialObject C ⥤ _) ⋙ Γ₂ ⟶ toKaroubi _ where
  app X :=
    { f :=
        { app := fun Δ => (Γ₀.splitting K[X]).desc Δ fun A => PInfty.f A.1.unop.len ≫ X.map A.e.op
          naturality := fun Δ Δ' θ => by
            apply (Γ₀.splitting K[X]).hom_ext'
            intro A
            change _ ≫ (Γ₀.obj K[X]).map θ ≫ _ = _
            simp only [Splitting.ι_desc_assoc, assoc, Γ₀.Obj.map_on_summand'_assoc,
              Splitting.ι_desc]
            erw [Γ₀_obj_termwise_mapMono_comp_PInfty_assoc X (image.ι (θ.unop ≫ A.e))]
            dsimp only [toKaroubi]
            simp only [← X.map_comp]
            congr 2
            simp only [eqToHom_refl, id_comp, comp_id, ← op_comp]
            

Proof state:
case h.e_a.e_a
C : Type u_1
inst✝² : Category.{?u.48241, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : SimplicialObject C
Δ Δ' : SimplexCategoryᵒᵖ
θ : Δ ⟶ Δ'
A : Splitting.IndexSet Δ
⊢ (Splitting.IndexSet.e (Splitting.IndexSet.pull A θ) ≫ image.ι (θ.unop ≫ Splitting.IndexSet.e A)).op =
    (Splitting.IndexSet.e A).op ≫ θ

Next tactic:
exact Quiver.Hom.unop_inj (A.fac_pull θ)
/-- The natural transformation `N₁ ⋙ Γ₂ ⟶ toKaroubi (SimplicialObject C)`. -/
@[simps]
def natTrans : (N₁ : SimplicialObject C ⥤ _) ⋙ Γ₂ ⟶ toKaroubi _ where
  app X :=
    { f :=
        { app := fun Δ => (Γ₀.splitting K[X]).desc Δ fun A => PInfty.f A.1.unop.len ≫ X.map A.e.op
          naturality := fun Δ Δ' θ => by
            apply (Γ₀.splitting K[X]).hom_ext'
            intro A
            change _ ≫ (Γ₀.obj K[X]).map θ ≫ _ = _
            simp only [Splitting.ι_desc_assoc, assoc, Γ₀.Obj.map_on_summand'_assoc,
              Splitting.ι_desc]
            erw [Γ₀_obj_termwise_mapMono_comp_PInfty_assoc X (image.ι (θ.unop ≫ A.e))]
            dsimp only [toKaroubi]
            simp only [← X.map_comp]
            congr 2
            simp only [eqToHom_refl, id_comp, comp_id, ← op_comp]
            exact Quiver.Hom.unop_inj (A.fac_pull θ) }
      comm := by
        

Proof state:
C : Type u_1
inst✝² : Category.{?u.48241, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : SimplicialObject C
⊢ (NatTrans.mk fun Δ =>
      Splitting.desc (Γ₀.splitting K[X]) Δ fun A =>
        HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫ X.map (Splitting.IndexSet.e A).op) =
    ((N₁ ⋙ Γ₂).obj X).p ≫
      (NatTrans.mk fun Δ =>
          Splitting.desc (Γ₀.splitting K[X]) Δ fun A =>
            HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫ X.map (Splitting.IndexSet.e A).op) ≫
        ((toKaroubi (SimplicialObject C)).obj X).p

Next tactic:
apply (Γ₀.splitting K[X]).hom_ext
/-- The natural transformation `N₁ ⋙ Γ₂ ⟶ toKaroubi (SimplicialObject C)`. -/
@[simps]
def natTrans : (N₁ : SimplicialObject C ⥤ _) ⋙ Γ₂ ⟶ toKaroubi _ where
  app X :=
    { f :=
        { app := fun Δ => (Γ₀.splitting K[X]).desc Δ fun A => PInfty.f A.1.unop.len ≫ X.map A.e.op
          naturality := fun Δ Δ' θ => by
            apply (Γ₀.splitting K[X]).hom_ext'
            intro A
            change _ ≫ (Γ₀.obj K[X]).map θ ≫ _ = _
            simp only [Splitting.ι_desc_assoc, assoc, Γ₀.Obj.map_on_summand'_assoc,
              Splitting.ι_desc]
            erw [Γ₀_obj_termwise_mapMono_comp_PInfty_assoc X (image.ι (θ.unop ≫ A.e))]
            dsimp only [toKaroubi]
            simp only [← X.map_comp]
            congr 2
            simp only [eqToHom_refl, id_comp, comp_id, ← op_comp]
            exact Quiver.Hom.unop_inj (A.fac_pull θ) }
      comm := by
        apply (Γ₀.splitting K[X]).hom_ext
        

Proof state:
case h
C : Type u_1
inst✝² : Category.{?u.48241, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : SimplicialObject C
⊢ ∀ (n : ℕ),
    Splitting.φ (Γ₀.splitting K[X])
        (NatTrans.mk fun Δ =>
          Splitting.desc (Γ₀.splitting K[X]) Δ fun A =>
            HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫ X.map (Splitting.IndexSet.e A).op)
        n =
      Splitting.φ (Γ₀.splitting K[X])
        (((N₁ ⋙ Γ₂).obj X).p ≫
          (NatTrans.mk fun Δ =>
              Splitting.desc (Γ₀.splitting K[X]) Δ fun A =>
                HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫ X.map (Splitting.IndexSet.e A).op) ≫
            ((toKaroubi (SimplicialObject C)).obj X).p)
        n

Next tactic:
intro n
/-- The natural transformation `N₁ ⋙ Γ₂ ⟶ toKaroubi (SimplicialObject C)`. -/
@[simps]
def natTrans : (N₁ : SimplicialObject C ⥤ _) ⋙ Γ₂ ⟶ toKaroubi _ where
  app X :=
    { f :=
        { app := fun Δ => (Γ₀.splitting K[X]).desc Δ fun A => PInfty.f A.1.unop.len ≫ X.map A.e.op
          naturality := fun Δ Δ' θ => by
            apply (Γ₀.splitting K[X]).hom_ext'
            intro A
            change _ ≫ (Γ₀.obj K[X]).map θ ≫ _ = _
            simp only [Splitting.ι_desc_assoc, assoc, Γ₀.Obj.map_on_summand'_assoc,
              Splitting.ι_desc]
            erw [Γ₀_obj_termwise_mapMono_comp_PInfty_assoc X (image.ι (θ.unop ≫ A.e))]
            dsimp only [toKaroubi]
            simp only [← X.map_comp]
            congr 2
            simp only [eqToHom_refl, id_comp, comp_id, ← op_comp]
            exact Quiver.Hom.unop_inj (A.fac_pull θ) }
      comm := by
        apply (Γ₀.splitting K[X]).hom_ext
        intro n
        

Proof state:
case h
C : Type u_1
inst✝² : Category.{?u.48241, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : SimplicialObject C
n : ℕ
⊢ Splitting.φ (Γ₀.splitting K[X])
      (NatTrans.mk fun Δ =>
        Splitting.desc (Γ₀.splitting K[X]) Δ fun A =>
          HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫ X.map (Splitting.IndexSet.e A).op)
      n =
    Splitting.φ (Γ₀.splitting K[X])
      (((N₁ ⋙ Γ₂).obj X).p ≫
        (NatTrans.mk fun Δ =>
            Splitting.desc (Γ₀.splitting K[X]) Δ fun A =>
              HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫ X.map (Splitting.IndexSet.e A).op) ≫
          ((toKaroubi (SimplicialObject C)).obj X).p)
      n

Next tactic:
dsimp [N₁]
/-- The natural transformation `N₁ ⋙ Γ₂ ⟶ toKaroubi (SimplicialObject C)`. -/
@[simps]
def natTrans : (N₁ : SimplicialObject C ⥤ _) ⋙ Γ₂ ⟶ toKaroubi _ where
  app X :=
    { f :=
        { app := fun Δ => (Γ₀.splitting K[X]).desc Δ fun A => PInfty.f A.1.unop.len ≫ X.map A.e.op
          naturality := fun Δ Δ' θ => by
            apply (Γ₀.splitting K[X]).hom_ext'
            intro A
            change _ ≫ (Γ₀.obj K[X]).map θ ≫ _ = _
            simp only [Splitting.ι_desc_assoc, assoc, Γ₀.Obj.map_on_summand'_assoc,
              Splitting.ι_desc]
            erw [Γ₀_obj_termwise_mapMono_comp_PInfty_assoc X (image.ι (θ.unop ≫ A.e))]
            dsimp only [toKaroubi]
            simp only [← X.map_comp]
            congr 2
            simp only [eqToHom_refl, id_comp, comp_id, ← op_comp]
            exact Quiver.Hom.unop_inj (A.fac_pull θ) }
      comm := by
        apply (Γ₀.splitting K[X]).hom_ext
        intro n
        dsimp [N₁]
        

Proof state:
case h
C : Type u_1
inst✝² : Category.{?u.48241, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : SimplicialObject C
n : ℕ
⊢ (Splitting.ι (Γ₀.splitting K[X]) n ≫
      Splitting.desc (Γ₀.splitting K[X]) (op [n]) fun A =>
        HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫ X.map (Splitting.IndexSet.e A).op) =
    Splitting.ι (Γ₀.splitting K[X]) n ≫
      (Splitting.desc (Γ₀.splitting K[X]) (op [n]) fun A =>
          HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫ Splitting.ιSummand (Γ₀.splitting K[X]) A) ≫
        (Splitting.desc (Γ₀.splitting K[X]) (op [n]) fun A =>
            HomologicalComplex.Hom.f PInfty (len A.fst.unop) ≫ X.map (Splitting.IndexSet.e A).op) ≫
          𝟙 (X.obj (op [n]))

Next tactic:
simp only [← Splitting.ιSummand_id, Splitting.ι_desc, comp_id, Splitting.ι_desc_assoc,
          assoc, PInfty_f_idem_assoc]