l3lab/ntp-mathlib huggingface dataset:
lemma map_comp {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k) :
    map F f i k (hij.trans hjk) = map F f i j hij ≫ map F f j k hjk := by
  obtain ⟨i, hi⟩ := i
  obtain ⟨j, hj⟩ := j
  obtain ⟨k, hk⟩ := k
  cases i
  · 

Proof state:
case mk.mk.mk.zero
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ left F
j : ℕ
hj : j < n + 1 + 1
k : ℕ
hk : k < n + 1 + 1
hjk : { val := j, isLt := hj } ≤ { val := k, isLt := hk }
hi : Nat.zero < n + 1 + 1
hij : { val := Nat.zero, isLt := hi } ≤ { val := j, isLt := hj }
⊢ map F f { val := Nat.zero, isLt := hi } { val := k, isLt := hk }
      (_ : { val := Nat.zero, isLt := hi } ≤ { val := k, isLt := hk }) =
    map F f { val := Nat.zero, isLt := hi } { val := j, isLt := hj } hij ≫
      map F f { val := j, isLt := hj } { val := k, isLt := hk } hjk

Next tactic:
obtain _ | _ | j := j
lemma map_comp {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k) :
    map F f i k (hij.trans hjk) = map F f i j hij ≫ map F f j k hjk := by
  obtain ⟨i, hi⟩ := i
  obtain ⟨j, hj⟩ := j
  obtain ⟨k, hk⟩ := k
  cases i
  · obtain _ | _ | j := j
    · 

Proof state:
case mk.mk.mk.zero.zero
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ left F
k : ℕ
hk : k < n + 1 + 1
hi hj : Nat.zero < n + 1 + 1
hjk : { val := Nat.zero, isLt := hj } ≤ { val := k, isLt := hk }
hij : { val := Nat.zero, isLt := hi } ≤ { val := Nat.zero, isLt := hj }
⊢ map F f { val := Nat.zero, isLt := hi } { val := k, isLt := hk }
      (_ : { val := Nat.zero, isLt := hi } ≤ { val := k, isLt := hk }) =
    map F f { val := Nat.zero, isLt := hi } { val := Nat.zero, isLt := hj } hij ≫
      map F f { val := Nat.zero, isLt := hj } { val := k, isLt := hk } hjk

Next tactic:
dsimp
lemma map_comp {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k) :
    map F f i k (hij.trans hjk) = map F f i j hij ≫ map F f j k hjk := by
  obtain ⟨i, hi⟩ := i
  obtain ⟨j, hj⟩ := j
  obtain ⟨k, hk⟩ := k
  cases i
  · obtain _ | _ | j := j
    · dsimp
      

Proof state:
case mk.mk.mk.zero.zero
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ left F
k : ℕ
hk : k < n + 1 + 1
hi hj : Nat.zero < n + 1 + 1
hjk : { val := Nat.zero, isLt := hj } ≤ { val := k, isLt := hk }
hij : { val := Nat.zero, isLt := hi } ≤ { val := Nat.zero, isLt := hj }
⊢ map F f 0 { val := k, isLt := hk } (_ : 0 ≤ { val := k, isLt := hk }) = 𝟙 X ≫ map F f 0 { val := k, isLt := hk } hjk

Next tactic:
rw [id_comp]
lemma map_comp {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k) :
    map F f i k (hij.trans hjk) = map F f i j hij ≫ map F f j k hjk := by
  obtain ⟨i, hi⟩ := i
  obtain ⟨j, hj⟩ := j
  obtain ⟨k, hk⟩ := k
  cases i
  · obtain _ | _ | j := j
    · dsimp
      rw [id_comp]
    · 

Proof state:
case mk.mk.mk.zero.succ.zero
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ left F
k : ℕ
hk : k < n + 1 + 1
hi : Nat.zero < n + 1 + 1
hj : Nat.succ Nat.zero < n + 1 + 1
hjk : { val := Nat.succ Nat.zero, isLt := hj } ≤ { val := k, isLt := hk }
hij : { val := Nat.zero, isLt := hi } ≤ { val := Nat.succ Nat.zero, isLt := hj }
⊢ map F f { val := Nat.zero, isLt := hi } { val := k, isLt := hk }
      (_ : { val := Nat.zero, isLt := hi } ≤ { val := k, isLt := hk }) =
    map F f { val := Nat.zero, isLt := hi } { val := Nat.succ Nat.zero, isLt := hj } hij ≫
      map F f { val := Nat.succ Nat.zero, isLt := hj } { val := k, isLt := hk } hjk

