l3lab/ntp-mathlib huggingface dataset:
/-- 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]
    simp only [shiftFun_succ]
  s_comp_δ n i := by
    

Proof state:
Δ : SimplexCategory
n : ℕ
i : Fin (n + 2)
⊢ (fun n f => shift f) (n + 1) ≫ SimplicialObject.δ (standardSimplex.obj Δ).left (Fin.succ i) =
    SimplicialObject.δ (standardSimplex.obj Δ).left i ≫ (fun n f => shift f) 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 φ
    apply SimplexCategory.Hom.ext
    ext i : 2
    dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
    simp only [shiftFun_succ]
  s_comp_δ n i := by
    ext1 φ
    

Proof state:
case h
Δ : SimplexCategory
n : ℕ
i : Fin (n + 2)
φ : (drop.obj (standardSimplex.obj Δ)).obj (op [n + 1])
⊢ ((fun n f => shift f) (n + 1) ≫ SimplicialObject.δ (standardSimplex.obj Δ).left (Fin.succ i)) φ =
    (SimplicialObject.δ (standardSimplex.obj Δ).left i ≫ (fun n f => shift f) 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
    ext i : 2
    dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
    simp only [shiftFun_succ]
  s_comp_δ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    

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

Next tactic:
ext j : 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
    dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
    simp only [shiftFun_succ]
  s_comp_δ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext j : 2
    

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

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]
    simp only [shiftFun_succ]
  s_comp_δ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext j : 2
    dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
    

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

Next tactic:
by_cases h : j = 0
/-- 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]
    simp only [shiftFun_succ]
  s_comp_δ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext j : 2
    dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
    by_cases h : j = 0
    · 

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

Next tactic:
subst h
/-- 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]
    simp only [shiftFun_succ]
  s_comp_δ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext j : 2
    dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
    by_cases h : j = 0
    · subst h
      

Proof state:
case pos
Δ : SimplexCategory
n : ℕ
i : Fin (n + 2)
φ : (drop.obj (standardSimplex.obj Δ)).obj (op [n + 1])
⊢ shiftFun (⇑(SimplexCategory.Hom.toOrderHom φ)) (Fin.succAbove (Fin.succ i) 0) =
    shiftFun (⇑(SimplexCategory.Hom.toOrderHom φ) ∘ ⇑(Fin.succAboveEmb i)) 0

Next tactic:
simp only [Fin.succ_succAbove_zero, shiftFun_0]
/-- 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]
    simp only [shiftFun_succ]
  s_comp_δ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext j : 2
    dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
    by_cases h : j = 0
    · subst h
      simp only [Fin.succ_succAbove_zero, shiftFun_0]
    · 

Proof state:
case neg
Δ : SimplexCategory
n : ℕ
i : Fin (n + 2)
φ : (drop.obj (standardSimplex.obj Δ)).obj (op [n + 1])
j : Fin (SimplexCategory.len (op [n + 1]).unop + 1)
h : ¬j = 0
⊢ shiftFun (⇑(SimplexCategory.Hom.toOrderHom φ)) (Fin.succAbove (Fin.succ i) j) =
    shiftFun (⇑(SimplexCategory.Hom.toOrderHom φ) ∘ ⇑(Fin.succAboveEmb i)) j

Next tactic:
obtain ⟨_, rfl⟩ := Fin.eq_succ_of_ne_zero <| h
/-- 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]
    simp only [shiftFun_succ]
  s_comp_δ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext j : 2
    dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
    by_cases h : j = 0
    · subst h
      simp only [Fin.succ_succAbove_zero, shiftFun_0]
    · obtain ⟨_, rfl⟩ := Fin.eq_succ_of_ne_zero <| h
      

