ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Localization.Lifting.ofIsos_iso'
@[simps]
def ofIsos {F₁ F₂ : C ⥤ E} {F₁' F₂' : D ⥤ E} (e : F₁ ≅ F₂) (e' : F₁' ≅ F₂') [Lifting L W F₁ F₁'] :
    Lifting L W F₂ F₂' 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] (L : CategoryTheory.Functor C D) (W : CategoryTheory.MorphismProperty C) {E : Type u_3} [CategoryTheory.Category.{u_6, u_3} E] {F₁ F₂ : CategoryTheory.Functor C E} {F₁' F₂' : CategoryTheory.Functor D E} (e : F₁ ≅ F₂) (e' : F₁' ≅ F₂') [CategoryTheory.Localization.Lifting L W F₁ F₁']
Goal: CategoryTheory.Localization.Lifting.iso' W =
  CategoryTheory.isoWhiskerLeft L e'.symm ≪≫ CategoryTheory.Localization.Lifting.iso L W F₁ F₁' ≪≫ e
-- CategoryTheory.Functor.IsLocalization.of_iso
theorem of_iso {L₁ L₂ : C ⥤ D} (e : L₁ ≅ L₂) [L₁.IsLocalization W] : L₂.IsLocalization W 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] (W : CategoryTheory.MorphismProperty C) {L₁ L₂ : CategoryTheory.Functor C D} (e : L₁ ≅ L₂) [L₁.IsLocalization W]
Goal: L₂.IsLocalization W
-- CategoryTheory.Functor.IsLocalization.of_equivalence_target
theorem of_equivalence_target {E : Type*} [Category E] (L' : C ⥤ E) (eq : D ≌ E)
    [L.IsLocalization W] (e : L ⋙ eq.functor ≅ L') : L'.IsLocalization W 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_6, u_1} C] [CategoryTheory.Category.{u_7, u_2} D] (L : CategoryTheory.Functor C D) (W : CategoryTheory.MorphismProperty C) {E : Type u_4} [CategoryTheory.Category.{u_5, u_4} E] (L' : CategoryTheory.Functor C E) (eq : D ≌ E) [L.IsLocalization W] (e : L.comp eq.functor ≅ L')
Goal: L'.IsLocalization W
-- CategoryTheory.Functor.IsLocalization.of_isEquivalence
lemma of_isEquivalence (L : C ⥤ D) (W : MorphismProperty C)
    (hW : W ≤ MorphismProperty.isomorphisms C) [IsEquivalence L] :
    L.IsLocalization W 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] (L : CategoryTheory.Functor C D) (W : CategoryTheory.MorphismProperty C) (hW : W ≤ CategoryTheory.MorphismProperty.isomorphisms C) [L.IsEquivalence]
Goal: L.IsLocalization W
-- CategoryTheory.Localization.uniq_symm
lemma uniq_symm : (uniq L₁ L₂ W').symm = uniq L₂ L₁ W' 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_8, u_1} C] {D₁ : Type u_4} {D₂ : Type u_5} [CategoryTheory.Category.{u_6, u_4} D₁] [CategoryTheory.Category.{u_7, u_5} D₂] (L₁ : CategoryTheory.Functor C D₁) (L₂ : CategoryTheory.Functor C D₂) (W' : CategoryTheory.MorphismProperty C) [L₁.IsLocalization W'] [L₂.IsLocalization W']
Goal: (CategoryTheory.Localization.uniq L₁ L₂ W').symm = CategoryTheory.Localization.uniq L₂ L₁ W'
-- CategoryTheory.areEqualizedByLocalization_iff
lemma areEqualizedByLocalization_iff [L.IsLocalization W] :
    AreEqualizedByLocalization W f g ↔ L.map f = L.map g 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] (L : CategoryTheory.Functor C D) (W : CategoryTheory.MorphismProperty C) {X Y : C} (f g : X ⟶ Y) [L.IsLocalization W]
Goal: CategoryTheory.AreEqualizedByLocalization W f g ↔ L.map f = L.map g
-- CategoryTheory.AreEqualizedByLocalization.mk
lemma mk (L : C ⥤ D) [L.IsLocalization W] (h : L.map f = L.map g) :
    AreEqualizedByLocalization W f g 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] (W : CategoryTheory.MorphismProperty C) {X Y : C} (f g : X ⟶ Y) (L : CategoryTheory.Functor C D) [L.IsLocalization W] (h : L.map f = L.map g)