Next tactic:
obtain _ | _ | k := k
lemma map_comp {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k) :
    map F f i k (hij.trans hjk) = map F f i j hij ≫ map F f j k hjk := by
  obtain ⟨i, hi⟩ := i
  obtain ⟨j, hj⟩ := j
  obtain ⟨k, hk⟩ := k
  cases i
  · obtain _ | _ | j := j
    · dsimp
      rw [id_comp]
    · obtain _ | _ | k := k
      · 

Proof state:
case mk.mk.mk.zero.succ.zero.zero
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ left F
hi : Nat.zero < n + 1 + 1
hj : Nat.succ Nat.zero < n + 1 + 1
hij : { val := Nat.zero, isLt := hi } ≤ { val := Nat.succ Nat.zero, isLt := hj }
hk : Nat.zero < n + 1 + 1
hjk : { val := Nat.succ Nat.zero, isLt := hj } ≤ { val := Nat.zero, isLt := hk }
⊢ map F f { val := Nat.zero, isLt := hi } { val := Nat.zero, isLt := hk }
      (_ : { val := Nat.zero, isLt := hi } ≤ { val := Nat.zero, isLt := hk }) =
    map F f { val := Nat.zero, isLt := hi } { val := Nat.succ Nat.zero, isLt := hj } hij ≫
      map F f { val := Nat.succ Nat.zero, isLt := hj } { val := Nat.zero, isLt := hk } hjk

Next tactic:
simp at hjk
lemma map_comp {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k) :
    map F f i k (hij.trans hjk) = map F f i j hij ≫ map F f j k hjk := by
  obtain ⟨i, hi⟩ := i
  obtain ⟨j, hj⟩ := j
  obtain ⟨k, hk⟩ := k
  cases i
  · obtain _ | _ | j := j
    · dsimp
      rw [id_comp]
    · obtain _ | _ | k := k
      · simp at hjk
      · 

Proof state:
case mk.mk.mk.zero.succ.zero.succ.zero
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ left F
hi : Nat.zero < n + 1 + 1
hj : Nat.succ Nat.zero < n + 1 + 1
hij : { val := Nat.zero, isLt := hi } ≤ { val := Nat.succ Nat.zero, isLt := hj }
hk : Nat.succ Nat.zero < n + 1 + 1
hjk : { val := Nat.succ Nat.zero, isLt := hj } ≤ { val := Nat.succ Nat.zero, isLt := hk }
⊢ map F f { val := Nat.zero, isLt := hi } { val := Nat.succ Nat.zero, isLt := hk }
      (_ : { val := Nat.zero, isLt := hi } ≤ { val := Nat.succ Nat.zero, isLt := hk }) =
    map F f { val := Nat.zero, isLt := hi } { val := Nat.succ Nat.zero, isLt := hj } hij ≫
      map F f { val := Nat.succ Nat.zero, isLt := hj } { val := Nat.succ Nat.zero, isLt := hk } hjk

Next tactic:
dsimp
lemma map_comp {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k) :
    map F f i k (hij.trans hjk) = map F f i j hij ≫ map F f j k hjk := by
  obtain ⟨i, hi⟩ := i
  obtain ⟨j, hj⟩ := j
  obtain ⟨k, hk⟩ := k
  cases i
  · obtain _ | _ | j := j
    · dsimp
      rw [id_comp]
    · obtain _ | _ | k := k
      · simp at hjk
      · dsimp
        

Proof state:
case mk.mk.mk.zero.succ.zero.succ.zero
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ left F
hi : Nat.zero < n + 1 + 1
hj : Nat.succ Nat.zero < n + 1 + 1
hij : { val := Nat.zero, isLt := hi } ≤ { val := Nat.succ Nat.zero, isLt := hj }
hk : Nat.succ Nat.zero < n + 1 + 1
hjk : { val := Nat.succ Nat.zero, isLt := hj } ≤ { val := Nat.succ Nat.zero, isLt := hk }
⊢ f = f ≫ F.map (𝟙 0)

