l3lab/ntp-mathlib huggingface dataset:
/-- If `ed` is an extra degeneracy for `X : SimplicialObject.Augmented C` and
`F : C ⥤ D` is a functor, then `ed.map F` is an extra degeneracy for the
augmented simplical object in `D` obtained by applying `F` to `X`. -/
def map {D : Type*} [Category D] {X : SimplicialObject.Augmented C} (ed : ExtraDegeneracy X)
    (F : C ⥤ D) : ExtraDegeneracy (((whiskering _ _).obj F).obj X) where
  s' := F.map ed.s'
  s n := F.map (ed.s n)
  s'_comp_ε := by
    dsimp
    erw [comp_id, ← F.map_comp, ed.s'_comp_ε, F.map_id]
  s₀_comp_δ₁ := by
    dsimp
    

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.94778, u_1} C
D : Type u_2
inst✝ : Category.{?u.94785, u_2} D
X : SimplicialObject.Augmented C
ed : ExtraDegeneracy X
F : C ⥤ D
⊢ F.map (s ed 0) ≫ SimplicialObject.δ (((SimplicialObject.whiskering C D).obj F).obj X.left) 1 =
    (F.map (X.hom.app (op [0])) ≫ 𝟙 (F.obj X.right)) ≫ F.map ed.s'

Next tactic:
erw [comp_id, ← F.map_comp, ← F.map_comp, ed.s₀_comp_δ₁]
/-- If `ed` is an extra degeneracy for `X : SimplicialObject.Augmented C` and
`F : C ⥤ D` is a functor, then `ed.map F` is an extra degeneracy for the
augmented simplical object in `D` obtained by applying `F` to `X`. -/
def map {D : Type*} [Category D] {X : SimplicialObject.Augmented C} (ed : ExtraDegeneracy X)
    (F : C ⥤ D) : ExtraDegeneracy (((whiskering _ _).obj F).obj X) where
  s' := F.map ed.s'
  s n := F.map (ed.s n)
  s'_comp_ε := by
    dsimp
    erw [comp_id, ← F.map_comp, ed.s'_comp_ε, F.map_id]
  s₀_comp_δ₁ := by
    dsimp
    erw [comp_id, ← F.map_comp, ← F.map_comp, ed.s₀_comp_δ₁]
  s_comp_δ₀ n := by
    

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.94778, u_1} C
D : Type u_2
inst✝ : Category.{?u.94785, u_2} D
X : SimplicialObject.Augmented C
ed : ExtraDegeneracy X
F : C ⥤ D
n : ℕ
⊢ (fun n => F.map (s ed n)) n ≫ SimplicialObject.δ (((whiskering C D).obj F).obj X).left 0 =
    𝟙 ((drop.obj (((whiskering C D).obj F).obj X)).obj (op [n]))

Next tactic:
dsimp
/-- If `ed` is an extra degeneracy for `X : SimplicialObject.Augmented C` and
`F : C ⥤ D` is a functor, then `ed.map F` is an extra degeneracy for the
augmented simplical object in `D` obtained by applying `F` to `X`. -/
def map {D : Type*} [Category D] {X : SimplicialObject.Augmented C} (ed : ExtraDegeneracy X)
    (F : C ⥤ D) : ExtraDegeneracy (((whiskering _ _).obj F).obj X) where
  s' := F.map ed.s'
  s n := F.map (ed.s n)
  s'_comp_ε := by
    dsimp
    erw [comp_id, ← F.map_comp, ed.s'_comp_ε, F.map_id]
  s₀_comp_δ₁ := by
    dsimp
    erw [comp_id, ← F.map_comp, ← F.map_comp, ed.s₀_comp_δ₁]
  s_comp_δ₀ n := by
    dsimp
    

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.94778, u_1} C
D : Type u_2
inst✝ : Category.{?u.94785, u_2} D
X : SimplicialObject.Augmented C
ed : ExtraDegeneracy X
F : C ⥤ D
n : ℕ
⊢ F.map (s ed n) ≫ SimplicialObject.δ (((SimplicialObject.whiskering C D).obj F).obj X.left) 0 =
    𝟙 (F.obj (X.left.obj (op [n])))

