l3lab/ntp-mathlib huggingface dataset:
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals try simp <;> linarith
  all_goals 

Proof state:
case neg
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : ¬k < i
h✝² : j + 1 < k + 1
h✝¹ : j < k
h✝ : ¬k - 1 < i
⊢ k + 1 - 1 = k - 1 + 1

Next tactic:
cases k
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals try simp <;> linarith
  all_goals cases k <;> 

Proof state:
case neg.zero
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : i ≤ j
hk : Nat.zero < n + 1 + 1
h✝³ : ¬Nat.zero < i
h✝² : j + 1 < Nat.zero + 1
h✝¹ : j < Nat.zero
h✝ : ¬Nat.zero - 1 < i
⊢ Nat.zero + 1 - 1 = Nat.zero - 1 + 1

Next tactic:
simp at *
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals try simp <;> linarith
  all_goals cases k <;> 

Proof state:
case neg.succ
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : i ≤ j
n✝ : ℕ
hk : Nat.succ n✝ < n + 1 + 1
h✝³ : ¬Nat.succ n✝ < i
h✝² : j + 1 < Nat.succ n✝ + 1
h✝¹ : j < Nat.succ n✝
h✝ : ¬Nat.succ n✝ - 1 < i
⊢ Nat.succ n✝ + 1 - 1 = Nat.succ n✝ - 1 + 1

Next tactic:
simp at *
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals try simp <;> linarith
  all_goals 

Proof state:
case pos
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
k : ℕ
hk : k < n + 1 + 1
H : i ≤ j
h✝³ : ¬k < i
h✝² : ¬j + 1 < k + 1
h✝¹ : j < k
h✝ : k - 1 < i
⊢ k + 1 = k - 1

Next tactic:
cases k
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals try simp <;> linarith
  all_goals cases k <;> 

Proof state:
case pos.zero
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : i ≤ j
hk : Nat.zero < n + 1 + 1
h✝³ : ¬Nat.zero < i
h✝² : ¬j + 1 < Nat.zero + 1
h✝¹ : j < Nat.zero
h✝ : Nat.zero - 1 < i
⊢ Nat.zero + 1 = Nat.zero - 1

Next tactic:
simp at *
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals try simp <;> linarith
  all_goals cases k <;> 

Proof state:
case pos.succ
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : i ≤ j
n✝ : ℕ
hk : Nat.succ n✝ < n + 1 + 1
h✝³ : ¬Nat.succ n✝ < i
h✝² : ¬j + 1 < Nat.succ n✝ + 1
h✝¹ : j < Nat.succ n✝
h✝ : Nat.succ n✝ - 1 < i
⊢ Nat.succ n✝ + 1 = Nat.succ n✝ - 1

Next tactic:
simp at *
/-- The second simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i := by
  rcases i with ⟨i, hi⟩
  rcases j with ⟨j, hj⟩
  ext ⟨k, hk⟩
  simp? at H hk says simp only [Fin.castSucc_mk, Fin.mk_le_mk, len_mk] at H hk
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite, Fin.coe_castSucc, Fin.val_succ]
  split_ifs
  all_goals try simp <;> linarith
  all_goals cases k <;> simp at * <;> 

Proof state:
case pos.succ
n i : ℕ
hi : i < n + 2
j : ℕ
hj : j < n + 1
H : i ≤ j
n✝ : ℕ
hk : Nat.succ n✝ < n + 1 + 1
h✝³ : j < Nat.succ n✝
h✝² : i ≤ Nat.succ n✝
h✝¹ : n✝ + 1 ≤ j
h✝ : n✝ < i
⊢ Nat.succ n✝ + 1 = n✝

Next tactic:
linarith
/-- The first part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_self {n} {i : Fin (n + 1)} :
    δ (Fin.castSucc i) ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  

Proof state:
n : ℕ
i : Fin (n + 1)
⊢ δ (Fin.castSucc i) ≫ σ i = 𝟙 [n]

Next tactic:
rcases i with ⟨i, hi⟩
/-- The first part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_self {n} {i : Fin (n + 1)} :
    δ (Fin.castSucc i) ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  rcases i with ⟨i, hi⟩
  

Proof state:
case mk
n i : ℕ
hi : i < n + 1
⊢ δ (Fin.castSucc { val := i, isLt := hi }) ≫ σ { val := i, isLt := hi } = 𝟙 [n]