Goal: CategoryTheory.AreEqualizedByLocalization W f g
-- CategoryTheory.AreEqualizedByLocalization.map_eq
lemma map_eq (h : AreEqualizedByLocalization W f g) (L : C ⥤ D) [L.IsLocalization W] :
    L.map f = L.map g 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] {W : CategoryTheory.MorphismProperty C} {X Y : C} {f g : X ⟶ Y} (h : CategoryTheory.AreEqualizedByLocalization W f g) (L : CategoryTheory.Functor C D) [L.IsLocalization W]
Goal: L.map f = L.map g
-- CategoryTheory.Square.fac
structure Square where
    {X₁ : C}
    {X₂ : C}
    {X₃ : C}
    {X₄ : C}
    f₁₂ : X₁ ⟶ X₂
    f₁₃ : X₁ ⟶ X₃
    f₂₄ : X₂ ⟶ X₄
    f₃₄ : X₃ ⟶ X₄
  fac : f₁₂ ≫ f₂₄ = f₁₃ ≫ f₃₄
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (self : CategoryTheory.Square C)
Goal: CategoryTheory.CategoryStruct.comp self.f₁₂ self.f₂₄ = CategoryTheory.CategoryStruct.comp self.f₁₃ self.f₃₄
-- CategoryTheory.Square.commSq
lemma commSq (sq : Square C) : CommSq sq.f₁₂ sq.f₁₃ sq.f₂₄ sq.f₃₄ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: CategoryTheory.CommSq sq.f₁₂ sq.f₁₃ sq.f₂₄ sq.f₃₄
-- CategoryTheory.Square.Hom.comm₁₃
@[ext]
structure Hom (sq₁ sq₂ : Square C) where
    τ₁ : sq₁.X₁ ⟶ sq₂.X₁
    τ₂ : sq₁.X₂ ⟶ sq₂.X₂
    τ₃ : sq₁.X₃ ⟶ sq₂.X₃
    τ₄ : sq₁.X₄ ⟶ sq₂.X₄
  comm₁₂ : sq₁.f₁₂ ≫ τ₂ = τ₁ ≫ sq₂.f₁₂ := by aesop_cat
  comm₁₃ : sq₁.f₁₃ ≫ τ₃ = τ₁ ≫ sq₂.f₁₃ := by aesop_cat
  comm₂₄ : sq₁.f₂₄ ≫ τ₄ = τ₂ ≫ sq₂.f₂₄ := by aesop_cat
  comm₃₄ : sq₁.f₃₄ ≫ τ₄ = τ₃ ≫ sq₂.f₃₄ := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {sq₁ sq₂ : CategoryTheory.Square C} (self : sq₁.Hom sq₂)
Goal: CategoryTheory.CategoryStruct.comp sq₁.f₁₃ self.τ₃ = CategoryTheory.CategoryStruct.comp self.τ₁ sq₂.f₁₃
-- CategoryTheory.Square.Hom.comm₃₄
@[ext]
structure Hom (sq₁ sq₂ : Square C) where
    τ₁ : sq₁.X₁ ⟶ sq₂.X₁
    τ₂ : sq₁.X₂ ⟶ sq₂.X₂
    τ₃ : sq₁.X₃ ⟶ sq₂.X₃
    τ₄ : sq₁.X₄ ⟶ sq₂.X₄
  comm₁₂ : sq₁.f₁₂ ≫ τ₂ = τ₁ ≫ sq₂.f₁₂ := by aesop_cat
  comm₁₃ : sq₁.f₁₃ ≫ τ₃ = τ₁ ≫ sq₂.f₁₃ := by aesop_cat
  comm₂₄ : sq₁.f₂₄ ≫ τ₄ = τ₂ ≫ sq₂.f₂₄ := by aesop_cat
  comm₃₄ : sq₁.f₃₄ ≫ τ₄ = τ₃ ≫ sq₂.f₃₄ := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {sq₁ sq₂ : CategoryTheory.Square C} (self : sq₁.Hom sq₂)