Next tactic:
rw [F.map_id, comp_id]
lemma map_comp {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k) :
    map F f i k (hij.trans hjk) = map F f i j hij ≫ map F f j k hjk := by
  obtain ⟨i, hi⟩ := i
  obtain ⟨j, hj⟩ := j
  obtain ⟨k, hk⟩ := k
  cases i
  · obtain _ | _ | j := j
    · dsimp
      rw [id_comp]
    · obtain _ | _ | k := k
      · simp at hjk
      · dsimp
        rw [F.map_id, comp_id]
      · 

Proof state:
case mk.mk.mk.zero.succ.zero.succ.succ
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ left F
hi : Nat.zero < n + 1 + 1
hj : Nat.succ Nat.zero < n + 1 + 1
hij : { val := Nat.zero, isLt := hi } ≤ { val := Nat.succ Nat.zero, isLt := hj }
k : ℕ
hk : Nat.succ (Nat.succ k) < n + 1 + 1
hjk : { val := Nat.succ Nat.zero, isLt := hj } ≤ { val := Nat.succ (Nat.succ k), isLt := hk }
⊢ map F f { val := Nat.zero, isLt := hi } { val := Nat.succ (Nat.succ k), isLt := hk }
      (_ : { val := Nat.zero, isLt := hi } ≤ { val := Nat.succ (Nat.succ k), isLt := hk }) =
    map F f { val := Nat.zero, isLt := hi } { val := Nat.succ Nat.zero, isLt := hj } hij ≫
      map F f { val := Nat.succ Nat.zero, isLt := hj } { val := Nat.succ (Nat.succ k), isLt := hk } hjk

Next tactic:
rfl
lemma map_comp {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k) :
    map F f i k (hij.trans hjk) = map F f i j hij ≫ map F f j k hjk := by
  obtain ⟨i, hi⟩ := i
  obtain ⟨j, hj⟩ := j
  obtain ⟨k, hk⟩ := k
  cases i
  · obtain _ | _ | j := j
    · dsimp
      rw [id_comp]
    · obtain _ | _ | k := k
      · simp at hjk
      · dsimp
        rw [F.map_id, comp_id]
      · rfl
    · 

Proof state:
case mk.mk.mk.zero.succ.succ
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ left F
k : ℕ
hk : k < n + 1 + 1
hi : Nat.zero < n + 1 + 1
j : ℕ
hj : Nat.succ (Nat.succ j) < n + 1 + 1
hjk : { val := Nat.succ (Nat.succ j), isLt := hj } ≤ { val := k, isLt := hk }
hij : { val := Nat.zero, isLt := hi } ≤ { val := Nat.succ (Nat.succ j), isLt := hj }
⊢ map F f { val := Nat.zero, isLt := hi } { val := k, isLt := hk }
      (_ : { val := Nat.zero, isLt := hi } ≤ { val := k, isLt := hk }) =
    map F f { val := Nat.zero, isLt := hi } { val := Nat.succ (Nat.succ j), isLt := hj } hij ≫
      map F f { val := Nat.succ (Nat.succ j), isLt := hj } { val := k, isLt := hk } hjk

Next tactic:
obtain _ | _ | k := k
lemma map_comp {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k) :
    map F f i k (hij.trans hjk) = map F f i j hij ≫ map F f j k hjk := by
  obtain ⟨i, hi⟩ := i
  obtain ⟨j, hj⟩ := j
  obtain ⟨k, hk⟩ := k
  cases i
  · obtain _ | _ | j := j
    · dsimp
      rw [id_comp]
    · obtain _ | _ | k := k
      · simp at hjk
      · dsimp
        rw [F.map_id, comp_id]
      · rfl
    · obtain _ | _ | k := k
      · 