Proof state:
case neg.intro
Δ : SimplexCategory
n : ℕ
i : Fin (n + 2)
φ : (drop.obj (standardSimplex.obj Δ)).obj (op [n + 1])
w✝ : Fin (SimplexCategory.len (op [n + 1]).unop)
h : ¬Fin.succ w✝ = 0
⊢ shiftFun (⇑(SimplexCategory.Hom.toOrderHom φ)) (Fin.succAbove (Fin.succ i) (Fin.succ w✝)) =
    shiftFun (⇑(SimplexCategory.Hom.toOrderHom φ) ∘ ⇑(Fin.succAboveEmb i)) (Fin.succ w✝)

Next tactic:
simp only [Fin.succ_succAbove_succ, shiftFun_succ, Function.comp_apply,
        Fin.succAboveEmb_apply]
/-- 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]
    simp only [shiftFun_succ]
  s_comp_δ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext j : 2
    dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
    by_cases h : j = 0
    · subst h
      simp only [Fin.succ_succAbove_zero, shiftFun_0]
    · obtain ⟨_, rfl⟩ := Fin.eq_succ_of_ne_zero <| h
      simp only [Fin.succ_succAbove_succ, shiftFun_succ, Function.comp_apply,
        Fin.succAboveEmb_apply]
  s_comp_σ n i := by
    

Proof state:
Δ : SimplexCategory
n : ℕ
i : Fin (n + 1)
⊢ (fun n f => shift f) n ≫ SimplicialObject.σ (standardSimplex.obj Δ).left (Fin.succ i) =
    SimplicialObject.σ (standardSimplex.obj Δ).left i ≫ (fun n f => shift f) (n + 1)

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 φ
    apply SimplexCategory.Hom.ext
    ext i : 2
    dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
    simp only [shiftFun_succ]
  s_comp_δ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext j : 2
    dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
    by_cases h : j = 0
    · subst h
      simp only [Fin.succ_succAbove_zero, shiftFun_0]
    · obtain ⟨_, rfl⟩ := Fin.eq_succ_of_ne_zero <| h
      simp only [Fin.succ_succAbove_succ, shiftFun_succ, Function.comp_apply,
        Fin.succAboveEmb_apply]
  s_comp_σ n i := by
    ext1 φ
    

Proof state:
case h
Δ : SimplexCategory
n : ℕ
i : Fin (n + 1)
φ : (drop.obj (standardSimplex.obj Δ)).obj (op [n])
⊢ ((fun n f => shift f) n ≫ SimplicialObject.σ (standardSimplex.obj Δ).left (Fin.succ i)) φ =
    (SimplicialObject.σ (standardSimplex.obj Δ).left i ≫ (fun n f => shift f) (n + 1)) φ

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
    ext i : 2
    dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
    simp only [shiftFun_succ]
  s_comp_δ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext j : 2
    dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
    by_cases h : j = 0
    · subst h
      simp only [Fin.succ_succAbove_zero, shiftFun_0]
    · obtain ⟨_, rfl⟩ := Fin.eq_succ_of_ne_zero <| h
      simp only [Fin.succ_succAbove_succ, shiftFun_succ, Function.comp_apply,
        Fin.succAboveEmb_apply]
  s_comp_σ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    

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

Next tactic:
ext j : 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
    dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
    simp only [shiftFun_succ]
  s_comp_δ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext j : 2
    dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
    by_cases h : j = 0
    · subst h
      simp only [Fin.succ_succAbove_zero, shiftFun_0]
    · obtain ⟨_, rfl⟩ := Fin.eq_succ_of_ne_zero <| h
      simp only [Fin.succ_succAbove_succ, shiftFun_succ, Function.comp_apply,
        Fin.succAboveEmb_apply]
  s_comp_σ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext j : 2
    

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

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]
    simp only [shiftFun_succ]
  s_comp_δ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext j : 2
    dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
    by_cases h : j = 0
    · subst h
      simp only [Fin.succ_succAbove_zero, shiftFun_0]
    · obtain ⟨_, rfl⟩ := Fin.eq_succ_of_ne_zero <| h
      simp only [Fin.succ_succAbove_succ, shiftFun_succ, Function.comp_apply,
        Fin.succAboveEmb_apply]
  s_comp_σ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext j : 2
    dsimp [SimplicialObject.σ, SimplexCategory.σ, SSet.standardSimplex]
    

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