Next tactic:
erw [← F.map_comp, ed.s_comp_δ₀, F.map_id]
/-- If `ed` is an extra degeneracy for `X : SimplicialObject.Augmented C` and
`F : C ⥤ D` is a functor, then `ed.map F` is an extra degeneracy for the
augmented simplical object in `D` obtained by applying `F` to `X`. -/
def map {D : Type*} [Category D] {X : SimplicialObject.Augmented C} (ed : ExtraDegeneracy X)
    (F : C ⥤ D) : ExtraDegeneracy (((whiskering _ _).obj F).obj X) where
  s' := F.map ed.s'
  s n := F.map (ed.s n)
  s'_comp_ε := by
    dsimp
    erw [comp_id, ← F.map_comp, ed.s'_comp_ε, F.map_id]
  s₀_comp_δ₁ := by
    dsimp
    erw [comp_id, ← F.map_comp, ← F.map_comp, ed.s₀_comp_δ₁]
  s_comp_δ₀ n := by
    dsimp
    erw [← F.map_comp, ed.s_comp_δ₀, F.map_id]
  s_comp_δ n i := by
    

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.94778, u_1} C
D : Type u_2
inst✝ : Category.{?u.94785, u_2} D
X : SimplicialObject.Augmented C
ed : ExtraDegeneracy X
F : C ⥤ D
n : ℕ
i : Fin (n + 2)
⊢ (fun n => F.map (s ed n)) (n + 1) ≫ SimplicialObject.δ (((whiskering C D).obj F).obj X).left (Fin.succ i) =
    SimplicialObject.δ (((whiskering C D).obj F).obj X).left i ≫ (fun n => F.map (s ed n)) n

Next tactic:
dsimp
/-- If `ed` is an extra degeneracy for `X : SimplicialObject.Augmented C` and
`F : C ⥤ D` is a functor, then `ed.map F` is an extra degeneracy for the
augmented simplical object in `D` obtained by applying `F` to `X`. -/
def map {D : Type*} [Category D] {X : SimplicialObject.Augmented C} (ed : ExtraDegeneracy X)
    (F : C ⥤ D) : ExtraDegeneracy (((whiskering _ _).obj F).obj X) where
  s' := F.map ed.s'
  s n := F.map (ed.s n)
  s'_comp_ε := by
    dsimp
    erw [comp_id, ← F.map_comp, ed.s'_comp_ε, F.map_id]
  s₀_comp_δ₁ := by
    dsimp
    erw [comp_id, ← F.map_comp, ← F.map_comp, ed.s₀_comp_δ₁]
  s_comp_δ₀ n := by
    dsimp
    erw [← F.map_comp, ed.s_comp_δ₀, F.map_id]
  s_comp_δ n i := by
    dsimp
    

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.94778, u_1} C
D : Type u_2
inst✝ : Category.{?u.94785, u_2} D
X : SimplicialObject.Augmented C
ed : ExtraDegeneracy X
F : C ⥤ D
n : ℕ
i : Fin (n + 2)
⊢ F.map (s ed (n + 1)) ≫ SimplicialObject.δ (((SimplicialObject.whiskering C D).obj F).obj X.left) (Fin.succ i) =
    SimplicialObject.δ (((SimplicialObject.whiskering C D).obj F).obj X.left) i ≫ F.map (s ed n)

Next tactic:
erw [← F.map_comp, ← F.map_comp, ed.s_comp_δ]
/-- If `ed` is an extra degeneracy for `X : SimplicialObject.Augmented C` and
`F : C ⥤ D` is a functor, then `ed.map F` is an extra degeneracy for the
augmented simplical object in `D` obtained by applying `F` to `X`. -/
def map {D : Type*} [Category D] {X : SimplicialObject.Augmented C} (ed : ExtraDegeneracy X)
    (F : C ⥤ D) : ExtraDegeneracy (((whiskering _ _).obj F).obj X) where
  s' := F.map ed.s'
  s n := F.map (ed.s n)
  s'_comp_ε := by
    dsimp
    erw [comp_id, ← F.map_comp, ed.s'_comp_ε, F.map_id]
  s₀_comp_δ₁ := by
    dsimp
    erw [comp_id, ← F.map_comp, ← F.map_comp, ed.s₀_comp_δ₁]
  s_comp_δ₀ n := by
    dsimp
    erw [← F.map_comp, ed.s_comp_δ₀, F.map_id]
  s_comp_δ n i := by
    dsimp
    erw [← F.map_comp, ← F.map_comp, ed.s_comp_δ]
    

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.94778, u_1} C
D : Type u_2
inst✝ : Category.{?u.94785, u_2} D
X : SimplicialObject.Augmented C
ed : ExtraDegeneracy X
F : C ⥤ D
n : ℕ
i : Fin (n + 2)
⊢ F.map (SimplicialObject.δ X.left i ≫ s ed n) = F.map (X.left.map (SimplexCategory.δ i).op ≫ s ed n)