Proof state:
case mk.mk.mk.zero.succ.succ.zero
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ left F
hi : Nat.zero < n + 1 + 1
j : ℕ
hj : Nat.succ (Nat.succ j) < n + 1 + 1
hij : { val := Nat.zero, isLt := hi } ≤ { val := Nat.succ (Nat.succ j), isLt := hj }
hk : Nat.zero < n + 1 + 1
hjk : { val := Nat.succ (Nat.succ j), isLt := hj } ≤ { val := Nat.zero, isLt := hk }
⊢ map F f { val := Nat.zero, isLt := hi } { val := Nat.zero, isLt := hk }
      (_ : { val := Nat.zero, isLt := hi } ≤ { val := Nat.zero, isLt := hk }) =
    map F f { val := Nat.zero, isLt := hi } { val := Nat.succ (Nat.succ j), isLt := hj } hij ≫
      map F f { val := Nat.succ (Nat.succ j), isLt := hj } { val := Nat.zero, isLt := hk } hjk

Next tactic:
simp [Fin.ext_iff] at hjk
lemma map_comp {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k) :
    map F f i k (hij.trans hjk) = map F f i j hij ≫ map F f j k hjk := by
  obtain ⟨i, hi⟩ := i
  obtain ⟨j, hj⟩ := j
  obtain ⟨k, hk⟩ := k
  cases i
  · obtain _ | _ | j := j
    · dsimp
      rw [id_comp]
    · obtain _ | _ | k := k
      · simp at hjk
      · dsimp
        rw [F.map_id, comp_id]
      · rfl
    · obtain _ | _ | k := k
      · simp [Fin.ext_iff] at hjk
      · 

Proof state:
case mk.mk.mk.zero.succ.succ.succ.zero
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ left F
hi : Nat.zero < n + 1 + 1
j : ℕ
hj : Nat.succ (Nat.succ j) < n + 1 + 1
hij : { val := Nat.zero, isLt := hi } ≤ { val := Nat.succ (Nat.succ j), isLt := hj }
hk : Nat.succ Nat.zero < n + 1 + 1
hjk : { val := Nat.succ (Nat.succ j), isLt := hj } ≤ { val := Nat.succ Nat.zero, isLt := hk }
⊢ map F f { val := Nat.zero, isLt := hi } { val := Nat.succ Nat.zero, isLt := hk }
      (_ : { val := Nat.zero, isLt := hi } ≤ { val := Nat.succ Nat.zero, isLt := hk }) =
    map F f { val := Nat.zero, isLt := hi } { val := Nat.succ (Nat.succ j), isLt := hj } hij ≫
      map F f { val := Nat.succ (Nat.succ j), isLt := hj } { val := Nat.succ Nat.zero, isLt := hk } hjk

Next tactic:
simp [Fin.le_def, Nat.succ_eq_add_one] at hjk
lemma map_comp {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k) :
    map F f i k (hij.trans hjk) = map F f i j hij ≫ map F f j k hjk := by
  obtain ⟨i, hi⟩ := i
  obtain ⟨j, hj⟩ := j
  obtain ⟨k, hk⟩ := k
  cases i
  · obtain _ | _ | j := j
    · dsimp
      rw [id_comp]
    · obtain _ | _ | k := k
      · simp at hjk
      · dsimp
        rw [F.map_id, comp_id]
      · rfl
    · obtain _ | _ | k := k
      · simp [Fin.ext_iff] at hjk
      · simp [Fin.le_def, Nat.succ_eq_add_one] at hjk
      · 

Proof state:
case mk.mk.mk.zero.succ.succ.succ.succ
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ left F
hi : Nat.zero < n + 1 + 1
j : ℕ
hj : Nat.succ (Nat.succ j) < n + 1 + 1
hij : { val := Nat.zero, isLt := hi } ≤ { val := Nat.succ (Nat.succ j), isLt := hj }
k : ℕ
hk : Nat.succ (Nat.succ k) < n + 1 + 1
hjk : { val := Nat.succ (Nat.succ j), isLt := hj } ≤ { val := Nat.succ (Nat.succ k), isLt := hk }
⊢ map F f { val := Nat.zero, isLt := hi } { val := Nat.succ (Nat.succ k), isLt := hk }
      (_ : { val := Nat.zero, isLt := hi } ≤ { val := Nat.succ (Nat.succ k), isLt := hk }) =
    map F f { val := Nat.zero, isLt := hi } { val := Nat.succ (Nat.succ j), isLt := hj } hij ≫
      map F f { val := Nat.succ (Nat.succ j), isLt := hj } { val := Nat.succ (Nat.succ k), isLt := hk } hjk

