File: Mathlib/CategoryTheory/ComposableArrows.lean

full_name: CategoryTheory.ComposableArrows
code: /-- `ComposableArrows C n` is the type of functors `Fin (n + 1) ⥤ C`. -/
abbrev ComposableArrows (n : ℕ) 
goal: Type (max u_2 u_1)

full_name: CategoryTheory.ComposableArrows.tacticValid
code: macro "valid" : tactic =>
  `(tactic| first | assumption | apply zero_le | apply le_rfl | transitivity <;> assumption | omega)
goal: Lean.ParserDescr

full_name: CategoryTheory.ComposableArrows._aux_Mathlib_CategoryTheory_ComposableArrows___macroRules_CategoryTheory_ComposableArrows_tacticValid_1
code: macro "valid" : tactic =>
  `(tactic| first | assumption | apply zero_le | apply le_rfl | transitivity <;> assumption | omega)
goal: Lean.Macro

full_name: CategoryTheory.ComposableArrows.obj'
code: /-- The `i`th object (with `i : ℕ` such that `i ≤ n`) of `F : ComposableArrows C n`. -/
@[simp]
abbrev obj' (i : ℕ) (hi : i ≤ n := by valid) : C 
goal: C

full_name: CategoryTheory.ComposableArrows.map'
code: /-- The map `F.obj' i ⟶ F.obj' j` when `F : ComposableArrows C n`, and `i` and `j`
are natural numbers such that `i ≤ j ≤ n`. -/
@[simp]
abbrev map' (i j : ℕ) (hij : i ≤ j := by valid) (hjn : j ≤ n := by valid) :
  F.obj ⟨i, by omega⟩ ⟶ F.obj ⟨j, by omega⟩ 
goal: F.obj ⟨i, ⋯⟩ ⟶ F.obj ⟨j, ⋯⟩

full_name: CategoryTheory.ComposableArrows.map'_self
code: lemma map'_self (i : ℕ) (hi : i ≤ n := by valid) :
    F.map' i i = 𝟙 _ 
goal: F.map' i i ⋯ hi = CategoryTheory.CategoryStruct.id (F.obj ⟨i, ⋯⟩)

full_name: CategoryTheory.ComposableArrows.map'_comp
code: lemma map'_comp (i j k : ℕ) (hij : i ≤ j := by valid)
    (hjk : j ≤ k := by valid) (hk : k ≤ n := by valid) :
    F.map' i k = F.map' i j ≫ F.map' j k 
goal: F.map' i k ⋯ hk = CategoryTheory.CategoryStruct.comp (F.map' i j hij ⋯) (F.map' j k hjk hk)

full_name: CategoryTheory.ComposableArrows.left
code: /-- The leftmost object of `F : ComposableArrows C n`. -/
abbrev left 
goal: C

full_name: CategoryTheory.ComposableArrows.right
code: /-- The rightmost object of `F : ComposableArrows C n`. -/
abbrev right 
goal: C

full_name: CategoryTheory.ComposableArrows.hom
code: /-- The canonical map `F.left ⟶ F.right` for `F : ComposableArrows C n`. -/
abbrev hom : F.left ⟶ F.right 
goal: F.left ⟶ F.right

full_name: CategoryTheory.ComposableArrows.app'
code: /-- The map `F.obj' i ⟶ G.obj' i` induced on `i`th objects by a morphism `F ⟶ G`
in `ComposableArrows C n` when `i` is a natural number such that `i ≤ n`. -/
@[simp]
abbrev app' (φ : F ⟶ G) (i : ℕ) (hi : i ≤ n := by valid) :
    F.obj' i ⟶ G.obj' i 
goal: F.obj' i hi ⟶ G.obj' i hi

full_name: CategoryTheory.ComposableArrows.naturality'
code: @[reassoc]
lemma naturality' (φ : F ⟶ G) (i j : ℕ) (hij : i ≤ j := by valid)
    (hj : j ≤ n := by valid) :
    F.map' i j ≫ app' φ j = app' φ i ≫ G.map' i j 
goal: CategoryTheory.CategoryStruct.comp (F.map' i j hij hj) (CategoryTheory.ComposableArrows.app' φ j hj) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.ComposableArrows.app' φ i ⋯) (G.map' i j hij hj)

full_name: CategoryTheory.ComposableArrows.mk₀
code: /-- Constructor for `ComposableArrows C 0`. -/
@[simps!]
def mk₀ (X : C) : ComposableArrows C 0 
goal: CategoryTheory.ComposableArrows C 0

full_name: CategoryTheory.ComposableArrows.mk₀_map
code: /-- Constructor for `ComposableArrows C 0`. -/
@[simps!]
def mk₀ (X : C) : ComposableArrows C 0 
goal: ∀ {X_1 Y : Fin 1} (x : X_1 ⟶ Y), (CategoryTheory.ComposableArrows.mk₀ X).map x = CategoryTheory.CategoryStruct.id X

full_name: CategoryTheory.ComposableArrows.mk₀_obj
code: /-- Constructor for `ComposableArrows C 0`. -/
@[simps!]
def mk₀ (X : C) : ComposableArrows C 0 
goal: ∀ (x : Fin 1), (CategoryTheory.ComposableArrows.mk₀ X).obj x = X

full_name: CategoryTheory.ComposableArrows.Mk₁.obj
code: /-- The map which sends `0 : Fin 2` to `X₀` and `1` to `X₁`. -/
@[simp]
def obj : Fin 2 → C
  
goal: Fin 2 → C

full_name: CategoryTheory.ComposableArrows.Mk₁.map
code: /-- The obvious map `obj X₀ X₁ i ⟶ obj X₀ X₁ j` whenever `i j : Fin 2` satisfy `i ≤ j`. -/
@[simp]
def map : ∀ (i j : Fin 2) (_ : i ≤ j), obj X₀ X₁ i ⟶ obj X₀ X₁ j
  
goal: i ≤ j → (CategoryTheory.ComposableArrows.Mk₁.obj X₀ X₁ i ⟶ CategoryTheory.ComposableArrows.Mk₁.obj X₀ X₁ j)

full_name: CategoryTheory.ComposableArrows.Mk₁.map_id
code: lemma map_id (i : Fin 2) : map f i i (by simp) = 𝟙 _ 
goal: CategoryTheory.ComposableArrows.Mk₁.map f i i ⋯ =
  CategoryTheory.CategoryStruct.id (CategoryTheory.ComposableArrows.Mk₁.obj X₀ X₁ i)

full_name: CategoryTheory.ComposableArrows.Mk₁.map_comp
code: lemma map_comp {i j k : Fin 2} (hij : i ≤ j) (hjk : j ≤ k) :
    map f i k (hij.trans hjk) = map f i j hij ≫ map f j k hjk 
goal: CategoryTheory.ComposableArrows.Mk₁.map f i k ⋯ =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.ComposableArrows.Mk₁.map f i j hij)
    (CategoryTheory.ComposableArrows.Mk₁.map f j k hjk)

full_name: CategoryTheory.ComposableArrows.mk₁
code: /-- Constructor for `ComposableArrows C 1`. -/
@[simps]
def mk₁ {X₀ X₁ : C} (f : X₀ ⟶ X₁) : ComposableArrows C 1 
goal: CategoryTheory.ComposableArrows C 1

full_name: CategoryTheory.ComposableArrows.mk₁_map
code: /-- Constructor for `ComposableArrows C 1`. -/
@[simps]
def mk₁ {X₀ X₁ : C} (f : X₀ ⟶ X₁) : ComposableArrows C 1 
goal: ∀ {X Y : Fin (1 + 1)} (g : X ⟶ Y),
  (CategoryTheory.ComposableArrows.mk₁ f).map g = CategoryTheory.ComposableArrows.Mk₁.map f X Y ⋯

full_name: CategoryTheory.ComposableArrows.mk₁_obj
code: /-- Constructor for `ComposableArrows C 1`. -/
@[simps]
def mk₁ {X₀ X₁ : C} (f : X₀ ⟶ X₁) : ComposableArrows C 1 
goal: ∀ (a : Fin 2), (CategoryTheory.ComposableArrows.mk₁ f).obj a = CategoryTheory.ComposableArrows.Mk₁.obj X₀ X₁ a

full_name: CategoryTheory.ComposableArrows.homMk
code: /-- 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 
goal: F ⟶ G

full_name: CategoryTheory.ComposableArrows.homMk_app
code: /-- 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 
goal: (CategoryTheory.ComposableArrows.homMk app w).app i = app i

full_name: CategoryTheory.ComposableArrows.isoMk_hom
code: /-- 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 
goal: (CategoryTheory.ComposableArrows.isoMk app w).hom = CategoryTheory.ComposableArrows.homMk (fun i => (app i).hom) w

full_name: CategoryTheory.ComposableArrows.isoMk
code: /-- 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 
goal: F ≅ G

full_name: CategoryTheory.ComposableArrows.isoMk_inv
code: /-- 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 
goal: (CategoryTheory.ComposableArrows.isoMk app w).inv = CategoryTheory.ComposableArrows.homMk (fun i => (app i).inv) ⋯