Next tactic:
ext ⟨j, hj⟩
/-- The first part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_self {n} {i : Fin (n + 1)} :
    δ (Fin.castSucc i) ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  rcases i with ⟨i, hi⟩
  ext ⟨j, hj⟩
  

Proof state:
case mk.a.h.h.mk.h
n i : ℕ
hi : i < n + 1
j : ℕ
hj : j < len [n] + 1
⊢ ↑((Hom.toOrderHom (δ (Fin.castSucc { val := i, isLt := hi }) ≫ σ { val := i, isLt := hi }))
        { val := j, isLt := hj }) =
    ↑((Hom.toOrderHom (𝟙 [n])) { val := j, isLt := hj })

Next tactic:
simp? at hj says simp only [len_mk] at hj
/-- The first part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_self {n} {i : Fin (n + 1)} :
    δ (Fin.castSucc i) ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  rcases i with ⟨i, hi⟩
  ext ⟨j, hj⟩
  simp? at hj says 

Proof state:
case mk.a.h.h.mk.h
n i : ℕ
hi : i < n + 1
j : ℕ
hj : j < len [n] + 1
⊢ ↑((Hom.toOrderHom (δ (Fin.castSucc { val := i, isLt := hi }) ≫ σ { val := i, isLt := hi }))
        { val := j, isLt := hj }) =
    ↑((Hom.toOrderHom (𝟙 [n])) { val := j, isLt := hj })

Next tactic:
simp only [len_mk] at hj
/-- The first part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_self {n} {i : Fin (n + 1)} :
    δ (Fin.castSucc i) ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  rcases i with ⟨i, hi⟩
  ext ⟨j, hj⟩
  simp? at hj says simp only [len_mk] at hj
  

Proof state:
case mk.a.h.h.mk.h
n i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 1
⊢ ↑((Hom.toOrderHom (δ (Fin.castSucc { val := i, isLt := hi }) ≫ σ { val := i, isLt := hi }))
        { val := j, isLt := hj }) =
    ↑((Hom.toOrderHom (𝟙 [n])) { val := j, isLt := hj })

Next tactic:
dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
/-- The first part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_self {n} {i : Fin (n + 1)} :
    δ (Fin.castSucc i) ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  rcases i with ⟨i, hi⟩
  ext ⟨j, hj⟩
  simp? at hj says simp only [len_mk] at hj
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  

Proof state:
case mk.a.h.h.mk.h
n i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 1
⊢ ↑(if h :
          { val := i, isLt := (_ : i < Nat.succ (n + 1)) } <
            if j < i then { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
            else { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) } then
        Fin.pred
          (if j < i then { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
          else { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) })
          (_ :
            (if j < i then { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
              else { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) }) ≠
              0)
      else
        Fin.castLT
          (if j < i then { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
          else { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) })
          (_ :
            ↑(if j < i then { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
                else { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) }) <
              n + 1)) =
    j

Next tactic:
simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite]
/-- The first part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_self {n} {i : Fin (n + 1)} :
    δ (Fin.castSucc i) ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  rcases i with ⟨i, hi⟩
  ext ⟨j, hj⟩
  simp? at hj says simp only [len_mk] at hj
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite]
  

Proof state:
case mk.a.h.h.mk.h
n i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 1
⊢ (if i < if j < i then j else j + 1 then (if j < i then j else j + 1) - 1 else if j < i then j else j + 1) = j

Next tactic:
split_ifs
/-- The first part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_self {n} {i : Fin (n + 1)} :
    δ (Fin.castSucc i) ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  rcases i with ⟨i, hi⟩
  ext ⟨j, hj⟩
  simp? at hj says simp only [len_mk] at hj
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite]
  split_ifs
  

Proof state:
case pos
n i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 1
h✝¹ : j < i
h✝ : i < j
⊢ j - 1 = j
case neg
n i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 1
h✝¹ : j < i
h✝ : ¬i < j
⊢ j = j
case pos
n i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 1
h✝¹ : ¬j < i
h✝ : i < j + 1
⊢ j + 1 - 1 = j
case neg n i : ℕ hi : i < n + 1 j : ℕ hj : j < n + 1 h✝¹ : ¬j < i h✝ : ¬i < j + 1 ⊢ j + 1 = j

Next tactic:
any_goals simp
/-- The first part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_self {n} {i : Fin (n + 1)} :
    δ (Fin.castSucc i) ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  rcases i with ⟨i, hi⟩
  ext ⟨j, hj⟩
  simp? at hj says simp only [len_mk] at hj
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite]
  split_ifs
  any_goals 

