ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.leftAdjointMate_comp
theorem leftAdjointMate_comp {X Y Z : C} [HasLeftDual X] [HasLeftDual Y] {f : X ⟶ Y}
    {g : (ᘁX) ⟶ Z} :
    (ᘁf) ≫ g =
      (λ_ _).inv ≫
        η_ (ᘁX) X ▷ _ ≫ (g ⊗ f) ▷ _ ≫ (α_ _ _ _).hom ≫ _ ◁ ε_ _ _ ≫ (ρ_ _).hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X Y Z : C} [CategoryTheory.HasLeftDual X] [CategoryTheory.HasLeftDual Y] {f : X ⟶ Y} {g : ᘁX ⟶ Z}
Goal: (ᘁf) ≫ g = (λ_ ᘁY).inv ≫ η_ (ᘁX) X ▷ ᘁY ≫ (g ⊗ f) ▷ ᘁY ≫ (α_ Z Y ᘁY).hom ≫ Z ◁ ε_ (ᘁY) Y ≫ (ρ_ Z).hom
-- CategoryTheory.comp_rightAdjointMate
@[reassoc]
theorem comp_rightAdjointMate {X Y Z : C} [HasRightDual X] [HasRightDual Y] [HasRightDual Z]
    {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g)ᘁ = gᘁ ≫ fᘁ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X Y Z : C} [CategoryTheory.HasRightDual X] [CategoryTheory.HasRightDual Y] [CategoryTheory.HasRightDual Z] {f : X ⟶ Y} {g : Y ⟶ Z}
Goal: (f ≫ g)ᘁ = gᘁ ≫ fᘁ
-- CategoryTheory.comp_leftAdjointMate
@[reassoc]
theorem comp_leftAdjointMate {X Y Z : C} [HasLeftDual X] [HasLeftDual Y] [HasLeftDual Z] {f : X ⟶ Y}
    {g : Y ⟶ Z} : (ᘁf ≫ g) = (ᘁg) ≫ ᘁf 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X Y Z : C} [CategoryTheory.HasLeftDual X] [CategoryTheory.HasLeftDual Y] [CategoryTheory.HasLeftDual Z] {f : X ⟶ Y} {g : Y ⟶ Z}