Goal: CategoryTheory.CategoryStruct.comp sq₁.f₃₄ self.τ₄ = CategoryTheory.CategoryStruct.comp self.τ₃ sq₂.f₃₄
-- CategoryTheory.Square.Hom.comm₁₂
@[ext]
structure Hom (sq₁ sq₂ : Square C) where
    τ₁ : sq₁.X₁ ⟶ sq₂.X₁
    τ₂ : sq₁.X₂ ⟶ sq₂.X₂
    τ₃ : sq₁.X₃ ⟶ sq₂.X₃
    τ₄ : sq₁.X₄ ⟶ sq₂.X₄
  comm₁₂ : sq₁.f₁₂ ≫ τ₂ = τ₁ ≫ sq₂.f₁₂ := by aesop_cat
  comm₁₃ : sq₁.f₁₃ ≫ τ₃ = τ₁ ≫ sq₂.f₁₃ := by aesop_cat
  comm₂₄ : sq₁.f₂₄ ≫ τ₄ = τ₂ ≫ sq₂.f₂₄ := by aesop_cat
  comm₃₄ : sq₁.f₃₄ ≫ τ₄ = τ₃ ≫ sq₂.f₃₄ := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {sq₁ sq₂ : CategoryTheory.Square C} (self : sq₁.Hom sq₂)
Goal: CategoryTheory.CategoryStruct.comp sq₁.f₁₂ self.τ₂ = CategoryTheory.CategoryStruct.comp self.τ₁ sq₂.f₁₂
-- CategoryTheory.Square.Hom.comm₂₄
@[ext]
structure Hom (sq₁ sq₂ : Square C) where
    τ₁ : sq₁.X₁ ⟶ sq₂.X₁
    τ₂ : sq₁.X₂ ⟶ sq₂.X₂
    τ₃ : sq₁.X₃ ⟶ sq₂.X₃
    τ₄ : sq₁.X₄ ⟶ sq₂.X₄
  comm₁₂ : sq₁.f₁₂ ≫ τ₂ = τ₁ ≫ sq₂.f₁₂ := by aesop_cat
  comm₁₃ : sq₁.f₁₃ ≫ τ₃ = τ₁ ≫ sq₂.f₁₃ := by aesop_cat
  comm₂₄ : sq₁.f₂₄ ≫ τ₄ = τ₂ ≫ sq₂.f₂₄ := by aesop_cat
  comm₃₄ : sq₁.f₃₄ ≫ τ₄ = τ₃ ≫ sq₂.f₃₄ := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {sq₁ sq₂ : CategoryTheory.Square C} (self : sq₁.Hom sq₂)
Goal: CategoryTheory.CategoryStruct.comp sq₁.f₂₄ self.τ₄ = CategoryTheory.CategoryStruct.comp self.τ₂ sq₂.f₂₄
-- CategoryTheory.Square.Hom.id_τ₂
@[simps]
def id (sq : Square C) : Hom sq sq 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: (CategoryTheory.Square.Hom.id sq).τ₂ = CategoryTheory.CategoryStruct.id sq.X₂
-- CategoryTheory.Square.Hom.id_τ₃
@[simps]
def id (sq : Square C) : Hom sq sq 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: (CategoryTheory.Square.Hom.id sq).τ₃ = CategoryTheory.CategoryStruct.id sq.X₃
-- CategoryTheory.Square.Hom.id_τ₄
@[simps]
def id (sq : Square C) : Hom sq sq 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: (CategoryTheory.Square.Hom.id sq).τ₄ = CategoryTheory.CategoryStruct.id sq.X₄
-- CategoryTheory.Square.Hom.id_τ₁
@[simps]
def id (sq : Square C) : Hom sq sq 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: (CategoryTheory.Square.Hom.id sq).τ₁ = CategoryTheory.CategoryStruct.id sq.X₁
-- CategoryTheory.Square.Hom.comp_τ₂
@[simps]
def comp {sq₁ sq₂ sq₃ : Square C} (f : Hom sq₁ sq₂) (g : Hom sq₂ sq₃) : Hom sq₁ sq₃ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {sq₁ sq₂ sq₃ : CategoryTheory.Square C} (f : sq₁.Hom sq₂) (g : sq₂.Hom sq₃)
Goal: (f.comp g).τ₂ = CategoryTheory.CategoryStruct.comp f.τ₂ g.τ₂
-- CategoryTheory.Square.Hom.comp_τ₄
@[simps]
def comp {sq₁ sq₂ sq₃ : Square C} (f : Hom sq₁ sq₂) (g : Hom sq₂ sq₃) : Hom sq₁ sq₃ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {sq₁ sq₂ sq₃ : CategoryTheory.Square C} (f : sq₁.Hom sq₂) (g : sq₂.Hom sq₃)
Goal: (f.comp g).τ₄ = CategoryTheory.CategoryStruct.comp f.τ₄ g.τ₄
-- CategoryTheory.Square.Hom.comp_τ₃
@[simps]
def comp {sq₁ sq₂ sq₃ : Square C} (f : Hom sq₁ sq₂) (g : Hom sq₂ sq₃) : Hom sq₁ sq₃ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {sq₁ sq₂ sq₃ : CategoryTheory.Square C} (f : sq₁.Hom sq₂) (g : sq₂.Hom sq₃)
Goal: (f.comp g).τ₃ = CategoryTheory.CategoryStruct.comp f.τ₃ g.τ₃
-- CategoryTheory.Square.Hom.comp_τ₁
@[simps]
def comp {sq₁ sq₂ sq₃ : Square C} (f : Hom sq₁ sq₂) (g : Hom sq₂ sq₃) : Hom sq₁ sq₃ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {sq₁ sq₂ sq₃ : CategoryTheory.Square C} (f : sq₁.Hom sq₂) (g : sq₂.Hom sq₃)
Goal: (f.comp g).τ₁ = CategoryTheory.CategoryStruct.comp f.τ₁ g.τ₁
-- CategoryTheory.Square.category_comp_τ₁
@[simps!]
instance category : Category (Square C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y Z : CategoryTheory.Square C} (f : X.Hom Y) (g : Y.Hom Z),
  (CategoryTheory.CategoryStruct.comp f g).τ₁ = CategoryTheory.CategoryStruct.comp f.τ₁ g.τ₁
