l3lab/ntp-mathlib huggingface dataset:
/-- The differentials in the normalized Moore complex.
-/
@[simp]
def objD : ∀ n : ℕ, (objX X (n + 1) : C) ⟶ (objX X n : C)
  | 0 => Subobject.arrow _ ≫ X.δ (0 : Fin 2) ≫ inv (⊤ : Subobject _).arrow
  | n + 1 => by
    -- The differential is `Subobject.arrow _ ≫ X.δ (0 : Fin (n+3))`,
    -- factored through the intersection of the kernels.
    

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.10000, u_1} C
inst✝ : Abelian C
X : SimplicialObject C
n : ℕ
⊢ underlying.obj (objX X (n + 1 + 1)) ⟶ underlying.obj (objX X (n + 1))

Next tactic:
refine' factorThru _ (arrow _ ≫ X.δ (0 : Fin (n + 3))) _
/-- The differentials in the normalized Moore complex.
-/
@[simp]
def objD : ∀ n : ℕ, (objX X (n + 1) : C) ⟶ (objX X n : C)
  | 0 => Subobject.arrow _ ≫ X.δ (0 : Fin 2) ≫ inv (⊤ : Subobject _).arrow
  | n + 1 => by
    -- The differential is `Subobject.arrow _ ≫ X.δ (0 : Fin (n+3))`,
    -- factored through the intersection of the kernels.
    refine' factorThru _ (arrow _ ≫ X.δ (0 : Fin (n + 3))) _
    -- We now need to show that it factors!
    -- A morphism factors through an intersection of subobjects if it factors through each.
    

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.10000, u_1} C
inst✝ : Abelian C
X : SimplicialObject C
n : ℕ
⊢ Factors (objX X (n + 1)) (arrow (objX X (n + 1 + 1)) ≫ SimplicialObject.δ X 0)

Next tactic:
refine' (finset_inf_factors _).mpr fun i _ => _
/-- The differentials in the normalized Moore complex.
-/
@[simp]
def objD : ∀ n : ℕ, (objX X (n + 1) : C) ⟶ (objX X n : C)
  | 0 => Subobject.arrow _ ≫ X.δ (0 : Fin 2) ≫ inv (⊤ : Subobject _).arrow
  | n + 1 => by
    -- The differential is `Subobject.arrow _ ≫ X.δ (0 : Fin (n+3))`,
    -- factored through the intersection of the kernels.
    refine' factorThru _ (arrow _ ≫ X.δ (0 : Fin (n + 3))) _
    -- We now need to show that it factors!
    -- A morphism factors through an intersection of subobjects if it factors through each.
    refine' (finset_inf_factors _).mpr fun i _ => _
    -- A morphism `f` factors through the kernel of `g` exactly if `f ≫ g = 0`.
    

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.10000, u_1} C
inst✝ : Abelian C
X : SimplicialObject C
n : ℕ
i : Fin (Nat.add n 0 + 1)
x✝ : i ∈ Finset.univ
⊢ Factors (kernelSubobject (SimplicialObject.δ X (Fin.succ i))) (arrow (objX X (n + 1 + 1)) ≫ SimplicialObject.δ X 0)

Next tactic:
apply kernelSubobject_factors
/-- The differentials in the normalized Moore complex.
-/
@[simp]
def objD : ∀ n : ℕ, (objX X (n + 1) : C) ⟶ (objX X n : C)
  | 0 => Subobject.arrow _ ≫ X.δ (0 : Fin 2) ≫ inv (⊤ : Subobject _).arrow
  | n + 1 => by
    -- The differential is `Subobject.arrow _ ≫ X.δ (0 : Fin (n+3))`,
    -- factored through the intersection of the kernels.
    refine' factorThru _ (arrow _ ≫ X.δ (0 : Fin (n + 3))) _
    -- We now need to show that it factors!
    -- A morphism factors through an intersection of subobjects if it factors through each.
    refine' (finset_inf_factors _).mpr fun i _ => _
    -- A morphism `f` factors through the kernel of `g` exactly if `f ≫ g = 0`.
    apply kernelSubobject_factors
    