Proof state:
case pos
n i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 1
h✝¹ : j < i
h✝ : i < j
⊢ j - 1 = j

Next tactic:
simp
/-- The first part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_self {n} {i : Fin (n + 1)} :
    δ (Fin.castSucc i) ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  rcases i with ⟨i, hi⟩
  ext ⟨j, hj⟩
  simp? at hj says simp only [len_mk] at hj
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite]
  split_ifs
  any_goals 

Proof state:
case neg
n i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 1
h✝¹ : j < i
h✝ : ¬i < j
⊢ j = j

Next tactic:
simp
/-- The first part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_self {n} {i : Fin (n + 1)} :
    δ (Fin.castSucc i) ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  rcases i with ⟨i, hi⟩
  ext ⟨j, hj⟩
  simp? at hj says simp only [len_mk] at hj
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite]
  split_ifs
  any_goals 

Proof state:
case pos
n i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 1
h✝¹ : ¬j < i
h✝ : i < j + 1
⊢ j + 1 - 1 = j

Next tactic:
simp
/-- The first part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_self {n} {i : Fin (n + 1)} :
    δ (Fin.castSucc i) ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  rcases i with ⟨i, hi⟩
  ext ⟨j, hj⟩
  simp? at hj says simp only [len_mk] at hj
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite]
  split_ifs
  any_goals 

Proof state:
case neg
n i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 1
h✝¹ : ¬j < i
h✝ : ¬i < j + 1
⊢ j + 1 = j

Next tactic:
simp
/-- The first part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_self {n} {i : Fin (n + 1)} :
    δ (Fin.castSucc i) ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  rcases i with ⟨i, hi⟩
  ext ⟨j, hj⟩
  simp? at hj says simp only [len_mk] at hj
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite]
  split_ifs
  any_goals simp
  

Proof state:
case pos
n i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 1
h✝¹ : j < i
h✝ : i < j
⊢ j - 1 = j
case neg n i : ℕ hi : i < n + 1 j : ℕ hj : j < n + 1 h✝¹ : ¬j < i h✝ : ¬i < j + 1 ⊢ False

Next tactic:
all_goals linarith
/-- The first part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_self {n} {i : Fin (n + 1)} :
    δ (Fin.castSucc i) ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  rcases i with ⟨i, hi⟩
  ext ⟨j, hj⟩
  simp? at hj says simp only [len_mk] at hj
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite]
  split_ifs
  any_goals simp
  all_goals 

Proof state:
case pos
n i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 1
h✝¹ : j < i
h✝ : i < j
⊢ j - 1 = j

Next tactic:
linarith
/-- The first part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_self {n} {i : Fin (n + 1)} :
    δ (Fin.castSucc i) ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  rcases i with ⟨i, hi⟩
  ext ⟨j, hj⟩
  simp? at hj says simp only [len_mk] at hj
  dsimp [σ, δ, Fin.predAbove, Fin.succAbove]
  simp only [Fin.lt_iff_val_lt_val, Fin.dite_val, Fin.ite_val, Fin.coe_pred, ge_iff_le,
    Fin.coe_castLT, dite_eq_ite]
  split_ifs
  any_goals simp
  all_goals 

Proof state:
case neg
n i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 1
h✝¹ : ¬j < i
h✝ : ¬i < j + 1
⊢ False

Next tactic:
linarith
@[reassoc]
theorem δ_comp_σ_self' {n} {j : Fin (n + 2)} {i : Fin (n + 1)} (H : j = Fin.castSucc i) :
    δ j ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  

Proof state:
n : ℕ
j : Fin (n + 2)
i : Fin (n + 1)
H : j = Fin.castSucc i
⊢ δ j ≫ σ i = 𝟙 [n]

Next tactic:
subst H
@[reassoc]
theorem δ_comp_σ_self' {n} {j : Fin (n + 2)} {i : Fin (n + 1)} (H : j = Fin.castSucc i) :
    δ j ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  subst H
  

Proof state:
n : ℕ
i : Fin (n + 1)
⊢ δ (Fin.castSucc i) ≫ σ i = 𝟙 [n]

Next tactic:
rw [δ_comp_σ_self]
/-- The second part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_succ {n} {i : Fin (n + 1)} : δ i.succ ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  

Proof state:
n : ℕ
i : Fin (n + 1)
⊢ δ (Fin.succ i) ≫ σ i = 𝟙 [n]

Next tactic:
ext j
/-- The second part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_succ {n} {i : Fin (n + 1)} : δ i.succ ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  ext j
  