Goal: (ᘁf ≫ g) = (ᘁg) ≫ ᘁf
-- CategoryTheory.tensorLeftHomEquiv_naturality
theorem tensorLeftHomEquiv_naturality {X Y Y' Z Z' : C} [ExactPairing Y Y'] (f : Y' ⊗ X ⟶ Z)
    (g : Z ⟶ Z') :
    (tensorLeftHomEquiv X Y Y' Z') (f ≫ g) = (tensorLeftHomEquiv X Y Y' Z) f ≫ Y ◁ g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X Y Y' Z Z' : C} [CategoryTheory.ExactPairing Y Y'] (f : Y' ⊗ X ⟶ Z) (g : Z ⟶ Z')
Goal: (CategoryTheory.tensorLeftHomEquiv X Y Y' Z') (f ≫ g) = (CategoryTheory.tensorLeftHomEquiv X Y Y' Z) f ≫ Y ◁ g
-- CategoryTheory.tensorLeftHomEquiv_symm_naturality
theorem tensorLeftHomEquiv_symm_naturality {X X' Y Y' Z : C} [ExactPairing Y Y'] (f : X ⟶ X')
    (g : X' ⟶ Y ⊗ Z) :
    (tensorLeftHomEquiv X Y Y' Z).symm (f ≫ g) =
      _ ◁ f ≫ (tensorLeftHomEquiv X' Y Y' Z).symm g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X X' Y Y' Z : C} [CategoryTheory.ExactPairing Y Y'] (f : X ⟶ X') (g : X' ⟶ Y ⊗ Z)
Goal: (CategoryTheory.tensorLeftHomEquiv X Y Y' Z).symm (f ≫ g) =
  Y' ◁ f ≫ (CategoryTheory.tensorLeftHomEquiv X' Y Y' Z).symm g
-- CategoryTheory.tensorRightHomEquiv_naturality
theorem tensorRightHomEquiv_naturality {X Y Y' Z Z' : C} [ExactPairing Y Y'] (f : X ⊗ Y ⟶ Z)
    (g : Z ⟶ Z') :
    (tensorRightHomEquiv X Y Y' Z') (f ≫ g) = (tensorRightHomEquiv X Y Y' Z) f ≫ g ▷ Y' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X Y Y' Z Z' : C} [CategoryTheory.ExactPairing Y Y'] (f : X ⊗ Y ⟶ Z) (g : Z ⟶ Z')
Goal: (CategoryTheory.tensorRightHomEquiv X Y Y' Z') (f ≫ g) = (CategoryTheory.tensorRightHomEquiv X Y Y' Z) f ≫ g ▷ Y'
-- CategoryTheory.tensorRightHomEquiv_symm_naturality
theorem tensorRightHomEquiv_symm_naturality {X X' Y Y' Z : C} [ExactPairing Y Y'] (f : X ⟶ X')
    (g : X' ⟶ Z ⊗ Y') :
    (tensorRightHomEquiv X Y Y' Z).symm (f ≫ g) =
      f ▷ Y ≫ (tensorRightHomEquiv X' Y Y' Z).symm g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X X' Y Y' Z : C} [CategoryTheory.ExactPairing Y Y'] (f : X ⟶ X') (g : X' ⟶ Z ⊗ Y')
Goal: (CategoryTheory.tensorRightHomEquiv X Y Y' Z).symm (f ≫ g) =
  f ▷ Y ≫ (CategoryTheory.tensorRightHomEquiv X' Y Y' Z).symm g
-- CategoryTheory.tensorLeftHomEquiv_tensor
theorem tensorLeftHomEquiv_tensor {X X' Y Y' Z Z' : C} [ExactPairing Y Y'] (f : X ⟶ Y ⊗ Z)
    (g : X' ⟶ Z') :
    (tensorLeftHomEquiv (X ⊗ X') Y Y' (Z ⊗ Z')).symm ((f ⊗ g) ≫ (α_ _ _ _).hom) =
      (α_ _ _ _).inv ≫ ((tensorLeftHomEquiv X Y Y' Z).symm f ⊗ g) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X X' Y Y' Z Z' : C} [CategoryTheory.ExactPairing Y Y'] (f : X ⟶ Y ⊗ Z) (g : X' ⟶ Z')
Goal: (CategoryTheory.tensorLeftHomEquiv (X ⊗ X') Y Y' (Z ⊗ Z')).symm ((f ⊗ g) ≫ (α_ Y Z Z').hom) =
  (α_ Y' X X').inv ≫ ((CategoryTheory.tensorLeftHomEquiv X Y Y' Z).symm f ⊗ g)
-- CategoryTheory.tensorRightHomEquiv_tensor
theorem tensorRightHomEquiv_tensor {X X' Y Y' Z Z' : C} [ExactPairing Y Y'] (f : X ⟶ Z ⊗ Y')
    (g : X' ⟶ Z') :
    (tensorRightHomEquiv (X' ⊗ X) Y Y' (Z' ⊗ Z)).symm ((g ⊗ f) ≫ (α_ _ _ _).inv) =
      (α_ _ _ _).hom ≫ (g ⊗ (tensorRightHomEquiv X Y Y' Z).symm f) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X X' Y Y' Z Z' : C} [CategoryTheory.ExactPairing Y Y'] (f : X ⟶ Z ⊗ Y') (g : X' ⟶ Z')
Goal: (CategoryTheory.tensorRightHomEquiv (X' ⊗ X) Y Y' (Z' ⊗ Z)).symm ((g ⊗ f) ≫ (α_ Z' Z Y').inv) =
  (α_ X' X Y).hom ≫ (g ⊗ (CategoryTheory.tensorRightHomEquiv X Y Y' Z).symm f)
-- CategoryTheory.tensorLeftHomEquiv_symm_coevaluation_comp_whiskerLeft
@[simp]
theorem tensorLeftHomEquiv_symm_coevaluation_comp_whiskerLeft {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y' ⟶ Z) : (tensorLeftHomEquiv _ _ _ _).symm (η_ _ _ ≫ Y ◁ f) = (ρ_ _).hom ≫ f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {Y Y' Z : C} [CategoryTheory.ExactPairing Y Y'] (f : Y' ⟶ Z)
Goal: (CategoryTheory.tensorLeftHomEquiv (𝟙_ C) Y Y' Z).symm (η_ Y Y' ≫ Y ◁ f) = (ρ_ Y').hom ≫ f
-- CategoryTheory.tensorLeftHomEquiv_symm_coevaluation_comp_whiskerRight
@[simp]
theorem tensorLeftHomEquiv_symm_coevaluation_comp_whiskerRight {X Y : C} [HasRightDual X]
    [HasRightDual Y] (f : X ⟶ Y) :
    (tensorLeftHomEquiv _ _ _ _).symm (η_ _ _ ≫ f ▷ (Xᘁ)) = (ρ_ _).hom ≫ fᘁ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X Y : C} [CategoryTheory.HasRightDual X] [CategoryTheory.HasRightDual Y] (f : X ⟶ Y)
Goal: (CategoryTheory.tensorLeftHomEquiv (𝟙_ C) Y Yᘁ Xᘁ).symm (η_ X Xᘁ ≫ f ▷ Xᘁ) = (ρ_ Yᘁ).hom ≫ fᘁ
-- CategoryTheory.tensorRightHomEquiv_symm_coevaluation_comp_whiskerLeft
@[simp]
theorem tensorRightHomEquiv_symm_coevaluation_comp_whiskerLeft {X Y : C} [HasLeftDual X]
    [HasLeftDual Y] (f : X ⟶ Y) :
    (tensorRightHomEquiv _ (ᘁY) _ _).symm (η_ (ᘁX) X ≫ (ᘁX) ◁ f) = (λ_ _).hom ≫ ᘁf 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X Y : C} [CategoryTheory.HasLeftDual X] [CategoryTheory.HasLeftDual Y] (f : X ⟶ Y)
Goal: (CategoryTheory.tensorRightHomEquiv (𝟙_ C) (ᘁY) Y ᘁX).symm (η_ (ᘁX) X ≫ ᘁX ◁ f) = (λ_ ᘁY).hom ≫ ᘁf
-- CategoryTheory.tensorRightHomEquiv_symm_coevaluation_comp_whiskerRight
@[simp]
theorem tensorRightHomEquiv_symm_coevaluation_comp_whiskerRight {Y Y' Z : C} [ExactPairing Y Y']
    (f : Y ⟶ Z) : (tensorRightHomEquiv _ Y _ _).symm (η_ Y Y' ≫ f ▷ Y') = (λ_ _).hom ≫ f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {Y Y' Z : C} [CategoryTheory.ExactPairing Y Y'] (f : Y ⟶ Z)
Goal: (CategoryTheory.tensorRightHomEquiv (𝟙_ C) Y Y' Z).symm (η_ Y Y' ≫ f ▷ Y') = (λ_ Y).hom ≫ f
-- CategoryTheory.tensorLeftHomEquiv_whiskerLeft_comp_evaluation
@[simp]
theorem tensorLeftHomEquiv_whiskerLeft_comp_evaluation {Y Z : C} [HasLeftDual Z] (f : Y ⟶ ᘁZ) :
    (tensorLeftHomEquiv _ _ _ _) (Z ◁ f ≫ ε_ _ _) = f ≫ (ρ_ _).inv 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {Y Z : C} [CategoryTheory.HasLeftDual Z] (f : Y ⟶ ᘁZ)
Goal: (CategoryTheory.tensorLeftHomEquiv Y (ᘁZ) Z (𝟙_ C)) (Z ◁ f ≫ ε_ (ᘁZ) Z) = f ≫ (ρ_ ᘁZ).inv
-- CategoryTheory.tensorLeftHomEquiv_whiskerRight_comp_evaluation
@[simp]
theorem tensorLeftHomEquiv_whiskerRight_comp_evaluation {X Y : C} [HasLeftDual X] [HasLeftDual Y]
    (f : X ⟶ Y) : (tensorLeftHomEquiv _ _ _ _) (f ▷ _ ≫ ε_ _ _) = (ᘁf) ≫ (ρ_ _).inv 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X Y : C} [CategoryTheory.HasLeftDual X] [CategoryTheory.HasLeftDual Y] (f : X ⟶ Y)
Goal: (CategoryTheory.tensorLeftHomEquiv (ᘁY) (ᘁX) X (𝟙_ C)) (f ▷ ᘁY ≫ ε_ (ᘁY) Y) = (ᘁf) ≫ (ρ_ ᘁX).inv
-- CategoryTheory.tensorRightHomEquiv_whiskerLeft_comp_evaluation
@[simp]
theorem tensorRightHomEquiv_whiskerLeft_comp_evaluation {X Y : C} [HasRightDual X] [HasRightDual Y]
    (f : X ⟶ Y) : (tensorRightHomEquiv _ _ _ _) ((Yᘁ) ◁ f ≫ ε_ _ _) = fᘁ ≫ (λ_ _).inv 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X Y : C} [CategoryTheory.HasRightDual X] [CategoryTheory.HasRightDual Y] (f : X ⟶ Y)
Goal: (CategoryTheory.tensorRightHomEquiv Yᘁ X Xᘁ (𝟙_ C)) (Yᘁ ◁ f ≫ ε_ Y Yᘁ) = fᘁ ≫ (λ_ Xᘁ).inv
-- CategoryTheory.tensorRightHomEquiv_whiskerRight_comp_evaluation
@[simp]
theorem tensorRightHomEquiv_whiskerRight_comp_evaluation {X Y : C} [HasRightDual X] (f : Y ⟶ Xᘁ) :
    (tensorRightHomEquiv _ _ _ _) (f ▷ X ≫ ε_ X (Xᘁ)) = f ≫ (λ_ _).inv 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X Y : C} [CategoryTheory.HasRightDual X] (f : Y ⟶ Xᘁ)
Goal: (CategoryTheory.tensorRightHomEquiv Y X Xᘁ (𝟙_ C)) (f ▷ X ≫ ε_ X Xᘁ) = f ≫ (λ_ Xᘁ).inv
-- CategoryTheory.coevaluation_comp_rightAdjointMate
@[reassoc]
theorem coevaluation_comp_rightAdjointMate {X Y : C} [HasRightDual X] [HasRightDual Y] (f : X ⟶ Y) :
    η_ Y (Yᘁ) ≫ _ ◁ (fᘁ) = η_ _ _ ≫ f ▷ _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X Y : C} [CategoryTheory.HasRightDual X] [CategoryTheory.HasRightDual Y] (f : X ⟶ Y)
Goal: η_ Y Yᘁ ≫ Y ◁ fᘁ = η_ X Xᘁ ≫ f ▷ Xᘁ
-- CategoryTheory.leftAdjointMate_comp_evaluation
@[reassoc]
theorem leftAdjointMate_comp_evaluation {X Y : C} [HasLeftDual X] [HasLeftDual Y] (f : X ⟶ Y) :
    X ◁ (ᘁf) ≫ ε_ _ _ = f ▷ _ ≫ ε_ _ _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X Y : C} [CategoryTheory.HasLeftDual X] [CategoryTheory.HasLeftDual Y] (f : X ⟶ Y)
Goal: (X ◁ ᘁf) ≫ ε_ (ᘁX) X = f ▷ ᘁY ≫ ε_ (ᘁY) Y
-- CategoryTheory.coevaluation_comp_leftAdjointMate
@[reassoc]
theorem coevaluation_comp_leftAdjointMate {X Y : C} [HasLeftDual X] [HasLeftDual Y] (f : X ⟶ Y) :
    η_ (ᘁY) Y ≫ (ᘁf) ▷ Y = η_ (ᘁX) X ≫ (ᘁX) ◁ f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X Y : C} [CategoryTheory.HasLeftDual X] [CategoryTheory.HasLeftDual Y] (f : X ⟶ Y)
Goal: η_ (ᘁY) Y ≫ (ᘁf) ▷ Y = η_ (ᘁX) X ≫ ᘁX ◁ f
-- CategoryTheory.rightAdjointMate_comp_evaluation
@[reassoc]
theorem rightAdjointMate_comp_evaluation {X Y : C} [HasRightDual X] [HasRightDual Y] (f : X ⟶ Y) :
    (fᘁ ▷ X) ≫ ε_ X (Xᘁ) = ((Yᘁ) ◁ f) ≫ ε_ Y (Yᘁ) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X Y : C} [CategoryTheory.HasRightDual X] [CategoryTheory.HasRightDual Y] (f : X ⟶ Y)
Goal: fᘁ ▷ X ≫ ε_ X Xᘁ = Yᘁ ◁ f ≫ ε_ Y Yᘁ
-- CategoryTheory.rightDualIso_id
@[simp]
theorem rightDualIso_id {X Y : C} (p : ExactPairing X Y) : rightDualIso p p = Iso.refl Y 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X Y : C} (p : CategoryTheory.ExactPairing X Y)
Goal: CategoryTheory.rightDualIso p p = CategoryTheory.Iso.refl Y
-- CategoryTheory.leftDualIso_id
@[simp]
theorem leftDualIso_id {X Y : C} (p : ExactPairing X Y) : leftDualIso p p = Iso.refl X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X Y : C} (p : CategoryTheory.ExactPairing X Y)
Goal: CategoryTheory.leftDualIso p p = CategoryTheory.Iso.refl X
-- CategoryTheory.ComposableArrows.map'_self
lemma map'_self (i : ℕ) (hi : i ≤ n := by valid) :
    F.map' i i = 𝟙 _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) (i : ℕ) (hi : i ≤ n := by valid)
Goal: F.map' i i ⋯ hi = CategoryTheory.CategoryStruct.id (F.obj ⟨i, ⋯⟩)
-- CategoryTheory.ComposableArrows.map'_comp
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 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) (i j k : ℕ) (hij : i ≤ j := by valid) (hjk : j ≤ k := by valid) (hk : k ≤ n := by valid)
Goal: F.map' i k ⋯ hk = CategoryTheory.CategoryStruct.comp (F.map' i j hij ⋯) (F.map' j k hjk hk)
-- CategoryTheory.ComposableArrows.naturality'
@[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 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C n} (φ : F ⟶ G) (i j : ℕ) (hij : i ≤ j := by valid) (hj : j ≤ n := by valid)
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)
-- CategoryTheory.ComposableArrows.mk₀_map
@[simps!]
def mk₀ (X : C) : ComposableArrows C 0 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (X : C)
Goal: ∀ {X_1 Y : Fin 1} (x : X_1 ⟶ Y), (CategoryTheory.ComposableArrows.mk₀ X).map x = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.ComposableArrows.mk₀_obj
@[simps!]
def mk₀ (X : C) : ComposableArrows C 0 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (X : C)
Goal: ∀ (x : Fin 1), (CategoryTheory.ComposableArrows.mk₀ X).obj x = X
-- CategoryTheory.ComposableArrows.Mk₁.map_id
lemma map_id (i : Fin 2) : map f i i (by simp) = 𝟙 _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X₀ X₁ : C} (f : X₀ ⟶ X₁) (i : Fin 2)
Goal: CategoryTheory.ComposableArrows.Mk₁.map f i i ⋯ =
  CategoryTheory.CategoryStruct.id (CategoryTheory.ComposableArrows.Mk₁.obj X₀ X₁ i)
-- CategoryTheory.ComposableArrows.Mk₁.map_comp
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 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X₀ X₁ : C} (f : X₀ ⟶ X₁) {i j k : Fin 2} (hij : i ≤ j) (hjk : j ≤ k)
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)
-- CategoryTheory.ComposableArrows.mk₁_map
@[simps]
def mk₁ {X₀ X₁ : C} (f : X₀ ⟶ X₁) : ComposableArrows C 1 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X₀ X₁ : C} (f : X₀ ⟶ X₁)
Goal: ∀ {X Y : Fin (1 + 1)} (g : X ⟶ Y),
  (CategoryTheory.ComposableArrows.mk₁ f).map g = CategoryTheory.ComposableArrows.Mk₁.map f X Y ⋯
-- CategoryTheory.ComposableArrows.mk₁_obj
@[simps]
def mk₁ {X₀ X₁ : C} (f : X₀ ⟶ X₁) : ComposableArrows C 1 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X₀ X₁ : C} (f : X₀ ⟶ X₁)
Goal: ∀ (a : Fin 2), (CategoryTheory.ComposableArrows.mk₁ f).obj a = CategoryTheory.ComposableArrows.Mk₁.obj X₀ X₁ a
-- CategoryTheory.ComposableArrows.homMk_app
@[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 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C n} (app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i) (w :
  ∀ (i : ℕ) (hi : i < n),
    CategoryTheory.CategoryStruct.comp (F.map' i (i + 1) ⋯ hi) (app ⟨i + 1, ⋯⟩) =
      CategoryTheory.CategoryStruct.comp (app ⟨i, ⋯⟩) (G.map' i (i + 1) ⋯ hi)) (i : Fin (n + 1))
Goal: (CategoryTheory.ComposableArrows.homMk app w).app i = app i
-- CategoryTheory.ComposableArrows.isoMk_hom
@[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 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C n} (app : (i : Fin (n + 1)) → F.obj i ≅ G.obj i) (w :
  ∀ (i : ℕ) (hi : i < n),
    CategoryTheory.CategoryStruct.comp (F.map' i (i + 1) ⋯ hi) (app ⟨i + 1, ⋯⟩).hom =
      CategoryTheory.CategoryStruct.comp (app ⟨i, ⋯⟩).hom (G.map' i (i + 1) ⋯ hi))
Goal: (CategoryTheory.ComposableArrows.isoMk app w).hom = CategoryTheory.ComposableArrows.homMk (fun i => (app i).hom) w
-- CategoryTheory.ComposableArrows.isoMk_inv
@[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 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C n} (app : (i : Fin (n + 1)) → F.obj i ≅ G.obj i) (w :
  ∀ (i : ℕ) (hi : i < n),
    CategoryTheory.CategoryStruct.comp (F.map' i (i + 1) ⋯ hi) (app ⟨i + 1, ⋯⟩).hom =
      CategoryTheory.CategoryStruct.comp (app ⟨i, ⋯⟩).hom (G.map' i (i + 1) ⋯ hi))
Goal: (CategoryTheory.ComposableArrows.isoMk app w).inv = CategoryTheory.ComposableArrows.homMk (fun i => (app i).inv) ⋯
-- CategoryTheory.ComposableArrows.ext
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 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C n} (h : ∀ (i : Fin (n + 1)), F.obj i = G.obj i) (w :
  ∀ (i : ℕ) (hi : i < n),
    F.map' i (i + 1) ⋯ hi =
      CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
        (CategoryTheory.CategoryStruct.comp (G.map' i (i + 1) ⋯ hi) (CategoryTheory.eqToHom ⋯)))
Goal: F = G
-- CategoryTheory.ComposableArrows.homMk₀_app
@[simps!]
def homMk₀ {F G : ComposableArrows C 0} (f : F.obj' 0 ⟶ G.obj' 0) : F ⟶ G 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {F G : CategoryTheory.ComposableArrows C 0} (f : F.obj' 0 ⋯ ⟶ G.obj' 0 ⋯) (i : Fin (0 + 1))
Goal: (CategoryTheory.ComposableArrows.homMk₀ f).app i =
  match i with
  | ⟨0, isLt⟩ => f
-- CategoryTheory.ComposableArrows.hom_ext₀
@[ext]
lemma hom_ext₀ {F G : ComposableArrows C 0} {φ φ' : F ⟶ G}
    (h : app' φ 0 = app' φ' 0) :
    φ = φ' 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {F G : CategoryTheory.ComposableArrows C 0} {φ φ' : F ⟶ G} (h : CategoryTheory.ComposableArrows.app' φ 0 ⋯ = CategoryTheory.ComposableArrows.app' φ' 0 ⋯)
Goal: φ = φ'
-- CategoryTheory.ComposableArrows.isoMk₀_hom_app
@[simps!]
def isoMk₀ {F G : ComposableArrows C 0} (e : F.obj' 0 ≅ G.obj' 0) : F ≅ G 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {F G : CategoryTheory.ComposableArrows C 0} (e : F.obj' 0 ⋯ ≅ G.obj' 0 ⋯) (i : Fin (0 + 1))
Goal: (CategoryTheory.ComposableArrows.isoMk₀ e).hom.app i =
  match i with
  | ⟨0, isLt⟩ => e.hom
-- CategoryTheory.ComposableArrows.isoMk₀_inv_app
@[simps!]
def isoMk₀ {F G : ComposableArrows C 0} (e : F.obj' 0 ≅ G.obj' 0) : F ≅ G 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {F G : CategoryTheory.ComposableArrows C 0} (e : F.obj' 0 ⋯ ≅ G.obj' 0 ⋯) (i : Fin (0 + 1))
Goal: (CategoryTheory.ComposableArrows.isoMk₀ e).inv.app i =
  match i with
  | ⟨0, isLt⟩ => e.inv
-- CategoryTheory.ComposableArrows.ext₀
lemma ext₀ {F G : ComposableArrows C 0} (h : F.obj' 0 = G.obj 0) : F = G 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {F G : CategoryTheory.ComposableArrows C 0} (h : F.obj' 0 ⋯ = G.obj 0)
Goal: F = G
-- CategoryTheory.ComposableArrows.mk₀_surjective
lemma mk₀_surjective (F : ComposableArrows C 0) : ∃ (X : C), F = mk₀ X 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (F : CategoryTheory.ComposableArrows C 0)
Goal: ∃ X, F = CategoryTheory.ComposableArrows.mk₀ X
-- CategoryTheory.ComposableArrows.homMk₁_app
@[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 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {F G : CategoryTheory.ComposableArrows C 1} (left : F.obj' 0 ⋯ ⟶ G.obj' 0 ⋯) (right : F.obj' 1 ⋯ ⟶ G.obj' 1 ⋯) (w :
  CategoryTheory.CategoryStruct.comp (F.map' 0 1 ⋯ ⋯) right =
    CategoryTheory.CategoryStruct.comp left (G.map' 0 1 ⋯ ⋯) := by
  aesop_cat) (i : Fin (1 + 1))
Goal: (CategoryTheory.ComposableArrows.homMk₁ left right w).app i =
  match i with
  | ⟨0, isLt⟩ => left
  | ⟨1, isLt⟩ => right
-- CategoryTheory.ComposableArrows.hom_ext₁
@[ext]
lemma hom_ext₁ {F G : ComposableArrows C 1} {φ φ' : F ⟶ G}
    (h₀ : app' φ 0 = app' φ' 0) (h₁ : app' φ 1 = app' φ' 1) :
    φ = φ' 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {F G : CategoryTheory.ComposableArrows C 1} {φ φ' : F ⟶ G} (h₀ : CategoryTheory.ComposableArrows.app' φ 0 ⋯ = CategoryTheory.ComposableArrows.app' φ' 0 ⋯) (h₁ : CategoryTheory.ComposableArrows.app' φ 1 ⋯ = CategoryTheory.ComposableArrows.app' φ' 1 ⋯)
Goal: φ = φ'
-- CategoryTheory.ComposableArrows.isoMk₁_hom_app
@[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 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {F G : CategoryTheory.ComposableArrows C 1} (left : F.obj' 0 ⋯ ≅ G.obj' 0 ⋯) (right : F.obj' 1 ⋯ ≅ G.obj' 1 ⋯) (w :
  CategoryTheory.CategoryStruct.comp (F.map' 0 1 ⋯ ⋯) right.hom =
    CategoryTheory.CategoryStruct.comp left.hom (G.map' 0 1 ⋯ ⋯) := by
  aesop_cat) (i : Fin (1 + 1))
Goal: (CategoryTheory.ComposableArrows.isoMk₁ left right w).hom.app i =
  match i with
  | ⟨0, isLt⟩ => left.hom
  | ⟨1, isLt⟩ => right.hom
-- CategoryTheory.ComposableArrows.isoMk₁_inv_app
@[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 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {F G : CategoryTheory.ComposableArrows C 1} (left : F.obj' 0 ⋯ ≅ G.obj' 0 ⋯) (right : F.obj' 1 ⋯ ≅ G.obj' 1 ⋯) (w :
  CategoryTheory.CategoryStruct.comp (F.map' 0 1 ⋯ ⋯) right.hom =
    CategoryTheory.CategoryStruct.comp left.hom (G.map' 0 1 ⋯ ⋯) := by
  aesop_cat) (i : Fin (1 + 1))
Goal: (CategoryTheory.ComposableArrows.isoMk₁ left right w).inv.app i =
  match i with
  | ⟨0, isLt⟩ => left.inv
  | ⟨1, isLt⟩ => right.inv
-- CategoryTheory.ComposableArrows.map'_eq_hom₁
lemma map'_eq_hom₁ (F : ComposableArrows C 1) : F.map' 0 1 = F.hom 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (F : CategoryTheory.ComposableArrows C 1)
Goal: F.map' 0 1 ⋯ ⋯ = F.hom
-- CategoryTheory.ComposableArrows.ext₁
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 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {F G : CategoryTheory.ComposableArrows C 1} (left : F.left = G.left) (right : F.right = G.right) (w :
  F.hom =
    CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom left)
      (CategoryTheory.CategoryStruct.comp G.hom (CategoryTheory.eqToHom ⋯)))
Goal: F = G
-- CategoryTheory.ComposableArrows.mk₁_surjective
lemma mk₁_surjective (X : ComposableArrows C 1) : ∃ (X₀ X₁ : C) (f : X₀ ⟶ X₁), X = mk₁ f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (X : CategoryTheory.ComposableArrows C 1)
Goal: ∃ X₀ X₁ f, X = CategoryTheory.ComposableArrows.mk₁ f
-- CategoryTheory.ComposableArrows.Precomp.obj_zero
@[simp]
lemma obj_zero : obj F X 0 = X 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) (X : C)
Goal: CategoryTheory.ComposableArrows.Precomp.obj F X 0 = X
-- CategoryTheory.ComposableArrows.Precomp.obj_one
@[simp]
lemma obj_one : obj F X 1 = F.obj' 0 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) (X : C)
Goal: CategoryTheory.ComposableArrows.Precomp.obj F X 1 = F.obj' 0 ⋯