Next tactic:
dsimp
lemma map_comp {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k) :
    map F f i k (hij.trans hjk) = map F f i j hij ≫ map F f j k hjk := by
  obtain ⟨i, hi⟩ := i
  obtain ⟨j, hj⟩ := j
  obtain ⟨k, hk⟩ := k
  cases i
  · obtain _ | _ | j := j
    · dsimp
      rw [id_comp]
    · obtain _ | _ | k := k
      · simp at hjk
      · dsimp
        rw [F.map_id, comp_id]
      · rfl
    · obtain _ | _ | k := k
      · simp [Fin.ext_iff] at hjk
      · simp [Fin.le_def, Nat.succ_eq_add_one] at hjk
      · dsimp
        

Proof state:
case mk.mk.mk.zero.succ.succ.succ.succ
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ left F
hi : Nat.zero < n + 1 + 1
j : ℕ
hj : Nat.succ (Nat.succ j) < n + 1 + 1
hij : { val := Nat.zero, isLt := hi } ≤ { val := Nat.succ (Nat.succ j), isLt := hj }
k : ℕ
hk : Nat.succ (Nat.succ k) < n + 1 + 1
hjk : { val := Nat.succ (Nat.succ j), isLt := hj } ≤ { val := Nat.succ (Nat.succ k), isLt := hk }
⊢ f ≫ F.map (homOfLE (_ : { val := 0, isLt := (_ : 0 < n + 1) } ≤ { val := k + 1, isLt := (_ : k + 1 < n + 1) })) =
    (f ≫ F.map (homOfLE (_ : { val := 0, isLt := (_ : 0 < n + 1) } ≤ { val := j + 1, isLt := (_ : j + 1 < n + 1) }))) ≫
      F.map
        (homOfLE (_ : { val := j + 1, isLt := (_ : j + 1 < n + 1) } ≤ { val := k + 1, isLt := (_ : k + 1 < n + 1) }))

Next tactic:
rw [assoc, ← F.map_comp, homOfLE_comp]
lemma map_comp {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k) :
    map F f i k (hij.trans hjk) = map F f i j hij ≫ map F f j k hjk := by
  obtain ⟨i, hi⟩ := i
  obtain ⟨j, hj⟩ := j
  obtain ⟨k, hk⟩ := k
  cases i
  · obtain _ | _ | j := j
    · dsimp
      rw [id_comp]
    · obtain _ | _ | k := k
      · simp at hjk
      · dsimp
        rw [F.map_id, comp_id]
      · rfl
    · obtain _ | _ | k := k
      · simp [Fin.ext_iff] at hjk
      · simp [Fin.le_def, Nat.succ_eq_add_one] at hjk
      · dsimp
        rw [assoc, ← F.map_comp, homOfLE_comp]
  · 

Proof state:
case mk.mk.mk.succ
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ left F
j : ℕ
hj : j < n + 1 + 1
k : ℕ
hk : k < n + 1 + 1
hjk : { val := j, isLt := hj } ≤ { val := k, isLt := hk }
n✝ : ℕ
hi : Nat.succ n✝ < n + 1 + 1
hij : { val := Nat.succ n✝, isLt := hi } ≤ { val := j, isLt := hj }
⊢ map F f { val := Nat.succ n✝, isLt := hi } { val := k, isLt := hk }
      (_ : { val := Nat.succ n✝, isLt := hi } ≤ { val := k, isLt := hk }) =
    map F f { val := Nat.succ n✝, isLt := hi } { val := j, isLt := hj } hij ≫
      map F f { val := j, isLt := hj } { val := k, isLt := hk } hjk

Next tactic:
obtain _ | j := j
lemma map_comp {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k) :
    map F f i k (hij.trans hjk) = map F f i j hij ≫ map F f j k hjk := by
  obtain ⟨i, hi⟩ := i
  obtain ⟨j, hj⟩ := j
  obtain ⟨k, hk⟩ := k
  cases i
  · obtain _ | _ | j := j
    · dsimp
      rw [id_comp]
    · obtain _ | _ | k := k
      · simp at hjk
      · dsimp
        rw [F.map_id, comp_id]
      · rfl
    · obtain _ | _ | k := k
      · simp [Fin.ext_iff] at hjk
      · simp [Fin.le_def, Nat.succ_eq_add_one] at hjk
      · dsimp
        rw [assoc, ← F.map_comp, homOfLE_comp]
  · obtain _ | j := j
    · 

