ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.ComposableArrows.Precomp.obj_succ
@[simp]
lemma obj_succ (i : ℕ) (hi : i + 1 < n + 1 + 1) : obj F X ⟨i + 1, hi⟩ = F.obj' i 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) (X : C) (i : ℕ) (hi : i + 1 < n + 1 + 1)
Goal: CategoryTheory.ComposableArrows.Precomp.obj F X ⟨i + 1, hi⟩ = F.obj' i ⋯
-- CategoryTheory.ComposableArrows.Precomp.map_zero_zero
@[simp]
lemma map_zero_zero : map F f 0 0 (by simp) = 𝟙 X 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) {X : C} (f : X ⟶ F.left)
Goal: CategoryTheory.ComposableArrows.Precomp.map F f 0 0 ⋯ = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.ComposableArrows.Precomp.map_one_one
@[simp]
lemma map_one_one : map F f 1 1 (by simp) = F.map (𝟙 _) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) {X : C} (f : X ⟶ F.left)
Goal: CategoryTheory.ComposableArrows.Precomp.map F f 1 1 ⋯ = F.map (CategoryTheory.CategoryStruct.id ⟨0, ⋯⟩)
-- CategoryTheory.ComposableArrows.Precomp.map_zero_one
@[simp]
lemma map_zero_one : map F f 0 1 (by simp) = f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) {X : C} (f : X ⟶ F.left)
Goal: CategoryTheory.ComposableArrows.Precomp.map F f 0 1 ⋯ = f
-- CategoryTheory.ComposableArrows.Precomp.map_zero_one'
@[simp]
lemma map_zero_one' : map F f 0 ⟨0 + 1, by simp⟩ (by simp) = f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) {X : C} (f : X ⟶ F.left)
Goal: CategoryTheory.ComposableArrows.Precomp.map F f 0 ⟨0 + 1, ⋯⟩ ⋯ = f
-- CategoryTheory.ComposableArrows.Precomp.map_zero_succ_succ
@[simp]
lemma map_zero_succ_succ (j : ℕ) (hj : j + 2 < n + 1 + 1) :
    map F f 0 ⟨j + 2, hj⟩ (by simp) = f ≫ F.map' 0 (j+1) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) {X : C} (f : X ⟶ F.left) (j : ℕ) (hj : j + 2 < n + 1 + 1)
Goal: CategoryTheory.ComposableArrows.Precomp.map F f 0 ⟨j + 2, hj⟩ ⋯ =
  CategoryTheory.CategoryStruct.comp f (F.map' 0 (j + 1) ⋯ ⋯)
-- CategoryTheory.ComposableArrows.Precomp.map_succ_succ
@[simp]
lemma map_succ_succ (i j : ℕ) (hi : i + 1 < n + 1 + 1) (hj : j + 1 < n + 1 + 1)
    (hij : i + 1 ≤ j + 1) :
    map F f ⟨i + 1, hi⟩ ⟨j + 1, hj⟩ hij = F.map' i j 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) {X : C} (f : X ⟶ F.left) (i j : ℕ) (hi : i + 1 < n + 1 + 1) (hj : j + 1 < n + 1 + 1) (hij : i + 1 ≤ j + 1)
Goal: CategoryTheory.ComposableArrows.Precomp.map F f ⟨i + 1, hi⟩ ⟨j + 1, hj⟩ hij = F.map' i j ⋯ ⋯
-- CategoryTheory.ComposableArrows.Precomp.map_one_succ
@[simp]
lemma map_one_succ (j : ℕ) (hj : j + 1 < n + 1 + 1) :
    map F f 1 ⟨j + 1, hj⟩ (by simp [Fin.le_def]) = F.map' 0 j 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) {X : C} (f : X ⟶ F.left) (j : ℕ) (hj : j + 1 < n + 1 + 1)
Goal: CategoryTheory.ComposableArrows.Precomp.map F f 1 ⟨j + 1, hj⟩ ⋯ = F.map' 0 j ⋯ ⋯
-- CategoryTheory.ComposableArrows.Precomp.map_id
lemma map_id (i : Fin (n + 1 + 1)) : map F f i i (by simp) = 𝟙 _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) {X : C} (f : X ⟶ F.left) (i : Fin (n + 1 + 1))
Goal: CategoryTheory.ComposableArrows.Precomp.map F f i i ⋯ =
  CategoryTheory.CategoryStruct.id (CategoryTheory.ComposableArrows.Precomp.obj F X i)