Proof state:
case a.h.h.h
n : ℕ
i : Fin (n + 1)
j : Fin (len [n] + 1)
⊢ ↑((Hom.toOrderHom (δ (Fin.succ i) ≫ σ i)) j) = ↑((Hom.toOrderHom (𝟙 [n])) j)

Next tactic:
rcases i with ⟨i, _⟩
/-- The second part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_succ {n} {i : Fin (n + 1)} : δ i.succ ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  ext j
  rcases i with ⟨i, _⟩
  

Proof state:
case a.h.h.h.mk
n : ℕ
j : Fin (len [n] + 1)
i : ℕ
isLt✝ : i < n + 1
⊢ ↑((Hom.toOrderHom (δ (Fin.succ { val := i, isLt := isLt✝ }) ≫ σ { val := i, isLt := isLt✝ })) j) =
    ↑((Hom.toOrderHom (𝟙 [n])) j)

Next tactic:
rcases j with ⟨j, _⟩
/-- The second part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_succ {n} {i : Fin (n + 1)} : δ i.succ ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  ext j
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  

Proof state:
case a.h.h.h.mk.mk
n i : ℕ
isLt✝¹ : i < n + 1
j : ℕ
isLt✝ : j < len [n] + 1
⊢ ↑((Hom.toOrderHom (δ (Fin.succ { val := i, isLt := isLt✝¹ }) ≫ σ { val := i, isLt := isLt✝¹ }))
        { val := j, isLt := isLt✝ }) =
    ↑((Hom.toOrderHom (𝟙 [n])) { val := j, isLt := isLt✝ })

Next tactic:
dsimp [δ, σ, Fin.succAbove, Fin.predAbove]
/-- The second part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_succ {n} {i : Fin (n + 1)} : δ i.succ ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  ext j
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  dsimp [δ, σ, Fin.succAbove, Fin.predAbove]
  

Proof state:
case a.h.h.h.mk.mk
n i : ℕ
isLt✝¹ : i < n + 1
j : ℕ
isLt✝ : j < len [n] + 1
⊢ ↑(if h :
          { val := i, isLt := (_ : i < Nat.succ (n + 1)) } <
            if j < i + 1 then { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
            else { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) } then
        Fin.pred
          (if j < i + 1 then { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
          else { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) })
          (_ :
            (if j < i + 1 then { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
              else { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) }) ≠
              0)
      else
        Fin.castLT
          (if j < i + 1 then { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
          else { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) })
          (_ :
            ↑(if j < i + 1 then { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
                else { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) }) <
              n + 1)) =
    j

Next tactic:
split_ifs
/-- The second part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_succ {n} {i : Fin (n + 1)} : δ i.succ ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  ext j
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  dsimp [δ, σ, Fin.succAbove, Fin.predAbove]
  split_ifs <;> 

Proof state:
case pos
n i : ℕ
isLt✝¹ : i < n + 1
j : ℕ
isLt✝ : j < len [n] + 1
h✝¹ : j < i + 1
h✝ : { val := i, isLt := (_ : i < Nat.succ (n + 1)) } < { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
⊢ ↑(Fin.pred { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
        (_ : { val := j, isLt := (_ : j < Nat.succ (n + 1)) } ≠ 0)) =
    j

Next tactic:
simp
/-- The second part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_succ {n} {i : Fin (n + 1)} : δ i.succ ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  ext j
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  dsimp [δ, σ, Fin.succAbove, Fin.predAbove]
  split_ifs <;> 

Proof state:
case neg
n i : ℕ
isLt✝¹ : i < n + 1
j : ℕ
isLt✝ : j < len [n] + 1
h✝¹ : j < i + 1
h✝ : ¬{ val := i, isLt := (_ : i < Nat.succ (n + 1)) } < { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
⊢ ↑(Fin.castLT { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
        (_ : ↑{ val := j, isLt := (_ : j < Nat.succ (n + 1)) } < n + 1)) =
    j

Next tactic:
simp
/-- The second part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_succ {n} {i : Fin (n + 1)} : δ i.succ ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  ext j
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  dsimp [δ, σ, Fin.succAbove, Fin.predAbove]
  split_ifs <;> 

Proof state:
case pos
n i : ℕ
isLt✝¹ : i < n + 1
j : ℕ
isLt✝ : j < len [n] + 1
h✝¹ : ¬j < i + 1
h✝ : { val := i, isLt := (_ : i < Nat.succ (n + 1)) } < { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) }
⊢ ↑(Fin.pred { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) }
        (_ : { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) } ≠ 0)) =
    j

Next tactic:
simp
/-- The second part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_succ {n} {i : Fin (n + 1)} : δ i.succ ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  ext j
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  dsimp [δ, σ, Fin.succAbove, Fin.predAbove]
  split_ifs <;> 

Proof state:
case neg
n i : ℕ
isLt✝¹ : i < n + 1
j : ℕ
isLt✝ : j < len [n] + 1
h✝¹ : ¬j < i + 1
h✝ : ¬{ val := i, isLt := (_ : i < Nat.succ (n + 1)) } < { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) }
⊢ ↑(Fin.castLT { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) }
        (_ : ↑{ val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) } < n + 1)) =
    j