-- CategoryTheory.Square.category_id_τ₁
@[simps!]
instance category : Category (Square C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: (CategoryTheory.CategoryStruct.id sq).τ₁ = CategoryTheory.CategoryStruct.id sq.X₁
-- CategoryTheory.Square.category_id_τ₂
@[simps!]
instance category : Category (Square C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: (CategoryTheory.CategoryStruct.id sq).τ₂ = CategoryTheory.CategoryStruct.id sq.X₂
-- CategoryTheory.Square.category_comp_τ₂
@[simps!]
instance category : Category (Square C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y Z : CategoryTheory.Square C} (f : X.Hom Y) (g : Y.Hom Z),
  (CategoryTheory.CategoryStruct.comp f g).τ₂ = CategoryTheory.CategoryStruct.comp f.τ₂ g.τ₂
-- CategoryTheory.Square.category_id_τ₃
@[simps!]
instance category : Category (Square C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: (CategoryTheory.CategoryStruct.id sq).τ₃ = CategoryTheory.CategoryStruct.id sq.X₃
-- CategoryTheory.Square.category_comp_τ₃
@[simps!]
instance category : Category (Square C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y Z : CategoryTheory.Square C} (f : X.Hom Y) (g : Y.Hom Z),
  (CategoryTheory.CategoryStruct.comp f g).τ₃ = CategoryTheory.CategoryStruct.comp f.τ₃ g.τ₃
-- CategoryTheory.Square.category_id_τ₄
@[simps!]
instance category : Category (Square C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: (CategoryTheory.CategoryStruct.id sq).τ₄ = CategoryTheory.CategoryStruct.id sq.X₄
-- CategoryTheory.Square.category_comp_τ₄
@[simps!]
instance category : Category (Square C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y Z : CategoryTheory.Square C} (f : X.Hom Y) (g : Y.Hom Z),
  (CategoryTheory.CategoryStruct.comp f g).τ₄ = CategoryTheory.CategoryStruct.comp f.τ₄ g.τ₄
-- CategoryTheory.Square.hom_ext
@[ext]
lemma hom_ext {sq₁ sq₂ : Square C} {f g : sq₁ ⟶ sq₂}
    (h₁ : f.τ₁ = g.τ₁) (h₂ : f.τ₂ = g.τ₂)
    (h₃ : f.τ₃ = g.τ₃) (h₄ : f.τ₄ = g.τ₄) : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {sq₁ sq₂ : CategoryTheory.Square C} {f g : sq₁ ⟶ sq₂} (h₁ : f.τ₁ = g.τ₁) (h₂ : f.τ₂ = g.τ₂) (h₃ : f.τ₃ = g.τ₃) (h₄ : f.τ₄ = g.τ₄)
Goal: f = g
-- CategoryTheory.Square.flip_X₄
@[simps]
def flip (sq : Square C) : Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: sq.flip.X₄ = sq.X₄
-- CategoryTheory.Square.flip_f₃₄
@[simps]
def flip (sq : Square C) : Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: sq.flip.f₃₄ = sq.f₂₄
-- CategoryTheory.Square.flip_f₂₄
@[simps]
def flip (sq : Square C) : Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: sq.flip.f₂₄ = sq.f₃₄
-- CategoryTheory.Square.flip_X₃
@[simps]
def flip (sq : Square C) : Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: sq.flip.X₃ = sq.X₂
-- CategoryTheory.Square.flip_f₁₃
@[simps]
def flip (sq : Square C) : Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: sq.flip.f₁₃ = sq.f₁₂
-- CategoryTheory.Square.flip_X₁
@[simps]
def flip (sq : Square C) : Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: sq.flip.X₁ = sq.X₁
-- CategoryTheory.Square.flip_X₂
@[simps]
def flip (sq : Square C) : Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: sq.flip.X₂ = sq.X₃
-- CategoryTheory.Square.flip_f₁₂
@[simps]
def flip (sq : Square C) : Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: sq.flip.f₁₂ = sq.f₁₃
-- CategoryTheory.Square.flipFunctor_map_τ₃
@[simps]
def flipFunctor : Square C ⥤ Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), (CategoryTheory.Square.flipFunctor.map φ).τ₃ = φ.τ₂
-- CategoryTheory.Square.flipFunctor_map_τ₁
@[simps]
def flipFunctor : Square C ⥤ Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), (CategoryTheory.Square.flipFunctor.map φ).τ₁ = φ.τ₁
-- CategoryTheory.Square.flipFunctor_map_τ₄
@[simps]
def flipFunctor : Square C ⥤ Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), (CategoryTheory.Square.flipFunctor.map φ).τ₄ = φ.τ₄
-- CategoryTheory.Square.flipFunctor_obj
@[simps]
def flipFunctor : Square C ⥤ Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: CategoryTheory.Square.flipFunctor.obj sq = sq.flip
-- CategoryTheory.Square.flipFunctor_map_τ₂
@[simps]
def flipFunctor : Square C ⥤ Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), (CategoryTheory.Square.flipFunctor.map φ).τ₂ = φ.τ₃
-- CategoryTheory.Square.flipEquivalence_unitIso
@[simps]
def flipEquivalence : Square C ≌ Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: CategoryTheory.Square.flipEquivalence.unitIso =
  CategoryTheory.Iso.refl (CategoryTheory.Functor.id (CategoryTheory.Square C))