Proof state:
case mk.mk.mk.succ.zero
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ left F
k : ℕ
hk : k < n + 1 + 1
n✝ : ℕ
hi : Nat.succ n✝ < n + 1 + 1
hj : Nat.zero < n + 1 + 1
hjk : { val := Nat.zero, isLt := hj } ≤ { val := k, isLt := hk }
hij : { val := Nat.succ n✝, isLt := hi } ≤ { val := Nat.zero, isLt := hj }
⊢ map F f { val := Nat.succ n✝, isLt := hi } { val := k, isLt := hk }
      (_ : { val := Nat.succ n✝, isLt := hi } ≤ { val := k, isLt := hk }) =
    map F f { val := Nat.succ n✝, isLt := hi } { val := Nat.zero, isLt := hj } hij ≫
      map F f { val := Nat.zero, isLt := hj } { val := k, isLt := hk } hjk

Next tactic:
simp [Fin.ext_iff] at hij
lemma map_comp {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k) :
    map F f i k (hij.trans hjk) = map F f i j hij ≫ map F f j k hjk := by
  obtain ⟨i, hi⟩ := i
  obtain ⟨j, hj⟩ := j
  obtain ⟨k, hk⟩ := k
  cases i
  · obtain _ | _ | j := j
    · dsimp
      rw [id_comp]
    · obtain _ | _ | k := k
      · simp at hjk
      · dsimp
        rw [F.map_id, comp_id]
      · rfl
    · obtain _ | _ | k := k
      · simp [Fin.ext_iff] at hjk
      · simp [Fin.le_def, Nat.succ_eq_add_one] at hjk
      · dsimp
        rw [assoc, ← F.map_comp, homOfLE_comp]
  · obtain _ | j := j
    · simp [Fin.ext_iff] at hij
    · 

Proof state:
case mk.mk.mk.succ.succ
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ left F
k : ℕ
hk : k < n + 1 + 1
n✝ : ℕ
hi : Nat.succ n✝ < n + 1 + 1
j : ℕ
hj : Nat.succ j < n + 1 + 1
hjk : { val := Nat.succ j, isLt := hj } ≤ { val := k, isLt := hk }
hij : { val := Nat.succ n✝, isLt := hi } ≤ { val := Nat.succ j, isLt := hj }
⊢ map F f { val := Nat.succ n✝, isLt := hi } { val := k, isLt := hk }
      (_ : { val := Nat.succ n✝, isLt := hi } ≤ { val := k, isLt := hk }) =
    map F f { val := Nat.succ n✝, isLt := hi } { val := Nat.succ j, isLt := hj } hij ≫
      map F f { val := Nat.succ j, isLt := hj } { val := k, isLt := hk } hjk

Next tactic:
obtain _ | k := k
lemma map_comp {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k) :
    map F f i k (hij.trans hjk) = map F f i j hij ≫ map F f j k hjk := by
  obtain ⟨i, hi⟩ := i
  obtain ⟨j, hj⟩ := j
  obtain ⟨k, hk⟩ := k
  cases i
  · obtain _ | _ | j := j
    · dsimp
      rw [id_comp]
    · obtain _ | _ | k := k
      · simp at hjk
      · dsimp
        rw [F.map_id, comp_id]
      · rfl
    · obtain _ | _ | k := k
      · simp [Fin.ext_iff] at hjk
      · simp [Fin.le_def, Nat.succ_eq_add_one] at hjk
      · dsimp
        rw [assoc, ← F.map_comp, homOfLE_comp]
  · obtain _ | j := j
    · simp [Fin.ext_iff] at hij
    · obtain _ | k := k
      · 