Proof state:
case w
C : Type u_1
inst✝¹ : Category.{?u.10000, u_1} C
inst✝ : Abelian C
X : SimplicialObject C
n : ℕ
i : Fin (Nat.add n 0 + 1)
x✝ : i ∈ Finset.univ
⊢ (arrow (objX X (n + 1 + 1)) ≫ SimplicialObject.δ X 0) ≫ SimplicialObject.δ X (Fin.succ i) = 0

Next tactic:
dsimp [objX]
/-- The differentials in the normalized Moore complex.
-/
@[simp]
def objD : ∀ n : ℕ, (objX X (n + 1) : C) ⟶ (objX X n : C)
  | 0 => Subobject.arrow _ ≫ X.δ (0 : Fin 2) ≫ inv (⊤ : Subobject _).arrow
  | n + 1 => by
    -- The differential is `Subobject.arrow _ ≫ X.δ (0 : Fin (n+3))`,
    -- factored through the intersection of the kernels.
    refine' factorThru _ (arrow _ ≫ X.δ (0 : Fin (n + 3))) _
    -- We now need to show that it factors!
    -- A morphism factors through an intersection of subobjects if it factors through each.
    refine' (finset_inf_factors _).mpr fun i _ => _
    -- A morphism `f` factors through the kernel of `g` exactly if `f ≫ g = 0`.
    apply kernelSubobject_factors
    dsimp [objX]
    -- Use a simplicial identity
    

Proof state:
case w
C : Type u_1
inst✝¹ : Category.{?u.10000, u_1} C
inst✝ : Abelian C
X : SimplicialObject C
n : ℕ
i : Fin (Nat.add n 0 + 1)
x✝ : i ∈ Finset.univ
⊢ (arrow (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k))) ≫
        SimplicialObject.δ X 0) ≫
      SimplicialObject.δ X (Fin.succ i) =
    0

Next tactic:
erw [Category.assoc, ← X.δ_comp_δ (Fin.zero_le i.succ)]
/-- The differentials in the normalized Moore complex.
-/
@[simp]
def objD : ∀ n : ℕ, (objX X (n + 1) : C) ⟶ (objX X n : C)
  | 0 => Subobject.arrow _ ≫ X.δ (0 : Fin 2) ≫ inv (⊤ : Subobject _).arrow
  | n + 1 => by
    -- The differential is `Subobject.arrow _ ≫ X.δ (0 : Fin (n+3))`,
    -- factored through the intersection of the kernels.
    refine' factorThru _ (arrow _ ≫ X.δ (0 : Fin (n + 3))) _
    -- We now need to show that it factors!
    -- A morphism factors through an intersection of subobjects if it factors through each.
    refine' (finset_inf_factors _).mpr fun i _ => _
    -- A morphism `f` factors through the kernel of `g` exactly if `f ≫ g = 0`.
    apply kernelSubobject_factors
    dsimp [objX]
    -- Use a simplicial identity
    erw [Category.assoc, ← X.δ_comp_δ (Fin.zero_le i.succ)]
    -- We can rewrite the arrow out of the intersection of all the kernels as a composition
    -- of a morphism we don't care about with the arrow out of the kernel of `X.δ i.succ.succ`.
    

Proof state:
case w
C : Type u_1
inst✝¹ : Category.{?u.10000, u_1} C
inst✝ : Abelian C
X : SimplicialObject C
n : ℕ
i : Fin (Nat.add n 0 + 1)
x✝ : i ∈ Finset.univ
⊢ arrow (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k))) ≫
      SimplicialObject.δ X (Fin.succ (Fin.succ i)) ≫ SimplicialObject.δ X 0 =
    0

Next tactic:
rw [← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ i.succ (by simp)),
      Category.assoc, kernelSubobject_arrow_comp_assoc, zero_comp, comp_zero]