Next tactic:
simp
/-- The second part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_succ {n} {i : Fin (n + 1)} : δ i.succ ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  ext j
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  dsimp [δ, σ, Fin.succAbove, Fin.predAbove]
  split_ifs <;> simp <;> 

Proof state:
case pos
n i : ℕ
isLt✝¹ : i < n + 1
j : ℕ
isLt✝ : j < len [n] + 1
h✝¹ : j < i + 1
h✝ : { val := i, isLt := (_ : i < Nat.succ (n + 1)) } < { val := j, isLt := (_ : j < Nat.succ (n + 1)) }
⊢ j - 1 = j

Next tactic:
simp at *
/-- The second part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_succ {n} {i : Fin (n + 1)} : δ i.succ ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  ext j
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  dsimp [δ, σ, Fin.succAbove, Fin.predAbove]
  split_ifs <;> simp <;> 

Proof state:
case neg
n i : ℕ
isLt✝¹ : i < n + 1
j : ℕ
isLt✝ : j < len [n] + 1
h✝¹ : ¬j < i + 1
h✝ : ¬{ val := i, isLt := (_ : i < Nat.succ (n + 1)) } < { val := j + 1, isLt := (_ : Nat.succ j < Nat.succ (n + 1)) }
⊢ False

Next tactic:
simp at *
/-- The second part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_succ {n} {i : Fin (n + 1)} : δ i.succ ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  ext j
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  dsimp [δ, σ, Fin.succAbove, Fin.predAbove]
  split_ifs <;> simp <;> simp at * <;> 

Proof state:
case pos
n i : ℕ
isLt✝¹ : i < n + 1
j : ℕ
isLt✝ : j < len [n] + 1
h✝¹ : j < i + 1
h✝ : i < j
⊢ j - 1 = j

Next tactic:
linarith
/-- The second part of the third simplicial identity -/
@[reassoc]
theorem δ_comp_σ_succ {n} {i : Fin (n + 1)} : δ i.succ ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  ext j
  rcases i with ⟨i, _⟩
  rcases j with ⟨j, _⟩
  dsimp [δ, σ, Fin.succAbove, Fin.predAbove]
  split_ifs <;> simp <;> simp at * <;> 

Proof state:
case neg
n i : ℕ
isLt✝¹ : i < n + 1
j : ℕ
isLt✝ : j < len [n] + 1
h✝¹ : i + 1 ≤ j
h✝ : j + 1 ≤ i
⊢ False

Next tactic:
linarith
@[reassoc]
theorem δ_comp_σ_succ' {n} (j : Fin (n + 2)) (i : Fin (n + 1)) (H : j = i.succ) :
    δ j ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  

Proof state:
n : ℕ
j : Fin (n + 2)
i : Fin (n + 1)
H : j = Fin.succ i
⊢ δ j ≫ σ i = 𝟙 [n]

Next tactic:
subst H
@[reassoc]
theorem δ_comp_σ_succ' {n} (j : Fin (n + 2)) (i : Fin (n + 1)) (H : j = i.succ) :
    δ j ≫ σ i = 𝟙 ([n] : SimplexCategory) := by
  subst H
  

Proof state:
n : ℕ
i : Fin (n + 1)
⊢ δ (Fin.succ i) ≫ σ i = 𝟙 [n]

Next tactic:
rw [δ_comp_σ_succ]
/-- The fourth simplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_gt {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : Fin.castSucc j < i) :
    δ i.succ ≫ σ (Fin.castSucc j) = σ j ≫ δ i := by
  

Proof state:
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : Fin.castSucc j < i
⊢ δ (Fin.succ i) ≫ σ (Fin.castSucc j) = σ j ≫ δ i

Next tactic:
ext ⟨k, hk⟩