l3lab/ntp-mathlib huggingface dataset:
/-- The functor `Γ₀ : ChainComplex C ℕ ⥤ SimplicialObject C`, on objects. -/
@[simps]
def obj (K : ChainComplex C ℕ) : SimplicialObject C where
  obj Δ := Obj.obj₂ K Δ
  map θ := Obj.map K θ
  map_id Δ := colimit.hom_ext (fun ⟨A⟩ => by
    dsimp
    have fac : A.e ≫ 𝟙 A.1.unop = (𝟙 Δ).unop ≫ A.e := by rw [unop_id, comp_id, id_comp]
    erw [Obj.map_on_summand₀ K A fac, Obj.Termwise.mapMono_id, id_comp, comp_id]
    rfl)
  map_comp {Δ'' Δ' Δ} θ' θ := colimit.hom_ext (fun ⟨A⟩ => by
    have fac : θ.unop ≫ θ'.unop ≫ A.e = (θ' ≫ θ).unop ≫ A.e := by rw [unop_comp, assoc]
    rw [← image.fac (θ'.unop ≫ A.e), ← assoc, ←
      image.fac (θ.unop ≫ factorThruImage (θ'.unop ≫ A.e)), assoc] at fac
    simp only [Obj.map_on_summand₀'_assoc K A θ', Obj.map_on_summand₀' K _ θ,
      Obj.Termwise.mapMono_comp_assoc, Obj.map_on_summand₀ K A fac]
    

Proof state:
C : Type u_1
inst✝² : Category.{?u.112409, u_1} C
inst✝¹ : Preadditive C
K✝ K' : ChainComplex C ℕ
f : K✝ ⟶ K'
Δ✝ Δ'✝ Δ''✝ : SimplexCategory
inst✝ : HasFiniteCoproducts C
K : ChainComplex C ℕ
Δ'' Δ' Δ : SimplexCategoryᵒᵖ
θ' : Δ'' ⟶ Δ'
θ : Δ' ⟶ Δ
x✝ : Discrete (Splitting.IndexSet Δ'')
A : Splitting.IndexSet Δ''
fac :
  factorThruImage (θ.unop ≫ factorThruImage (θ'.unop ≫ Splitting.IndexSet.e A)) ≫
      image.ι (θ.unop ≫ factorThruImage (θ'.unop ≫ Splitting.IndexSet.e A)) ≫
        image.ι (θ'.unop ≫ Splitting.IndexSet.e A) =
    (θ' ≫ θ).unop ≫ Splitting.IndexSet.e A
⊢ Obj.Termwise.mapMono K
        (image.ι (θ.unop ≫ factorThruImage (θ'.unop ≫ Splitting.IndexSet.e A)) ≫
          image.ι (θ'.unop ≫ Splitting.IndexSet.e A)) ≫
      Sigma.ι (Obj.summand K Δ)
        (Splitting.IndexSet.mk (factorThruImage (θ.unop ≫ factorThruImage (θ'.unop ≫ Splitting.IndexSet.e A)))) =
    Obj.Termwise.mapMono K
        (image.ι (θ.unop ≫ Splitting.IndexSet.e (Splitting.IndexSet.pull A θ')) ≫
          image.ι (θ'.unop ≫ Splitting.IndexSet.e A)) ≫
      Sigma.ι (Obj.summand K Δ) (Splitting.IndexSet.pull (Splitting.IndexSet.pull A θ') θ)

Next tactic:
rfl
theorem splitting_map_eq_id (Δ : SimplexCategoryᵒᵖ) :
    SimplicialObject.Splitting.map (Γ₀.obj K)
        (fun n : ℕ => Sigma.ι (Γ₀.Obj.summand K (op [n])) (Splitting.IndexSet.id (op [n]))) Δ =
      𝟙 _ := colimit.hom_ext (fun ⟨A⟩ => by
  

Proof state:
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ✝ Δ' Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
Δ : SimplexCategoryᵒᵖ
x✝ : Discrete (Splitting.IndexSet Δ)
A : Splitting.IndexSet Δ
⊢ colimit.ι (Discrete.functor (Splitting.summand (fun n => Obj.summand K (op [n]) (Splitting.IndexSet.id (op [n]))) Δ))
        { as := A } ≫
      Splitting.map (obj K) (fun n => Sigma.ι (Obj.summand K (op [n])) (Splitting.IndexSet.id (op [n]))) Δ =
    colimit.ι
        (Discrete.functor (Splitting.summand (fun n => Obj.summand K (op [n]) (Splitting.IndexSet.id (op [n]))) Δ))
        { as := A } ≫
      𝟙 (Splitting.coprod (fun n => Obj.summand K (op [n]) (Splitting.IndexSet.id (op [n]))) Δ)

Next tactic:
induction' Δ using Opposite.rec' with Δ
theorem splitting_map_eq_id (Δ : SimplexCategoryᵒᵖ) :
    SimplicialObject.Splitting.map (Γ₀.obj K)
        (fun n : ℕ => Sigma.ι (Γ₀.Obj.summand K (op [n])) (Splitting.IndexSet.id (op [n]))) Δ =
      𝟙 _ := colimit.hom_ext (fun ⟨A⟩ => by
  induction' Δ using Opposite.rec' with Δ
  

Proof state:
case h
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ✝ Δ' Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
Δ : SimplexCategory
x✝ : Discrete (Splitting.IndexSet (op Δ))
A : Splitting.IndexSet (op Δ)
⊢ colimit.ι
        (Discrete.functor (Splitting.summand (fun n => Obj.summand K (op [n]) (Splitting.IndexSet.id (op [n]))) (op Δ)))
        { as := A } ≫
      Splitting.map (obj K) (fun n => Sigma.ι (Obj.summand K (op [n])) (Splitting.IndexSet.id (op [n]))) (op Δ) =
    colimit.ι
        (Discrete.functor (Splitting.summand (fun n => Obj.summand K (op [n]) (Splitting.IndexSet.id (op [n]))) (op Δ)))
        { as := A } ≫
      𝟙 (Splitting.coprod (fun n => Obj.summand K (op [n]) (Splitting.IndexSet.id (op [n]))) (op Δ))

Next tactic:
induction' Δ using SimplexCategory.rec with n
theorem splitting_map_eq_id (Δ : SimplexCategoryᵒᵖ) :
    SimplicialObject.Splitting.map (Γ₀.obj K)
        (fun n : ℕ => Sigma.ι (Γ₀.Obj.summand K (op [n])) (Splitting.IndexSet.id (op [n]))) Δ =
      𝟙 _ := colimit.hom_ext (fun ⟨A⟩ => by
  induction' Δ using Opposite.rec' with Δ
  induction' Δ using SimplexCategory.rec with n
  

Proof state:
case h.h
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
n : ℕ
x✝ : Discrete (Splitting.IndexSet (op [n]))
A : Splitting.IndexSet (op [n])
⊢ colimit.ι
        (Discrete.functor
          (Splitting.summand (fun n => Obj.summand K (op [n]) (Splitting.IndexSet.id (op [n]))) (op [n])))
        { as := A } ≫
      Splitting.map (obj K) (fun n => Sigma.ι (Obj.summand K (op [n])) (Splitting.IndexSet.id (op [n]))) (op [n]) =
    colimit.ι
        (Discrete.functor
          (Splitting.summand (fun n => Obj.summand K (op [n]) (Splitting.IndexSet.id (op [n]))) (op [n])))
        { as := A } ≫
      𝟙 (Splitting.coprod (fun n => Obj.summand K (op [n]) (Splitting.IndexSet.id (op [n]))) (op [n]))

Next tactic:
dsimp [Splitting.map]
theorem splitting_map_eq_id (Δ : SimplexCategoryᵒᵖ) :
    SimplicialObject.Splitting.map (Γ₀.obj K)
        (fun n : ℕ => Sigma.ι (Γ₀.Obj.summand K (op [n])) (Splitting.IndexSet.id (op [n]))) Δ =
      𝟙 _ := colimit.hom_ext (fun ⟨A⟩ => by
  induction' Δ using Opposite.rec' with Δ
  induction' Δ using SimplexCategory.rec with n
  dsimp [Splitting.map]
  

Proof state:
case h.h
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
n : ℕ
x✝ : Discrete (Splitting.IndexSet (op [n]))
A : Splitting.IndexSet (op [n])
⊢ (colimit.ι
        (Discrete.functor
          (Splitting.summand (fun n => Obj.summand K (op [n]) (Splitting.IndexSet.id (op [n]))) (op [n])))
        { as := A } ≫
      Sigma.desc fun A =>
        Sigma.ι (Obj.summand K A.fst) (Splitting.IndexSet.id A.fst) ≫ Obj.map K (Splitting.IndexSet.e A).op) =
    colimit.ι
        (Discrete.functor
          (Splitting.summand (fun n => Obj.summand K (op [n]) (Splitting.IndexSet.id (op [n]))) (op [n])))
        { as := A } ≫
      𝟙 (Splitting.coprod (fun n => Obj.summand K (op [n]) (Splitting.IndexSet.id (op [n]))) (op [n]))

Next tactic:
simp only [colimit.ι_desc, Cofan.mk_ι_app, Γ₀.obj_map]
theorem splitting_map_eq_id (Δ : SimplexCategoryᵒᵖ) :
    SimplicialObject.Splitting.map (Γ₀.obj K)
        (fun n : ℕ => Sigma.ι (Γ₀.Obj.summand K (op [n])) (Splitting.IndexSet.id (op [n]))) Δ =
      𝟙 _ := colimit.hom_ext (fun ⟨A⟩ => by
  induction' Δ using Opposite.rec' with Δ
  induction' Δ using SimplexCategory.rec with n
  dsimp [Splitting.map]
  simp only [colimit.ι_desc, Cofan.mk_ι_app, Γ₀.obj_map]
  

Proof state:
case h.h
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
n : ℕ
x✝ : Discrete (Splitting.IndexSet (op [n]))
A : Splitting.IndexSet (op [n])
⊢ Sigma.ι (Obj.summand K A.fst) (Splitting.IndexSet.id A.fst) ≫ Obj.map K (Splitting.IndexSet.e A).op =
    colimit.ι
        (Discrete.functor
          (Splitting.summand (fun n => Obj.summand K (op [n]) (Splitting.IndexSet.id (op [n]))) (op [n])))
        { as := A } ≫
      𝟙 (Splitting.coprod (fun n => Obj.summand K (op [n]) (Splitting.IndexSet.id (op [n]))) (op [n]))

Next tactic:
erw [Γ₀.Obj.map_on_summand₀ K (SimplicialObject.Splitting.IndexSet.id A.1)
      (show A.e ≫ 𝟙 _ = A.e.op.unop ≫ 𝟙 _ by rfl),
    Γ₀.Obj.Termwise.mapMono_id, A.ext', id_comp, comp_id]
theorem splitting_map_eq_id (Δ : SimplexCategoryᵒᵖ) :
    SimplicialObject.Splitting.map (Γ₀.obj K)
        (fun n : ℕ => Sigma.ι (Γ₀.Obj.summand K (op [n])) (Splitting.IndexSet.id (op [n]))) Δ =
      𝟙 _ := colimit.hom_ext (fun ⟨A⟩ => by
  induction' Δ using Opposite.rec' with Δ
  induction' Δ using SimplexCategory.rec with n
  dsimp [Splitting.map]
  simp only [colimit.ι_desc, Cofan.mk_ι_app, Γ₀.obj_map]
  erw [Γ₀.Obj.map_on_summand₀ K (SimplicialObject.Splitting.IndexSet.id A.1)
      (show A.e ≫ 𝟙 _ = A.e.op.unop ≫ 𝟙 _ by 

Proof state:
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
n : ℕ
x✝ : Discrete (Splitting.IndexSet (op [n]))
A : Splitting.IndexSet (op [n])
⊢ Splitting.IndexSet.e A ≫ 𝟙 A.fst.unop = (Splitting.IndexSet.e A).op.unop ≫ 𝟙 (op A.fst.unop).unop

Next tactic:
rfl
theorem splitting_map_eq_id (Δ : SimplexCategoryᵒᵖ) :
    SimplicialObject.Splitting.map (Γ₀.obj K)
        (fun n : ℕ => Sigma.ι (Γ₀.Obj.summand K (op [n])) (Splitting.IndexSet.id (op [n]))) Δ =
      𝟙 _ := colimit.hom_ext (fun ⟨A⟩ => by
  induction' Δ using Opposite.rec' with Δ
  induction' Δ using SimplexCategory.rec with n
  dsimp [Splitting.map]
  simp only [colimit.ι_desc, Cofan.mk_ι_app, Γ₀.obj_map]
  erw [Γ₀.Obj.map_on_summand₀ K (SimplicialObject.Splitting.IndexSet.id A.1)
      (show A.e ≫ 𝟙 _ = A.e.op.unop ≫ 𝟙 _ by rfl),
    Γ₀.Obj.Termwise.mapMono_id, A.ext', id_comp, comp_id]
  

Proof state:
case h.h
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
n : ℕ
x✝ : Discrete (Splitting.IndexSet (op [n]))
A : Splitting.IndexSet (op [n])
⊢ Sigma.ι (Obj.summand K (op [n]))
      (Splitting.IndexSet.mk
        (Splitting.IndexSet.e
          { fst := A.fst, snd := { val := Splitting.IndexSet.e A, property := (_ : Epi ↑A.snd) } })) =
    colimit.ι
      (Discrete.functor (Splitting.summand (fun n => Obj.summand K (op [n]) (Splitting.IndexSet.id (op [n]))) (op [n])))
      { as := { fst := A.fst, snd := { val := Splitting.IndexSet.e A, property := (_ : Epi ↑A.snd) } } }

Next tactic:
rfl
/-- By construction, the simplicial `Γ₀.obj K` is equipped with a splitting. -/
def splitting (K : ChainComplex C ℕ) : SimplicialObject.Splitting (Γ₀.obj K) where
  N n := K.X n
  ι n := Sigma.ι (Γ₀.Obj.summand K (op [n])) (Splitting.IndexSet.id (op [n]))
  map_isIso Δ := by
    

Proof state:
C : Type u_1
inst✝² : Category.{?u.147300, u_1} C
inst✝¹ : Preadditive C
K✝ K' : ChainComplex C ℕ
f : K✝ ⟶ K'
Δ✝ Δ' Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
K : ChainComplex C ℕ
Δ : SimplexCategoryᵒᵖ
⊢ IsIso (Splitting.map (obj K) (fun n => Sigma.ι (Obj.summand K (op [n])) (Splitting.IndexSet.id (op [n]))) Δ)

Next tactic:
rw [Γ₀.splitting_map_eq_id]
/-- By construction, the simplicial `Γ₀.obj K` is equipped with a splitting. -/
def splitting (K : ChainComplex C ℕ) : SimplicialObject.Splitting (Γ₀.obj K) where
  N n := K.X n
  ι n := Sigma.ι (Γ₀.Obj.summand K (op [n])) (Splitting.IndexSet.id (op [n]))
  map_isIso Δ := by
    rw [Γ₀.splitting_map_eq_id]
    

Proof state:
C : Type u_1
inst✝² : Category.{?u.147300, u_1} C
inst✝¹ : Preadditive C
K✝ K' : ChainComplex C ℕ
f : K✝ ⟶ K'
Δ✝ Δ' Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
K : ChainComplex C ℕ
Δ : SimplexCategoryᵒᵖ
⊢ IsIso (𝟙 (Splitting.coprod (fun n => Obj.summand K (op [n]) (Splitting.IndexSet.id (op [n]))) Δ))

Next tactic:
apply IsIso.id
@[reassoc]
theorem Obj.map_on_summand {Δ Δ' : SimplexCategoryᵒᵖ} (A : Splitting.IndexSet Δ) (θ : Δ ⟶ Δ')
    {Δ'' : SimplexCategory} {e : Δ'.unop ⟶ Δ''} {i : Δ'' ⟶ A.1.unop} [Epi e] [Mono i]
    (fac : e ≫ i = θ.unop ≫ A.e) :
    (Γ₀.splitting K).ιSummand A ≫ (Γ₀.obj K).map θ =
      Γ₀.Obj.Termwise.mapMono K i ≫ (Γ₀.splitting K).ιSummand (Splitting.IndexSet.mk e) := by
  

Proof state:
C : Type u_1
inst✝⁴ : Category.{u_2, u_1} C
inst✝³ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ✝ Δ'✝ Δ''✝ : SimplexCategory
inst✝² : HasFiniteCoproducts C
Δ Δ' : SimplexCategoryᵒᵖ
A : Splitting.IndexSet Δ
θ : Δ ⟶ Δ'
Δ'' : SimplexCategory
e : Δ'.unop ⟶ Δ''
i : Δ'' ⟶ A.fst.unop
inst✝¹ : Epi e
inst✝ : Mono i
fac : e ≫ i = θ.unop ≫ Splitting.IndexSet.e A
⊢ Splitting.ιSummand (splitting K) A ≫ (obj K).map θ =
    Termwise.mapMono K i ≫ Splitting.ιSummand (splitting K) (Splitting.IndexSet.mk e)

Next tactic:
dsimp only [SimplicialObject.Splitting.ιSummand, SimplicialObject.Splitting.ιCoprod]
@[reassoc]
theorem Obj.map_on_summand {Δ Δ' : SimplexCategoryᵒᵖ} (A : Splitting.IndexSet Δ) (θ : Δ ⟶ Δ')
    {Δ'' : SimplexCategory} {e : Δ'.unop ⟶ Δ''} {i : Δ'' ⟶ A.1.unop} [Epi e] [Mono i]
    (fac : e ≫ i = θ.unop ≫ A.e) :
    (Γ₀.splitting K).ιSummand A ≫ (Γ₀.obj K).map θ =
      Γ₀.Obj.Termwise.mapMono K i ≫ (Γ₀.splitting K).ιSummand (Splitting.IndexSet.mk e) := by
  dsimp only [SimplicialObject.Splitting.ιSummand, SimplicialObject.Splitting.ιCoprod]
  

Proof state:
C : Type u_1
inst✝⁴ : Category.{u_2, u_1} C
inst✝³ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ✝ Δ'✝ Δ''✝ : SimplexCategory
inst✝² : HasFiniteCoproducts C
Δ Δ' : SimplexCategoryᵒᵖ
A : Splitting.IndexSet Δ
θ : Δ ⟶ Δ'
Δ'' : SimplexCategory
e : Δ'.unop ⟶ Δ''
i : Δ'' ⟶ A.fst.unop
inst✝¹ : Epi e
inst✝ : Mono i
fac : e ≫ i = θ.unop ≫ Splitting.IndexSet.e A
⊢ (Sigma.ι (Splitting.summand (splitting K).N Δ) A ≫ (Splitting.iso (splitting K) Δ).hom) ≫ (obj K).map θ =
    Termwise.mapMono K i ≫
      Sigma.ι (Splitting.summand (splitting K).N (op Δ'.unop)) (Splitting.IndexSet.mk e) ≫
        (Splitting.iso (splitting K) (op Δ'.unop)).hom

Next tactic:
simp only [assoc, Γ₀.splitting_iso_hom_eq_id, id_comp, comp_id]
@[reassoc]
theorem Obj.map_on_summand {Δ Δ' : SimplexCategoryᵒᵖ} (A : Splitting.IndexSet Δ) (θ : Δ ⟶ Δ')
    {Δ'' : SimplexCategory} {e : Δ'.unop ⟶ Δ''} {i : Δ'' ⟶ A.1.unop} [Epi e] [Mono i]
    (fac : e ≫ i = θ.unop ≫ A.e) :
    (Γ₀.splitting K).ιSummand A ≫ (Γ₀.obj K).map θ =
      Γ₀.Obj.Termwise.mapMono K i ≫ (Γ₀.splitting K).ιSummand (Splitting.IndexSet.mk e) := by
  dsimp only [SimplicialObject.Splitting.ιSummand, SimplicialObject.Splitting.ιCoprod]
  simp only [assoc, Γ₀.splitting_iso_hom_eq_id, id_comp, comp_id]
  

Proof state:
C : Type u_1
inst✝⁴ : Category.{u_2, u_1} C
inst✝³ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ✝ Δ'✝ Δ''✝ : SimplexCategory
inst✝² : HasFiniteCoproducts C
Δ Δ' : SimplexCategoryᵒᵖ
A : Splitting.IndexSet Δ
θ : Δ ⟶ Δ'
Δ'' : SimplexCategory
e : Δ'.unop ⟶ Δ''
i : Δ'' ⟶ A.fst.unop
inst✝¹ : Epi e
inst✝ : Mono i
fac : e ≫ i = θ.unop ≫ Splitting.IndexSet.e A
⊢ Sigma.ι (Splitting.summand (splitting K).N Δ) A ≫ (obj K).map θ =
    Termwise.mapMono K i ≫ Sigma.ι (Splitting.summand (splitting K).N (op Δ'.unop)) (Splitting.IndexSet.mk e)

Next tactic:
exact Γ₀.Obj.map_on_summand₀ K A fac
@[reassoc]
theorem Obj.map_on_summand' {Δ Δ' : SimplexCategoryᵒᵖ} (A : Splitting.IndexSet Δ) (θ : Δ ⟶ Δ') :
    (splitting K).ιSummand A ≫ (obj K).map θ =
      Obj.Termwise.mapMono K (image.ι (θ.unop ≫ A.e)) ≫ (splitting K).ιSummand (A.pull θ) := by
  

Proof state:
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ✝ Δ'✝ Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
Δ Δ' : SimplexCategoryᵒᵖ
A : Splitting.IndexSet Δ
θ : Δ ⟶ Δ'
⊢ Splitting.ιSummand (splitting K) A ≫ (obj K).map θ =
    Termwise.mapMono K (image.ι (θ.unop ≫ Splitting.IndexSet.e A)) ≫
      Splitting.ιSummand (splitting K) (Splitting.IndexSet.pull A θ)

Next tactic:
apply Obj.map_on_summand
@[reassoc]
theorem Obj.map_on_summand' {Δ Δ' : SimplexCategoryᵒᵖ} (A : Splitting.IndexSet Δ) (θ : Δ ⟶ Δ') :
    (splitting K).ιSummand A ≫ (obj K).map θ =
      Obj.Termwise.mapMono K (image.ι (θ.unop ≫ A.e)) ≫ (splitting K).ιSummand (A.pull θ) := by
  apply Obj.map_on_summand
  

Proof state:
case fac
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ✝ Δ'✝ Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
Δ Δ' : SimplexCategoryᵒᵖ
A : Splitting.IndexSet Δ
θ : Δ ⟶ Δ'
⊢ factorThruImage (θ.unop ≫ Splitting.IndexSet.e A) ≫ image.ι (θ.unop ≫ Splitting.IndexSet.e A) =
    θ.unop ≫ Splitting.IndexSet.e A

Next tactic:
apply image.fac
@[reassoc]
theorem Obj.map_epi_on_summand_id {Δ Δ' : SimplexCategory} (e : Δ' ⟶ Δ) [Epi e] :
    (Γ₀.splitting K).ιSummand (Splitting.IndexSet.id (op Δ)) ≫ (Γ₀.obj K).map e.op =
      (Γ₀.splitting K).ιSummand (Splitting.IndexSet.mk e) := by
  

Proof state:
C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ✝ Δ'✝ Δ'' : SimplexCategory
inst✝¹ : HasFiniteCoproducts C
Δ Δ' : SimplexCategory
e : Δ' ⟶ Δ
inst✝ : Epi e
⊢ Splitting.ιSummand (splitting K) (Splitting.IndexSet.id (op Δ)) ≫ (obj K).map e.op =
    Splitting.ιSummand (splitting K) (Splitting.IndexSet.mk e)

Next tactic:
simpa only [Γ₀.Obj.map_on_summand K (Splitting.IndexSet.id (op Δ)) e.op
      (rfl : e ≫ 𝟙 Δ = e ≫ 𝟙 Δ),
    Γ₀.Obj.Termwise.mapMono_id] using id_comp _
/-- The functor `Γ₀ : ChainComplex C ℕ ⥤ SimplicialObject C`, on morphisms. -/
@[simps]
def map {K K' : ChainComplex C ℕ} (f : K ⟶ K') : obj K ⟶ obj K' where
  app Δ := (Γ₀.splitting K).desc Δ fun A => f.f A.1.unop.len ≫ (Γ₀.splitting K').ιSummand A
  naturality {Δ' Δ} θ := by
    

Proof state:
C : Type u_1
inst✝² : Category.{?u.176725, u_1} C
inst✝¹ : Preadditive C
K✝ K'✝ : ChainComplex C ℕ
f✝ : K✝ ⟶ K'✝
Δ✝ Δ'✝ Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ' Δ : SimplexCategoryᵒᵖ
θ : Δ' ⟶ Δ
⊢ (obj K).map θ ≫
      (fun Δ =>
          Splitting.desc (splitting K) Δ fun A =>
            HomologicalComplex.Hom.f f (len A.fst.unop) ≫ Splitting.ιSummand (splitting K') A)
        Δ =
    (fun Δ =>
          Splitting.desc (splitting K) Δ fun A =>
            HomologicalComplex.Hom.f f (len A.fst.unop) ≫ Splitting.ιSummand (splitting K') A)
        Δ' ≫
      (obj K').map θ

Next tactic:
apply (Γ₀.splitting K).hom_ext'
/-- The functor `Γ₀ : ChainComplex C ℕ ⥤ SimplicialObject C`, on morphisms. -/
@[simps]
def map {K K' : ChainComplex C ℕ} (f : K ⟶ K') : obj K ⟶ obj K' where
  app Δ := (Γ₀.splitting K).desc Δ fun A => f.f A.1.unop.len ≫ (Γ₀.splitting K').ιSummand A
  naturality {Δ' Δ} θ := by
    apply (Γ₀.splitting K).hom_ext'
    

Proof state:
case h
C : Type u_1
inst✝² : Category.{?u.176725, u_1} C
inst✝¹ : Preadditive C
K✝ K'✝ : ChainComplex C ℕ
f✝ : K✝ ⟶ K'✝
Δ✝ Δ'✝ Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ' Δ : SimplexCategoryᵒᵖ
θ : Δ' ⟶ Δ
⊢ ∀ (A : Splitting.IndexSet Δ'),
    Splitting.ιSummand (splitting K) A ≫
        (obj K).map θ ≫
          (fun Δ =>
              Splitting.desc (splitting K) Δ fun A =>
                HomologicalComplex.Hom.f f (len A.fst.unop) ≫ Splitting.ιSummand (splitting K') A)
            Δ =
      Splitting.ιSummand (splitting K) A ≫
        (fun Δ =>
              Splitting.desc (splitting K) Δ fun A =>
                HomologicalComplex.Hom.f f (len A.fst.unop) ≫ Splitting.ιSummand (splitting K') A)
            Δ' ≫
          (obj K').map θ

Next tactic:
intro A
/-- The functor `Γ₀ : ChainComplex C ℕ ⥤ SimplicialObject C`, on morphisms. -/
@[simps]
def map {K K' : ChainComplex C ℕ} (f : K ⟶ K') : obj K ⟶ obj K' where
  app Δ := (Γ₀.splitting K).desc Δ fun A => f.f A.1.unop.len ≫ (Γ₀.splitting K').ιSummand A
  naturality {Δ' Δ} θ := by
    apply (Γ₀.splitting K).hom_ext'
    intro A
    

Proof state:
case h
C : Type u_1
inst✝² : Category.{?u.176725, u_1} C
inst✝¹ : Preadditive C
K✝ K'✝ : ChainComplex C ℕ
f✝ : K✝ ⟶ K'✝
Δ✝ Δ'✝ Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ' Δ : SimplexCategoryᵒᵖ
θ : Δ' ⟶ Δ
A : Splitting.IndexSet Δ'
⊢ Splitting.ιSummand (splitting K) A ≫
      (obj K).map θ ≫
        (fun Δ =>
            Splitting.desc (splitting K) Δ fun A =>
              HomologicalComplex.Hom.f f (len A.fst.unop) ≫ Splitting.ιSummand (splitting K') A)
          Δ =
    Splitting.ιSummand (splitting K) A ≫
      (fun Δ =>
            Splitting.desc (splitting K) Δ fun A =>
              HomologicalComplex.Hom.f f (len A.fst.unop) ≫ Splitting.ιSummand (splitting K') A)
          Δ' ≫
        (obj K').map θ

Next tactic:
simp only [(splitting K).ι_desc_assoc, Obj.map_on_summand'_assoc K _ θ, (splitting K).ι_desc,
      assoc, Obj.map_on_summand' K' _ θ]
/-- The functor `Γ₀ : ChainComplex C ℕ ⥤ SimplicialObject C`, on morphisms. -/
@[simps]
def map {K K' : ChainComplex C ℕ} (f : K ⟶ K') : obj K ⟶ obj K' where
  app Δ := (Γ₀.splitting K).desc Δ fun A => f.f A.1.unop.len ≫ (Γ₀.splitting K').ιSummand A
  naturality {Δ' Δ} θ := by
    apply (Γ₀.splitting K).hom_ext'
    intro A
    simp only [(splitting K).ι_desc_assoc, Obj.map_on_summand'_assoc K _ θ, (splitting K).ι_desc,
      assoc, Obj.map_on_summand' K' _ θ]
    

Proof state:
case h
C : Type u_1
inst✝² : Category.{?u.176725, u_1} C
inst✝¹ : Preadditive C
K✝ K'✝ : ChainComplex C ℕ
f✝ : K✝ ⟶ K'✝
Δ✝ Δ'✝ Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ' Δ : SimplexCategoryᵒᵖ
θ : Δ' ⟶ Δ
A : Splitting.IndexSet Δ'
⊢ Obj.Termwise.mapMono K (image.ι (θ.unop ≫ Splitting.IndexSet.e A)) ≫
      HomologicalComplex.Hom.f f (len (Splitting.IndexSet.pull A θ).fst.unop) ≫
        Splitting.ιSummand (splitting K') (Splitting.IndexSet.pull A θ) =
    HomologicalComplex.Hom.f f (len A.fst.unop) ≫
      Obj.Termwise.mapMono K' (image.ι (θ.unop ≫ Splitting.IndexSet.e A)) ≫
        Splitting.ιSummand (splitting K') (Splitting.IndexSet.pull A θ)

Next tactic:
apply Obj.Termwise.mapMono_naturality_assoc
/-- The functor `Γ₀' : ChainComplex C ℕ ⥤ SimplicialObject.Split C`
that induces `Γ₀ : ChainComplex C ℕ ⥤ SimplicialObject C`, which
shall be the inverse functor of the Dold-Kan equivalence for
abelian or pseudo-abelian categories. -/
@[simps]
def Γ₀' : ChainComplex C ℕ ⥤ SimplicialObject.Split C where
  obj K := SimplicialObject.Split.mk' (Γ₀.splitting K)
  map {K K'} f :=
    { F := Γ₀.map f
      f := f.f
      comm := fun n => by
        

Proof state:
C : Type u_1
inst✝² : Category.{?u.179643, u_1} C
inst✝¹ : Preadditive C
K✝ K'✝ : ChainComplex C ℕ
f✝ : K✝ ⟶ K'✝
Δ Δ' Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
K K' : ChainComplex C ℕ
f : K ⟶ K'
n : ℕ
⊢ Splitting.ι ((fun K => Split.mk' (Γ₀.splitting K)) K).s n ≫ (Γ₀.map f).app (op [n]) =
    HomologicalComplex.Hom.f f n ≫ Splitting.ι ((fun K => Split.mk' (Γ₀.splitting K)) K').s n

Next tactic:
dsimp
/-- The functor `Γ₀' : ChainComplex C ℕ ⥤ SimplicialObject.Split C`
that induces `Γ₀ : ChainComplex C ℕ ⥤ SimplicialObject C`, which
shall be the inverse functor of the Dold-Kan equivalence for
abelian or pseudo-abelian categories. -/
@[simps]
def Γ₀' : ChainComplex C ℕ ⥤ SimplicialObject.Split C where
  obj K := SimplicialObject.Split.mk' (Γ₀.splitting K)
  map {K K'} f :=
    { F := Γ₀.map f
      f := f.f
      comm := fun n => by
        dsimp
        

Proof state:
C : Type u_1
inst✝² : Category.{?u.179643, u_1} C
inst✝¹ : Preadditive C
K✝ K'✝ : ChainComplex C ℕ
f✝ : K✝ ⟶ K'✝
Δ Δ' Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
K K' : ChainComplex C ℕ
f : K ⟶ K'
n : ℕ
⊢ (Splitting.ι (Γ₀.splitting K) n ≫
      Splitting.desc (Γ₀.splitting K) (op [n]) fun A =>
        HomologicalComplex.Hom.f f (len A.fst.unop) ≫ Splitting.ιSummand (Γ₀.splitting K') A) =
    HomologicalComplex.Hom.f f n ≫ Splitting.ι (Γ₀.splitting K') n

Next tactic:
simp only [← Splitting.ιSummand_id, (Γ₀.splitting K).ι_desc]