l3lab/ntp-mathlib huggingface dataset:
/-- 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
    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 + 1)
h : s ed n ≫ SimplicialObject.σ X.left (Fin.succ i) = SimplicialObject.σ X.left i ≫ s ed (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:
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 ⊢
    simp only [assoc, ← SimplicialObject.δ_naturality, reassoc_of% h,
      ← SimplicialObject.δ_naturality_assoc]
  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 + 1)
h : s ed n ≫ SimplicialObject.σ X.left (Fin.succ i) = SimplicialObject.σ X.left i ≫ s ed (n + 1)
⊢ (e.inv.left.app (op [n]) ≫ s ed n ≫ e.hom.left.app (op [n + 1])) ≫ SimplicialObject.σ Y.left (Fin.succ i) =
    SimplicialObject.σ Y.left i ≫ e.inv.left.app (op [n + 1]) ≫ s ed (n + 1) ≫ e.hom.left.app (op [n + 1 + 1])

Next tactic:
simp only [assoc, ← SimplicialObject.σ_naturality, reassoc_of% h,
      ← SimplicialObject.σ_naturality_assoc]
@[simp]
theorem shiftFun_succ {n : ℕ} {X : Type*} [Zero X] (f : Fin n → X) (i : Fin n) :
    shiftFun f i.succ = f i := by
  

Proof state:
n : ℕ
X : Type u_1
inst✝ : Zero X
f : Fin n → X
i : Fin n
⊢ shiftFun f (Fin.succ i) = f i

Next tactic:
dsimp [shiftFun]
@[simp]
theorem shiftFun_succ {n : ℕ} {X : Type*} [Zero X] (f : Fin n → X) (i : Fin n) :
    shiftFun f i.succ = f i := by
  dsimp [shiftFun]
  

Proof state:
n : ℕ
X : Type u_1
inst✝ : Zero X
f : Fin n → X
i : Fin n
⊢ (if x : Fin.succ i = 0 then 0 else f (Fin.pred (Fin.succ i) x)) = f i

Next tactic:
split_ifs with h
@[simp]
theorem shiftFun_succ {n : ℕ} {X : Type*} [Zero X] (f : Fin n → X) (i : Fin n) :
    shiftFun f i.succ = f i := by
  dsimp [shiftFun]
  split_ifs with h
  · 

Proof state:
case pos
n : ℕ
X : Type u_1
inst✝ : Zero X
f : Fin n → X
i : Fin n
h : Fin.succ i = 0
⊢ 0 = f i

Next tactic:
exfalso
@[simp]
theorem shiftFun_succ {n : ℕ} {X : Type*} [Zero X] (f : Fin n → X) (i : Fin n) :
    shiftFun f i.succ = f i := by
  dsimp [shiftFun]
  split_ifs with h
  · exfalso
    

Proof state:
case pos.h
n : ℕ
X : Type u_1
inst✝ : Zero X
f : Fin n → X
i : Fin n
h : Fin.succ i = 0
⊢ False

Next tactic:
simp only [Fin.ext_iff, Fin.val_succ, Fin.val_zero, add_eq_zero, and_false] at h
@[simp]
theorem shiftFun_succ {n : ℕ} {X : Type*} [Zero X] (f : Fin n → X) (i : Fin n) :
    shiftFun f i.succ = f i := by
  dsimp [shiftFun]
  split_ifs with h
  · exfalso
    simp only [Fin.ext_iff, Fin.val_succ, Fin.val_zero, add_eq_zero, and_false] at h
  · 

Proof state:
case neg
n : ℕ
X : Type u_1
inst✝ : Zero X
f : Fin n → X
i : Fin n
h : ¬Fin.succ i = 0
⊢ f (Fin.pred (Fin.succ i) h) = f i