/-- The differentials in the normalized Moore complex.
-/
@[simp]
def objD : ∀ n : ℕ, (objX X (n + 1) : C) ⟶ (objX X n : C)
  | 0 => Subobject.arrow _ ≫ X.δ (0 : Fin 2) ≫ inv (⊤ : Subobject _).arrow
  | n + 1 => by
    -- The differential is `Subobject.arrow _ ≫ X.δ (0 : Fin (n+3))`,
    -- factored through the intersection of the kernels.
    refine' factorThru _ (arrow _ ≫ X.δ (0 : Fin (n + 3))) _
    -- We now need to show that it factors!
    -- A morphism factors through an intersection of subobjects if it factors through each.
    refine' (finset_inf_factors _).mpr fun i _ => _
    -- A morphism `f` factors through the kernel of `g` exactly if `f ≫ g = 0`.
    apply kernelSubobject_factors
    dsimp [objX]
    -- Use a simplicial identity
    erw [Category.assoc, ← X.δ_comp_δ (Fin.zero_le i.succ)]
    -- We can rewrite the arrow out of the intersection of all the kernels as a composition
    -- of a morphism we don't care about with the arrow out of the kernel of `X.δ i.succ.succ`.
    rw [← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ i.succ (by 

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.10000, u_1} C
inst✝ : Abelian C
X : SimplicialObject C
n : ℕ
i : Fin (Nat.add n 0 + 1)
x✝ : i ∈ Finset.univ
⊢ Fin.succ i ∈ Finset.univ

Next tactic:
simp
theorem d_squared (n : ℕ) : objD X (n + 1) ≫ objD X n = 0 := by
  -- It's a pity we need to do a case split here;
    -- after the first erw the proofs are almost identical
  

Proof state:
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X : SimplicialObject C
n : ℕ
⊢ objD X (n + 1) ≫ objD X n = 0

Next tactic:
rcases n with _ | n
theorem d_squared (n : ℕ) : objD X (n + 1) ≫ objD X n = 0 := by
  -- It's a pity we need to do a case split here;
    -- after the first erw the proofs are almost identical
  rcases n with _ | n <;> 

Proof state:
case zero
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X : SimplicialObject C
⊢ objD X (Nat.zero + 1) ≫ objD X Nat.zero = 0

Next tactic:
dsimp [objD]
theorem d_squared (n : ℕ) : objD X (n + 1) ≫ objD X n = 0 := by
  -- It's a pity we need to do a case split here;
    -- after the first erw the proofs are almost identical
  rcases n with _ | n <;> 

Proof state:
case succ
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X : SimplicialObject C
n : ℕ
⊢ objD X (Nat.succ n + 1) ≫ objD X (Nat.succ n) = 0

Next tactic:
dsimp [objD]
theorem d_squared (n : ℕ) : objD X (n + 1) ≫ objD X n = 0 := by
  -- It's a pity we need to do a case split here;
    -- after the first erw the proofs are almost identical
  rcases n with _ | n <;> dsimp [objD]
  · 

Proof state:
case zero
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X : SimplicialObject C
⊢ factorThru (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k)))
        (arrow (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k))) ≫
          SimplicialObject.δ X 0)
        (_ :
          Factors (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k)))
            (arrow (objX X (0 + 1 + 1)) ≫ SimplicialObject.δ X 0)) ≫
      arrow (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k))) ≫
        SimplicialObject.δ X 0 ≫ inv (arrow ⊤) =
    0

Next tactic:
erw [Subobject.factorThru_arrow_assoc, Category.assoc,
      ← X.δ_comp_δ_assoc (Fin.zero_le (0 : Fin 2)),
      ← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ (0 : Fin 2) (by simp)),
      Category.assoc, kernelSubobject_arrow_comp_assoc, zero_comp, comp_zero]