full_name: CategoryTheory.ComposableArrows.ext
code: lemma ext {F G : ComposableArrows C n} (h : ∀ i, F.obj i = G.obj i)
    (w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) =
      eqToHom (h _) ≫ G.map' i (i + 1) ≫ eqToHom (h _).symm) : F = G 
goal: F = G

full_name: CategoryTheory.ComposableArrows.homMk₀_app
code: /-- Constructor for morphisms in `ComposableArrows C 0`. -/
@[simps!]
def homMk₀ {F G : ComposableArrows C 0} (f : F.obj' 0 ⟶ G.obj' 0) : F ⟶ G 
goal: (CategoryTheory.ComposableArrows.homMk₀ f).app i =
  match i with
  | ⟨0, isLt⟩ => f

full_name: CategoryTheory.ComposableArrows.homMk₀
code: /-- Constructor for morphisms in `ComposableArrows C 0`. -/
@[simps!]
def homMk₀ {F G : ComposableArrows C 0} (f : F.obj' 0 ⟶ G.obj' 0) : F ⟶ G 
goal: F ⟶ G

full_name: CategoryTheory.ComposableArrows.hom_ext₀
code: @[ext]
lemma hom_ext₀ {F G : ComposableArrows C 0} {φ φ' : F ⟶ G}
    (h : app' φ 0 = app' φ' 0) :
    φ = φ' 
goal: φ = φ'

full_name: CategoryTheory.ComposableArrows.isoMk₀_hom_app
code: /-- Constructor for isomorphisms in `ComposableArrows C 0`. -/
@[simps!]
def isoMk₀ {F G : ComposableArrows C 0} (e : F.obj' 0 ≅ G.obj' 0) : F ≅ G 
goal: (CategoryTheory.ComposableArrows.isoMk₀ e).hom.app i =
  match i with
  | ⟨0, isLt⟩ => e.hom

full_name: CategoryTheory.ComposableArrows.isoMk₀_inv_app
code: /-- Constructor for isomorphisms in `ComposableArrows C 0`. -/
@[simps!]
def isoMk₀ {F G : ComposableArrows C 0} (e : F.obj' 0 ≅ G.obj' 0) : F ≅ G 
goal: (CategoryTheory.ComposableArrows.isoMk₀ e).inv.app i =
  match i with
  | ⟨0, isLt⟩ => e.inv

full_name: CategoryTheory.ComposableArrows.isoMk₀
code: /-- Constructor for isomorphisms in `ComposableArrows C 0`. -/
@[simps!]
def isoMk₀ {F G : ComposableArrows C 0} (e : F.obj' 0 ≅ G.obj' 0) : F ≅ G 
goal: F ≅ G

full_name: CategoryTheory.ComposableArrows.ext₀
code: lemma ext₀ {F G : ComposableArrows C 0} (h : F.obj' 0 = G.obj 0) : F = G 
goal: F = G

full_name: CategoryTheory.ComposableArrows.mk₀_surjective
code: lemma mk₀_surjective (F : ComposableArrows C 0) : ∃ (X : C), F = mk₀ X 
goal: ∃ X, F = CategoryTheory.ComposableArrows.mk₀ X

full_name: CategoryTheory.ComposableArrows.homMk₁
code: /-- Constructor for morphisms in `ComposableArrows C 1`. -/
@[simps!]
def homMk₁ {F G : ComposableArrows C 1}
    (left : F.obj' 0 ⟶ G.obj' 0) (right : F.obj' 1 ⟶ G.obj' 1)
    (w : F.map' 0 1 ≫ right = left ≫ G.map' 0 1 := by aesop_cat) :
    F ⟶ G 
goal: F ⟶ G

full_name: CategoryTheory.ComposableArrows.homMk₁_app
code: /-- Constructor for morphisms in `ComposableArrows C 1`. -/
@[simps!]
def homMk₁ {F G : ComposableArrows C 1}
    (left : F.obj' 0 ⟶ G.obj' 0) (right : F.obj' 1 ⟶ G.obj' 1)
    (w : F.map' 0 1 ≫ right = left ≫ G.map' 0 1 := by aesop_cat) :
    F ⟶ G 
goal: (CategoryTheory.ComposableArrows.homMk₁ left right w).app i =
  match i with
  | ⟨0, isLt⟩ => left
  | ⟨1, isLt⟩ => right

full_name: CategoryTheory.ComposableArrows.hom_ext₁
code: @[ext]
lemma hom_ext₁ {F G : ComposableArrows C 1} {φ φ' : F ⟶ G}
    (h₀ : app' φ 0 = app' φ' 0) (h₁ : app' φ 1 = app' φ' 1) :
    φ = φ' 
goal: φ = φ'

full_name: CategoryTheory.ComposableArrows.isoMk₁_hom_app
code: /-- Constructor for isomorphisms in `ComposableArrows C 1`. -/
@[simps!]
def isoMk₁ {F G : ComposableArrows C 1}
    (left : F.obj' 0 ≅ G.obj' 0) (right : F.obj' 1 ≅ G.obj' 1)
    (w : F.map' 0 1 ≫ right.hom = left.hom ≫ G.map' 0 1 := by aesop_cat) :
    F ≅ G 
goal: (CategoryTheory.ComposableArrows.isoMk₁ left right w).hom.app i =
  match i with
  | ⟨0, isLt⟩ => left.hom
  | ⟨1, isLt⟩ => right.hom

full_name: CategoryTheory.ComposableArrows.isoMk₁_inv_app
code: /-- Constructor for isomorphisms in `ComposableArrows C 1`. -/
@[simps!]
def isoMk₁ {F G : ComposableArrows C 1}
    (left : F.obj' 0 ≅ G.obj' 0) (right : F.obj' 1 ≅ G.obj' 1)
    (w : F.map' 0 1 ≫ right.hom = left.hom ≫ G.map' 0 1 := by aesop_cat) :
    F ≅ G 
goal: (CategoryTheory.ComposableArrows.isoMk₁ left right w).inv.app i =
  match i with
  | ⟨0, isLt⟩ => left.inv
  | ⟨1, isLt⟩ => right.inv

full_name: CategoryTheory.ComposableArrows.isoMk₁
code: /-- Constructor for isomorphisms in `ComposableArrows C 1`. -/
@[simps!]
def isoMk₁ {F G : ComposableArrows C 1}
    (left : F.obj' 0 ≅ G.obj' 0) (right : F.obj' 1 ≅ G.obj' 1)
    (w : F.map' 0 1 ≫ right.hom = left.hom ≫ G.map' 0 1 := by aesop_cat) :
    F ≅ G 
goal: F ≅ G

full_name: CategoryTheory.ComposableArrows.map'_eq_hom₁
code: lemma map'_eq_hom₁ (F : ComposableArrows C 1) : F.map' 0 1 = F.hom 
goal: F.map' 0 1 ⋯ ⋯ = F.hom

full_name: CategoryTheory.ComposableArrows.ext₁
code: lemma ext₁ {F G : ComposableArrows C 1}
    (left : F.left = G.left) (right : F.right = G.right)
    (w : F.hom = eqToHom left ≫ G.hom ≫ eqToHom right.symm) : F = G 
goal: F = G

full_name: CategoryTheory.ComposableArrows.mk₁_surjective
code: lemma mk₁_surjective (X : ComposableArrows C 1) : ∃ (X₀ X₁ : C) (f : X₀ ⟶ X₁), X = mk₁ f 
goal: ∃ X₀ X₁ f, X = CategoryTheory.ComposableArrows.mk₁ f

full_name: CategoryTheory.ComposableArrows.Precomp.obj
code: /-- The map `Fin (n + 1 + 1) → C` which "shifts" `F.obj'` to the right and inserts `X` in
the zeroth position. -/
def obj : Fin (n + 1 + 1) → C
  
goal: Fin (n + 1 + 1) → C

full_name: CategoryTheory.ComposableArrows.Precomp.obj_zero
code: @[simp]
lemma obj_zero : obj F X 0 = X 
goal: CategoryTheory.ComposableArrows.Precomp.obj F X 0 = X

full_name: CategoryTheory.ComposableArrows.Precomp.obj_one
code: @[simp]
lemma obj_one : obj F X 1 = F.obj' 0 
goal: CategoryTheory.ComposableArrows.Precomp.obj F X 1 = F.obj' 0 ⋯

full_name: CategoryTheory.ComposableArrows.Precomp.obj_succ
code: @[simp]
lemma obj_succ (i : ℕ) (hi : i + 1 < n + 1 + 1) : obj F X ⟨i + 1, hi⟩ = F.obj' i 
goal: CategoryTheory.ComposableArrows.Precomp.obj F X ⟨i + 1, hi⟩ = F.obj' i ⋯

full_name: CategoryTheory.ComposableArrows.Precomp.map
code: /-- Auxiliary definition for the action on maps of the functor `F.precomp f`.
It sends `0 ≤ 1` to `f` and `i + 1 ≤ j + 1` to `F.map' i j`. -/
def map : ∀ (i j : Fin (n + 1 + 1)) (_ : i ≤ j), obj F X i ⟶ obj F X j
  
goal: i ≤ j → (CategoryTheory.ComposableArrows.Precomp.obj F X i ⟶ CategoryTheory.ComposableArrows.Precomp.obj F X j)

full_name: CategoryTheory.ComposableArrows.Precomp.map_zero_zero
code: @[simp]
lemma map_zero_zero : map F f 0 0 (by simp) = 𝟙 X 
goal: CategoryTheory.ComposableArrows.Precomp.map F f 0 0 ⋯ = CategoryTheory.CategoryStruct.id X

full_name: CategoryTheory.ComposableArrows.Precomp.map_one_one
code: @[simp]
lemma map_one_one : map F f 1 1 (by simp) = F.map (𝟙 _) 
goal: CategoryTheory.ComposableArrows.Precomp.map F f 1 1 ⋯ = F.map (CategoryTheory.CategoryStruct.id ⟨0, ⋯⟩)

full_name: CategoryTheory.ComposableArrows.Precomp.map_zero_one
code: @[simp]
lemma map_zero_one : map F f 0 1 (by simp) = f 
goal: CategoryTheory.ComposableArrows.Precomp.map F f 0 1 ⋯ = f

full_name: CategoryTheory.ComposableArrows.Precomp.map_zero_one'
code: @[simp]
lemma map_zero_one' : map F f 0 ⟨0 + 1, by simp⟩ (by simp) = f 
goal: CategoryTheory.ComposableArrows.Precomp.map F f 0 ⟨0 + 1, ⋯⟩ ⋯ = f

full_name: CategoryTheory.ComposableArrows.Precomp.map_zero_succ_succ
code: @[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) 
goal: CategoryTheory.ComposableArrows.Precomp.map F f 0 ⟨j + 2, hj⟩ ⋯ =
  CategoryTheory.CategoryStruct.comp f (F.map' 0 (j + 1) ⋯ ⋯)

full_name: CategoryTheory.ComposableArrows.Precomp.map_succ_succ
code: @[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 
goal: CategoryTheory.ComposableArrows.Precomp.map F f ⟨i + 1, hi⟩ ⟨j + 1, hj⟩ hij = F.map' i j ⋯ ⋯

full_name: CategoryTheory.ComposableArrows.Precomp.map_one_succ
code: @[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 
goal: CategoryTheory.ComposableArrows.Precomp.map F f 1 ⟨j + 1, hj⟩ ⋯ = F.map' 0 j ⋯ ⋯

full_name: CategoryTheory.ComposableArrows.Precomp.map_id
code: lemma map_id (i : Fin (n + 1 + 1)) : map F f i i (by simp) = 𝟙 _ 
goal: CategoryTheory.ComposableArrows.Precomp.map F f i i ⋯ =
  CategoryTheory.CategoryStruct.id (CategoryTheory.ComposableArrows.Precomp.obj F X i)

full_name: CategoryTheory.ComposableArrows.Precomp.map_comp
code: 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 
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)

full_name: CategoryTheory.ComposableArrows.precomp_obj
code: /-- "Precomposition" of `F : ComposableArrows C n` by a morphism `f : X ⟶ F.left`. -/
@[simps]
def precomp {X : C} (f : X ⟶ F.left) : ComposableArrows C (n + 1) 
goal: ∀ (a : Fin (n + 1 + 1)), (F.precomp f).obj a = CategoryTheory.ComposableArrows.Precomp.obj F X a

full_name: CategoryTheory.ComposableArrows.precomp_map
code: /-- "Precomposition" of `F : ComposableArrows C n` by a morphism `f : X ⟶ F.left`. -/
@[simps]
def precomp {X : C} (f : X ⟶ F.left) : ComposableArrows C (n + 1) 
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 ⋯

full_name: CategoryTheory.ComposableArrows.precomp
code: /-- "Precomposition" of `F : ComposableArrows C n` by a morphism `f : X ⟶ F.left`. -/
@[simps]
def precomp {X : C} (f : X ⟶ F.left) : ComposableArrows C (n + 1) 
goal: CategoryTheory.ComposableArrows C (n + 1)

full_name: CategoryTheory.ComposableArrows.mk₂
code: /-- Constructor for `ComposableArrows C 2`. -/
@[simp]
def mk₂ {X₀ X₁ X₂ : C} (f : X₀ ⟶ X₁) (g : X₁ ⟶ X₂) : ComposableArrows C 2 
goal: CategoryTheory.ComposableArrows C 2

full_name: CategoryTheory.ComposableArrows.mk₃
code: /-- Constructor for `ComposableArrows C 3`. -/
@[simp]
def mk₃ {X₀ X₁ X₂ X₃ : C} (f : X₀ ⟶ X₁) (g : X₁ ⟶ X₂) (h : X₂ ⟶ X₃) : ComposableArrows C 3 
goal: CategoryTheory.ComposableArrows C 3

full_name: CategoryTheory.ComposableArrows.mk₄
code: /-- Constructor for `ComposableArrows C 4`. -/
@[simp]
def mk₄ {X₀ X₁ X₂ X₃ X₄ : C} (f : X₀ ⟶ X₁) (g : X₁ ⟶ X₂) (h : X₂ ⟶ X₃) (i : X₃ ⟶ X₄) :
    ComposableArrows C 4 
goal: CategoryTheory.ComposableArrows C 4

full_name: CategoryTheory.ComposableArrows.mk₅
code: /-- Constructor for `ComposableArrows C 5`. -/
@[simp]
def mk₅ {X₀ X₁ X₂ X₃ X₄ X₅ : C} (f : X₀ ⟶ X₁) (g : X₁ ⟶ X₂) (h : X₂ ⟶ X₃)
    (i : X₃ ⟶ X₄) (j : X₄ ⟶ X₅) :
    ComposableArrows C 5 
goal: CategoryTheory.ComposableArrows C 5

full_name: CategoryTheory.ComposableArrows.whiskerLeft_map
code: /-- The map `ComposableArrows C m → ComposableArrows C n` obtained by precomposition with
a functor `Fin (n + 1) ⥤ Fin (m + 1)`. -/
@[simps!]
def whiskerLeft (F : ComposableArrows C m) (Φ : Fin (n + 1) ⥤ Fin (m + 1)) :
    ComposableArrows C n 
goal: ∀ {X Y : Fin (n + 1)} (f : X ⟶ Y), (F.whiskerLeft Φ).map f = F.map (Φ.map f)

full_name: CategoryTheory.ComposableArrows.whiskerLeft
code: /-- The map `ComposableArrows C m → ComposableArrows C n` obtained by precomposition with
a functor `Fin (n + 1) ⥤ Fin (m + 1)`. -/
@[simps!]
def whiskerLeft (F : ComposableArrows C m) (Φ : Fin (n + 1) ⥤ Fin (m + 1)) :
    ComposableArrows C n 
goal: CategoryTheory.ComposableArrows C n

full_name: CategoryTheory.ComposableArrows.whiskerLeft_obj
code: /-- The map `ComposableArrows C m → ComposableArrows C n` obtained by precomposition with
a functor `Fin (n + 1) ⥤ Fin (m + 1)`. -/
@[simps!]
def whiskerLeft (F : ComposableArrows C m) (Φ : Fin (n + 1) ⥤ Fin (m + 1)) :
    ComposableArrows C n 
goal: (F.whiskerLeft Φ).obj X = F.obj (Φ.obj X)

full_name: CategoryTheory.ComposableArrows.whiskerLeftFunctor_obj_obj
code: /-- The functor `ComposableArrows C m ⥤ ComposableArrows C n` obtained by precomposition with
a functor `Fin (n + 1) ⥤ Fin (m + 1)`. -/
@[simps!]
def whiskerLeftFunctor (Φ : Fin (n + 1) ⥤ Fin (m + 1)) :
    ComposableArrows C m ⥤ ComposableArrows C n 
goal: ((CategoryTheory.ComposableArrows.whiskerLeftFunctor Φ).obj F).obj X = F.obj (Φ.obj X)

full_name: CategoryTheory.ComposableArrows.whiskerLeftFunctor
code: /-- The functor `ComposableArrows C m ⥤ ComposableArrows C n` obtained by precomposition with
a functor `Fin (n + 1) ⥤ Fin (m + 1)`. -/
@[simps!]
def whiskerLeftFunctor (Φ : Fin (n + 1) ⥤ Fin (m + 1)) :
    ComposableArrows C m ⥤ ComposableArrows C n 
goal: CategoryTheory.Functor (CategoryTheory.ComposableArrows C m) (CategoryTheory.ComposableArrows C n)

full_name: CategoryTheory.ComposableArrows.whiskerLeftFunctor_map_app
code: /-- The functor `ComposableArrows C m ⥤ ComposableArrows C n` obtained by precomposition with
a functor `Fin (n + 1) ⥤ Fin (m + 1)`. -/
@[simps!]
def whiskerLeftFunctor (Φ : Fin (n + 1) ⥤ Fin (m + 1)) :
    ComposableArrows C m ⥤ ComposableArrows C n 
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)

full_name: CategoryTheory.ComposableArrows.whiskerLeftFunctor_obj_map
code: /-- The functor `ComposableArrows C m ⥤ ComposableArrows C n` obtained by precomposition with
a functor `Fin (n + 1) ⥤ Fin (m + 1)`. -/
@[simps!]
def whiskerLeftFunctor (Φ : Fin (n + 1) ⥤ Fin (m + 1)) :
    ComposableArrows C m ⥤ ComposableArrows C n 
goal: ∀ {X Y : Fin (n + 1)} (f : X ⟶ Y),
  ((CategoryTheory.ComposableArrows.whiskerLeftFunctor Φ).obj F).map f = F.map (Φ.map f)

full_name: Fin.succFunctor_obj
code: /-- The functor `Fin n ⥤ Fin (n + 1)` which sends `i` to `i.succ`. -/
@[simps]
def _root_.Fin.succFunctor (n : ℕ) : Fin n ⥤ Fin (n + 1) 
goal: (Fin.succFunctor n).obj i = i.succ

full_name: Fin.succFunctor_map
code: /-- The functor `Fin n ⥤ Fin (n + 1)` which sends `i` to `i.succ`. -/
@[simps]
def _root_.Fin.succFunctor (n : ℕ) : Fin n ⥤ Fin (n + 1) 
goal: (Fin.succFunctor n).map hij = CategoryTheory.homOfLE ⋯

full_name: Fin.succFunctor
code: /-- The functor `Fin n ⥤ Fin (n + 1)` which sends `i` to `i.succ`. -/
@[simps]
def _root_.Fin.succFunctor (n : ℕ) : Fin n ⥤ Fin (n + 1) 
goal: CategoryTheory.Functor (Fin n) (Fin (n + 1))

full_name: CategoryTheory.ComposableArrows.δ₀Functor_obj_obj
code: /-- The functor `ComposableArrows C (n + 1) ⥤ ComposableArrows C n` which forgets
the first arrow. -/
@[simps!]
def δ₀Functor : ComposableArrows C (n + 1) ⥤ ComposableArrows C n 
goal: (CategoryTheory.ComposableArrows.δ₀Functor.obj F).obj X = F.obj X.succ

full_name: CategoryTheory.ComposableArrows.δ₀Functor_map_app
code: /-- The functor `ComposableArrows C (n + 1) ⥤ ComposableArrows C n` which forgets
the first arrow. -/
@[simps!]
def δ₀Functor : ComposableArrows C (n + 1) ⥤ ComposableArrows 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

full_name: CategoryTheory.ComposableArrows.δ₀Functor
code: /-- The functor `ComposableArrows C (n + 1) ⥤ ComposableArrows C n` which forgets
the first arrow. -/
@[simps!]
def δ₀Functor : ComposableArrows C (n + 1) ⥤ ComposableArrows C n 
goal: CategoryTheory.Functor (CategoryTheory.ComposableArrows C (n + 1)) (CategoryTheory.ComposableArrows C n)

full_name: CategoryTheory.ComposableArrows.δ₀Functor_obj_map
code: /-- The functor `ComposableArrows C (n + 1) ⥤ ComposableArrows C n` which forgets
the first arrow. -/
@[simps!]
def δ₀Functor : ComposableArrows C (n + 1) ⥤ ComposableArrows C n 
goal: ∀ {X Y : Fin (n + 1)} (f : X ⟶ Y),
  (CategoryTheory.ComposableArrows.δ₀Functor.obj F).map f = F.map (CategoryTheory.homOfLE ⋯)

full_name: CategoryTheory.ComposableArrows.δ₀
code: /-- The `ComposableArrows C n` obtained by forgetting the first arrow. -/
abbrev δ₀ (F : ComposableArrows C (n + 1)) 
goal: CategoryTheory.ComposableArrows C n

full_name: CategoryTheory.ComposableArrows.precomp_δ₀
code: @[simp]
lemma precomp_δ₀ {X : C} (f : X ⟶ F.left) : (F.precomp f).δ₀ = F 
goal: (F.precomp f).δ₀ = F

full_name: Fin.castSuccFunctor_obj
code: /-- The functor `Fin n ⥤ Fin (n + 1)` which sends `i` to `i.castSucc`. -/
@[simps]
def _root_.Fin.castSuccFunctor (n : ℕ) : Fin n ⥤ Fin (n + 1) 
goal: (Fin.castSuccFunctor n).obj i = i.castSucc

full_name: Fin.castSuccFunctor
code: /-- The functor `Fin n ⥤ Fin (n + 1)` which sends `i` to `i.castSucc`. -/
@[simps]
def _root_.Fin.castSuccFunctor (n : ℕ) : Fin n ⥤ Fin (n + 1) 
goal: CategoryTheory.Functor (Fin n) (Fin (n + 1))

full_name: Fin.castSuccFunctor_map
code: /-- The functor `Fin n ⥤ Fin (n + 1)` which sends `i` to `i.castSucc`. -/
@[simps]
def _root_.Fin.castSuccFunctor (n : ℕ) : Fin n ⥤ Fin (n + 1) 
goal: ∀ {X Y : Fin n} (hij : X ⟶ Y), (Fin.castSuccFunctor n).map hij = hij

full_name: CategoryTheory.ComposableArrows.δlastFunctor_obj_map
code: /-- The functor `ComposableArrows C (n + 1) ⥤ ComposableArrows C n` which forgets
the last arrow. -/
@[simps!]
def δlastFunctor : ComposableArrows C (n + 1) ⥤ ComposableArrows C n 
goal: ∀ {X Y : Fin (n + 1)} (f : X ⟶ Y), (CategoryTheory.ComposableArrows.δlastFunctor.obj F).map f = F.map f

full_name: CategoryTheory.ComposableArrows.δlastFunctor_map_app
code: /-- The functor `ComposableArrows C (n + 1) ⥤ ComposableArrows C n` which forgets
the last arrow. -/
@[simps!]
def δlastFunctor : ComposableArrows C (n + 1) ⥤ ComposableArrows 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

full_name: CategoryTheory.ComposableArrows.δlastFunctor_obj_obj
code: /-- The functor `ComposableArrows C (n + 1) ⥤ ComposableArrows C n` which forgets
the last arrow. -/
@[simps!]
def δlastFunctor : ComposableArrows C (n + 1) ⥤ ComposableArrows C n 
goal: (CategoryTheory.ComposableArrows.δlastFunctor.obj F).obj X = F.obj X.castSucc

full_name: CategoryTheory.ComposableArrows.δlastFunctor
code: /-- The functor `ComposableArrows C (n + 1) ⥤ ComposableArrows C n` which forgets
the last arrow. -/
@[simps!]
def δlastFunctor : ComposableArrows C (n + 1) ⥤ ComposableArrows C n 
goal: CategoryTheory.Functor (CategoryTheory.ComposableArrows C (n + 1)) (CategoryTheory.ComposableArrows C n)

full_name: CategoryTheory.ComposableArrows.δlast
code: /-- The `ComposableArrows C n` obtained by forgetting the first arrow. -/
abbrev δlast (F : ComposableArrows C (n + 1)) 
goal: CategoryTheory.ComposableArrows C n

full_name: CategoryTheory.ComposableArrows.homMkSucc
code: /-- Inductive construction of morphisms in `ComposableArrows C (n + 1)`: in order to construct
a morphism `F ⟶ G`, it suffices to provide `α : F.obj' 0 ⟶ G.obj' 0` and `β : F.δ₀ ⟶ G.δ₀`
such that `F.map' 0 1 ≫ app' β 0 = α ≫ G.map' 0 1`. -/
def homMkSucc (α : F.obj' 0 ⟶ G.obj' 0) (β : F.δ₀ ⟶ G.δ₀)
    (w : F.map' 0 1 ≫ app' β 0 = α ≫ G.map' 0 1) : F ⟶ G 
goal: F ⟶ G

full_name: CategoryTheory.ComposableArrows.homMkSucc_app_zero
code: @[simp]
lemma homMkSucc_app_zero : (homMkSucc α β w).app 0 = α 
goal: (CategoryTheory.ComposableArrows.homMkSucc α β w).app 0 = α

full_name: CategoryTheory.ComposableArrows.homMkSucc_app_succ
code: @[simp]
lemma homMkSucc_app_succ (i : ℕ) (hi : i + 1 < n + 1 + 1) :
    (homMkSucc α β w).app ⟨i + 1, hi⟩ = app' β i 
goal: (CategoryTheory.ComposableArrows.homMkSucc α β w).app ⟨i + 1, hi⟩ = CategoryTheory.ComposableArrows.app' β i ⋯

full_name: CategoryTheory.ComposableArrows.hom_ext_succ
code: 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 
goal: f = g

full_name: CategoryTheory.ComposableArrows.isoMkSucc
code: /-- Inductive construction of isomorphisms in `ComposableArrows C (n + 1)`: in order to
construct an isomorphism `F ≅ G`, it suffices to provide `α : F.obj' 0 ≅ G.obj' 0` and
`β : F.δ₀ ≅ G.δ₀` such that `F.map' 0 1 ≫ app' β.hom 0 = α.hom ≫ G.map' 0 1`. -/
@[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 
goal: F ≅ G

full_name: CategoryTheory.ComposableArrows.isoMkSucc_inv
code: /-- Inductive construction of isomorphisms in `ComposableArrows C (n + 1)`: in order to
construct an isomorphism `F ≅ G`, it suffices to provide `α : F.obj' 0 ≅ G.obj' 0` and
`β : F.δ₀ ≅ G.δ₀` such that `F.map' 0 1 ≫ app' β.hom 0 = α.hom ≫ G.map' 0 1`. -/
@[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 
goal: (CategoryTheory.ComposableArrows.isoMkSucc α β w).inv = CategoryTheory.ComposableArrows.homMkSucc α.inv β.inv ⋯

full_name: CategoryTheory.ComposableArrows.isoMkSucc_hom
code: /-- Inductive construction of isomorphisms in `ComposableArrows C (n + 1)`: in order to
construct an isomorphism `F ≅ G`, it suffices to provide `α : F.obj' 0 ≅ G.obj' 0` and
`β : F.δ₀ ≅ G.δ₀` such that `F.map' 0 1 ≫ app' β.hom 0 = α.hom ≫ G.map' 0 1`. -/
@[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 
goal: (CategoryTheory.ComposableArrows.isoMkSucc α β w).hom = CategoryTheory.ComposableArrows.homMkSucc α.hom β.hom w

full_name: CategoryTheory.ComposableArrows.ext_succ
code: 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 
goal: F = G

full_name: CategoryTheory.ComposableArrows.precomp_surjective
code: lemma precomp_surjective (F : ComposableArrows C (n + 1)) :
    ∃ (F₀ : ComposableArrows C n) (X₀ : C) (f₀ : X₀ ⟶ F₀.left), F = F₀.precomp f₀ 
goal: ∃ F₀ X₀ f₀, F = F₀.precomp f₀

full_name: CategoryTheory.ComposableArrows.homMk₂
code: /-- Constructor for morphisms in `ComposableArrows C 2`. -/
def homMk₂ : f ⟶ g 
goal: f ⟶ g

full_name: CategoryTheory.ComposableArrows.homMk₂_app_zero
code: @[simp]
lemma homMk₂_app_zero : (homMk₂ app₀ app₁ app₂ w₀ w₁).app 0 = app₀ 
goal: (CategoryTheory.ComposableArrows.homMk₂ app₀ app₁ app₂ w₀ w₁).app 0 = app₀

full_name: CategoryTheory.ComposableArrows.homMk₂_app_one
code: @[simp]
lemma homMk₂_app_one : (homMk₂ app₀ app₁ app₂ w₀ w₁).app 1 = app₁ 
goal: (CategoryTheory.ComposableArrows.homMk₂ app₀ app₁ app₂ w₀ w₁).app 1 = app₁

full_name: CategoryTheory.ComposableArrows.homMk₂_app_two
code: @[simp]
lemma homMk₂_app_two : (homMk₂ app₀ app₁ app₂ w₀ w₁).app ⟨2, by valid⟩ = app₂ 
goal: (CategoryTheory.ComposableArrows.homMk₂ app₀ app₁ app₂ w₀ w₁).app ⟨2, ⋯⟩ = app₂

full_name: CategoryTheory.ComposableArrows.hom_ext₂
code: @[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) :
    φ = φ' 
goal: φ = φ'

full_name: CategoryTheory.ComposableArrows.isoMk₂
code: /-- Constructor for isomorphisms in `ComposableArrows C 2`. -/
@[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 
goal: f ≅ g

full_name: CategoryTheory.ComposableArrows.isoMk₂_inv
code: /-- Constructor for isomorphisms in `ComposableArrows C 2`. -/
@[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 
goal: (CategoryTheory.ComposableArrows.isoMk₂ app₀ app₁ app₂ w₀ w₁).inv =
  CategoryTheory.ComposableArrows.homMk₂ app₀.inv app₁.inv app₂.inv ⋯ ⋯

full_name: CategoryTheory.ComposableArrows.isoMk₂_hom
code: /-- Constructor for isomorphisms in `ComposableArrows C 2`. -/
@[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 
goal: (CategoryTheory.ComposableArrows.isoMk₂ app₀ app₁ app₂ w₀ w₁).hom =
  CategoryTheory.ComposableArrows.homMk₂ app₀.hom app₁.hom app₂.hom w₀ w₁

full_name: CategoryTheory.ComposableArrows.ext₂
code: 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 
goal: f = g

full_name: CategoryTheory.ComposableArrows.mk₂_surjective
code: lemma mk₂_surjective (X : ComposableArrows C 2) :
    ∃ (X₀ X₁ X₂ : C) (f₀ : X₀ ⟶ X₁) (f₁ : X₁ ⟶ X₂), X = mk₂ f₀ f₁ 
goal: ∃ X₀ X₁ X₂ f₀ f₁, X = CategoryTheory.ComposableArrows.mk₂ f₀ f₁

full_name: CategoryTheory.ComposableArrows.homMk₃
code: /-- Constructor for morphisms in `ComposableArrows C 3`. -/
def homMk₃ : f ⟶ g 
goal: f ⟶ g

full_name: CategoryTheory.ComposableArrows.homMk₃_app_zero
code: @[simp]
lemma homMk₃_app_zero : (homMk₃ app₀ app₁ app₂ app₃ w₀ w₁ w₂).app 0 = app₀ 
goal: (CategoryTheory.ComposableArrows.homMk₃ app₀ app₁ app₂ app₃ w₀ w₁ w₂).app 0 = app₀

full_name: CategoryTheory.ComposableArrows.homMk₃_app_one
code: @[simp]
lemma homMk₃_app_one : (homMk₃ app₀ app₁ app₂ app₃ w₀ w₁ w₂).app 1 = app₁ 
goal: (CategoryTheory.ComposableArrows.homMk₃ app₀ app₁ app₂ app₃ w₀ w₁ w₂).app 1 = app₁

full_name: CategoryTheory.ComposableArrows.homMk₃_app_two
code: @[simp]
lemma homMk₃_app_two : (homMk₃ app₀ app₁ app₂ app₃ w₀ w₁ w₂).app ⟨2, by valid⟩ = app₂ 
goal: (CategoryTheory.ComposableArrows.homMk₃ app₀ app₁ app₂ app₃ w₀ w₁ w₂).app ⟨2, ⋯⟩ = app₂

full_name: CategoryTheory.ComposableArrows.homMk₃_app_three
code: @[simp]
lemma homMk₃_app_three : (homMk₃ app₀ app₁ app₂ app₃ w₀ w₁ w₂).app ⟨3, by valid⟩ = app₃ 
goal: (CategoryTheory.ComposableArrows.homMk₃ app₀ app₁ app₂ app₃ w₀ w₁ w₂).app ⟨3, ⋯⟩ = app₃

full_name: CategoryTheory.ComposableArrows.hom_ext₃
code: @[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) :
    φ = φ' 
goal: φ = φ'

full_name: CategoryTheory.ComposableArrows.isoMk₃_hom
code: /-- Constructor for isomorphisms in `ComposableArrows C 3`. -/
@[simps]
def isoMk₃ {f g : 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₀ : 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)
    (w₂ : f.map' 2 3 ≫ app₃.hom = app₂.hom ≫ g.map' 2 3) : f ≅ g 
goal: (CategoryTheory.ComposableArrows.isoMk₃ app₀ app₁ app₂ app₃ w₀ w₁ w₂).hom =
  CategoryTheory.ComposableArrows.homMk₃ app₀.hom app₁.hom app₂.hom app₃.hom w₀ w₁ w₂

full_name: CategoryTheory.ComposableArrows.isoMk₃_inv
code: /-- Constructor for isomorphisms in `ComposableArrows C 3`. -/
@[simps]
def isoMk₃ {f g : 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₀ : 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)
    (w₂ : f.map' 2 3 ≫ app₃.hom = app₂.hom ≫ g.map' 2 3) : f ≅ g 
goal: (CategoryTheory.ComposableArrows.isoMk₃ app₀ app₁ app₂ app₃ w₀ w₁ w₂).inv =
  CategoryTheory.ComposableArrows.homMk₃ app₀.inv app₁.inv app₂.inv app₃.inv ⋯ ⋯ ⋯

full_name: CategoryTheory.ComposableArrows.isoMk₃
code: /-- Constructor for isomorphisms in `ComposableArrows C 3`. -/
@[simps]
def isoMk₃ {f g : 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₀ : 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)
    (w₂ : f.map' 2 3 ≫ app₃.hom = app₂.hom ≫ g.map' 2 3) : f ≅ g 
goal: f ≅ g

full_name: CategoryTheory.ComposableArrows.ext₃
code: lemma ext₃ {f g : ComposableArrows C 3}
    (h₀ : f.obj' 0 = g.obj' 0) (h₁ : f.obj' 1 = g.obj' 1) (h₂ : f.obj' 2 = g.obj' 2)
    (h₃ : f.obj' 3 = g.obj' 3)
    (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)
    (w₂ : f.map' 2 3 = eqToHom h₂ ≫ g.map' 2 3 ≫ eqToHom h₃.symm) : f = g 
goal: f = g

full_name: CategoryTheory.ComposableArrows.mk₃_surjective
code: lemma mk₃_surjective (X : ComposableArrows C 3) :
    ∃ (X₀ X₁ X₂ X₃ : C) (f₀ : X₀ ⟶ X₁) (f₁ : X₁ ⟶ X₂) (f₂ : X₂ ⟶ X₃), X = mk₃ f₀ f₁ f₂ 
goal: ∃ X₀ X₁ X₂ X₃ f₀ f₁ f₂, X = CategoryTheory.ComposableArrows.mk₃ f₀ f₁ f₂

full_name: CategoryTheory.ComposableArrows.homMk₄
code: /-- Constructor for morphisms in `ComposableArrows C 4`. -/
def homMk₄ : f ⟶ g 
goal: f ⟶ g

full_name: CategoryTheory.ComposableArrows.homMk₄_app_zero
code: @[simp]
lemma homMk₄_app_zero : (homMk₄ app₀ app₁ app₂ app₃ app₄ w₀ w₁ w₂ w₃).app 0 = app₀ 
goal: (CategoryTheory.ComposableArrows.homMk₄ app₀ app₁ app₂ app₃ app₄ w₀ w₁ w₂ w₃).app 0 = app₀

full_name: CategoryTheory.ComposableArrows.homMk₄_app_one
code: @[simp]
lemma homMk₄_app_one : (homMk₄ app₀ app₁ app₂ app₃ app₄ w₀ w₁ w₂ w₃).app 1 = app₁ 
goal: (CategoryTheory.ComposableArrows.homMk₄ app₀ app₁ app₂ app₃ app₄ w₀ w₁ w₂ w₃).app 1 = app₁

full_name: CategoryTheory.ComposableArrows.homMk₄_app_two
code: @[simp]
lemma homMk₄_app_two :
    (homMk₄ app₀ app₁ app₂ app₃ app₄ w₀ w₁ w₂ w₃).app ⟨2, by valid⟩ = app₂ 
goal: (CategoryTheory.ComposableArrows.homMk₄ app₀ app₁ app₂ app₃ app₄ w₀ w₁ w₂ w₃).app ⟨2, ⋯⟩ = app₂

full_name: CategoryTheory.ComposableArrows.homMk₄_app_three
code: @[simp]
lemma homMk₄_app_three :
    (homMk₄ app₀ app₁ app₂ app₃ app₄ w₀ w₁ w₂ w₃).app ⟨3, by valid⟩ = app₃ 
goal: (CategoryTheory.ComposableArrows.homMk₄ app₀ app₁ app₂ app₃ app₄ w₀ w₁ w₂ w₃).app ⟨3, ⋯⟩ = app₃

full_name: CategoryTheory.ComposableArrows.homMk₄_app_four
code: @[simp]
lemma homMk₄_app_four :
    (homMk₄ app₀ app₁ app₂ app₃ app₄ w₀ w₁ w₂ w₃).app ⟨4, by valid⟩ = app₄ 
goal: (CategoryTheory.ComposableArrows.homMk₄ app₀ app₁ app₂ app₃ app₄ w₀ w₁ w₂ w₃).app ⟨4, ⋯⟩ = app₄

full_name: CategoryTheory.ComposableArrows.hom_ext₄
code: @[ext]
lemma hom_ext₄ {f g : ComposableArrows C 4} {φ φ' : f ⟶ g}
    (h₀ : app' φ 0 = app' φ' 0) (h₁ : app' φ 1 = app' φ' 1) (h₂ : app' φ 2 = app' φ' 2)
    (h₃ : app' φ 3 = app' φ' 3) (h₄ : app' φ 4 = app' φ' 4) :
    φ = φ' 
goal: φ = φ'

full_name: CategoryTheory.ComposableArrows.map'_inv_eq_inv_map'
code: lemma map'_inv_eq_inv_map' {n m : ℕ} (h : n+1 ≤ m) {f g : ComposableArrows C m}
    (app : f.obj' n ≅ g.obj' n) (app' : f.obj' (n+1) ≅ g.obj' (n+1))
    (w : f.map' n (n+1) ≫ app'.hom = app.hom ≫ g.map' n (n+1)) :
    map' g n (n+1) ≫ app'.inv = app.inv ≫ map' f n (n+1) 
goal: CategoryTheory.CategoryStruct.comp (g.map' n (n + 1) ⋯ h) app'.inv =
  CategoryTheory.CategoryStruct.comp app.inv (f.map' n (n + 1) ⋯ h)

full_name: CategoryTheory.ComposableArrows.isoMk₄
code: /-- Constructor for isomorphisms in `ComposableArrows C 4`. -/
@[simps]
def isoMk₄ {f g : ComposableArrows C 4}
    (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) (app₄ : f.obj' 4 ≅ g.obj' 4)
    (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)
    (w₂ : f.map' 2 3 ≫ app₃.hom = app₂.hom ≫ g.map' 2 3)
    (w₃ : f.map' 3 4 ≫ app₄.hom = app₃.hom ≫ g.map' 3 4) :
    f ≅ g 
goal: f ≅ g

full_name: CategoryTheory.ComposableArrows.isoMk₄_hom
code: /-- Constructor for isomorphisms in `ComposableArrows C 4`. -/
@[simps]
def isoMk₄ {f g : ComposableArrows C 4}
    (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) (app₄ : f.obj' 4 ≅ g.obj' 4)
    (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)
    (w₂ : f.map' 2 3 ≫ app₃.hom = app₂.hom ≫ g.map' 2 3)
    (w₃ : f.map' 3 4 ≫ app₄.hom = app₃.hom ≫ g.map' 3 4) :
    f ≅ g 
goal: (CategoryTheory.ComposableArrows.isoMk₄ app₀ app₁ app₂ app₃ app₄ w₀ w₁ w₂ w₃).hom =
  CategoryTheory.ComposableArrows.homMk₄ app₀.hom app₁.hom app₂.hom app₃.hom app₄.hom w₀ w₁ w₂ w₃

full_name: CategoryTheory.ComposableArrows.isoMk₄_inv
code: /-- Constructor for isomorphisms in `ComposableArrows C 4`. -/
@[simps]
def isoMk₄ {f g : ComposableArrows C 4}
    (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) (app₄ : f.obj' 4 ≅ g.obj' 4)
    (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)
    (w₂ : f.map' 2 3 ≫ app₃.hom = app₂.hom ≫ g.map' 2 3)
    (w₃ : f.map' 3 4 ≫ app₄.hom = app₃.hom ≫ g.map' 3 4) :
    f ≅ g 
goal: (CategoryTheory.ComposableArrows.isoMk₄ app₀ app₁ app₂ app₃ app₄ w₀ w₁ w₂ w₃).inv =
  CategoryTheory.ComposableArrows.homMk₄ app₀.inv app₁.inv app₂.inv app₃.inv app₄.inv ⋯ ⋯ ⋯ ⋯

full_name: CategoryTheory.ComposableArrows.ext₄
code: lemma ext₄ {f g : ComposableArrows C 4}
    (h₀ : f.obj' 0 = g.obj' 0) (h₁ : f.obj' 1 = g.obj' 1) (h₂ : f.obj' 2 = g.obj' 2)
    (h₃ : f.obj' 3 = g.obj' 3) (h₄ : f.obj' 4 = g.obj' 4)
    (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)
    (w₂ : f.map' 2 3 = eqToHom h₂ ≫ g.map' 2 3 ≫ eqToHom h₃.symm)
    (w₃ : f.map' 3 4 = eqToHom h₃ ≫ g.map' 3 4 ≫ eqToHom h₄.symm) :
    f = g 
goal: f = g

full_name: CategoryTheory.ComposableArrows.mk₄_surjective
code: lemma mk₄_surjective (X : ComposableArrows C 4) :
    ∃ (X₀ X₁ X₂ X₃ X₄ : C) (f₀ : X₀ ⟶ X₁) (f₁ : X₁ ⟶ X₂) (f₂ : X₂ ⟶ X₃) (f₃ : X₃ ⟶ X₄),
      X = mk₄ f₀ f₁ f₂ f₃ 
goal: ∃ X₀ X₁ X₂ X₃ X₄ f₀ f₁ f₂ f₃, X = CategoryTheory.ComposableArrows.mk₄ f₀ f₁ f₂ f₃

full_name: CategoryTheory.ComposableArrows.homMk₅
code: /-- Constructor for morphisms in `ComposableArrows C 5`. -/
def homMk₅ : f ⟶ g 
goal: f ⟶ g

full_name: CategoryTheory.ComposableArrows.homMk₅_app_zero
code: @[simp]
lemma homMk₅_app_zero : (homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app 0 = app₀ 
goal: (CategoryTheory.ComposableArrows.homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app 0 = app₀

full_name: CategoryTheory.ComposableArrows.homMk₅_app_one
code: @[simp]
lemma homMk₅_app_one : (homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app 1 = app₁ 
goal: (CategoryTheory.ComposableArrows.homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app 1 = app₁

full_name: CategoryTheory.ComposableArrows.homMk₅_app_two
code: @[simp]
lemma homMk₅_app_two :
    (homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app ⟨2, by valid⟩ = app₂ 
goal: (CategoryTheory.ComposableArrows.homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app ⟨2, ⋯⟩ = app₂

full_name: CategoryTheory.ComposableArrows.homMk₅_app_three
code: @[simp]
lemma homMk₅_app_three :
    (homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app ⟨3, by valid⟩ = app₃ 
goal: (CategoryTheory.ComposableArrows.homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app ⟨3, ⋯⟩ = app₃

full_name: CategoryTheory.ComposableArrows.homMk₅_app_four
code: @[simp]
lemma homMk₅_app_four :
    (homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app ⟨4, by valid⟩ = app₄ 
goal: (CategoryTheory.ComposableArrows.homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app ⟨4, ⋯⟩ = app₄

full_name: CategoryTheory.ComposableArrows.homMk₅_app_five
code: @[simp]
lemma homMk₅_app_five :
    (homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app ⟨5, by valid⟩ = app₅ 
goal: (CategoryTheory.ComposableArrows.homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app ⟨5, ⋯⟩ = app₅

full_name: CategoryTheory.ComposableArrows.hom_ext₅
code: @[ext]
lemma hom_ext₅ {f g : ComposableArrows C 5} {φ φ' : f ⟶ g}
    (h₀ : app' φ 0 = app' φ' 0) (h₁ : app' φ 1 = app' φ' 1) (h₂ : app' φ 2 = app' φ' 2)
    (h₃ : app' φ 3 = app' φ' 3) (h₄ : app' φ 4 = app' φ' 4) (h₅ : app' φ 5 = app' φ' 5) :
    φ = φ' 
goal: φ = φ'

full_name: CategoryTheory.ComposableArrows.isoMk₅_inv
code: /-- Constructor for isomorphisms in `ComposableArrows C 5`. -/
@[simps]
def isoMk₅ {f g : ComposableArrows C 5}
    (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) (app₄ : f.obj' 4 ≅ g.obj' 4) (app₅ : f.obj' 5 ≅ g.obj' 5)
    (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)
    (w₂ : f.map' 2 3 ≫ app₃.hom = app₂.hom ≫ g.map' 2 3)
    (w₃ : f.map' 3 4 ≫ app₄.hom = app₃.hom ≫ g.map' 3 4)
    (w₄ : f.map' 4 5 ≫ app₅.hom = app₄.hom ≫ g.map' 4 5) :
    f ≅ g 
goal: (CategoryTheory.ComposableArrows.isoMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).inv =
  CategoryTheory.ComposableArrows.homMk₅ app₀.inv app₁.inv app₂.inv app₃.inv app₄.inv app₅.inv ⋯ ⋯ ⋯ ⋯ ⋯

full_name: CategoryTheory.ComposableArrows.isoMk₅_hom
code: /-- Constructor for isomorphisms in `ComposableArrows C 5`. -/
@[simps]
def isoMk₅ {f g : ComposableArrows C 5}
    (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) (app₄ : f.obj' 4 ≅ g.obj' 4) (app₅ : f.obj' 5 ≅ g.obj' 5)
    (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)
    (w₂ : f.map' 2 3 ≫ app₃.hom = app₂.hom ≫ g.map' 2 3)
    (w₃ : f.map' 3 4 ≫ app₄.hom = app₃.hom ≫ g.map' 3 4)
    (w₄ : f.map' 4 5 ≫ app₅.hom = app₄.hom ≫ g.map' 4 5) :
    f ≅ g 
goal: (CategoryTheory.ComposableArrows.isoMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).hom =
  CategoryTheory.ComposableArrows.homMk₅ app₀.hom app₁.hom app₂.hom app₃.hom app₄.hom app₅.hom w₀ w₁ w₂ w₃ w₄

full_name: CategoryTheory.ComposableArrows.isoMk₅
code: /-- Constructor for isomorphisms in `ComposableArrows C 5`. -/
@[simps]
def isoMk₅ {f g : ComposableArrows C 5}
    (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) (app₄ : f.obj' 4 ≅ g.obj' 4) (app₅ : f.obj' 5 ≅ g.obj' 5)
    (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)
    (w₂ : f.map' 2 3 ≫ app₃.hom = app₂.hom ≫ g.map' 2 3)
    (w₃ : f.map' 3 4 ≫ app₄.hom = app₃.hom ≫ g.map' 3 4)
    (w₄ : f.map' 4 5 ≫ app₅.hom = app₄.hom ≫ g.map' 4 5) :
    f ≅ g 
goal: f ≅ g

full_name: CategoryTheory.ComposableArrows.ext₅
code: lemma ext₅ {f g : ComposableArrows C 5}
    (h₀ : f.obj' 0 = g.obj' 0) (h₁ : f.obj' 1 = g.obj' 1) (h₂ : f.obj' 2 = g.obj' 2)
    (h₃ : f.obj' 3 = g.obj' 3) (h₄ : f.obj' 4 = g.obj' 4) (h₅ : f.obj' 5 = g.obj' 5)
    (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)
    (w₂ : f.map' 2 3 = eqToHom h₂ ≫ g.map' 2 3 ≫ eqToHom h₃.symm)
    (w₃ : f.map' 3 4 = eqToHom h₃ ≫ g.map' 3 4 ≫ eqToHom h₄.symm)
    (w₄ : f.map' 4 5 = eqToHom h₄ ≫ g.map' 4 5 ≫ eqToHom h₅.symm) :
    f = g 
goal: f = g

full_name: CategoryTheory.ComposableArrows.mk₅_surjective
code: lemma mk₅_surjective (X : ComposableArrows C 5) :
    ∃ (X₀ X₁ X₂ X₃ X₄ X₅ : C) (f₀ : X₀ ⟶ X₁) (f₁ : X₁ ⟶ X₂) (f₂ : X₂ ⟶ X₃)
      (f₃ : X₃ ⟶ X₄) (f₄ : X₄ ⟶ X₅), X = mk₅ f₀ f₁ f₂ f₃ f₄ 
goal: ∃ X₀ X₁ X₂ X₃ X₄ X₅ f₀ f₁ f₂ f₃ f₄, X = CategoryTheory.ComposableArrows.mk₅ f₀ f₁ f₂ f₃ f₄

full_name: CategoryTheory.ComposableArrows.arrow
code: /-- The `i`th arrow of `F : ComposableArrows C n`. -/
def arrow (i : ℕ) (hi : i < n := by valid) :
    ComposableArrows C 1 
goal: CategoryTheory.ComposableArrows C 1

full_name: CategoryTheory.ComposableArrows.mkOfObjOfMapSucc_exists
code: lemma mkOfObjOfMapSucc_exists : ∃ (F : ComposableArrows C n) (e : ∀ i, F.obj i ≅ obj i),
    ∀ (i : ℕ) (hi : i < n), mapSucc ⟨i, hi⟩ =
      (e ⟨i, _⟩).inv ≫ F.map' i (i + 1) ≫ (e ⟨i + 1, _⟩).hom 
goal: ∃ F e,
  ∀ (i : ℕ) (hi : i < n),
    mapSucc ⟨i, hi⟩ =
      CategoryTheory.CategoryStruct.comp (e ⟨i, ⋯⟩).inv
        (CategoryTheory.CategoryStruct.comp (F.map' i (i + 1) ⋯ hi) (e ⟨i + 1, ⋯⟩).hom)

full_name: CategoryTheory.ComposableArrows.mkOfObjOfMapSucc
code: /-- Given `obj : Fin (n + 1) → C` and `mapSucc i : obj i.castSucc ⟶ obj i.succ`
for all `i : Fin n`, this is `F : ComposableArrows C n` such that `F.obj i` is
definitionally equal to `obj i` and such that `F.map' i (i + 1) = mapSucc ⟨i, hi⟩`. -/
noncomputable def mkOfObjOfMapSucc : ComposableArrows C n 
goal: CategoryTheory.ComposableArrows C n

full_name: CategoryTheory.ComposableArrows.mkOfObjOfMapSucc_obj
code: @[simp]
lemma mkOfObjOfMapSucc_obj (i : Fin (n + 1)) :
    (mkOfObjOfMapSucc obj mapSucc).obj i = obj i 
goal: (CategoryTheory.ComposableArrows.mkOfObjOfMapSucc obj mapSucc).obj i = obj i

full_name: CategoryTheory.ComposableArrows.mkOfObjOfMapSucc_map_succ
code: lemma mkOfObjOfMapSucc_map_succ (i : ℕ) (hi : i < n := by valid) :
    (mkOfObjOfMapSucc obj mapSucc).map' i (i + 1) = mapSucc ⟨i, hi⟩ 
goal: (CategoryTheory.ComposableArrows.mkOfObjOfMapSucc obj mapSucc).map' i (i + 1) ⋯ hi = mapSucc ⟨i, hi⟩

full_name: CategoryTheory.ComposableArrows.mkOfObjOfMapSucc_arrow
code: lemma mkOfObjOfMapSucc_arrow (i : ℕ) (hi : i < n := by valid) :
    (mkOfObjOfMapSucc obj mapSucc).arrow i = mk₁ (mapSucc ⟨i, hi⟩) 
goal: (CategoryTheory.ComposableArrows.mkOfObjOfMapSucc obj mapSucc).arrow i hi =
  CategoryTheory.ComposableArrows.mk₁ (mapSucc ⟨i, hi⟩)

full_name: CategoryTheory.ComposableArrows.opEquivalence_functor_obj_obj
code: /-- The equivalence `(ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n` obtained
by reversing the arrows. -/
@[simps!]
def opEquivalence : (ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n 
goal: ∀ (X_1 : Fin (n + 1)),
  ((CategoryTheory.ComposableArrows.opEquivalence C n).functor.obj X).obj X_1 =
    Opposite.op ((Opposite.unop X).obj X_1.rev)

full_name: CategoryTheory.ComposableArrows.opEquivalence
code: /-- The equivalence `(ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n` obtained
by reversing the arrows. -/
@[simps!]
def opEquivalence : (ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n 
goal: (CategoryTheory.ComposableArrows C n)ᵒᵖ ≌ CategoryTheory.ComposableArrows Cᵒᵖ n

full_name: CategoryTheory.ComposableArrows.opEquivalence_inverse_map
code: /-- The equivalence `(ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n` obtained
by reversing the arrows. -/
@[simps!]
def opEquivalence : (ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n 
goal: ∀ {X Y : CategoryTheory.ComposableArrows Cᵒᵖ n} (f : X ⟶ Y),
  (CategoryTheory.ComposableArrows.opEquivalence C n).inverse.map f =
    (CategoryTheory.whiskerLeft (⋯.functor.comp (CategoryTheory.orderDualEquivalence (Fin (n + 1))).functor)
        (CategoryTheory.NatTrans.leftOp f)).op

full_name: CategoryTheory.ComposableArrows.opEquivalence_unitIso_inv_app
code: /-- The equivalence `(ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n` obtained
by reversing the arrows. -/
@[simps!]
def opEquivalence : (ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n 
goal: (CategoryTheory.ComposableArrows.opEquivalence C n).unitIso.inv.app X =
  CategoryTheory.CategoryStruct.comp
    (CategoryTheory.whiskerLeft (⋯.functor.comp (CategoryTheory.orderDualEquivalence (Fin (n + 1))).functor)
        (((CategoryTheory.orderDualEquivalence (Fin (n + 1))).inverse.comp ⋯.functor).comp
              (Opposite.unop X)).rightOpLeftOpIso.inv).op
    ((CategoryTheory.Equivalence.adjointifyη
              (CategoryTheory.NatIso.ofComponents
                (fun F =>
                  (((CategoryTheory.orderDualEquivalence (Fin (n + 1))).symm.trans
                            Fin.revOrderIso.equivalence).symm.funInvIdAssoc
                      F).symm)
                ⋯)
              (CategoryTheory.NatIso.ofComponents
                (fun F =>
                  ((CategoryTheory.orderDualEquivalence (Fin (n + 1))).symm.trans
                          Fin.revOrderIso.equivalence).symm.invFunIdAssoc
                    F)
                ⋯)).hom.app
        (Opposite.unop X)).op

full_name: CategoryTheory.ComposableArrows.opEquivalence_functor_obj_map
code: /-- The equivalence `(ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n` obtained
by reversing the arrows. -/
@[simps!]
def opEquivalence : (ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n 
goal: ∀ {X_1 Y : Fin (n + 1)} (f : X_1 ⟶ Y),
  ((CategoryTheory.ComposableArrows.opEquivalence C n).functor.obj X).map f =
    ((Opposite.unop X).map (⋯.functor.map (CategoryTheory.homOfLE ⋯))).op

full_name: CategoryTheory.ComposableArrows.opEquivalence_inverse_obj
code: /-- The equivalence `(ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n` obtained
by reversing the arrows. -/
@[simps!]
def opEquivalence : (ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n 
goal: (CategoryTheory.ComposableArrows.opEquivalence C n).inverse.obj X =
  Opposite.op
    ((⋯.functor.comp (CategoryTheory.orderDualEquivalence (Fin (n + 1))).functor).comp
      (CategoryTheory.Functor.leftOp X))

full_name: CategoryTheory.ComposableArrows.opEquivalence_counitIso_hom_app_app
code: /-- The equivalence `(ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n` obtained
by reversing the arrows. -/
@[simps!]
def opEquivalence : (ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n 
goal: ∀ (X_1 : Fin (n + 1)),
  ((CategoryTheory.ComposableArrows.opEquivalence C n).counitIso.hom.app X).app X_1 =
    X.map
      (((CategoryTheory.orderDualEquivalence (Fin (n + 1))).symm.trans Fin.revOrderIso.equivalence).symm.counitInv.app
          (Opposite.op X_1)).unop

full_name: CategoryTheory.ComposableArrows.opEquivalence_unitIso_hom_app
code: /-- The equivalence `(ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n` obtained
by reversing the arrows. -/
@[simps!]
def opEquivalence : (ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n 
goal: (CategoryTheory.ComposableArrows.opEquivalence C n).unitIso.hom.app X =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.Equivalence.adjointifyη
              (CategoryTheory.NatIso.ofComponents
                (fun F =>
                  (((CategoryTheory.orderDualEquivalence (Fin (n + 1))).symm.trans
                            Fin.revOrderIso.equivalence).symm.funInvIdAssoc
                      F).symm)
                ⋯)
              (CategoryTheory.NatIso.ofComponents
                (fun F =>
                  ((CategoryTheory.orderDualEquivalence (Fin (n + 1))).symm.trans
                          Fin.revOrderIso.equivalence).symm.invFunIdAssoc
                    F)
                ⋯)).inv.app
        (Opposite.unop X)).op
    (CategoryTheory.whiskerLeft (⋯.functor.comp (CategoryTheory.orderDualEquivalence (Fin (n + 1))).functor)
        (((CategoryTheory.orderDualEquivalence (Fin (n + 1))).inverse.comp ⋯.functor).comp
              (Opposite.unop X)).rightOpLeftOpIso.hom).op

full_name: CategoryTheory.ComposableArrows.opEquivalence_functor_map_app
code: /-- The equivalence `(ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n` obtained
by reversing the arrows. -/
@[simps!]
def opEquivalence : (ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n 
goal: ∀ {X Y : (CategoryTheory.Functor (Fin (n + 1)) C)ᵒᵖ} (f : X ⟶ Y) (X_1 : Fin (n + 1)),
  ((CategoryTheory.ComposableArrows.opEquivalence C n).functor.map f).app X_1 = (f.unop.app X_1.rev).op

full_name: CategoryTheory.ComposableArrows.opEquivalence_counitIso_inv_app_app
code: /-- The equivalence `(ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n` obtained
by reversing the arrows. -/
@[simps!]
def opEquivalence : (ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n 
goal: ∀ (X_1 : Fin (n + 1)),
  ((CategoryTheory.ComposableArrows.opEquivalence C n).counitIso.inv.app X).app X_1 =
    X.map
      (((CategoryTheory.orderDualEquivalence (Fin (n + 1))).symm.trans Fin.revOrderIso.equivalence).symm.counit.app
          (Opposite.op X_1)).unop

full_name: CategoryTheory.Functor.mapComposableArrows_map_app
code: /-- The functor `ComposableArrows C n ⥤ ComposableArrows D n` obtained by postcomposition
with a functor `C ⥤ D`. -/
@[simps!]
def Functor.mapComposableArrows :
    ComposableArrows C n ⥤ ComposableArrows D n 
goal: ∀ {X Y : CategoryTheory.Functor (Fin (n + 1)) C} (α : X ⟶ Y) (X_1 : Fin (n + 1)),
  ((G.mapComposableArrows n).map α).app X_1 = G.map (α.app X_1)

full_name: CategoryTheory.Functor.mapComposableArrows_obj_map
code: /-- The functor `ComposableArrows C n ⥤ ComposableArrows D n` obtained by postcomposition
with a functor `C ⥤ D`. -/
@[simps!]
def Functor.mapComposableArrows :
    ComposableArrows C n ⥤ ComposableArrows D n 
goal: ∀ {X Y : Fin (n + 1)} (f : X ⟶ Y), ((G.mapComposableArrows n).obj F).map f = G.map (F.map f)

full_name: CategoryTheory.Functor.mapComposableArrows_obj_obj
code: /-- The functor `ComposableArrows C n ⥤ ComposableArrows D n` obtained by postcomposition
with a functor `C ⥤ D`. -/
@[simps!]
def Functor.mapComposableArrows :
    ComposableArrows C n ⥤ ComposableArrows D n 
goal: ((G.mapComposableArrows n).obj F).obj X = G.obj (F.obj X)

full_name: CategoryTheory.Functor.mapComposableArrows
code: /-- The functor `ComposableArrows C n ⥤ ComposableArrows D n` obtained by postcomposition
with a functor `C ⥤ D`. -/
@[simps!]
def Functor.mapComposableArrows :
    ComposableArrows C n ⥤ ComposableArrows D n 
goal: CategoryTheory.Functor (CategoryTheory.ComposableArrows C n) (CategoryTheory.ComposableArrows D n)

full_name: CategoryTheory.Functor.mapComposableArrowsOpIso
code: /-- The functor `ComposableArrows C n ⥤ ComposableArrows D n` induced by `G : C ⥤ D`
commutes with `opEquivalence`. -/
def Functor.mapComposableArrowsOpIso :
    G.mapComposableArrows n ⋙ (opEquivalence D n).functor.rightOp ≅
      (opEquivalence C n).functor.rightOp ⋙ (G.op.mapComposableArrows n).op 
goal: (G.mapComposableArrows n).comp (CategoryTheory.ComposableArrows.opEquivalence D n).functor.rightOp ≅
  (CategoryTheory.ComposableArrows.opEquivalence C n).functor.rightOp.comp (G.op.mapComposableArrows n).op