Proof state:
case mk.mk.mk.succ.succ.zero
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ left F
n✝ : ℕ
hi : Nat.succ n✝ < n + 1 + 1
j : ℕ
hj : Nat.succ j < n + 1 + 1
hij : { val := Nat.succ n✝, isLt := hi } ≤ { val := Nat.succ j, isLt := hj }
hk : Nat.zero < n + 1 + 1
hjk : { val := Nat.succ j, isLt := hj } ≤ { val := Nat.zero, isLt := hk }
⊢ map F f { val := Nat.succ n✝, isLt := hi } { val := Nat.zero, isLt := hk }
      (_ : { val := Nat.succ n✝, isLt := hi } ≤ { val := Nat.zero, isLt := hk }) =
    map F f { val := Nat.succ n✝, isLt := hi } { val := Nat.succ j, isLt := hj } hij ≫
      map F f { val := Nat.succ j, isLt := hj } { val := Nat.zero, isLt := hk } hjk

Next tactic:
simp [Fin.ext_iff] at hjk
lemma map_comp {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k) :
    map F f i k (hij.trans hjk) = map F f i j hij ≫ map F f j k hjk := by
  obtain ⟨i, hi⟩ := i
  obtain ⟨j, hj⟩ := j
  obtain ⟨k, hk⟩ := k
  cases i
  · obtain _ | _ | j := j
    · dsimp
      rw [id_comp]
    · obtain _ | _ | k := k
      · simp at hjk
      · dsimp
        rw [F.map_id, comp_id]
      · rfl
    · obtain _ | _ | k := k
      · simp [Fin.ext_iff] at hjk
      · simp [Fin.le_def, Nat.succ_eq_add_one] at hjk
      · dsimp
        rw [assoc, ← F.map_comp, homOfLE_comp]
  · obtain _ | j := j
    · simp [Fin.ext_iff] at hij
    · obtain _ | k := k
      · simp [Fin.ext_iff] at hjk
      · 

Proof state:
case mk.mk.mk.succ.succ.succ
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ left F
n✝ : ℕ
hi : Nat.succ n✝ < n + 1 + 1
j : ℕ
hj : Nat.succ j < n + 1 + 1
hij : { val := Nat.succ n✝, isLt := hi } ≤ { val := Nat.succ j, isLt := hj }
k : ℕ
hk : Nat.succ k < n + 1 + 1
hjk : { val := Nat.succ j, isLt := hj } ≤ { val := Nat.succ k, isLt := hk }
⊢ map F f { val := Nat.succ n✝, isLt := hi } { val := Nat.succ k, isLt := hk }
      (_ : { val := Nat.succ n✝, isLt := hi } ≤ { val := Nat.succ k, isLt := hk }) =
    map F f { val := Nat.succ n✝, isLt := hi } { val := Nat.succ j, isLt := hj } hij ≫
      map F f { val := Nat.succ j, isLt := hj } { val := Nat.succ k, isLt := hk } hjk

Next tactic:
dsimp
lemma map_comp {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k) :
    map F f i k (hij.trans hjk) = map F f i j hij ≫ map F f j k hjk := by
  obtain ⟨i, hi⟩ := i
  obtain ⟨j, hj⟩ := j
  obtain ⟨k, hk⟩ := k
  cases i
  · obtain _ | _ | j := j
    · dsimp
      rw [id_comp]
    · obtain _ | _ | k := k
      · simp at hjk
      · dsimp
        rw [F.map_id, comp_id]
      · rfl
    · obtain _ | _ | k := k
      · simp [Fin.ext_iff] at hjk
      · simp [Fin.le_def, Nat.succ_eq_add_one] at hjk
      · dsimp
        rw [assoc, ← F.map_comp, homOfLE_comp]
  · obtain _ | j := j
    · simp [Fin.ext_iff] at hij
    · obtain _ | k := k
      · simp [Fin.ext_iff] at hjk
      · dsimp
        

Proof state:
case mk.mk.mk.succ.succ.succ
C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ left F
n✝ : ℕ
hi : Nat.succ n✝ < n + 1 + 1
j : ℕ
hj : Nat.succ j < n + 1 + 1
hij : { val := Nat.succ n✝, isLt := hi } ≤ { val := Nat.succ j, isLt := hj }
k : ℕ
hk : Nat.succ k < n + 1 + 1
hjk : { val := Nat.succ j, isLt := hj } ≤ { val := Nat.succ k, isLt := hk }
⊢ F.map (homOfLE (_ : { val := n✝, isLt := (_ : n✝ < n + 1) } ≤ { val := k, isLt := (_ : k < n + 1) })) =
    F.map (homOfLE (_ : { val := n✝, isLt := (_ : n✝ < n + 1) } ≤ { val := j, isLt := (_ : j < n + 1) })) ≫
      F.map (homOfLE (_ : { val := j, isLt := (_ : j < n + 1) } ≤ { val := k, isLt := (_ : k < n + 1) }))