theorem d_squared (n : ℕ) : objD X (n + 1) ≫ objD X n = 0 := by
  -- It's a pity we need to do a case split here;
    -- after the first erw the proofs are almost identical
  rcases n with _ | n <;> dsimp [objD]
  · erw [Subobject.factorThru_arrow_assoc, Category.assoc,
      ← X.δ_comp_δ_assoc (Fin.zero_le (0 : Fin 2)),
      ← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ (0 : Fin 2) (by 

Proof state:
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X : SimplicialObject C
⊢ 0 ∈ Finset.univ

Next tactic:
simp
theorem d_squared (n : ℕ) : objD X (n + 1) ≫ objD X n = 0 := by
  -- It's a pity we need to do a case split here;
    -- after the first erw the proofs are almost identical
  rcases n with _ | n <;> dsimp [objD]
  · erw [Subobject.factorThru_arrow_assoc, Category.assoc,
      ← X.δ_comp_δ_assoc (Fin.zero_le (0 : Fin 2)),
      ← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ (0 : Fin 2) (by simp)),
      Category.assoc, kernelSubobject_arrow_comp_assoc, zero_comp, comp_zero]
  · 

Proof state:
case succ
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X : SimplicialObject C
n : ℕ
⊢ factorThru (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k)))
        (arrow (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k))) ≫
          SimplicialObject.δ X 0)
        (_ :
          Factors (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k)))
            (arrow (objX X (n + 1 + 1 + 1)) ≫ SimplicialObject.δ X 0)) ≫
      factorThru (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k)))
        (arrow (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k))) ≫
          SimplicialObject.δ X 0)
        (_ :
          Factors (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k)))
            (arrow (objX X (n + 1 + 1)) ≫ SimplicialObject.δ X 0)) =
    0

Next tactic:
erw [factorThru_right, factorThru_eq_zero, factorThru_arrow_assoc, Category.assoc,
      ← X.δ_comp_δ (Fin.zero_le (0 : Fin (n + 3))),
      ← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ (0 : Fin (n + 3)) (by simp)),
      Category.assoc, kernelSubobject_arrow_comp_assoc, zero_comp, comp_zero]