-- CategoryTheory.ComposableArrows.Precomp.map_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 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) {X : C} (f : X ⟶ F.left) {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k)
Goal: CategoryTheory.ComposableArrows.Precomp.map F f i k ⋯ =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.ComposableArrows.Precomp.map F f i j hij)
    (CategoryTheory.ComposableArrows.Precomp.map F f j k hjk)
-- CategoryTheory.ComposableArrows.precomp_obj
@[simps]
def precomp {X : C} (f : X ⟶ F.left) : ComposableArrows C (n + 1) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) {X : C} (f : X ⟶ F.left)
Goal: ∀ (a : Fin (n + 1 + 1)), (F.precomp f).obj a = CategoryTheory.ComposableArrows.Precomp.obj F X a
-- CategoryTheory.ComposableArrows.precomp_map
@[simps]
def precomp {X : C} (f : X ⟶ F.left) : ComposableArrows C (n + 1) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) {X : C} (f : X ⟶ F.left)
Goal: ∀ {X_1 Y : Fin (n + 1 + 1)} (g : X_1 ⟶ Y), (F.precomp f).map g = CategoryTheory.ComposableArrows.Precomp.map F f X_1 Y ⋯
-- CategoryTheory.ComposableArrows.whiskerLeft_map
@[simps!]
def whiskerLeft (F : ComposableArrows C m) (Φ : Fin (n + 1) ⥤ Fin (m + 1)) :
    ComposableArrows C n 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n m : ℕ} (F : CategoryTheory.ComposableArrows C m) (Φ : CategoryTheory.Functor (Fin (n + 1)) (Fin (m + 1)))
Goal: ∀ {X Y : Fin (n + 1)} (f : X ⟶ Y), (F.whiskerLeft Φ).map f = F.map (Φ.map f)
-- CategoryTheory.ComposableArrows.whiskerLeft_obj
@[simps!]
def whiskerLeft (F : ComposableArrows C m) (Φ : Fin (n + 1) ⥤ Fin (m + 1)) :
    ComposableArrows C n 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n m : ℕ} (F : CategoryTheory.ComposableArrows C m) (Φ : CategoryTheory.Functor (Fin (n + 1)) (Fin (m + 1))) (X : Fin (n + 1))
Goal: (F.whiskerLeft Φ).obj X = F.obj (Φ.obj X)
-- CategoryTheory.ComposableArrows.whiskerLeftFunctor_obj_obj
@[simps!]
def whiskerLeftFunctor (Φ : Fin (n + 1) ⥤ Fin (m + 1)) :
    ComposableArrows C m ⥤ ComposableArrows C n 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n m : ℕ} (Φ : CategoryTheory.Functor (Fin (n + 1)) (Fin (m + 1))) (F : CategoryTheory.ComposableArrows C m) (X : Fin (n + 1))
Goal: ((CategoryTheory.ComposableArrows.whiskerLeftFunctor Φ).obj F).obj X = F.obj (Φ.obj X)
-- CategoryTheory.ComposableArrows.whiskerLeftFunctor_map_app
@[simps!]
def whiskerLeftFunctor (Φ : Fin (n + 1) ⥤ Fin (m + 1)) :
    ComposableArrows C m ⥤ ComposableArrows C n 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n m : ℕ} (Φ : CategoryTheory.Functor (Fin (n + 1)) (Fin (m + 1)))
Goal: ∀ {X Y : CategoryTheory.ComposableArrows C m} (f : X ⟶ Y) (X_1 : Fin (n + 1)),
  ((CategoryTheory.ComposableArrows.whiskerLeftFunctor Φ).map f).app X_1 = f.app (Φ.obj X_1)
-- CategoryTheory.ComposableArrows.whiskerLeftFunctor_obj_map
@[simps!]
def whiskerLeftFunctor (Φ : Fin (n + 1) ⥤ Fin (m + 1)) :
    ComposableArrows C m ⥤ ComposableArrows C n 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n m : ℕ} (Φ : CategoryTheory.Functor (Fin (n + 1)) (Fin (m + 1))) (F : CategoryTheory.ComposableArrows C m)
Goal: ∀ {X Y : Fin (n + 1)} (f : X ⟶ Y),
  ((CategoryTheory.ComposableArrows.whiskerLeftFunctor Φ).obj F).map f = F.map (Φ.map f)