Next tactic:
rfl
/-- If `ed` is an extra degeneracy for `X : SimplicialObject.Augmented C` and
`F : C ⥤ D` is a functor, then `ed.map F` is an extra degeneracy for the
augmented simplical object in `D` obtained by applying `F` to `X`. -/
def map {D : Type*} [Category D] {X : SimplicialObject.Augmented C} (ed : ExtraDegeneracy X)
    (F : C ⥤ D) : ExtraDegeneracy (((whiskering _ _).obj F).obj X) where
  s' := F.map ed.s'
  s n := F.map (ed.s n)
  s'_comp_ε := by
    dsimp
    erw [comp_id, ← F.map_comp, ed.s'_comp_ε, F.map_id]
  s₀_comp_δ₁ := by
    dsimp
    erw [comp_id, ← F.map_comp, ← F.map_comp, ed.s₀_comp_δ₁]
  s_comp_δ₀ n := by
    dsimp
    erw [← F.map_comp, ed.s_comp_δ₀, F.map_id]
  s_comp_δ n i := by
    dsimp
    erw [← F.map_comp, ← F.map_comp, ed.s_comp_δ]
    rfl
  s_comp_σ n i := by
    

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.94778, u_1} C
D : Type u_2
inst✝ : Category.{?u.94785, u_2} D
X : SimplicialObject.Augmented C
ed : ExtraDegeneracy X
F : C ⥤ D
n : ℕ
i : Fin (n + 1)
⊢ (fun n => F.map (s ed n)) n ≫ SimplicialObject.σ (((whiskering C D).obj F).obj X).left (Fin.succ i) =
    SimplicialObject.σ (((whiskering C D).obj F).obj X).left i ≫ (fun n => F.map (s ed n)) (n + 1)

Next tactic:
dsimp
/-- If `ed` is an extra degeneracy for `X : SimplicialObject.Augmented C` and
`F : C ⥤ D` is a functor, then `ed.map F` is an extra degeneracy for the
augmented simplical object in `D` obtained by applying `F` to `X`. -/
def map {D : Type*} [Category D] {X : SimplicialObject.Augmented C} (ed : ExtraDegeneracy X)
    (F : C ⥤ D) : ExtraDegeneracy (((whiskering _ _).obj F).obj X) where
  s' := F.map ed.s'
  s n := F.map (ed.s n)
  s'_comp_ε := by
    dsimp
    erw [comp_id, ← F.map_comp, ed.s'_comp_ε, F.map_id]
  s₀_comp_δ₁ := by
    dsimp
    erw [comp_id, ← F.map_comp, ← F.map_comp, ed.s₀_comp_δ₁]
  s_comp_δ₀ n := by
    dsimp
    erw [← F.map_comp, ed.s_comp_δ₀, F.map_id]
  s_comp_δ n i := by
    dsimp
    erw [← F.map_comp, ← F.map_comp, ed.s_comp_δ]
    rfl
  s_comp_σ n i := by
    dsimp
    

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.94778, u_1} C
D : Type u_2
inst✝ : Category.{?u.94785, u_2} D
X : SimplicialObject.Augmented C
ed : ExtraDegeneracy X
F : C ⥤ D
n : ℕ
i : Fin (n + 1)
⊢ F.map (s ed n) ≫ SimplicialObject.σ (((SimplicialObject.whiskering C D).obj F).obj X.left) (Fin.succ i) =
    SimplicialObject.σ (((SimplicialObject.whiskering C D).obj F).obj X.left) i ≫ F.map (s ed (n + 1))