theorem d_squared (n : ℕ) : objD X (n + 1) ≫ objD X n = 0 := by
  -- It's a pity we need to do a case split here;
    -- after the first erw the proofs are almost identical
  rcases n with _ | n <;> dsimp [objD]
  · erw [Subobject.factorThru_arrow_assoc, Category.assoc,
      ← X.δ_comp_δ_assoc (Fin.zero_le (0 : Fin 2)),
      ← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ (0 : Fin 2) (by simp)),
      Category.assoc, kernelSubobject_arrow_comp_assoc, zero_comp, comp_zero]
  · erw [factorThru_right, factorThru_eq_zero, factorThru_arrow_assoc, Category.assoc,
      ← X.δ_comp_δ (Fin.zero_le (0 : Fin (n + 3))),
      ← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ (0 : Fin (n + 3)) (by 

Proof state:
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X : SimplicialObject C
n : ℕ
⊢ 0 ∈ Finset.univ

Next tactic:
simp
/-- The normalized Moore complex functor, on morphisms.
-/
@[simps!]
def map (f : X ⟶ Y) : obj X ⟶ obj Y :=
  ChainComplex.ofHom _ _ _ _ _ _
    (fun n => factorThru _ (arrow _ ≫ f.app (op (SimplexCategory.mk n))) (by
      

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.62442, u_1} C
inst✝ : Abelian C
X Y : SimplicialObject C
f✝ f : X ⟶ Y
n : ℕ
⊢ Factors (objX Y n) (arrow (objX X n) ≫ f.app (op (SimplexCategory.mk n)))

Next tactic:
cases n
/-- The normalized Moore complex functor, on morphisms.
-/
@[simps!]
def map (f : X ⟶ Y) : obj X ⟶ obj Y :=
  ChainComplex.ofHom _ _ _ _ _ _
    (fun n => factorThru _ (arrow _ ≫ f.app (op (SimplexCategory.mk n))) (by
      cases n <;> 

Proof state:
case zero
C : Type u_1
inst✝¹ : Category.{?u.62442, u_1} C
inst✝ : Abelian C
X Y : SimplicialObject C
f✝ f : X ⟶ Y
⊢ Factors (objX Y Nat.zero) (arrow (objX X Nat.zero) ≫ f.app (op (SimplexCategory.mk Nat.zero)))

Next tactic:
dsimp
/-- The normalized Moore complex functor, on morphisms.
-/
@[simps!]
def map (f : X ⟶ Y) : obj X ⟶ obj Y :=
  ChainComplex.ofHom _ _ _ _ _ _
    (fun n => factorThru _ (arrow _ ≫ f.app (op (SimplexCategory.mk n))) (by
      cases n <;> 

Proof state:
case succ
C : Type u_1
inst✝¹ : Category.{?u.62442, u_1} C
inst✝ : Abelian C
X Y : SimplicialObject C
f✝ f : X ⟶ Y
n✝ : ℕ
⊢ Factors (objX Y (Nat.succ n✝)) (arrow (objX X (Nat.succ n✝)) ≫ f.app (op (SimplexCategory.mk (Nat.succ n✝))))

Next tactic:
dsimp
/-- The normalized Moore complex functor, on morphisms.
-/
@[simps!]
def map (f : X ⟶ Y) : obj X ⟶ obj Y :=
  ChainComplex.ofHom _ _ _ _ _ _
    (fun n => factorThru _ (arrow _ ≫ f.app (op (SimplexCategory.mk n))) (by
      cases n <;> dsimp
      · 

Proof state:
case zero
C : Type u_1
inst✝¹ : Category.{?u.62442, u_1} C
inst✝ : Abelian C
X Y : SimplicialObject C
f✝ f : X ⟶ Y
⊢ Factors ⊤ (arrow ⊤ ≫ f.app (op (SimplexCategory.mk 0)))

Next tactic:
apply top_factors
/-- The normalized Moore complex functor, on morphisms.
-/
@[simps!]
def map (f : X ⟶ Y) : obj X ⟶ obj Y :=
  ChainComplex.ofHom _ _ _ _ _ _
    (fun n => factorThru _ (arrow _ ≫ f.app (op (SimplexCategory.mk n))) (by
      cases n <;> dsimp
      · apply top_factors
      · 

Proof state:
case succ
C : Type u_1
inst✝¹ : Category.{?u.62442, u_1} C
inst✝ : Abelian C
X Y : SimplicialObject C
f✝ f : X ⟶ Y
n✝ : ℕ
⊢ Factors (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ Y (Fin.succ k)))
    (arrow (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k))) ≫
      f.app (op (SimplexCategory.mk (Nat.succ n✝))))

Next tactic:
refine' (finset_inf_factors _).mpr fun i _ => kernelSubobject_factors _ _ _
/-- The normalized Moore complex functor, on morphisms.
-/
@[simps!]
def map (f : X ⟶ Y) : obj X ⟶ obj Y :=
  ChainComplex.ofHom _ _ _ _ _ _
    (fun n => factorThru _ (arrow _ ≫ f.app (op (SimplexCategory.mk n))) (by
      cases n <;> dsimp
      · apply top_factors
      · refine' (finset_inf_factors _).mpr fun i _ => kernelSubobject_factors _ _ _
        

Proof state:
case succ
C : Type u_1
inst✝¹ : Category.{?u.62442, u_1} C
inst✝ : Abelian C
X Y : SimplicialObject C
f✝ f : X ⟶ Y
n✝ : ℕ
i : Fin (n✝ + 1)
x✝ : i ∈ Finset.univ
⊢ (arrow (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k))) ≫
        f.app (op (SimplexCategory.mk (Nat.succ n✝)))) ≫
      SimplicialObject.δ Y (Fin.succ i) =
    0

Next tactic:
erw [Category.assoc, ← f.naturality,
          ← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ i (by simp)),
          Category.assoc, kernelSubobject_arrow_comp_assoc, zero_comp, comp_zero]
/-- The normalized Moore complex functor, on morphisms.
-/
@[simps!]
def map (f : X ⟶ Y) : obj X ⟶ obj Y :=
  ChainComplex.ofHom _ _ _ _ _ _
    (fun n => factorThru _ (arrow _ ≫ f.app (op (SimplexCategory.mk n))) (by
      cases n <;> dsimp
      · apply top_factors
      · refine' (finset_inf_factors _).mpr fun i _ => kernelSubobject_factors _ _ _
        erw [Category.assoc, ← f.naturality,
          ← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ i (by 

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.62442, u_1} C
inst✝ : Abelian C
X Y : SimplicialObject C
f✝ f : X ⟶ Y
n✝ : ℕ
i : Fin (n✝ + 1)
x✝ : i ∈ Finset.univ
⊢ i ∈ Finset.univ

Next tactic:
simp
/-- The normalized Moore complex functor, on morphisms.
-/
@[simps!]
def map (f : X ⟶ Y) : obj X ⟶ obj Y :=
  ChainComplex.ofHom _ _ _ _ _ _
    (fun n => factorThru _ (arrow _ ≫ f.app (op (SimplexCategory.mk n))) (by
      cases n <;> dsimp
      · apply top_factors
      · refine' (finset_inf_factors _).mpr fun i _ => kernelSubobject_factors _ _ _
        erw [Category.assoc, ← f.naturality,
          ← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ i (by simp)),
          Category.assoc, kernelSubobject_arrow_comp_assoc, zero_comp, comp_zero]))
    fun n => by
    

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.62442, u_1} C
inst✝ : Abelian C
X Y : SimplicialObject C
f✝ f : X ⟶ Y
n : ℕ
⊢ (fun n =>
          factorThru (objX Y n) (arrow (objX X n) ≫ f.app (op (SimplexCategory.mk n)))
            (_ : Factors (objX Y n) (arrow (objX X n) ≫ f.app (op (SimplexCategory.mk n)))))
        (n + 1) ≫
      objD Y n =
    objD X n ≫
      (fun n =>
          factorThru (objX Y n) (arrow (objX X n) ≫ f.app (op (SimplexCategory.mk n)))
            (_ : Factors (objX Y n) (arrow (objX X n) ≫ f.app (op (SimplexCategory.mk n)))))
        n

Next tactic:
cases n
/-- The normalized Moore complex functor, on morphisms.
-/
@[simps!]
def map (f : X ⟶ Y) : obj X ⟶ obj Y :=
  ChainComplex.ofHom _ _ _ _ _ _
    (fun n => factorThru _ (arrow _ ≫ f.app (op (SimplexCategory.mk n))) (by
      cases n <;> dsimp
      · apply top_factors
      · refine' (finset_inf_factors _).mpr fun i _ => kernelSubobject_factors _ _ _
        erw [Category.assoc, ← f.naturality,
          ← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ i (by simp)),
          Category.assoc, kernelSubobject_arrow_comp_assoc, zero_comp, comp_zero]))
    fun n => by
    cases n <;> 

Proof state:
case zero
C : Type u_1
inst✝¹ : Category.{?u.62442, u_1} C
inst✝ : Abelian C
X Y : SimplicialObject C
f✝ f : X ⟶ Y
⊢ (fun n =>
          factorThru (objX Y n) (arrow (objX X n) ≫ f.app (op (SimplexCategory.mk n)))
            (_ : Factors (objX Y n) (arrow (objX X n) ≫ f.app (op (SimplexCategory.mk n)))))
        (Nat.zero + 1) ≫
      objD Y Nat.zero =
    objD X Nat.zero ≫
      (fun n =>
          factorThru (objX Y n) (arrow (objX X n) ≫ f.app (op (SimplexCategory.mk n)))
            (_ : Factors (objX Y n) (arrow (objX X n) ≫ f.app (op (SimplexCategory.mk n)))))
        Nat.zero

Next tactic:
dsimp [objD, objX]
/-- The normalized Moore complex functor, on morphisms.
-/
@[simps!]
def map (f : X ⟶ Y) : obj X ⟶ obj Y :=
  ChainComplex.ofHom _ _ _ _ _ _
    (fun n => factorThru _ (arrow _ ≫ f.app (op (SimplexCategory.mk n))) (by
      cases n <;> dsimp
      · apply top_factors
      · refine' (finset_inf_factors _).mpr fun i _ => kernelSubobject_factors _ _ _
        erw [Category.assoc, ← f.naturality,
          ← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ i (by simp)),
          Category.assoc, kernelSubobject_arrow_comp_assoc, zero_comp, comp_zero]))
    fun n => by
    cases n <;> 

Proof state:
case succ
C : Type u_1
inst✝¹ : Category.{?u.62442, u_1} C
inst✝ : Abelian C
X Y : SimplicialObject C
f✝ f : X ⟶ Y
n✝ : ℕ
⊢ (fun n =>
          factorThru (objX Y n) (arrow (objX X n) ≫ f.app (op (SimplexCategory.mk n)))
            (_ : Factors (objX Y n) (arrow (objX X n) ≫ f.app (op (SimplexCategory.mk n)))))
        (Nat.succ n✝ + 1) ≫
      objD Y (Nat.succ n✝) =
    objD X (Nat.succ n✝) ≫
      (fun n =>
          factorThru (objX Y n) (arrow (objX X n) ≫ f.app (op (SimplexCategory.mk n)))
            (_ : Factors (objX Y n) (arrow (objX X n) ≫ f.app (op (SimplexCategory.mk n)))))
        (Nat.succ n✝)

Next tactic:
dsimp [objD, objX]
/-- The normalized Moore complex functor, on morphisms.
-/
@[simps!]
def map (f : X ⟶ Y) : obj X ⟶ obj Y :=
  ChainComplex.ofHom _ _ _ _ _ _
    (fun n => factorThru _ (arrow _ ≫ f.app (op (SimplexCategory.mk n))) (by
      cases n <;> dsimp
      · apply top_factors
      · refine' (finset_inf_factors _).mpr fun i _ => kernelSubobject_factors _ _ _
        erw [Category.assoc, ← f.naturality,
          ← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ i (by simp)),
          Category.assoc, kernelSubobject_arrow_comp_assoc, zero_comp, comp_zero]))
    fun n => by
    cases n <;> dsimp [objD, objX] <;> 

Proof state:
case zero
C : Type u_1
inst✝¹ : Category.{?u.62442, u_1} C
inst✝ : Abelian C
X Y : SimplicialObject C
f✝ f : X ⟶ Y
⊢ factorThru (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ Y (Fin.succ k)))
        (arrow (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k))) ≫
          f.app (op (SimplexCategory.mk (0 + 1))))
        (_ :
          Factors (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ Y (Fin.succ k)))
            (arrow (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k))) ≫
              f.app (op (SimplexCategory.mk (Nat.succ 0))))) ≫
      arrow (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ Y (Fin.succ k))) ≫
        SimplicialObject.δ Y 0 ≫ inv (arrow ⊤) =
    (arrow (Finset.inf Finset.univ fun k => kernelSubobject (SimplicialObject.δ X (Fin.succ k))) ≫
        SimplicialObject.δ X 0 ≫ inv (arrow ⊤)) ≫
      factorThru ⊤ (arrow ⊤ ≫ f.app (op (SimplexCategory.mk 0)))
        (_ : Factors ⊤ (arrow ⊤ ≫ f.app (op (SimplexCategory.mk 0))))

Next tactic:
aesop_cat