-- CategoryTheory.Square.flipEquivalence_functor
@[simps]
def flipEquivalence : Square C ≌ Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: CategoryTheory.Square.flipEquivalence.functor = CategoryTheory.Square.flipFunctor
-- CategoryTheory.Square.flipEquivalence_inverse
@[simps]
def flipEquivalence : Square C ≌ Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: CategoryTheory.Square.flipEquivalence.inverse = CategoryTheory.Square.flipFunctor
-- CategoryTheory.Square.flipEquivalence_counitIso
@[simps]
def flipEquivalence : Square C ≌ Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: CategoryTheory.Square.flipEquivalence.counitIso =
  CategoryTheory.Iso.refl (CategoryTheory.Square.flipFunctor.comp CategoryTheory.Square.flipFunctor)
-- CategoryTheory.Square.toArrowArrowFunctor_obj_left_hom
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: (CategoryTheory.Square.toArrowArrowFunctor.obj sq).left.hom = sq.f₁₃
-- CategoryTheory.Square.toArrowArrowFunctor_map_left_right
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), (CategoryTheory.Square.toArrowArrowFunctor.map φ).left.right = φ.τ₃
-- CategoryTheory.Square.toArrowArrowFunctor_obj_left_right
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: (CategoryTheory.Square.toArrowArrowFunctor.obj sq).left.right = sq.X₃
-- CategoryTheory.Square.toArrowArrowFunctor_obj_hom_left
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: (CategoryTheory.Square.toArrowArrowFunctor.obj sq).hom.left = sq.f₁₂
-- CategoryTheory.Square.toArrowArrowFunctor_map_right_left
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), (CategoryTheory.Square.toArrowArrowFunctor.map φ).right.left = φ.τ₂
-- CategoryTheory.Square.toArrowArrowFunctor_obj_right_hom
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: (CategoryTheory.Square.toArrowArrowFunctor.obj sq).right.hom = sq.f₂₄
-- CategoryTheory.Square.toArrowArrowFunctor_obj_right_right
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: (CategoryTheory.Square.toArrowArrowFunctor.obj sq).right.right = sq.X₄
-- CategoryTheory.Square.toArrowArrowFunctor_obj_right_left
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: (CategoryTheory.Square.toArrowArrowFunctor.obj sq).right.left = sq.X₂
-- CategoryTheory.Square.toArrowArrowFunctor_obj_hom_right
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: (CategoryTheory.Square.toArrowArrowFunctor.obj sq).hom.right = sq.f₃₄
-- CategoryTheory.Square.toArrowArrowFunctor_obj_left_left
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: (CategoryTheory.Square.toArrowArrowFunctor.obj sq).left.left = sq.X₁
-- CategoryTheory.Square.toArrowArrowFunctor_map_right_right
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), (CategoryTheory.Square.toArrowArrowFunctor.map φ).right.right = φ.τ₄
-- CategoryTheory.Square.toArrowArrowFunctor_map_left_left
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), (CategoryTheory.Square.toArrowArrowFunctor.map φ).left.left = φ.τ₁
-- CategoryTheory.Square.fromArrowArrowFunctor_map_τ₁
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Arrow (CategoryTheory.Arrow C)} (φ : X ⟶ Y),
  (CategoryTheory.Square.fromArrowArrowFunctor.map φ).τ₁ = φ.left.left