Next tactic:
erw [← F.map_comp, ← F.map_comp, ed.s_comp_σ]
/-- If `ed` is an extra degeneracy for `X : SimplicialObject.Augmented C` and
`F : C ⥤ D` is a functor, then `ed.map F` is an extra degeneracy for the
augmented simplical object in `D` obtained by applying `F` to `X`. -/
def map {D : Type*} [Category D] {X : SimplicialObject.Augmented C} (ed : ExtraDegeneracy X)
    (F : C ⥤ D) : ExtraDegeneracy (((whiskering _ _).obj F).obj X) where
  s' := F.map ed.s'
  s n := F.map (ed.s n)
  s'_comp_ε := by
    dsimp
    erw [comp_id, ← F.map_comp, ed.s'_comp_ε, F.map_id]
  s₀_comp_δ₁ := by
    dsimp
    erw [comp_id, ← F.map_comp, ← F.map_comp, ed.s₀_comp_δ₁]
  s_comp_δ₀ n := by
    dsimp
    erw [← F.map_comp, ed.s_comp_δ₀, F.map_id]
  s_comp_δ n i := by
    dsimp
    erw [← F.map_comp, ← F.map_comp, ed.s_comp_δ]
    rfl
  s_comp_σ n i := by
    dsimp
    erw [← F.map_comp, ← F.map_comp, ed.s_comp_σ]
    

Proof state:
C : Type u_1
inst✝¹ : Category.{?u.94778, u_1} C
D : Type u_2
inst✝ : Category.{?u.94785, u_2} D
X : SimplicialObject.Augmented C
ed : ExtraDegeneracy X
F : C ⥤ D
n : ℕ
i : Fin (n + 1)
⊢ F.map (SimplicialObject.σ X.left i ≫ s ed (n + 1)) = F.map (X.left.map (SimplexCategory.σ i).op ≫ s ed (n + 1))

Next tactic:
rfl
/-- If `X` and `Y` are isomorphic augmented simplicial objects, then an extra
degeneracy for `X` gives also an extra degeneracy for `Y` -/
def ofIso {X Y : SimplicialObject.Augmented C} (e : X ≅ Y) (ed : ExtraDegeneracy X) :
    ExtraDegeneracy Y where
  s' := (point.mapIso e).inv ≫ ed.s' ≫ (drop.mapIso e).hom.app (op [0])
  s n := (drop.mapIso e).inv.app (op [n]) ≫ ed.s n ≫ (drop.mapIso e).hom.app (op [n + 1])
  s'_comp_ε := by
    

Proof state:
C : Type u_1
inst✝ : Category.{?u.104215, u_1} C
X Y : SimplicialObject.Augmented C
e : X ≅ Y
ed : ExtraDegeneracy X
⊢ ((point.mapIso e).inv ≫ ed.s' ≫ (drop.mapIso e).hom.app (op [0])) ≫ Y.hom.app (op [0]) = 𝟙 (point.obj Y)

Next tactic:
simpa only [Functor.mapIso, assoc, w₀, ed.s'_comp_ε_assoc] using (point.mapIso e).inv_hom_id
/-- If `X` and `Y` are isomorphic augmented simplicial objects, then an extra
degeneracy for `X` gives also an extra degeneracy for `Y` -/
def ofIso {X Y : SimplicialObject.Augmented C} (e : X ≅ Y) (ed : ExtraDegeneracy X) :
    ExtraDegeneracy Y where
  s' := (point.mapIso e).inv ≫ ed.s' ≫ (drop.mapIso e).hom.app (op [0])
  s n := (drop.mapIso e).inv.app (op [n]) ≫ ed.s n ≫ (drop.mapIso e).hom.app (op [n + 1])
  s'_comp_ε := by
    simpa only [Functor.mapIso, assoc, w₀, ed.s'_comp_ε_assoc] using (point.mapIso e).inv_hom_id
  s₀_comp_δ₁ := by
    

Proof state:
C : Type u_1
inst✝ : Category.{?u.104215, u_1} C
X Y : SimplicialObject.Augmented C
e : X ≅ Y
ed : ExtraDegeneracy X
⊢ (fun n => (drop.mapIso e).inv.app (op [n]) ≫ s ed n ≫ (drop.mapIso e).hom.app (op [n + 1])) 0 ≫
      SimplicialObject.δ Y.left 1 =
    Y.hom.app (op [0]) ≫ (point.mapIso e).inv ≫ ed.s' ≫ (drop.mapIso e).hom.app (op [0])

Next tactic:
have h := w₀ e.inv
/-- If `X` and `Y` are isomorphic augmented simplicial objects, then an extra
degeneracy for `X` gives also an extra degeneracy for `Y` -/
def ofIso {X Y : SimplicialObject.Augmented C} (e : X ≅ Y) (ed : ExtraDegeneracy X) :
    ExtraDegeneracy Y where
  s' := (point.mapIso e).inv ≫ ed.s' ≫ (drop.mapIso e).hom.app (op [0])
  s n := (drop.mapIso e).inv.app (op [n]) ≫ ed.s n ≫ (drop.mapIso e).hom.app (op [n + 1])
  s'_comp_ε := by
    simpa only [Functor.mapIso, assoc, w₀, ed.s'_comp_ε_assoc] using (point.mapIso e).inv_hom_id
  s₀_comp_δ₁ := by
    have h := w₀ e.inv
    

Proof state:
C : Type u_1
inst✝ : Category.{?u.104215, u_1} C
X Y : SimplicialObject.Augmented C
e : X ≅ Y
ed : ExtraDegeneracy X
h : (drop.map e.inv).app (op [0]) ≫ X.hom.app (op [0]) = Y.hom.app (op [0]) ≫ point.map e.inv
⊢ (fun n => (drop.mapIso e).inv.app (op [n]) ≫ s ed n ≫ (drop.mapIso e).hom.app (op [n + 1])) 0 ≫
      SimplicialObject.δ Y.left 1 =
    Y.hom.app (op [0]) ≫ (point.mapIso e).inv ≫ ed.s' ≫ (drop.mapIso e).hom.app (op [0])

Next tactic:
dsimp at h ⊢
/-- If `X` and `Y` are isomorphic augmented simplicial objects, then an extra
degeneracy for `X` gives also an extra degeneracy for `Y` -/
def ofIso {X Y : SimplicialObject.Augmented C} (e : X ≅ Y) (ed : ExtraDegeneracy X) :
    ExtraDegeneracy Y where
  s' := (point.mapIso e).inv ≫ ed.s' ≫ (drop.mapIso e).hom.app (op [0])
  s n := (drop.mapIso e).inv.app (op [n]) ≫ ed.s n ≫ (drop.mapIso e).hom.app (op [n + 1])
  s'_comp_ε := by
    simpa only [Functor.mapIso, assoc, w₀, ed.s'_comp_ε_assoc] using (point.mapIso e).inv_hom_id
  s₀_comp_δ₁ := by
    have h := w₀ e.inv
    dsimp at h ⊢
    

Proof state:
C : Type u_1
inst✝ : Category.{?u.104215, u_1} C
X Y : SimplicialObject.Augmented C
e : X ≅ Y
ed : ExtraDegeneracy X
h : e.inv.left.app (op [0]) ≫ X.hom.app (op [0]) = Y.hom.app (op [0]) ≫ e.inv.right
⊢ (e.inv.left.app (op [0]) ≫ s ed 0 ≫ e.hom.left.app (op [0 + 1])) ≫ SimplicialObject.δ Y.left 1 =
    Y.hom.app (op [0]) ≫ e.inv.right ≫ ed.s' ≫ e.hom.left.app (op [0])

Next tactic:
simp only [assoc, ← SimplicialObject.δ_naturality, ed.s₀_comp_δ₁_assoc, reassoc_of% h]
/-- If `X` and `Y` are isomorphic augmented simplicial objects, then an extra
degeneracy for `X` gives also an extra degeneracy for `Y` -/
def ofIso {X Y : SimplicialObject.Augmented C} (e : X ≅ Y) (ed : ExtraDegeneracy X) :
    ExtraDegeneracy Y where
  s' := (point.mapIso e).inv ≫ ed.s' ≫ (drop.mapIso e).hom.app (op [0])
  s n := (drop.mapIso e).inv.app (op [n]) ≫ ed.s n ≫ (drop.mapIso e).hom.app (op [n + 1])
  s'_comp_ε := by
    simpa only [Functor.mapIso, assoc, w₀, ed.s'_comp_ε_assoc] using (point.mapIso e).inv_hom_id
  s₀_comp_δ₁ := by
    have h := w₀ e.inv
    dsimp at h ⊢
    simp only [assoc, ← SimplicialObject.δ_naturality, ed.s₀_comp_δ₁_assoc, reassoc_of% h]
  s_comp_δ₀ n := by
    

Proof state:
C : Type u_1
inst✝ : Category.{?u.104215, u_1} C
X Y : SimplicialObject.Augmented C
e : X ≅ Y
ed : ExtraDegeneracy X
n : ℕ
⊢ (fun n => (drop.mapIso e).inv.app (op [n]) ≫ s ed n ≫ (drop.mapIso e).hom.app (op [n + 1])) n ≫
      SimplicialObject.δ Y.left 0 =
    𝟙 ((drop.obj Y).obj (op [n]))

Next tactic:
have h := ed.s_comp_δ₀
/-- If `X` and `Y` are isomorphic augmented simplicial objects, then an extra
degeneracy for `X` gives also an extra degeneracy for `Y` -/
def ofIso {X Y : SimplicialObject.Augmented C} (e : X ≅ Y) (ed : ExtraDegeneracy X) :
    ExtraDegeneracy Y where
  s' := (point.mapIso e).inv ≫ ed.s' ≫ (drop.mapIso e).hom.app (op [0])
  s n := (drop.mapIso e).inv.app (op [n]) ≫ ed.s n ≫ (drop.mapIso e).hom.app (op [n + 1])
  s'_comp_ε := by
    simpa only [Functor.mapIso, assoc, w₀, ed.s'_comp_ε_assoc] using (point.mapIso e).inv_hom_id
  s₀_comp_δ₁ := by
    have h := w₀ e.inv
    dsimp at h ⊢
    simp only [assoc, ← SimplicialObject.δ_naturality, ed.s₀_comp_δ₁_assoc, reassoc_of% h]
  s_comp_δ₀ n := by
    have h := ed.s_comp_δ₀
    

Proof state:
C : Type u_1
inst✝ : Category.{?u.104215, u_1} C
X Y : SimplicialObject.Augmented C
e : X ≅ Y
ed : ExtraDegeneracy X
n : ℕ
h : ∀ (n : ℕ), s ed n ≫ SimplicialObject.δ X.left 0 = 𝟙 ((drop.obj X).obj (op [n]))
⊢ (fun n => (drop.mapIso e).inv.app (op [n]) ≫ s ed n ≫ (drop.mapIso e).hom.app (op [n + 1])) n ≫
      SimplicialObject.δ Y.left 0 =
    𝟙 ((drop.obj Y).obj (op [n]))

Next tactic:
dsimp at h ⊢
/-- If `X` and `Y` are isomorphic augmented simplicial objects, then an extra
degeneracy for `X` gives also an extra degeneracy for `Y` -/
def ofIso {X Y : SimplicialObject.Augmented C} (e : X ≅ Y) (ed : ExtraDegeneracy X) :
    ExtraDegeneracy Y where
  s' := (point.mapIso e).inv ≫ ed.s' ≫ (drop.mapIso e).hom.app (op [0])
  s n := (drop.mapIso e).inv.app (op [n]) ≫ ed.s n ≫ (drop.mapIso e).hom.app (op [n + 1])
  s'_comp_ε := by
    simpa only [Functor.mapIso, assoc, w₀, ed.s'_comp_ε_assoc] using (point.mapIso e).inv_hom_id
  s₀_comp_δ₁ := by
    have h := w₀ e.inv
    dsimp at h ⊢
    simp only [assoc, ← SimplicialObject.δ_naturality, ed.s₀_comp_δ₁_assoc, reassoc_of% h]
  s_comp_δ₀ n := by
    have h := ed.s_comp_δ₀
    dsimp at h ⊢
    

Proof state:
C : Type u_1
inst✝ : Category.{?u.104215, u_1} C
X Y : SimplicialObject.Augmented C
e : X ≅ Y
ed : ExtraDegeneracy X
n : ℕ
h : ∀ (n : ℕ), s ed n ≫ SimplicialObject.δ X.left 0 = 𝟙 (X.left.obj (op [n]))
⊢ (e.inv.left.app (op [n]) ≫ s ed n ≫ e.hom.left.app (op [n + 1])) ≫ SimplicialObject.δ Y.left 0 =
    𝟙 (Y.left.obj (op [n]))

Next tactic:
simpa only [assoc, ← SimplicialObject.δ_naturality, reassoc_of% h] using
      congr_app (drop.mapIso e).inv_hom_id (op [n])
/-- If `X` and `Y` are isomorphic augmented simplicial objects, then an extra
degeneracy for `X` gives also an extra degeneracy for `Y` -/
def ofIso {X Y : SimplicialObject.Augmented C} (e : X ≅ Y) (ed : ExtraDegeneracy X) :
    ExtraDegeneracy Y where
  s' := (point.mapIso e).inv ≫ ed.s' ≫ (drop.mapIso e).hom.app (op [0])
  s n := (drop.mapIso e).inv.app (op [n]) ≫ ed.s n ≫ (drop.mapIso e).hom.app (op [n + 1])
  s'_comp_ε := by
    simpa only [Functor.mapIso, assoc, w₀, ed.s'_comp_ε_assoc] using (point.mapIso e).inv_hom_id
  s₀_comp_δ₁ := by
    have h := w₀ e.inv
    dsimp at h ⊢
    simp only [assoc, ← SimplicialObject.δ_naturality, ed.s₀_comp_δ₁_assoc, reassoc_of% h]
  s_comp_δ₀ n := by
    have h := ed.s_comp_δ₀
    dsimp at h ⊢
    simpa only [assoc, ← SimplicialObject.δ_naturality, reassoc_of% h] using
      congr_app (drop.mapIso e).inv_hom_id (op [n])
  s_comp_δ n i := by
    

Proof state:
C : Type u_1
inst✝ : Category.{?u.104215, u_1} C
X Y : SimplicialObject.Augmented C
e : X ≅ Y
ed : ExtraDegeneracy X
n : ℕ
i : Fin (n + 2)
⊢ (fun n => (drop.mapIso e).inv.app (op [n]) ≫ s ed n ≫ (drop.mapIso e).hom.app (op [n + 1])) (n + 1) ≫
      SimplicialObject.δ Y.left (Fin.succ i) =
    SimplicialObject.δ Y.left i ≫
      (fun n => (drop.mapIso e).inv.app (op [n]) ≫ s ed n ≫ (drop.mapIso e).hom.app (op [n + 1])) n

Next tactic:
have h := ed.s_comp_δ n i
/-- If `X` and `Y` are isomorphic augmented simplicial objects, then an extra
degeneracy for `X` gives also an extra degeneracy for `Y` -/
def ofIso {X Y : SimplicialObject.Augmented C} (e : X ≅ Y) (ed : ExtraDegeneracy X) :
    ExtraDegeneracy Y where
  s' := (point.mapIso e).inv ≫ ed.s' ≫ (drop.mapIso e).hom.app (op [0])
  s n := (drop.mapIso e).inv.app (op [n]) ≫ ed.s n ≫ (drop.mapIso e).hom.app (op [n + 1])
  s'_comp_ε := by
    simpa only [Functor.mapIso, assoc, w₀, ed.s'_comp_ε_assoc] using (point.mapIso e).inv_hom_id
  s₀_comp_δ₁ := by
    have h := w₀ e.inv
    dsimp at h ⊢
    simp only [assoc, ← SimplicialObject.δ_naturality, ed.s₀_comp_δ₁_assoc, reassoc_of% h]
  s_comp_δ₀ n := by
    have h := ed.s_comp_δ₀
    dsimp at h ⊢
    simpa only [assoc, ← SimplicialObject.δ_naturality, reassoc_of% h] using
      congr_app (drop.mapIso e).inv_hom_id (op [n])
  s_comp_δ n i := by
    have h := ed.s_comp_δ n i
    

Proof state:
C : Type u_1
inst✝ : Category.{?u.104215, u_1} C
X Y : SimplicialObject.Augmented C
e : X ≅ Y
ed : ExtraDegeneracy X
n : ℕ
i : Fin (n + 2)
h : s ed (n + 1) ≫ SimplicialObject.δ X.left (Fin.succ i) = SimplicialObject.δ X.left i ≫ s ed n
⊢ (fun n => (drop.mapIso e).inv.app (op [n]) ≫ s ed n ≫ (drop.mapIso e).hom.app (op [n + 1])) (n + 1) ≫
      SimplicialObject.δ Y.left (Fin.succ i) =
    SimplicialObject.δ Y.left i ≫
      (fun n => (drop.mapIso e).inv.app (op [n]) ≫ s ed n ≫ (drop.mapIso e).hom.app (op [n + 1])) n

Next tactic:
dsimp at h ⊢
/-- If `X` and `Y` are isomorphic augmented simplicial objects, then an extra
degeneracy for `X` gives also an extra degeneracy for `Y` -/
def ofIso {X Y : SimplicialObject.Augmented C} (e : X ≅ Y) (ed : ExtraDegeneracy X) :
    ExtraDegeneracy Y where
  s' := (point.mapIso e).inv ≫ ed.s' ≫ (drop.mapIso e).hom.app (op [0])
  s n := (drop.mapIso e).inv.app (op [n]) ≫ ed.s n ≫ (drop.mapIso e).hom.app (op [n + 1])
  s'_comp_ε := by
    simpa only [Functor.mapIso, assoc, w₀, ed.s'_comp_ε_assoc] using (point.mapIso e).inv_hom_id
  s₀_comp_δ₁ := by
    have h := w₀ e.inv
    dsimp at h ⊢
    simp only [assoc, ← SimplicialObject.δ_naturality, ed.s₀_comp_δ₁_assoc, reassoc_of% h]
  s_comp_δ₀ n := by
    have h := ed.s_comp_δ₀
    dsimp at h ⊢
    simpa only [assoc, ← SimplicialObject.δ_naturality, reassoc_of% h] using
      congr_app (drop.mapIso e).inv_hom_id (op [n])
  s_comp_δ n i := by
    have h := ed.s_comp_δ n i
    dsimp at h ⊢
    

Proof state:
C : Type u_1
inst✝ : Category.{?u.104215, u_1} C
X Y : SimplicialObject.Augmented C
e : X ≅ Y
ed : ExtraDegeneracy X
n : ℕ
i : Fin (n + 2)
h : s ed (n + 1) ≫ SimplicialObject.δ X.left (Fin.succ i) = SimplicialObject.δ X.left i ≫ s ed n
⊢ (e.inv.left.app (op [n + 1]) ≫ s ed (n + 1) ≫ e.hom.left.app (op [n + 1 + 1])) ≫
      SimplicialObject.δ Y.left (Fin.succ i) =
    SimplicialObject.δ Y.left i ≫ e.inv.left.app (op [n]) ≫ s ed n ≫ e.hom.left.app (op [n + 1])

Next tactic:
simp only [assoc, ← SimplicialObject.δ_naturality, reassoc_of% h,
      ← SimplicialObject.δ_naturality_assoc]
/-- If `X` and `Y` are isomorphic augmented simplicial objects, then an extra
degeneracy for `X` gives also an extra degeneracy for `Y` -/
def ofIso {X Y : SimplicialObject.Augmented C} (e : X ≅ Y) (ed : ExtraDegeneracy X) :
    ExtraDegeneracy Y where
  s' := (point.mapIso e).inv ≫ ed.s' ≫ (drop.mapIso e).hom.app (op [0])
  s n := (drop.mapIso e).inv.app (op [n]) ≫ ed.s n ≫ (drop.mapIso e).hom.app (op [n + 1])
  s'_comp_ε := by
    simpa only [Functor.mapIso, assoc, w₀, ed.s'_comp_ε_assoc] using (point.mapIso e).inv_hom_id
  s₀_comp_δ₁ := by
    have h := w₀ e.inv
    dsimp at h ⊢
    simp only [assoc, ← SimplicialObject.δ_naturality, ed.s₀_comp_δ₁_assoc, reassoc_of% h]
  s_comp_δ₀ n := by
    have h := ed.s_comp_δ₀
    dsimp at h ⊢
    simpa only [assoc, ← SimplicialObject.δ_naturality, reassoc_of% h] using
      congr_app (drop.mapIso e).inv_hom_id (op [n])
  s_comp_δ n i := by
    have h := ed.s_comp_δ n i
    dsimp at h ⊢
    simp only [assoc, ← SimplicialObject.δ_naturality, reassoc_of% h,
      ← SimplicialObject.δ_naturality_assoc]
  s_comp_σ n i := by
    

Proof state:
C : Type u_1
inst✝ : Category.{?u.104215, u_1} C
X Y : SimplicialObject.Augmented C
e : X ≅ Y
ed : ExtraDegeneracy X
n : ℕ
i : Fin (n + 1)
⊢ (fun n => (drop.mapIso e).inv.app (op [n]) ≫ s ed n ≫ (drop.mapIso e).hom.app (op [n + 1])) n ≫
      SimplicialObject.σ Y.left (Fin.succ i) =
    SimplicialObject.σ Y.left i ≫
      (fun n => (drop.mapIso e).inv.app (op [n]) ≫ s ed n ≫ (drop.mapIso e).hom.app (op [n + 1])) (n + 1)

Next tactic:
have h := ed.s_comp_σ n i