-- Fin.succFunctor_obj
@[simps]
def _root_.Fin.succFunctor (n : ℕ) : Fin n ⥤ Fin (n + 1) 
Arguments: (n : ℕ) (i : Fin n)
Goal: (Fin.succFunctor n).obj i = i.succ
-- Fin.succFunctor_map
@[simps]
def _root_.Fin.succFunctor (n : ℕ) : Fin n ⥤ Fin (n + 1) 
Arguments: (n : ℕ) {i j : Fin n} (hij : i ⟶ j)
Goal: (Fin.succFunctor n).map hij = CategoryTheory.homOfLE ⋯
-- CategoryTheory.ComposableArrows.δ₀Functor_obj_obj
@[simps!]
def δ₀Functor : ComposableArrows C (n + 1) ⥤ ComposableArrows C n 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C (n + 1)) (X : Fin (n + 1))
Goal: (CategoryTheory.ComposableArrows.δ₀Functor.obj F).obj X = F.obj X.succ
-- CategoryTheory.ComposableArrows.δ₀Functor_map_app
@[simps!]
def δ₀Functor : ComposableArrows C (n + 1) ⥤ ComposableArrows C n 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ}
Goal: ∀ {X Y : CategoryTheory.ComposableArrows C (n + 1)} (f : X ⟶ Y) (X_1 : Fin (n + 1)),
  (CategoryTheory.ComposableArrows.δ₀Functor.map f).app X_1 = f.app X_1.succ
-- CategoryTheory.ComposableArrows.δ₀Functor_obj_map
@[simps!]
def δ₀Functor : ComposableArrows C (n + 1) ⥤ ComposableArrows C n 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C (n + 1))
Goal: ∀ {X Y : Fin (n + 1)} (f : X ⟶ Y),
  (CategoryTheory.ComposableArrows.δ₀Functor.obj F).map f = F.map (CategoryTheory.homOfLE ⋯)
-- CategoryTheory.ComposableArrows.precomp_δ₀
@[simp]
lemma precomp_δ₀ {X : C} (f : X ⟶ F.left) : (F.precomp f).δ₀ = F 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) {X : C} (f : X ⟶ F.left)
Goal: (F.precomp f).δ₀ = F
-- Fin.castSuccFunctor_obj
@[simps]
def _root_.Fin.castSuccFunctor (n : ℕ) : Fin n ⥤ Fin (n + 1) 
Arguments: (n : ℕ) (i : Fin n)
Goal: (Fin.castSuccFunctor n).obj i = i.castSucc
-- Fin.castSuccFunctor_map
@[simps]
def _root_.Fin.castSuccFunctor (n : ℕ) : Fin n ⥤ Fin (n + 1) 
Arguments: (n : ℕ)
Goal: ∀ {X Y : Fin n} (hij : X ⟶ Y), (Fin.castSuccFunctor n).map hij = hij
-- CategoryTheory.ComposableArrows.δlastFunctor_obj_map
@[simps!]
def δlastFunctor : ComposableArrows C (n + 1) ⥤ ComposableArrows C n 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C (n + 1))
Goal: ∀ {X Y : Fin (n + 1)} (f : X ⟶ Y), (CategoryTheory.ComposableArrows.δlastFunctor.obj F).map f = F.map f
-- CategoryTheory.ComposableArrows.δlastFunctor_map_app
@[simps!]
def δlastFunctor : ComposableArrows C (n + 1) ⥤ ComposableArrows C n 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ}
Goal: ∀ {X Y : CategoryTheory.ComposableArrows C (n + 1)} (f : X ⟶ Y) (X_1 : Fin (n + 1)),
  (CategoryTheory.ComposableArrows.δlastFunctor.map f).app X_1 = f.app X_1.castSucc
