l3lab/ntp-mathlib huggingface dataset:
/-- Constructor for morphisms `F ⟶ G` in `ComposableArrows C n` which takes as inputs
a family of morphisms `F.obj i ⟶ G.obj i` and the naturality condition only for the
maps in `Fin (n + 1)` given by inequalities of the form `i ≤ i + 1`. -/
@[simps]
def homMk {F G : ComposableArrows C n} (app : ∀ i, F.obj i ⟶ G.obj i)
    (w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ≫ app _ = app _ ≫ G.map' i (i + 1)) :
    F ⟶ G where
  app := app
  naturality := by
    suffices ∀ (k i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
        F.map' i j ≫ app _ = app _ ≫ G.map' i j by
      rintro ⟨i, hi⟩ ⟨j, hj⟩ hij
      have hij' := leOfHom hij
      simp only [Fin.mk_le_mk] at hij'
      obtain ⟨k, hk⟩ := Nat.le.dest hij'
      

Proof state:
case mk.mk.intro
C : Type u_1
inst✝ : Category.{?u.72425, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i
w :
  ∀ (i : ℕ) (hi : i < n),
    map' F i (i + 1) ≫ app { val := i + 1, isLt := (_ : i + 1 < n + 1) } =
      app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i (i + 1)
this :
  ∀ (k i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
    map' F i j ≫ app { val := j, isLt := (_ : j < n + 1) } = app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i j
i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 1
hij : { val := i, isLt := hi } ⟶ { val := j, isLt := hj }
hij' : i ≤ j
k : ℕ
hk : i + k = j
⊢ F.map hij ≫ app { val := j, isLt := hj } = app { val := i, isLt := hi } ≫ G.map hij

Next tactic:
exact this k i j hk (by linarith)
/-- Constructor for morphisms `F ⟶ G` in `ComposableArrows C n` which takes as inputs
a family of morphisms `F.obj i ⟶ G.obj i` and the naturality condition only for the
maps in `Fin (n + 1)` given by inequalities of the form `i ≤ i + 1`. -/
@[simps]
def homMk {F G : ComposableArrows C n} (app : ∀ i, F.obj i ⟶ G.obj i)
    (w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ≫ app _ = app _ ≫ G.map' i (i + 1)) :
    F ⟶ G where
  app := app
  naturality := by
    suffices ∀ (k i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
        F.map' i j ≫ app _ = app _ ≫ G.map' i j by
      rintro ⟨i, hi⟩ ⟨j, hj⟩ hij
      have hij' := leOfHom hij
      simp only [Fin.mk_le_mk] at hij'
      obtain ⟨k, hk⟩ := Nat.le.dest hij'
      exact this k i j hk (by 

Proof state:
C : Type u_1
inst✝ : Category.{?u.72425, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i
w :
  ∀ (i : ℕ) (hi : i < n),
    map' F i (i + 1) ≫ app { val := i + 1, isLt := (_ : i + 1 < n + 1) } =
      app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i (i + 1)
this :
  ∀ (k i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
    map' F i j ≫ app { val := j, isLt := (_ : j < n + 1) } = app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i j
i : ℕ
hi : i < n + 1
j : ℕ
hj : j < n + 1
hij : { val := i, isLt := hi } ⟶ { val := j, isLt := hj }
hij' : i ≤ j
k : ℕ
hk : i + k = j
⊢ j ≤ n

Next tactic:
linarith
/-- Constructor for morphisms `F ⟶ G` in `ComposableArrows C n` which takes as inputs
a family of morphisms `F.obj i ⟶ G.obj i` and the naturality condition only for the
maps in `Fin (n + 1)` given by inequalities of the form `i ≤ i + 1`. -/
@[simps]
def homMk {F G : ComposableArrows C n} (app : ∀ i, F.obj i ⟶ G.obj i)
    (w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ≫ app _ = app _ ≫ G.map' i (i + 1)) :
    F ⟶ G where
  app := app
  naturality := by
    suffices ∀ (k i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
        F.map' i j ≫ app _ = app _ ≫ G.map' i j by
      rintro ⟨i, hi⟩ ⟨j, hj⟩ hij
      have hij' := leOfHom hij
      simp only [Fin.mk_le_mk] at hij'
      obtain ⟨k, hk⟩ := Nat.le.dest hij'
      exact this k i j hk (by linarith)
    

Proof state:
C : Type u_1
inst✝ : Category.{?u.72425, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i
w :
  ∀ (i : ℕ) (hi : i < n),
    map' F i (i + 1) ≫ app { val := i + 1, isLt := (_ : i + 1 < n + 1) } =
      app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i (i + 1)
⊢ ∀ (k i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
    map' F i j ≫ app { val := j, isLt := (_ : j < n + 1) } = app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i j

Next tactic:
intro k
/-- Constructor for morphisms `F ⟶ G` in `ComposableArrows C n` which takes as inputs
a family of morphisms `F.obj i ⟶ G.obj i` and the naturality condition only for the
maps in `Fin (n + 1)` given by inequalities of the form `i ≤ i + 1`. -/
@[simps]
def homMk {F G : ComposableArrows C n} (app : ∀ i, F.obj i ⟶ G.obj i)
    (w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ≫ app _ = app _ ≫ G.map' i (i + 1)) :
    F ⟶ G where
  app := app
  naturality := by
    suffices ∀ (k i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
        F.map' i j ≫ app _ = app _ ≫ G.map' i j by
      rintro ⟨i, hi⟩ ⟨j, hj⟩ hij
      have hij' := leOfHom hij
      simp only [Fin.mk_le_mk] at hij'
      obtain ⟨k, hk⟩ := Nat.le.dest hij'
      exact this k i j hk (by linarith)
    intro k
    

Proof state:
C : Type u_1
inst✝ : Category.{?u.72425, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i
w :
  ∀ (i : ℕ) (hi : i < n),
    map' F i (i + 1) ≫ app { val := i + 1, isLt := (_ : i + 1 < n + 1) } =
      app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i (i + 1)
k : ℕ
⊢ ∀ (i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
    map' F i j ≫ app { val := j, isLt := (_ : j < n + 1) } = app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i j

Next tactic:
induction' k with k hk
/-- Constructor for morphisms `F ⟶ G` in `ComposableArrows C n` which takes as inputs
a family of morphisms `F.obj i ⟶ G.obj i` and the naturality condition only for the
maps in `Fin (n + 1)` given by inequalities of the form `i ≤ i + 1`. -/
@[simps]
def homMk {F G : ComposableArrows C n} (app : ∀ i, F.obj i ⟶ G.obj i)
    (w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ≫ app _ = app _ ≫ G.map' i (i + 1)) :
    F ⟶ G where
  app := app
  naturality := by
    suffices ∀ (k i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
        F.map' i j ≫ app _ = app _ ≫ G.map' i j by
      rintro ⟨i, hi⟩ ⟨j, hj⟩ hij
      have hij' := leOfHom hij
      simp only [Fin.mk_le_mk] at hij'
      obtain ⟨k, hk⟩ := Nat.le.dest hij'
      exact this k i j hk (by linarith)
    intro k
    induction' k with k hk
    · 

Proof state:
case zero
C : Type u_1
inst✝ : Category.{?u.72425, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i
w :
  ∀ (i : ℕ) (hi : i < n),
    map' F i (i + 1) ≫ app { val := i + 1, isLt := (_ : i + 1 < n + 1) } =
      app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i (i + 1)
⊢ ∀ (i j : ℕ) (hj : i + Nat.zero = j) (hj' : j ≤ n),
    map' F i j ≫ app { val := j, isLt := (_ : j < n + 1) } = app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i j

Next tactic:
intro i j hj hj'
/-- Constructor for morphisms `F ⟶ G` in `ComposableArrows C n` which takes as inputs
a family of morphisms `F.obj i ⟶ G.obj i` and the naturality condition only for the
maps in `Fin (n + 1)` given by inequalities of the form `i ≤ i + 1`. -/
@[simps]
def homMk {F G : ComposableArrows C n} (app : ∀ i, F.obj i ⟶ G.obj i)
    (w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ≫ app _ = app _ ≫ G.map' i (i + 1)) :
    F ⟶ G where
  app := app
  naturality := by
    suffices ∀ (k i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
        F.map' i j ≫ app _ = app _ ≫ G.map' i j by
      rintro ⟨i, hi⟩ ⟨j, hj⟩ hij
      have hij' := leOfHom hij
      simp only [Fin.mk_le_mk] at hij'
      obtain ⟨k, hk⟩ := Nat.le.dest hij'
      exact this k i j hk (by linarith)
    intro k
    induction' k with k hk
    · intro i j hj hj'
      

Proof state:
case zero
C : Type u_1
inst✝ : Category.{?u.72425, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i
w :
  ∀ (i : ℕ) (hi : i < n),
    map' F i (i + 1) ≫ app { val := i + 1, isLt := (_ : i + 1 < n + 1) } =
      app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i (i + 1)
i j : ℕ
hj : i + Nat.zero = j
hj' : j ≤ n
⊢ map' F i j ≫ app { val := j, isLt := (_ : j < n + 1) } = app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i j

Next tactic:
simp only [Nat.zero_eq, add_zero] at hj
/-- Constructor for morphisms `F ⟶ G` in `ComposableArrows C n` which takes as inputs
a family of morphisms `F.obj i ⟶ G.obj i` and the naturality condition only for the
maps in `Fin (n + 1)` given by inequalities of the form `i ≤ i + 1`. -/
@[simps]
def homMk {F G : ComposableArrows C n} (app : ∀ i, F.obj i ⟶ G.obj i)
    (w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ≫ app _ = app _ ≫ G.map' i (i + 1)) :
    F ⟶ G where
  app := app
  naturality := by
    suffices ∀ (k i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
        F.map' i j ≫ app _ = app _ ≫ G.map' i j by
      rintro ⟨i, hi⟩ ⟨j, hj⟩ hij
      have hij' := leOfHom hij
      simp only [Fin.mk_le_mk] at hij'
      obtain ⟨k, hk⟩ := Nat.le.dest hij'
      exact this k i j hk (by linarith)
    intro k
    induction' k with k hk
    · intro i j hj hj'
      simp only [Nat.zero_eq, add_zero] at hj
      

Proof state:
case zero
C : Type u_1
inst✝ : Category.{?u.72425, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i
w :
  ∀ (i : ℕ) (hi : i < n),
    map' F i (i + 1) ≫ app { val := i + 1, isLt := (_ : i + 1 < n + 1) } =
      app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i (i + 1)
i j : ℕ
hj✝ : i + Nat.zero = j
hj' : j ≤ n
hj : i = j
⊢ map' F i j ≫ app { val := j, isLt := (_ : j < n + 1) } = app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i j

Next tactic:
obtain rfl := hj
/-- Constructor for morphisms `F ⟶ G` in `ComposableArrows C n` which takes as inputs
a family of morphisms `F.obj i ⟶ G.obj i` and the naturality condition only for the
maps in `Fin (n + 1)` given by inequalities of the form `i ≤ i + 1`. -/
@[simps]
def homMk {F G : ComposableArrows C n} (app : ∀ i, F.obj i ⟶ G.obj i)
    (w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ≫ app _ = app _ ≫ G.map' i (i + 1)) :
    F ⟶ G where
  app := app
  naturality := by
    suffices ∀ (k i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
        F.map' i j ≫ app _ = app _ ≫ G.map' i j by
      rintro ⟨i, hi⟩ ⟨j, hj⟩ hij
      have hij' := leOfHom hij
      simp only [Fin.mk_le_mk] at hij'
      obtain ⟨k, hk⟩ := Nat.le.dest hij'
      exact this k i j hk (by linarith)
    intro k
    induction' k with k hk
    · intro i j hj hj'
      simp only [Nat.zero_eq, add_zero] at hj
      obtain rfl := hj
      

Proof state:
case zero
C : Type u_1
inst✝ : Category.{?u.72425, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i
w :
  ∀ (i : ℕ) (hi : i < n),
    map' F i (i + 1) ≫ app { val := i + 1, isLt := (_ : i + 1 < n + 1) } =
      app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i (i + 1)
i : ℕ
hj : i + Nat.zero = i
hj' : i ≤ n
⊢ map' F i i ≫ app { val := i, isLt := (_ : i < n + 1) } = app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i i

Next tactic:
rw [F.map'_self i, G.map'_self i, id_comp, comp_id]
/-- Constructor for morphisms `F ⟶ G` in `ComposableArrows C n` which takes as inputs
a family of morphisms `F.obj i ⟶ G.obj i` and the naturality condition only for the
maps in `Fin (n + 1)` given by inequalities of the form `i ≤ i + 1`. -/
@[simps]
def homMk {F G : ComposableArrows C n} (app : ∀ i, F.obj i ⟶ G.obj i)
    (w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ≫ app _ = app _ ≫ G.map' i (i + 1)) :
    F ⟶ G where
  app := app
  naturality := by
    suffices ∀ (k i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
        F.map' i j ≫ app _ = app _ ≫ G.map' i j by
      rintro ⟨i, hi⟩ ⟨j, hj⟩ hij
      have hij' := leOfHom hij
      simp only [Fin.mk_le_mk] at hij'
      obtain ⟨k, hk⟩ := Nat.le.dest hij'
      exact this k i j hk (by linarith)
    intro k
    induction' k with k hk
    · intro i j hj hj'
      simp only [Nat.zero_eq, add_zero] at hj
      obtain rfl := hj
      rw [F.map'_self i, G.map'_self i, id_comp, comp_id]
    · 

Proof state:
case succ
C : Type u_1
inst✝ : Category.{?u.72425, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i
w :
  ∀ (i : ℕ) (hi : i < n),
    map' F i (i + 1) ≫ app { val := i + 1, isLt := (_ : i + 1 < n + 1) } =
      app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i (i + 1)
k : ℕ
hk :
  ∀ (i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
    map' F i j ≫ app { val := j, isLt := (_ : j < n + 1) } = app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i j
⊢ ∀ (i j : ℕ) (hj : i + Nat.succ k = j) (hj' : j ≤ n),
    map' F i j ≫ app { val := j, isLt := (_ : j < n + 1) } = app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i j

Next tactic:
intro i j hj hj'
/-- Constructor for morphisms `F ⟶ G` in `ComposableArrows C n` which takes as inputs
a family of morphisms `F.obj i ⟶ G.obj i` and the naturality condition only for the
maps in `Fin (n + 1)` given by inequalities of the form `i ≤ i + 1`. -/
@[simps]
def homMk {F G : ComposableArrows C n} (app : ∀ i, F.obj i ⟶ G.obj i)
    (w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ≫ app _ = app _ ≫ G.map' i (i + 1)) :
    F ⟶ G where
  app := app
  naturality := by
    suffices ∀ (k i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
        F.map' i j ≫ app _ = app _ ≫ G.map' i j by
      rintro ⟨i, hi⟩ ⟨j, hj⟩ hij
      have hij' := leOfHom hij
      simp only [Fin.mk_le_mk] at hij'
      obtain ⟨k, hk⟩ := Nat.le.dest hij'
      exact this k i j hk (by linarith)
    intro k
    induction' k with k hk
    · intro i j hj hj'
      simp only [Nat.zero_eq, add_zero] at hj
      obtain rfl := hj
      rw [F.map'_self i, G.map'_self i, id_comp, comp_id]
    · intro i j hj hj'
      

Proof state:
case succ
C : Type u_1
inst✝ : Category.{?u.72425, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i
w :
  ∀ (i : ℕ) (hi : i < n),
    map' F i (i + 1) ≫ app { val := i + 1, isLt := (_ : i + 1 < n + 1) } =
      app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i (i + 1)
k : ℕ
hk :
  ∀ (i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
    map' F i j ≫ app { val := j, isLt := (_ : j < n + 1) } = app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i j
i j : ℕ
hj : i + Nat.succ k = j
hj' : j ≤ n
⊢ map' F i j ≫ app { val := j, isLt := (_ : j < n + 1) } = app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i j

Next tactic:
rw [Nat.succ_eq_add_one, ← add_assoc] at hj
/-- Constructor for morphisms `F ⟶ G` in `ComposableArrows C n` which takes as inputs
a family of morphisms `F.obj i ⟶ G.obj i` and the naturality condition only for the
maps in `Fin (n + 1)` given by inequalities of the form `i ≤ i + 1`. -/
@[simps]
def homMk {F G : ComposableArrows C n} (app : ∀ i, F.obj i ⟶ G.obj i)
    (w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ≫ app _ = app _ ≫ G.map' i (i + 1)) :
    F ⟶ G where
  app := app
  naturality := by
    suffices ∀ (k i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
        F.map' i j ≫ app _ = app _ ≫ G.map' i j by
      rintro ⟨i, hi⟩ ⟨j, hj⟩ hij
      have hij' := leOfHom hij
      simp only [Fin.mk_le_mk] at hij'
      obtain ⟨k, hk⟩ := Nat.le.dest hij'
      exact this k i j hk (by linarith)
    intro k
    induction' k with k hk
    · intro i j hj hj'
      simp only [Nat.zero_eq, add_zero] at hj
      obtain rfl := hj
      rw [F.map'_self i, G.map'_self i, id_comp, comp_id]
    · intro i j hj hj'
      rw [Nat.succ_eq_add_one, ← add_assoc] at hj
      

Proof state:
case succ
C : Type u_1
inst✝ : Category.{?u.72425, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i
w :
  ∀ (i : ℕ) (hi : i < n),
    map' F i (i + 1) ≫ app { val := i + 1, isLt := (_ : i + 1 < n + 1) } =
      app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i (i + 1)
k : ℕ
hk :
  ∀ (i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
    map' F i j ≫ app { val := j, isLt := (_ : j < n + 1) } = app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i j
i j : ℕ
hj✝ : i + Nat.succ k = j
hj : i + k + 1 = j
hj' : j ≤ n
⊢ map' F i j ≫ app { val := j, isLt := (_ : j < n + 1) } = app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i j

Next tactic:
subst hj
/-- Constructor for morphisms `F ⟶ G` in `ComposableArrows C n` which takes as inputs
a family of morphisms `F.obj i ⟶ G.obj i` and the naturality condition only for the
maps in `Fin (n + 1)` given by inequalities of the form `i ≤ i + 1`. -/
@[simps]
def homMk {F G : ComposableArrows C n} (app : ∀ i, F.obj i ⟶ G.obj i)
    (w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ≫ app _ = app _ ≫ G.map' i (i + 1)) :
    F ⟶ G where
  app := app
  naturality := by
    suffices ∀ (k i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
        F.map' i j ≫ app _ = app _ ≫ G.map' i j by
      rintro ⟨i, hi⟩ ⟨j, hj⟩ hij
      have hij' := leOfHom hij
      simp only [Fin.mk_le_mk] at hij'
      obtain ⟨k, hk⟩ := Nat.le.dest hij'
      exact this k i j hk (by linarith)
    intro k
    induction' k with k hk
    · intro i j hj hj'
      simp only [Nat.zero_eq, add_zero] at hj
      obtain rfl := hj
      rw [F.map'_self i, G.map'_self i, id_comp, comp_id]
    · intro i j hj hj'
      rw [Nat.succ_eq_add_one, ← add_assoc] at hj
      subst hj
      

Proof state:
case succ
C : Type u_1
inst✝ : Category.{?u.72425, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i
w :
  ∀ (i : ℕ) (hi : i < n),
    map' F i (i + 1) ≫ app { val := i + 1, isLt := (_ : i + 1 < n + 1) } =
      app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i (i + 1)
k : ℕ
hk :
  ∀ (i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
    map' F i j ≫ app { val := j, isLt := (_ : j < n + 1) } = app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i j
i : ℕ
hj : i + Nat.succ k = i + k + 1
hj' : i + k + 1 ≤ n
⊢ map' F i (i + k + 1) ≫ app { val := i + k + 1, isLt := (_ : i + k + 1 < n + 1) } =
    app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i (i + k + 1)

Next tactic:
rw [F.map'_comp i (i + k) (i + k + 1), G.map'_comp i (i + k) (i + k + 1), assoc,
        w (i + k) (by linarith), reassoc_of% (hk i (i + k) rfl (by linarith))]
/-- Constructor for morphisms `F ⟶ G` in `ComposableArrows C n` which takes as inputs
a family of morphisms `F.obj i ⟶ G.obj i` and the naturality condition only for the
maps in `Fin (n + 1)` given by inequalities of the form `i ≤ i + 1`. -/
@[simps]
def homMk {F G : ComposableArrows C n} (app : ∀ i, F.obj i ⟶ G.obj i)
    (w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ≫ app _ = app _ ≫ G.map' i (i + 1)) :
    F ⟶ G where
  app := app
  naturality := by
    suffices ∀ (k i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
        F.map' i j ≫ app _ = app _ ≫ G.map' i j by
      rintro ⟨i, hi⟩ ⟨j, hj⟩ hij
      have hij' := leOfHom hij
      simp only [Fin.mk_le_mk] at hij'
      obtain ⟨k, hk⟩ := Nat.le.dest hij'
      exact this k i j hk (by linarith)
    intro k
    induction' k with k hk
    · intro i j hj hj'
      simp only [Nat.zero_eq, add_zero] at hj
      obtain rfl := hj
      rw [F.map'_self i, G.map'_self i, id_comp, comp_id]
    · intro i j hj hj'
      rw [Nat.succ_eq_add_one, ← add_assoc] at hj
      subst hj
      rw [F.map'_comp i (i + k) (i + k + 1), G.map'_comp i (i + k) (i + k + 1), assoc,
        w (i + k) (by 

Proof state:
C : Type u_1
inst✝ : Category.{?u.72425, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i
w :
  ∀ (i : ℕ) (hi : i < n),
    map' F i (i + 1) ≫ app { val := i + 1, isLt := (_ : i + 1 < n + 1) } =
      app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i (i + 1)
k : ℕ
hk :
  ∀ (i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
    map' F i j ≫ app { val := j, isLt := (_ : j < n + 1) } = app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i j
i : ℕ
hj : i + Nat.succ k = i + k + 1
hj' : i + k + 1 ≤ n
⊢ i + k < n

Next tactic:
linarith
/-- Constructor for morphisms `F ⟶ G` in `ComposableArrows C n` which takes as inputs
a family of morphisms `F.obj i ⟶ G.obj i` and the naturality condition only for the
maps in `Fin (n + 1)` given by inequalities of the form `i ≤ i + 1`. -/
@[simps]
def homMk {F G : ComposableArrows C n} (app : ∀ i, F.obj i ⟶ G.obj i)
    (w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ≫ app _ = app _ ≫ G.map' i (i + 1)) :
    F ⟶ G where
  app := app
  naturality := by
    suffices ∀ (k i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
        F.map' i j ≫ app _ = app _ ≫ G.map' i j by
      rintro ⟨i, hi⟩ ⟨j, hj⟩ hij
      have hij' := leOfHom hij
      simp only [Fin.mk_le_mk] at hij'
      obtain ⟨k, hk⟩ := Nat.le.dest hij'
      exact this k i j hk (by linarith)
    intro k
    induction' k with k hk
    · intro i j hj hj'
      simp only [Nat.zero_eq, add_zero] at hj
      obtain rfl := hj
      rw [F.map'_self i, G.map'_self i, id_comp, comp_id]
    · intro i j hj hj'
      rw [Nat.succ_eq_add_one, ← add_assoc] at hj
      subst hj
      rw [F.map'_comp i (i + k) (i + k + 1), G.map'_comp i (i + k) (i + k + 1), assoc,
        w (i + k) (by linarith), reassoc_of% (hk i (i + k) rfl (by 

Proof state:
C : Type u_1
inst✝ : Category.{?u.72425, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i
w :
  ∀ (i : ℕ) (hi : i < n),
    map' F i (i + 1) ≫ app { val := i + 1, isLt := (_ : i + 1 < n + 1) } =
      app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i (i + 1)
k : ℕ
hk :
  ∀ (i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
    map' F i j ≫ app { val := j, isLt := (_ : j < n + 1) } = app { val := i, isLt := (_ : i < n + 1) } ≫ map' G i j
i : ℕ
hj : i + Nat.succ k = i + k + 1
hj' : i + k + 1 ≤ n
⊢ i + k ≤ n

Next tactic:
linarith
/-- Constructor for isomorphisms `F ≅ G` in `ComposableArrows C n` which takes as inputs
a family of isomorphisms `F.obj i ≅ G.obj i` and the naturality condition only for the
maps in `Fin (n + 1)` given by inequalities of the form `i ≤ i + 1`. -/
@[simps]
def isoMk {F G : ComposableArrows C n} (app : ∀ i, F.obj i ≅ G.obj i)
    (w : ∀ (i : ℕ) (hi : i < n),
      F.map' i (i + 1) ≫ (app _).hom = (app _).hom ≫ G.map' i (i + 1)) :
    F ≅ G where
  hom := homMk (fun i => (app i).hom) w
  inv := homMk (fun i => (app i).inv) (fun i hi => by
    

Proof state:
C : Type u_1
inst✝ : Category.{?u.134717, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ≅ G.obj i
w :
  ∀ (i : ℕ) (hi : i < n),
    map' F i (i + 1) ≫ (app { val := i + 1, isLt := (_ : i + 1 < n + 1) }).hom =
      (app { val := i, isLt := (_ : i < n + 1) }).hom ≫ map' G i (i + 1)
i : ℕ
hi : i < n
⊢ map' G i (i + 1) ≫ (fun i => (app i).inv) { val := i + 1, isLt := (_ : i + 1 < n + 1) } =
    (fun i => (app i).inv) { val := i, isLt := (_ : i < n + 1) } ≫ map' F i (i + 1)

Next tactic:
dsimp only
/-- Constructor for isomorphisms `F ≅ G` in `ComposableArrows C n` which takes as inputs
a family of isomorphisms `F.obj i ≅ G.obj i` and the naturality condition only for the
maps in `Fin (n + 1)` given by inequalities of the form `i ≤ i + 1`. -/
@[simps]
def isoMk {F G : ComposableArrows C n} (app : ∀ i, F.obj i ≅ G.obj i)
    (w : ∀ (i : ℕ) (hi : i < n),
      F.map' i (i + 1) ≫ (app _).hom = (app _).hom ≫ G.map' i (i + 1)) :
    F ≅ G where
  hom := homMk (fun i => (app i).hom) w
  inv := homMk (fun i => (app i).inv) (fun i hi => by
    dsimp only
    

Proof state:
C : Type u_1
inst✝ : Category.{?u.134717, u_1} C
n m : ℕ
F✝ G✝ F G : ComposableArrows C n
app : (i : Fin (n + 1)) → F.obj i ≅ G.obj i
w :
  ∀ (i : ℕ) (hi : i < n),
    map' F i (i + 1) ≫ (app { val := i + 1, isLt := (_ : i + 1 < n + 1) }).hom =
      (app { val := i, isLt := (_ : i < n + 1) }).hom ≫ map' G i (i + 1)
i : ℕ
hi : i < n
⊢ map' G i (i + 1) ≫ (app { val := i + 1, isLt := (_ : i + 1 < n + 1) }).inv =
    (app { val := i, isLt := (_ : i < n + 1) }).inv ≫ map' F i (i + 1)

Next tactic:
rw [← cancel_epi ((app _).hom), ← reassoc_of% (w i hi), Iso.hom_inv_id, comp_id,
      Iso.hom_inv_id_assoc]