Next tactic:
by_cases h : j = 0
/-- 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]
    simp only [shiftFun_succ]
  s_comp_δ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext j : 2
    dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
    by_cases h : j = 0
    · subst h
      simp only [Fin.succ_succAbove_zero, shiftFun_0]
    · obtain ⟨_, rfl⟩ := Fin.eq_succ_of_ne_zero <| h
      simp only [Fin.succ_succAbove_succ, shiftFun_succ, Function.comp_apply,
        Fin.succAboveEmb_apply]
  s_comp_σ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext j : 2
    dsimp [SimplicialObject.σ, SimplexCategory.σ, SSet.standardSimplex]
    by_cases h : j = 0
    · 

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

Next tactic:
subst h
/-- 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]
    simp only [shiftFun_succ]
  s_comp_δ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext j : 2
    dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
    by_cases h : j = 0
    · subst h
      simp only [Fin.succ_succAbove_zero, shiftFun_0]
    · obtain ⟨_, rfl⟩ := Fin.eq_succ_of_ne_zero <| h
      simp only [Fin.succ_succAbove_succ, shiftFun_succ, Function.comp_apply,
        Fin.succAboveEmb_apply]
  s_comp_σ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext j : 2
    dsimp [SimplicialObject.σ, SimplexCategory.σ, SSet.standardSimplex]
    by_cases h : j = 0
    · subst h
      

Proof state:
case pos
Δ : SimplexCategory
n : ℕ
i : Fin (n + 1)
φ : (drop.obj (standardSimplex.obj Δ)).obj (op [n])
⊢ shiftFun (⇑(SimplexCategory.Hom.toOrderHom φ)) (Fin.predAbove (Fin.succ i) 0) =
    shiftFun (⇑(SimplexCategory.Hom.toOrderHom φ) ∘ Fin.predAbove i) 0

Next tactic:
simp only [shiftFun_0]
/-- 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]
    simp only [shiftFun_succ]
  s_comp_δ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext j : 2
    dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
    by_cases h : j = 0
    · subst h
      simp only [Fin.succ_succAbove_zero, shiftFun_0]
    · obtain ⟨_, rfl⟩ := Fin.eq_succ_of_ne_zero <| h
      simp only [Fin.succ_succAbove_succ, shiftFun_succ, Function.comp_apply,
        Fin.succAboveEmb_apply]
  s_comp_σ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext j : 2
    dsimp [SimplicialObject.σ, SimplexCategory.σ, SSet.standardSimplex]
    by_cases h : j = 0
    · subst h
      simp only [shiftFun_0]
      

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

Next tactic:
exact shiftFun_0 φ.toOrderHom
/-- 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]
    simp only [shiftFun_succ]
  s_comp_δ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext j : 2
    dsimp [SimplicialObject.δ, SimplexCategory.δ, SSet.standardSimplex]
    by_cases h : j = 0
    · subst h
      simp only [Fin.succ_succAbove_zero, shiftFun_0]
    · obtain ⟨_, rfl⟩ := Fin.eq_succ_of_ne_zero <| h
      simp only [Fin.succ_succAbove_succ, shiftFun_succ, Function.comp_apply,
        Fin.succAboveEmb_apply]
  s_comp_σ n i := by
    ext1 φ
    apply SimplexCategory.Hom.ext
    ext j : 2
    dsimp [SimplicialObject.σ, SimplexCategory.σ, SSet.standardSimplex]
    by_cases h : j = 0
    · subst h
      simp only [shiftFun_0]
      exact shiftFun_0 φ.toOrderHom
    · 

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

Next tactic:
obtain ⟨_, rfl⟩ := Fin.eq_succ_of_ne_zero h