-- CategoryTheory.ComposableArrows.δlastFunctor_obj_obj
@[simps!]
def δlastFunctor : ComposableArrows C (n + 1) ⥤ ComposableArrows C n 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C (n + 1)) (X : Fin (n + 1))
Goal: (CategoryTheory.ComposableArrows.δlastFunctor.obj F).obj X = F.obj X.castSucc
-- CategoryTheory.ComposableArrows.homMkSucc_app_zero
@[simp]
lemma homMkSucc_app_zero : (homMkSucc α β w).app 0 = α 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C (n + 1)} (α : F.obj' 0 ⋯ ⟶ G.obj' 0 ⋯) (β : F.δ₀ ⟶ G.δ₀) (w :
  CategoryTheory.CategoryStruct.comp (F.map' 0 1 ⋯ ⋯) (CategoryTheory.ComposableArrows.app' β 0 ⋯) =
    CategoryTheory.CategoryStruct.comp α (G.map' 0 1 ⋯ ⋯))
Goal: (CategoryTheory.ComposableArrows.homMkSucc α β w).app 0 = α
-- CategoryTheory.ComposableArrows.homMkSucc_app_succ
@[simp]
lemma homMkSucc_app_succ (i : ℕ) (hi : i + 1 < n + 1 + 1) :
    (homMkSucc α β w).app ⟨i + 1, hi⟩ = app' β i 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C (n + 1)} (α : F.obj' 0 ⋯ ⟶ G.obj' 0 ⋯) (β : F.δ₀ ⟶ G.δ₀) (w :
  CategoryTheory.CategoryStruct.comp (F.map' 0 1 ⋯ ⋯) (CategoryTheory.ComposableArrows.app' β 0 ⋯) =
    CategoryTheory.CategoryStruct.comp α (G.map' 0 1 ⋯ ⋯)) (i : ℕ) (hi : i + 1 < n + 1 + 1)
Goal: (CategoryTheory.ComposableArrows.homMkSucc α β w).app ⟨i + 1, hi⟩ = CategoryTheory.ComposableArrows.app' β i ⋯
-- CategoryTheory.ComposableArrows.hom_ext_succ
lemma hom_ext_succ {F G : ComposableArrows C (n + 1)} {f g : F ⟶ G}
    (h₀ : app' f 0 = app' g 0) (h₁ : δ₀Functor.map f = δ₀Functor.map g) : f = g 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C (n + 1)} {f g : F ⟶ G} (h₀ : CategoryTheory.ComposableArrows.app' f 0 ⋯ = CategoryTheory.ComposableArrows.app' g 0 ⋯) (h₁ : CategoryTheory.ComposableArrows.δ₀Functor.map f = CategoryTheory.ComposableArrows.δ₀Functor.map g)
Goal: f = g
-- CategoryTheory.ComposableArrows.isoMkSucc_inv
@[simps]
def isoMkSucc {F G : ComposableArrows C (n + 1)} (α : F.obj' 0 ≅ G.obj' 0)
    (β : F.δ₀ ≅ G.δ₀) (w : F.map' 0 1 ≫ app' β.hom 0 = α.hom ≫ G.map' 0 1) : F ≅ G 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C (n + 1)} (α : F.obj' 0 ⋯ ≅ G.obj' 0 ⋯) (β : F.δ₀ ≅ G.δ₀) (w :
  CategoryTheory.CategoryStruct.comp (F.map' 0 1 ⋯ ⋯) (CategoryTheory.ComposableArrows.app' β.hom 0 ⋯) =
    CategoryTheory.CategoryStruct.comp α.hom (G.map' 0 1 ⋯ ⋯))
Goal: (CategoryTheory.ComposableArrows.isoMkSucc α β w).inv = CategoryTheory.ComposableArrows.homMkSucc α.inv β.inv ⋯
-- CategoryTheory.ComposableArrows.isoMkSucc_hom
@[simps]
def isoMkSucc {F G : ComposableArrows C (n + 1)} (α : F.obj' 0 ≅ G.obj' 0)
    (β : F.δ₀ ≅ G.δ₀) (w : F.map' 0 1 ≫ app' β.hom 0 = α.hom ≫ G.map' 0 1) : F ≅ G 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C (n + 1)} (α : F.obj' 0 ⋯ ≅ G.obj' 0 ⋯) (β : F.δ₀ ≅ G.δ₀) (w :
  CategoryTheory.CategoryStruct.comp (F.map' 0 1 ⋯ ⋯) (CategoryTheory.ComposableArrows.app' β.hom 0 ⋯) =
    CategoryTheory.CategoryStruct.comp α.hom (G.map' 0 1 ⋯ ⋯))
Goal: (CategoryTheory.ComposableArrows.isoMkSucc α β w).hom = CategoryTheory.ComposableArrows.homMkSucc α.hom β.hom w
-- CategoryTheory.ComposableArrows.ext_succ
lemma ext_succ {F G : ComposableArrows C (n + 1)} (h₀ : F.obj' 0 = G.obj' 0)
    (h : F.δ₀ = G.δ₀) (w : F.map' 0 1 = eqToHom h₀ ≫ G.map' 0 1 ≫
      eqToHom (Functor.congr_obj h.symm 0)) : F = G 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C (n + 1)} (h₀ : F.obj' 0 ⋯ = G.obj' 0 ⋯) (h : F.δ₀ = G.δ₀) (w :
  F.map' 0 1 ⋯ ⋯ =
    CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom h₀)
      (CategoryTheory.CategoryStruct.comp (G.map' 0 1 ⋯ ⋯) (CategoryTheory.eqToHom ⋯)))
Goal: F = G
-- CategoryTheory.ComposableArrows.precomp_surjective
lemma precomp_surjective (F : ComposableArrows C (n + 1)) :
    ∃ (F₀ : ComposableArrows C n) (X₀ : C) (f₀ : X₀ ⟶ F₀.left), F = F₀.precomp f₀ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C (n + 1))
Goal: ∃ F₀ X₀ f₀, F = F₀.precomp f₀
-- CategoryTheory.ComposableArrows.homMk₂_app_zero
@[simp]
lemma homMk₂_app_zero : (homMk₂ app₀ app₁ app₂ w₀ w₁).app 0 = app₀ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {f g : CategoryTheory.ComposableArrows C 2} (app₀ : f.obj' 0 ⋯ ⟶ g.obj' 0 ⋯) (app₁ : f.obj' 1 ⋯ ⟶ g.obj' 1 ⋯) (app₂ : f.obj' 2 ⋯ ⟶ g.obj' 2 ⋯) (w₀ :
  CategoryTheory.CategoryStruct.comp (f.map' 0 1 ⋯ ⋯) app₁ = CategoryTheory.CategoryStruct.comp app₀ (g.map' 0 1 ⋯ ⋯)) (w₁ :
  CategoryTheory.CategoryStruct.comp (f.map' 1 2 ⋯ ⋯) app₂ = CategoryTheory.CategoryStruct.comp app₁ (g.map' 1 2 ⋯ ⋯))
Goal: (CategoryTheory.ComposableArrows.homMk₂ app₀ app₁ app₂ w₀ w₁).app 0 = app₀
-- CategoryTheory.ComposableArrows.homMk₂_app_one
@[simp]
lemma homMk₂_app_one : (homMk₂ app₀ app₁ app₂ w₀ w₁).app 1 = app₁ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {f g : CategoryTheory.ComposableArrows C 2} (app₀ : f.obj' 0 ⋯ ⟶ g.obj' 0 ⋯) (app₁ : f.obj' 1 ⋯ ⟶ g.obj' 1 ⋯) (app₂ : f.obj' 2 ⋯ ⟶ g.obj' 2 ⋯) (w₀ :
  CategoryTheory.CategoryStruct.comp (f.map' 0 1 ⋯ ⋯) app₁ = CategoryTheory.CategoryStruct.comp app₀ (g.map' 0 1 ⋯ ⋯)) (w₁ :
  CategoryTheory.CategoryStruct.comp (f.map' 1 2 ⋯ ⋯) app₂ = CategoryTheory.CategoryStruct.comp app₁ (g.map' 1 2 ⋯ ⋯))
Goal: (CategoryTheory.ComposableArrows.homMk₂ app₀ app₁ app₂ w₀ w₁).app 1 = app₁
-- CategoryTheory.ComposableArrows.homMk₂_app_two
@[simp]
lemma homMk₂_app_two : (homMk₂ app₀ app₁ app₂ w₀ w₁).app ⟨2, by valid⟩ = app₂ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {f g : CategoryTheory.ComposableArrows C 2} (app₀ : f.obj' 0 ⋯ ⟶ g.obj' 0 ⋯) (app₁ : f.obj' 1 ⋯ ⟶ g.obj' 1 ⋯) (app₂ : f.obj' 2 ⋯ ⟶ g.obj' 2 ⋯) (w₀ :
  CategoryTheory.CategoryStruct.comp (f.map' 0 1 ⋯ ⋯) app₁ = CategoryTheory.CategoryStruct.comp app₀ (g.map' 0 1 ⋯ ⋯)) (w₁ :
  CategoryTheory.CategoryStruct.comp (f.map' 1 2 ⋯ ⋯) app₂ = CategoryTheory.CategoryStruct.comp app₁ (g.map' 1 2 ⋯ ⋯))
Goal: (CategoryTheory.ComposableArrows.homMk₂ app₀ app₁ app₂ w₀ w₁).app ⟨2, ⋯⟩ = app₂
-- CategoryTheory.ComposableArrows.hom_ext₂
@[ext]
lemma hom_ext₂ {f g : ComposableArrows C 2} {φ φ' : f ⟶ g}
    (h₀ : app' φ 0 = app' φ' 0) (h₁ : app' φ 1 = app' φ' 1) (h₂ : app' φ 2 = app' φ' 2) :
    φ = φ' 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {f g : CategoryTheory.ComposableArrows C 2} {φ φ' : f ⟶ g} (h₀ : CategoryTheory.ComposableArrows.app' φ 0 ⋯ = CategoryTheory.ComposableArrows.app' φ' 0 ⋯) (h₁ : CategoryTheory.ComposableArrows.app' φ 1 ⋯ = CategoryTheory.ComposableArrows.app' φ' 1 ⋯) (h₂ : CategoryTheory.ComposableArrows.app' φ 2 ⋯ = CategoryTheory.ComposableArrows.app' φ' 2 ⋯)
Goal: φ = φ'
-- CategoryTheory.ComposableArrows.isoMk₂_inv
@[simps]
def isoMk₂ {f g : ComposableArrows C 2}
    (app₀ : f.obj' 0 ≅ g.obj' 0) (app₁ : f.obj' 1 ≅ g.obj' 1) (app₂ : f.obj' 2 ≅ g.obj' 2)
    (w₀ : f.map' 0 1 ≫ app₁.hom = app₀.hom ≫ g.map' 0 1)
    (w₁ : f.map' 1 2 ≫ app₂.hom = app₁.hom ≫ g.map' 1 2) : f ≅ g 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {f g : CategoryTheory.ComposableArrows C 2} (app₀ : f.obj' 0 ⋯ ≅ g.obj' 0 ⋯) (app₁ : f.obj' 1 ⋯ ≅ g.obj' 1 ⋯) (app₂ : f.obj' 2 ⋯ ≅ g.obj' 2 ⋯) (w₀ :
  CategoryTheory.CategoryStruct.comp (f.map' 0 1 ⋯ ⋯) app₁.hom =
    CategoryTheory.CategoryStruct.comp app₀.hom (g.map' 0 1 ⋯ ⋯)) (w₁ :
  CategoryTheory.CategoryStruct.comp (f.map' 1 2 ⋯ ⋯) app₂.hom =
    CategoryTheory.CategoryStruct.comp app₁.hom (g.map' 1 2 ⋯ ⋯))
Goal: (CategoryTheory.ComposableArrows.isoMk₂ app₀ app₁ app₂ w₀ w₁).inv =
  CategoryTheory.ComposableArrows.homMk₂ app₀.inv app₁.inv app₂.inv ⋯ ⋯
-- CategoryTheory.ComposableArrows.isoMk₂_hom
@[simps]
def isoMk₂ {f g : ComposableArrows C 2}
    (app₀ : f.obj' 0 ≅ g.obj' 0) (app₁ : f.obj' 1 ≅ g.obj' 1) (app₂ : f.obj' 2 ≅ g.obj' 2)
    (w₀ : f.map' 0 1 ≫ app₁.hom = app₀.hom ≫ g.map' 0 1)
    (w₁ : f.map' 1 2 ≫ app₂.hom = app₁.hom ≫ g.map' 1 2) : f ≅ g 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {f g : CategoryTheory.ComposableArrows C 2} (app₀ : f.obj' 0 ⋯ ≅ g.obj' 0 ⋯) (app₁ : f.obj' 1 ⋯ ≅ g.obj' 1 ⋯) (app₂ : f.obj' 2 ⋯ ≅ g.obj' 2 ⋯) (w₀ :
  CategoryTheory.CategoryStruct.comp (f.map' 0 1 ⋯ ⋯) app₁.hom =
    CategoryTheory.CategoryStruct.comp app₀.hom (g.map' 0 1 ⋯ ⋯)) (w₁ :
  CategoryTheory.CategoryStruct.comp (f.map' 1 2 ⋯ ⋯) app₂.hom =
    CategoryTheory.CategoryStruct.comp app₁.hom (g.map' 1 2 ⋯ ⋯))
Goal: (CategoryTheory.ComposableArrows.isoMk₂ app₀ app₁ app₂ w₀ w₁).hom =
  CategoryTheory.ComposableArrows.homMk₂ app₀.hom app₁.hom app₂.hom w₀ w₁
-- CategoryTheory.ComposableArrows.ext₂
lemma ext₂ {f g : ComposableArrows C 2}
    (h₀ : f.obj' 0 = g.obj' 0) (h₁ : f.obj' 1 = g.obj' 1) (h₂ : f.obj' 2 = g.obj' 2)
    (w₀ : f.map' 0 1 = eqToHom h₀ ≫ g.map' 0 1 ≫ eqToHom h₁.symm)
    (w₁ : f.map' 1 2 = eqToHom h₁ ≫ g.map' 1 2 ≫ eqToHom h₂.symm) : f = g 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {f g : CategoryTheory.ComposableArrows C 2} (h₀ : f.obj' 0 ⋯ = g.obj' 0 ⋯) (h₁ : f.obj' 1 ⋯ = g.obj' 1 ⋯) (h₂ : f.obj' 2 ⋯ = g.obj' 2 ⋯) (w₀ :
  f.map' 0 1 ⋯ ⋯ =
    CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom h₀)
      (CategoryTheory.CategoryStruct.comp (g.map' 0 1 ⋯ ⋯) (CategoryTheory.eqToHom ⋯))) (w₁ :
  f.map' 1 2 ⋯ ⋯ =
    CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom h₁)
      (CategoryTheory.CategoryStruct.comp (g.map' 1 2 ⋯ ⋯) (CategoryTheory.eqToHom ⋯)))
Goal: f = g
-- CategoryTheory.ComposableArrows.mk₂_surjective
lemma mk₂_surjective (X : ComposableArrows C 2) :
    ∃ (X₀ X₁ X₂ : C) (f₀ : X₀ ⟶ X₁) (f₁ : X₁ ⟶ X₂), X = mk₂ f₀ f₁ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (X : CategoryTheory.ComposableArrows C 2)
Goal: ∃ X₀ X₁ X₂ f₀ f₁, X = CategoryTheory.ComposableArrows.mk₂ f₀ f₁
-- CategoryTheory.ComposableArrows.homMk₃_app_zero
@[simp]
lemma homMk₃_app_zero : (homMk₃ app₀ app₁ app₂ app₃ w₀ w₁ w₂).app 0 = app₀ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {f g : CategoryTheory.ComposableArrows C 3} (app₀ : f.obj' 0 ⋯ ⟶ g.obj' 0 ⋯) (app₁ : f.obj' 1 ⋯ ⟶ g.obj' 1 ⋯) (app₂ : f.obj' 2 ⋯ ⟶ g.obj' 2 ⋯) (app₃ : f.obj' 3 ⋯ ⟶ g.obj' 3 ⋯) (w₀ :
  CategoryTheory.CategoryStruct.comp (f.map' 0 1 ⋯ ⋯) app₁ = CategoryTheory.CategoryStruct.comp app₀ (g.map' 0 1 ⋯ ⋯)) (w₁ :
  CategoryTheory.CategoryStruct.comp (f.map' 1 2 ⋯ ⋯) app₂ = CategoryTheory.CategoryStruct.comp app₁ (g.map' 1 2 ⋯ ⋯)) (w₂ :
  CategoryTheory.CategoryStruct.comp (f.map' 2 3 ⋯ ⋯) app₃ = CategoryTheory.CategoryStruct.comp app₂ (g.map' 2 3 ⋯ ⋯))
Goal: (CategoryTheory.ComposableArrows.homMk₃ app₀ app₁ app₂ app₃ w₀ w₁ w₂).app 0 = app₀
-- CategoryTheory.ComposableArrows.homMk₃_app_one
@[simp]
lemma homMk₃_app_one : (homMk₃ app₀ app₁ app₂ app₃ w₀ w₁ w₂).app 1 = app₁ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {f g : CategoryTheory.ComposableArrows C 3} (app₀ : f.obj' 0 ⋯ ⟶ g.obj' 0 ⋯) (app₁ : f.obj' 1 ⋯ ⟶ g.obj' 1 ⋯) (app₂ : f.obj' 2 ⋯ ⟶ g.obj' 2 ⋯) (app₃ : f.obj' 3 ⋯ ⟶ g.obj' 3 ⋯) (w₀ :
  CategoryTheory.CategoryStruct.comp (f.map' 0 1 ⋯ ⋯) app₁ = CategoryTheory.CategoryStruct.comp app₀ (g.map' 0 1 ⋯ ⋯)) (w₁ :
  CategoryTheory.CategoryStruct.comp (f.map' 1 2 ⋯ ⋯) app₂ = CategoryTheory.CategoryStruct.comp app₁ (g.map' 1 2 ⋯ ⋯)) (w₂ :
  CategoryTheory.CategoryStruct.comp (f.map' 2 3 ⋯ ⋯) app₃ = CategoryTheory.CategoryStruct.comp app₂ (g.map' 2 3 ⋯ ⋯))
Goal: (CategoryTheory.ComposableArrows.homMk₃ app₀ app₁ app₂ app₃ w₀ w₁ w₂).app 1 = app₁
-- CategoryTheory.ComposableArrows.homMk₃_app_two
@[simp]
lemma homMk₃_app_two : (homMk₃ app₀ app₁ app₂ app₃ w₀ w₁ w₂).app ⟨2, by valid⟩ = app₂ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {f g : CategoryTheory.ComposableArrows C 3} (app₀ : f.obj' 0 ⋯ ⟶ g.obj' 0 ⋯) (app₁ : f.obj' 1 ⋯ ⟶ g.obj' 1 ⋯) (app₂ : f.obj' 2 ⋯ ⟶ g.obj' 2 ⋯) (app₃ : f.obj' 3 ⋯ ⟶ g.obj' 3 ⋯) (w₀ :
  CategoryTheory.CategoryStruct.comp (f.map' 0 1 ⋯ ⋯) app₁ = CategoryTheory.CategoryStruct.comp app₀ (g.map' 0 1 ⋯ ⋯)) (w₁ :
  CategoryTheory.CategoryStruct.comp (f.map' 1 2 ⋯ ⋯) app₂ = CategoryTheory.CategoryStruct.comp app₁ (g.map' 1 2 ⋯ ⋯)) (w₂ :
  CategoryTheory.CategoryStruct.comp (f.map' 2 3 ⋯ ⋯) app₃ = CategoryTheory.CategoryStruct.comp app₂ (g.map' 2 3 ⋯ ⋯))
Goal: (CategoryTheory.ComposableArrows.homMk₃ app₀ app₁ app₂ app₃ w₀ w₁ w₂).app ⟨2, ⋯⟩ = app₂
-- CategoryTheory.ComposableArrows.homMk₃_app_three
@[simp]
lemma homMk₃_app_three : (homMk₃ app₀ app₁ app₂ app₃ w₀ w₁ w₂).app ⟨3, by valid⟩ = app₃ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {f g : CategoryTheory.ComposableArrows C 3} (app₀ : f.obj' 0 ⋯ ⟶ g.obj' 0 ⋯) (app₁ : f.obj' 1 ⋯ ⟶ g.obj' 1 ⋯) (app₂ : f.obj' 2 ⋯ ⟶ g.obj' 2 ⋯) (app₃ : f.obj' 3 ⋯ ⟶ g.obj' 3 ⋯) (w₀ :
  CategoryTheory.CategoryStruct.comp (f.map' 0 1 ⋯ ⋯) app₁ = CategoryTheory.CategoryStruct.comp app₀ (g.map' 0 1 ⋯ ⋯)) (w₁ :
  CategoryTheory.CategoryStruct.comp (f.map' 1 2 ⋯ ⋯) app₂ = CategoryTheory.CategoryStruct.comp app₁ (g.map' 1 2 ⋯ ⋯)) (w₂ :
  CategoryTheory.CategoryStruct.comp (f.map' 2 3 ⋯ ⋯) app₃ = CategoryTheory.CategoryStruct.comp app₂ (g.map' 2 3 ⋯ ⋯))
Goal: (CategoryTheory.ComposableArrows.homMk₃ app₀ app₁ app₂ app₃ w₀ w₁ w₂).app ⟨3, ⋯⟩ = app₃
-- CategoryTheory.ComposableArrows.hom_ext₃
@[ext]
lemma hom_ext₃ {f g : ComposableArrows C 3} {φ φ' : f ⟶ g}
    (h₀ : app' φ 0 = app' φ' 0) (h₁ : app' φ 1 = app' φ' 1) (h₂ : app' φ 2 = app' φ' 2)
    (h₃ : app' φ 3 = app' φ' 3) :
    φ = φ' 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {f g : CategoryTheory.ComposableArrows C 3} {φ φ' : f ⟶ g} (h₀ : CategoryTheory.ComposableArrows.app' φ 0 ⋯ = CategoryTheory.ComposableArrows.app' φ' 0 ⋯) (h₁ : CategoryTheory.ComposableArrows.app' φ 1 ⋯ = CategoryTheory.ComposableArrows.app' φ' 1 ⋯) (h₂ : CategoryTheory.ComposableArrows.app' φ 2 ⋯ = CategoryTheory.ComposableArrows.app' φ' 2 ⋯) (h₃ : CategoryTheory.ComposableArrows.app' φ 3 ⋯ = CategoryTheory.ComposableArrows.app' φ' 3 ⋯)
Goal: φ = φ'