Next tactic:
rw [← F.map_comp, homOfLE_comp]
example : map' (mk₂ f g) 0 1 = f := by 

Proof state:
C : Type u_1
inst✝ : Category.{?u.506401, u_1} C
n m : ℕ
F G : ComposableArrows C n
X₀ X₁ X₂ X₃ X₄ : C
f : X₀ ⟶ X₁
g : X₁ ⟶ X₂
h : X₂ ⟶ X₃
i : X₃ ⟶ X₄
⊢ map' (mk₂ f g) 0 1 = f

Next tactic:
dsimp
example : map' (mk₂ f g) 1 2 = g := by 

Proof state:
C : Type u_1
inst✝ : Category.{?u.510370, u_1} C
n m : ℕ
F G : ComposableArrows C n
X₀ X₁ X₂ X₃ X₄ : C
f : X₀ ⟶ X₁
g : X₁ ⟶ X₂
h : X₂ ⟶ X₃
i : X₃ ⟶ X₄
⊢ map' (mk₂ f g) 1 2 = g

Next tactic:
dsimp
example : map' (mk₂ f g) 0 2 = f ≫ g := by 

Proof state:
C : Type u_1
inst✝ : Category.{?u.514731, u_1} C
n m : ℕ
F G : ComposableArrows C n
X₀ X₁ X₂ X₃ X₄ : C
f : X₀ ⟶ X₁
g : X₁ ⟶ X₂
h : X₂ ⟶ X₃
i : X₃ ⟶ X₄
⊢ map' (mk₂ f g) 0 2 = f ≫ g

Next tactic:
dsimp
example : (mk₂ f g).hom = f ≫ g := by 

Proof state:
C : Type u_1
inst✝ : Category.{?u.519372, u_1} C
n m : ℕ
F G : ComposableArrows C n
X₀ X₁ X₂ X₃ X₄ : C
f : X₀ ⟶ X₁
g : X₁ ⟶ X₂
h : X₂ ⟶ X₃
i : X₃ ⟶ X₄
⊢ hom (mk₂ f g) = f ≫ g

Next tactic:
dsimp
example : map' (mk₂ f g) 0 0 = 𝟙 _ := by 

Proof state:
C : Type u_1
inst✝ : Category.{?u.521198, u_1} C
n m : ℕ
F G : ComposableArrows C n
X₀ X₁ X₂ X₃ X₄ : C
f : X₀ ⟶ X₁
g : X₁ ⟶ X₂
h : X₂ ⟶ X₃
i : X₃ ⟶ X₄
⊢ map' (mk₂ f g) 0 0 = 𝟙 ((mk₂ f g).obj { val := 0, isLt := (_ : 0 < 2 + 1) })

Next tactic:
dsimp
example : map' (mk₂ f g) 1 1 = 𝟙 _ := by 

Proof state:
C : Type u_1
inst✝ : Category.{?u.524961, u_1} C
n m : ℕ
F G : ComposableArrows C n
X₀ X₁ X₂ X₃ X₄ : C
f : X₀ ⟶ X₁
g : X₁ ⟶ X₂
h : X₂ ⟶ X₃
i : X₃ ⟶ X₄
⊢ map' (mk₂ f g) 1 1 = 𝟙 ((mk₂ f g).obj { val := 1, isLt := (_ : 1 < 2 + 1) })

Next tactic:
dsimp
example : map' (mk₂ f g) 2 2 = 𝟙 _ := by 

Proof state:
C : Type u_1
inst✝ : Category.{?u.529111, u_1} C
n m : ℕ
F G : ComposableArrows C n
X₀ X₁ X₂ X₃ X₄ : C
f : X₀ ⟶ X₁
g : X₁ ⟶ X₂
h : X₂ ⟶ X₃
i : X₃ ⟶ X₄
⊢ map' (mk₂ f g) 2 2 = 𝟙 ((mk₂ f g).obj { val := 2, isLt := (_ : 2 < 2 + 1) })

Next tactic:
dsimp