Next tactic:
simp only [Fin.pred_succ]
/-- The shift of a morphism `f : [n] → Δ` in `SimplexCategory` corresponds to
the monotone map which sends `0` to `0` and `i.succ` to `f.to_order_hom i`. -/
@[simp]
def shift {n : ℕ} {Δ : SimplexCategory}
    (f : ([n] : SimplexCategory) ⟶ Δ) : ([n + 1] : SimplexCategory) ⟶ Δ :=
  SimplexCategory.Hom.mk
    { toFun := shiftFun f.toOrderHom
      monotone' := fun i₁ i₂ hi => by
        

Proof state:
n : ℕ
Δ : SimplexCategory
f : [n] ⟶ Δ
i₁ i₂ : Fin (SimplexCategory.len [n + 1] + 1)
hi : i₁ ≤ i₂
⊢ shiftFun (⇑(SimplexCategory.Hom.toOrderHom f)) i₁ ≤ shiftFun (⇑(SimplexCategory.Hom.toOrderHom f)) i₂

Next tactic:
by_cases h₁ : i₁ = 0
/-- The shift of a morphism `f : [n] → Δ` in `SimplexCategory` corresponds to
the monotone map which sends `0` to `0` and `i.succ` to `f.to_order_hom i`. -/
@[simp]
def shift {n : ℕ} {Δ : SimplexCategory}
    (f : ([n] : SimplexCategory) ⟶ Δ) : ([n + 1] : SimplexCategory) ⟶ Δ :=
  SimplexCategory.Hom.mk
    { toFun := shiftFun f.toOrderHom
      monotone' := fun i₁ i₂ hi => by
        by_cases h₁ : i₁ = 0
        · 

Proof state:
case pos
n : ℕ
Δ : SimplexCategory
f : [n] ⟶ Δ
i₁ i₂ : Fin (SimplexCategory.len [n + 1] + 1)
hi : i₁ ≤ i₂
h₁ : i₁ = 0
⊢ shiftFun (⇑(SimplexCategory.Hom.toOrderHom f)) i₁ ≤ shiftFun (⇑(SimplexCategory.Hom.toOrderHom f)) i₂

Next tactic:
subst h₁
/-- The shift of a morphism `f : [n] → Δ` in `SimplexCategory` corresponds to
the monotone map which sends `0` to `0` and `i.succ` to `f.to_order_hom i`. -/
@[simp]
def shift {n : ℕ} {Δ : SimplexCategory}
    (f : ([n] : SimplexCategory) ⟶ Δ) : ([n + 1] : SimplexCategory) ⟶ Δ :=
  SimplexCategory.Hom.mk
    { toFun := shiftFun f.toOrderHom
      monotone' := fun i₁ i₂ hi => by
        by_cases h₁ : i₁ = 0
        · subst h₁
          

Proof state:
case pos
n : ℕ
Δ : SimplexCategory
f : [n] ⟶ Δ
i₂ : Fin (SimplexCategory.len [n + 1] + 1)
hi : 0 ≤ i₂
⊢ shiftFun (⇑(SimplexCategory.Hom.toOrderHom f)) 0 ≤ shiftFun (⇑(SimplexCategory.Hom.toOrderHom f)) i₂

Next tactic:
simp only [shiftFun_0, Fin.zero_le]
/-- The shift of a morphism `f : [n] → Δ` in `SimplexCategory` corresponds to
the monotone map which sends `0` to `0` and `i.succ` to `f.to_order_hom i`. -/
@[simp]
def shift {n : ℕ} {Δ : SimplexCategory}
    (f : ([n] : SimplexCategory) ⟶ Δ) : ([n + 1] : SimplexCategory) ⟶ Δ :=
  SimplexCategory.Hom.mk
    { toFun := shiftFun f.toOrderHom
      monotone' := fun i₁ i₂ hi => by
        by_cases h₁ : i₁ = 0
        · subst h₁
          simp only [shiftFun_0, Fin.zero_le]
        · 

Proof state:
case neg
n : ℕ
Δ : SimplexCategory
f : [n] ⟶ Δ
i₁ i₂ : Fin (SimplexCategory.len [n + 1] + 1)
hi : i₁ ≤ i₂
h₁ : ¬i₁ = 0
⊢ shiftFun (⇑(SimplexCategory.Hom.toOrderHom f)) i₁ ≤ shiftFun (⇑(SimplexCategory.Hom.toOrderHom f)) i₂

Next tactic:
have h₂ : i₂ ≠ 0 := by
            intro h₂
            subst h₂
            exact h₁ (le_antisymm hi (Fin.zero_le _))
/-- The shift of a morphism `f : [n] → Δ` in `SimplexCategory` corresponds to
the monotone map which sends `0` to `0` and `i.succ` to `f.to_order_hom i`. -/
@[simp]
def shift {n : ℕ} {Δ : SimplexCategory}
    (f : ([n] : SimplexCategory) ⟶ Δ) : ([n + 1] : SimplexCategory) ⟶ Δ :=
  SimplexCategory.Hom.mk
    { toFun := shiftFun f.toOrderHom
      monotone' := fun i₁ i₂ hi => by
        by_cases h₁ : i₁ = 0
        · subst h₁
          simp only [shiftFun_0, Fin.zero_le]
        · have h₂ : i₂ ≠ 0 := by
            

Proof state:
n : ℕ
Δ : SimplexCategory
f : [n] ⟶ Δ
i₁ i₂ : Fin (SimplexCategory.len [n + 1] + 1)
hi : i₁ ≤ i₂
h₁ : ¬i₁ = 0
⊢ i₂ ≠ 0

Next tactic:
intro h₂
/-- The shift of a morphism `f : [n] → Δ` in `SimplexCategory` corresponds to
the monotone map which sends `0` to `0` and `i.succ` to `f.to_order_hom i`. -/
@[simp]
def shift {n : ℕ} {Δ : SimplexCategory}
    (f : ([n] : SimplexCategory) ⟶ Δ) : ([n + 1] : SimplexCategory) ⟶ Δ :=
  SimplexCategory.Hom.mk
    { toFun := shiftFun f.toOrderHom
      monotone' := fun i₁ i₂ hi => by
        by_cases h₁ : i₁ = 0
        · subst h₁
          simp only [shiftFun_0, Fin.zero_le]
        · have h₂ : i₂ ≠ 0 := by
            intro h₂
            

Proof state:
n : ℕ
Δ : SimplexCategory
f : [n] ⟶ Δ
i₁ i₂ : Fin (SimplexCategory.len [n + 1] + 1)
hi : i₁ ≤ i₂
h₁ : ¬i₁ = 0
h₂ : i₂ = 0
⊢ False

Next tactic:
subst h₂
/-- The shift of a morphism `f : [n] → Δ` in `SimplexCategory` corresponds to
the monotone map which sends `0` to `0` and `i.succ` to `f.to_order_hom i`. -/
@[simp]
def shift {n : ℕ} {Δ : SimplexCategory}
    (f : ([n] : SimplexCategory) ⟶ Δ) : ([n + 1] : SimplexCategory) ⟶ Δ :=
  SimplexCategory.Hom.mk
    { toFun := shiftFun f.toOrderHom
      monotone' := fun i₁ i₂ hi => by
        by_cases h₁ : i₁ = 0
        · subst h₁
          simp only [shiftFun_0, Fin.zero_le]
        · have h₂ : i₂ ≠ 0 := by
            intro h₂
            subst h₂
            

Proof state:
n : ℕ
Δ : SimplexCategory
f : [n] ⟶ Δ
i₁ : Fin (SimplexCategory.len [n + 1] + 1)
h₁ : ¬i₁ = 0
hi : i₁ ≤ 0
⊢ False

Next tactic:
exact h₁ (le_antisymm hi (Fin.zero_le _))
/-- The shift of a morphism `f : [n] → Δ` in `SimplexCategory` corresponds to
the monotone map which sends `0` to `0` and `i.succ` to `f.to_order_hom i`. -/
@[simp]
def shift {n : ℕ} {Δ : SimplexCategory}
    (f : ([n] : SimplexCategory) ⟶ Δ) : ([n + 1] : SimplexCategory) ⟶ Δ :=
  SimplexCategory.Hom.mk
    { toFun := shiftFun f.toOrderHom
      monotone' := fun i₁ i₂ hi => by
        by_cases h₁ : i₁ = 0
        · subst h₁
          simp only [shiftFun_0, Fin.zero_le]
        · have h₂ : i₂ ≠ 0 := by
            intro h₂
            subst h₂
            exact h₁ (le_antisymm hi (Fin.zero_le _))
          

Proof state:
case neg
n : ℕ
Δ : SimplexCategory
f : [n] ⟶ Δ
i₁ i₂ : Fin (SimplexCategory.len [n + 1] + 1)
hi : i₁ ≤ i₂
h₁ : ¬i₁ = 0
h₂ : i₂ ≠ 0
⊢ shiftFun (⇑(SimplexCategory.Hom.toOrderHom f)) i₁ ≤ shiftFun (⇑(SimplexCategory.Hom.toOrderHom f)) i₂

Next tactic:
cases' Fin.eq_succ_of_ne_zero h₁ with j₁ hj₁
/-- The shift of a morphism `f : [n] → Δ` in `SimplexCategory` corresponds to
the monotone map which sends `0` to `0` and `i.succ` to `f.to_order_hom i`. -/
@[simp]
def shift {n : ℕ} {Δ : SimplexCategory}
    (f : ([n] : SimplexCategory) ⟶ Δ) : ([n + 1] : SimplexCategory) ⟶ Δ :=
  SimplexCategory.Hom.mk
    { toFun := shiftFun f.toOrderHom
      monotone' := fun i₁ i₂ hi => by
        by_cases h₁ : i₁ = 0
        · subst h₁
          simp only [shiftFun_0, Fin.zero_le]
        · have h₂ : i₂ ≠ 0 := by
            intro h₂
            subst h₂
            exact h₁ (le_antisymm hi (Fin.zero_le _))
          cases' Fin.eq_succ_of_ne_zero h₁ with j₁ hj₁
          

Proof state:
case neg.intro
n : ℕ
Δ : SimplexCategory
f : [n] ⟶ Δ
i₁ i₂ : Fin (SimplexCategory.len [n + 1] + 1)
hi : i₁ ≤ i₂
h₁ : ¬i₁ = 0
h₂ : i₂ ≠ 0
j₁ : Fin (SimplexCategory.len [n + 1])
hj₁ : i₁ = Fin.succ j₁
⊢ shiftFun (⇑(SimplexCategory.Hom.toOrderHom f)) i₁ ≤ shiftFun (⇑(SimplexCategory.Hom.toOrderHom f)) i₂

Next tactic:
cases' Fin.eq_succ_of_ne_zero h₂ with j₂ hj₂
/-- The shift of a morphism `f : [n] → Δ` in `SimplexCategory` corresponds to
the monotone map which sends `0` to `0` and `i.succ` to `f.to_order_hom i`. -/
@[simp]
def shift {n : ℕ} {Δ : SimplexCategory}
    (f : ([n] : SimplexCategory) ⟶ Δ) : ([n + 1] : SimplexCategory) ⟶ Δ :=
  SimplexCategory.Hom.mk
    { toFun := shiftFun f.toOrderHom
      monotone' := fun i₁ i₂ hi => by
        by_cases h₁ : i₁ = 0
        · subst h₁
          simp only [shiftFun_0, Fin.zero_le]
        · have h₂ : i₂ ≠ 0 := by
            intro h₂
            subst h₂
            exact h₁ (le_antisymm hi (Fin.zero_le _))
          cases' Fin.eq_succ_of_ne_zero h₁ with j₁ hj₁
          cases' Fin.eq_succ_of_ne_zero h₂ with j₂ hj₂
          

Proof state:
case neg.intro.intro
n : ℕ
Δ : SimplexCategory
f : [n] ⟶ Δ
i₁ i₂ : Fin (SimplexCategory.len [n + 1] + 1)
hi : i₁ ≤ i₂
h₁ : ¬i₁ = 0
h₂ : i₂ ≠ 0
j₁ : Fin (SimplexCategory.len [n + 1])
hj₁ : i₁ = Fin.succ j₁
j₂ : Fin (SimplexCategory.len [n + 1])
hj₂ : i₂ = Fin.succ j₂
⊢ shiftFun (⇑(SimplexCategory.Hom.toOrderHom f)) i₁ ≤ shiftFun (⇑(SimplexCategory.Hom.toOrderHom f)) i₂

Next tactic:
substs hj₁ hj₂
/-- The shift of a morphism `f : [n] → Δ` in `SimplexCategory` corresponds to
the monotone map which sends `0` to `0` and `i.succ` to `f.to_order_hom i`. -/
@[simp]
def shift {n : ℕ} {Δ : SimplexCategory}
    (f : ([n] : SimplexCategory) ⟶ Δ) : ([n + 1] : SimplexCategory) ⟶ Δ :=
  SimplexCategory.Hom.mk
    { toFun := shiftFun f.toOrderHom
      monotone' := fun i₁ i₂ hi => by
        by_cases h₁ : i₁ = 0
        · subst h₁
          simp only [shiftFun_0, Fin.zero_le]
        · have h₂ : i₂ ≠ 0 := by
            intro h₂
            subst h₂
            exact h₁ (le_antisymm hi (Fin.zero_le _))
          cases' Fin.eq_succ_of_ne_zero h₁ with j₁ hj₁
          cases' Fin.eq_succ_of_ne_zero h₂ with j₂ hj₂
          substs hj₁ hj₂
          

Proof state:
case neg.intro.intro
n : ℕ
Δ : SimplexCategory
f : [n] ⟶ Δ
j₁ j₂ : Fin (SimplexCategory.len [n + 1])
h₁ : ¬Fin.succ j₁ = 0
h₂ : Fin.succ j₂ ≠ 0
hi : Fin.succ j₁ ≤ Fin.succ j₂
⊢ shiftFun (⇑(SimplexCategory.Hom.toOrderHom f)) (Fin.succ j₁) ≤
    shiftFun (⇑(SimplexCategory.Hom.toOrderHom f)) (Fin.succ j₂)

Next tactic:
simpa only [shiftFun_succ] using f.toOrderHom.monotone (Fin.succ_le_succ_iff.mp hi)
/-- The obvious extra degeneracy on the standard simplex. -/
protected noncomputable def extraDegeneracy (Δ : SimplexCategory) :
    SimplicialObject.Augmented.ExtraDegeneracy (standardSimplex.obj Δ) where
  s' _ := SimplexCategory.Hom.mk (OrderHom.const _ 0)
  s n f := shift f
  s'_comp_ε := by
    

Proof state:
Δ : SimplexCategory
⊢ (fun x => SimplexCategory.Hom.mk ((OrderHom.const (Fin (SimplexCategory.len (op [0]).unop + 1))) 0)) ≫
      (standardSimplex.obj Δ).hom.app (op [0]) =
    𝟙 (point.obj (standardSimplex.obj Δ))

Next tactic:
dsimp
/-- The obvious extra degeneracy on the standard simplex. -/
protected noncomputable def extraDegeneracy (Δ : SimplexCategory) :
    SimplicialObject.Augmented.ExtraDegeneracy (standardSimplex.obj Δ) where
  s' _ := SimplexCategory.Hom.mk (OrderHom.const _ 0)
  s n f := shift f
  s'_comp_ε := by
    dsimp
    

Proof state:
Δ : SimplexCategory
⊢ (fun x => SimplexCategory.Hom.mk ((OrderHom.const (Fin (0 + 1))) 0)) ≫ (standardSimplex.obj Δ).hom.app (op [0]) =
    𝟙 (⊤_ Type)

Next tactic:
apply Subsingleton.elim
/-- The obvious extra degeneracy on the standard simplex. -/
protected noncomputable def extraDegeneracy (Δ : SimplexCategory) :
    SimplicialObject.Augmented.ExtraDegeneracy (standardSimplex.obj Δ) where
  s' _ := SimplexCategory.Hom.mk (OrderHom.const _ 0)
  s n f := shift f
  s'_comp_ε := by
    dsimp
    apply Subsingleton.elim
  s₀_comp_δ₁ := by
    

Proof state:
Δ : SimplexCategory
⊢ (fun n f => shift f) 0 ≫ SimplicialObject.δ (standardSimplex.obj Δ).left 1 =
    (standardSimplex.obj Δ).hom.app (op [0]) ≫ fun x =>
      SimplexCategory.Hom.mk ((OrderHom.const (Fin (SimplexCategory.len (op [0]).unop + 1))) 0)

Next tactic:
ext1 x
/-- The obvious extra degeneracy on the standard simplex. -/
protected noncomputable def extraDegeneracy (Δ : SimplexCategory) :
    SimplicialObject.Augmented.ExtraDegeneracy (standardSimplex.obj Δ) where
  s' _ := SimplexCategory.Hom.mk (OrderHom.const _ 0)
  s n f := shift f
  s'_comp_ε := by
    dsimp
    apply Subsingleton.elim
  s₀_comp_δ₁ := by
    ext1 x
    

Proof state:
case h
Δ : SimplexCategory
x : (drop.obj (standardSimplex.obj Δ)).obj (op [0])
⊢ ((fun n f => shift f) 0 ≫ SimplicialObject.δ (standardSimplex.obj Δ).left 1) x =
    ((standardSimplex.obj Δ).hom.app (op [0]) ≫ fun x =>
        SimplexCategory.Hom.mk ((OrderHom.const (Fin (SimplexCategory.len (op [0]).unop + 1))) 0))
      x

Next tactic:
apply SimplexCategory.Hom.ext
/-- The obvious extra degeneracy on the standard simplex. -/
protected noncomputable def extraDegeneracy (Δ : SimplexCategory) :
    SimplicialObject.Augmented.ExtraDegeneracy (standardSimplex.obj Δ) where
  s' _ := SimplexCategory.Hom.mk (OrderHom.const _ 0)
  s n f := shift f
  s'_comp_ε := by
    dsimp
    apply Subsingleton.elim
  s₀_comp_δ₁ := by
    ext1 x
    apply SimplexCategory.Hom.ext
    

Proof state:
case h.a
Δ : SimplexCategory
x : (drop.obj (standardSimplex.obj Δ)).obj (op [0])
⊢ SimplexCategory.Hom.toOrderHom (((fun n f => shift f) 0 ≫ SimplicialObject.δ (standardSimplex.obj Δ).left 1) x) =
    SimplexCategory.Hom.toOrderHom
      (((standardSimplex.obj Δ).hom.app (op [0]) ≫ fun x =>
          SimplexCategory.Hom.mk ((OrderHom.const (Fin (SimplexCategory.len (op [0]).unop + 1))) 0))
        x)

Next tactic:
ext j
/-- The obvious extra degeneracy on the standard simplex. -/
protected noncomputable def extraDegeneracy (Δ : SimplexCategory) :
    SimplicialObject.Augmented.ExtraDegeneracy (standardSimplex.obj Δ) where
  s' _ := SimplexCategory.Hom.mk (OrderHom.const _ 0)
  s n f := shift f
  s'_comp_ε := by
    dsimp
    apply Subsingleton.elim
  s₀_comp_δ₁ := by
    ext1 x
    apply SimplexCategory.Hom.ext
    ext j
    

Proof state:
case h.a.h.h.h
Δ : SimplexCategory
x : (drop.obj (standardSimplex.obj Δ)).obj (op [0])
j : Fin (SimplexCategory.len (op [0]).unop + 1)
⊢ ↑((SimplexCategory.Hom.toOrderHom (((fun n f => shift f) 0 ≫ SimplicialObject.δ (standardSimplex.obj Δ).left 1) x))
        j) =
    ↑((SimplexCategory.Hom.toOrderHom
          (((standardSimplex.obj Δ).hom.app (op [0]) ≫ fun x =>
              SimplexCategory.Hom.mk ((OrderHom.const (Fin (SimplexCategory.len (op [0]).unop + 1))) 0))
            x))
        j)

Next tactic:
fin_cases j
/-- The obvious extra degeneracy on the standard simplex. -/
protected noncomputable def extraDegeneracy (Δ : SimplexCategory) :
    SimplicialObject.Augmented.ExtraDegeneracy (standardSimplex.obj Δ) where
  s' _ := SimplexCategory.Hom.mk (OrderHom.const _ 0)
  s n f := shift f
  s'_comp_ε := by
    dsimp
    apply Subsingleton.elim
  s₀_comp_δ₁ := by
    ext1 x
    apply SimplexCategory.Hom.ext
    ext j
    fin_cases j
    

Proof state:
case h.a.h.h.h.head
Δ : SimplexCategory
x : (drop.obj (standardSimplex.obj Δ)).obj (op [0])
⊢ ↑((SimplexCategory.Hom.toOrderHom (((fun n f => shift f) 0 ≫ SimplicialObject.δ (standardSimplex.obj Δ).left 1) x))
        { val := 0, isLt := (_ : 0 < SimplexCategory.len (op [0]).unop + 1) }) =
    ↑((SimplexCategory.Hom.toOrderHom
          (((standardSimplex.obj Δ).hom.app (op [0]) ≫ fun x =>
              SimplexCategory.Hom.mk ((OrderHom.const (Fin (SimplexCategory.len (op [0]).unop + 1))) 0))
            x))
        { val := 0, isLt := (_ : 0 < SimplexCategory.len (op [0]).unop + 1) })

Next tactic:
rfl
/-- The obvious extra degeneracy on the standard simplex. -/
protected noncomputable def extraDegeneracy (Δ : SimplexCategory) :
    SimplicialObject.Augmented.ExtraDegeneracy (standardSimplex.obj Δ) where
  s' _ := SimplexCategory.Hom.mk (OrderHom.const _ 0)
  s n f := shift f
  s'_comp_ε := by
    dsimp
    apply Subsingleton.elim
  s₀_comp_δ₁ := by
    ext1 x
    apply SimplexCategory.Hom.ext
    ext j
    fin_cases j
    rfl
  s_comp_δ₀ n := by
    

Proof state:
Δ : SimplexCategory
n : ℕ
⊢ (fun n f => shift f) n ≫ SimplicialObject.δ (standardSimplex.obj Δ).left 0 =
    𝟙 ((drop.obj (standardSimplex.obj Δ)).obj (op [n]))

Next tactic:
ext1 φ
/-- The obvious extra degeneracy on the standard simplex. -/
protected noncomputable def extraDegeneracy (Δ : SimplexCategory) :
    SimplicialObject.Augmented.ExtraDegeneracy (standardSimplex.obj Δ) where
  s' _ := SimplexCategory.Hom.mk (OrderHom.const _ 0)
  s n f := shift f
  s'_comp_ε := by
    dsimp
    apply Subsingleton.elim
  s₀_comp_δ₁ := by
    ext1 x
    apply SimplexCategory.Hom.ext
    ext j
    fin_cases j
    rfl
  s_comp_δ₀ n := by
    ext1 φ
    

Proof state:
case h
Δ : SimplexCategory
n : ℕ
φ : (drop.obj (standardSimplex.obj Δ)).obj (op [n])
⊢ ((fun n f => shift f) n ≫ SimplicialObject.δ (standardSimplex.obj Δ).left 0) φ =
    𝟙 ((drop.obj (standardSimplex.obj Δ)).obj (op [n])) φ

Next tactic:
apply SimplexCategory.Hom.ext
/-- The obvious extra degeneracy on the standard simplex. -/
protected noncomputable def extraDegeneracy (Δ : SimplexCategory) :
    SimplicialObject.Augmented.ExtraDegeneracy (standardSimplex.obj Δ) where
  s' _ := SimplexCategory.Hom.mk (OrderHom.const _ 0)
  s n f := shift f
  s'_comp_ε := by
    dsimp
    apply Subsingleton.elim
  s₀_comp_δ₁ := by
    ext1 x
    apply SimplexCategory.Hom.ext
    ext j
    fin_cases j
    rfl
  s_comp_δ₀ n := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    

Proof state:
case h.a
Δ : SimplexCategory
n : ℕ
φ : (drop.obj (standardSimplex.obj Δ)).obj (op [n])
⊢ SimplexCategory.Hom.toOrderHom (((fun n f => shift f) n ≫ SimplicialObject.δ (standardSimplex.obj Δ).left 0) φ) =
    SimplexCategory.Hom.toOrderHom (𝟙 ((drop.obj (standardSimplex.obj Δ)).obj (op [n])) φ)

Next tactic:
ext i : 2
/-- The obvious extra degeneracy on the standard simplex. -/
protected noncomputable def extraDegeneracy (Δ : SimplexCategory) :
    SimplicialObject.Augmented.ExtraDegeneracy (standardSimplex.obj Δ) where
  s' _ := SimplexCategory.Hom.mk (OrderHom.const _ 0)
  s n f := shift f
  s'_comp_ε := by
    dsimp
    apply Subsingleton.elim
  s₀_comp_δ₁ := by
    ext1 x
    apply SimplexCategory.Hom.ext
    ext j
    fin_cases j
    rfl
  s_comp_δ₀ n := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext i : 2
    

Proof state:
case h.a.h.h
Δ : SimplexCategory
n : ℕ
φ : (drop.obj (standardSimplex.obj Δ)).obj (op [n])
i : Fin (SimplexCategory.len (op [n]).unop + 1)
⊢ (SimplexCategory.Hom.toOrderHom (((fun n f => shift f) n ≫ SimplicialObject.δ (standardSimplex.obj Δ).left 0) φ)) i =
    (SimplexCategory.Hom.toOrderHom (𝟙 ((drop.obj (standardSimplex.obj Δ)).obj (op [n])) φ)) i

Next tactic:
dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
/-- The obvious extra degeneracy on the standard simplex. -/
protected noncomputable def extraDegeneracy (Δ : SimplexCategory) :
    SimplicialObject.Augmented.ExtraDegeneracy (standardSimplex.obj Δ) where
  s' _ := SimplexCategory.Hom.mk (OrderHom.const _ 0)
  s n f := shift f
  s'_comp_ε := by
    dsimp
    apply Subsingleton.elim
  s₀_comp_δ₁ := by
    ext1 x
    apply SimplexCategory.Hom.ext
    ext j
    fin_cases j
    rfl
  s_comp_δ₀ n := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext i : 2
    dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
    

Proof state:
case h.a.h.h
Δ : SimplexCategory
n : ℕ
φ : (drop.obj (standardSimplex.obj Δ)).obj (op [n])
i : Fin (SimplexCategory.len (op [n]).unop + 1)
⊢ shiftFun (⇑(SimplexCategory.Hom.toOrderHom φ)) (Fin.succ i) = (SimplexCategory.Hom.toOrderHom φ) i

Next tactic:
simp only [shiftFun_succ]