-- CategoryTheory.Square.fromArrowArrowFunctor_obj_f₃₄
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C))
Goal: (CategoryTheory.Square.fromArrowArrowFunctor.obj f).f₃₄ = f.hom.right
-- CategoryTheory.Square.fromArrowArrowFunctor_map_τ₂
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Arrow (CategoryTheory.Arrow C)} (φ : X ⟶ Y),
  (CategoryTheory.Square.fromArrowArrowFunctor.map φ).τ₂ = φ.right.left
-- CategoryTheory.Square.fromArrowArrowFunctor_obj_X₃
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C))
Goal: (CategoryTheory.Square.fromArrowArrowFunctor.obj f).X₃ = f.left.right
-- CategoryTheory.Square.fromArrowArrowFunctor_obj_X₄
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C))
Goal: (CategoryTheory.Square.fromArrowArrowFunctor.obj f).X₄ = f.right.right
-- CategoryTheory.Square.fromArrowArrowFunctor_obj_X₂
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C))
Goal: (CategoryTheory.Square.fromArrowArrowFunctor.obj f).X₂ = f.right.left
-- CategoryTheory.Square.fromArrowArrowFunctor_obj_f₁₂
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C))
Goal: (CategoryTheory.Square.fromArrowArrowFunctor.obj f).f₁₂ = f.hom.left
-- CategoryTheory.Square.fromArrowArrowFunctor_obj_f₁₃
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C))
Goal: (CategoryTheory.Square.fromArrowArrowFunctor.obj f).f₁₃ = f.left.hom
-- CategoryTheory.Square.fromArrowArrowFunctor_obj_f₂₄
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C))
Goal: (CategoryTheory.Square.fromArrowArrowFunctor.obj f).f₂₄ = f.right.hom
-- CategoryTheory.Square.fromArrowArrowFunctor_map_τ₃
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Arrow (CategoryTheory.Arrow C)} (φ : X ⟶ Y),
  (CategoryTheory.Square.fromArrowArrowFunctor.map φ).τ₃ = φ.left.right
-- CategoryTheory.Square.fromArrowArrowFunctor_map_τ₄
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Arrow (CategoryTheory.Arrow C)} (φ : X ⟶ Y),
  (CategoryTheory.Square.fromArrowArrowFunctor.map φ).τ₄ = φ.right.right
-- CategoryTheory.Square.fromArrowArrowFunctor_obj_X₁
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C))
Goal: (CategoryTheory.Square.fromArrowArrowFunctor.obj f).X₁ = f.left.left
-- CategoryTheory.Square.arrowArrowEquivalence_unitIso
@[simps]
def arrowArrowEquivalence : Square C ≌ Arrow (Arrow C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: CategoryTheory.Square.arrowArrowEquivalence.unitIso =
  CategoryTheory.Iso.refl (CategoryTheory.Functor.id (CategoryTheory.Square C))
-- CategoryTheory.Square.arrowArrowEquivalence_functor
@[simps]
def arrowArrowEquivalence : Square C ≌ Arrow (Arrow C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: CategoryTheory.Square.arrowArrowEquivalence.functor = CategoryTheory.Square.toArrowArrowFunctor