ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Square.arrowArrowEquivalence_inverse
@[simps]
def arrowArrowEquivalence : Square C ≌ Arrow (Arrow C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: CategoryTheory.Square.arrowArrowEquivalence.inverse = CategoryTheory.Square.fromArrowArrowFunctor
-- CategoryTheory.Square.arrowArrowEquivalence_counitIso
@[simps]
def arrowArrowEquivalence : Square C ≌ Arrow (Arrow C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: CategoryTheory.Square.arrowArrowEquivalence.counitIso =
  CategoryTheory.Iso.refl (CategoryTheory.Square.fromArrowArrowFunctor.comp CategoryTheory.Square.toArrowArrowFunctor)
-- 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_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_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'_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.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'_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'_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_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'_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_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'_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.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'_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.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'_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'_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.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'_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_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'_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_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.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'
-- CategoryTheory.Square.arrowArrowEquivalence'_inverse
@[simps]
def arrowArrowEquivalence' : Square C ≌ Arrow (Arrow C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: CategoryTheory.Square.arrowArrowEquivalence'.inverse = CategoryTheory.Square.fromArrowArrowFunctor'
-- CategoryTheory.Square.arrowArrowEquivalence'_counitIso
@[simps]
def arrowArrowEquivalence' : Square C ≌ Arrow (Arrow C) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: CategoryTheory.Square.arrowArrowEquivalence'.counitIso =
  CategoryTheory.Iso.refl (CategoryTheory.Square.fromArrowArrowFunctor'.comp CategoryTheory.Square.toArrowArrowFunctor')
-- CategoryTheory.Square.evaluation₁_obj
@[simps]
def evaluation₁ : Square C ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: CategoryTheory.Square.evaluation₁.obj sq = sq.X₁
-- CategoryTheory.Square.evaluation₁_map
@[simps]
def evaluation₁ : Square C ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), CategoryTheory.Square.evaluation₁.map φ = φ.τ₁
-- CategoryTheory.Square.evaluation₂_map
@[simps]
def evaluation₂ : Square C ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), CategoryTheory.Square.evaluation₂.map φ = φ.τ₂
-- CategoryTheory.Square.evaluation₂_obj
@[simps]
def evaluation₂ : Square C ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: CategoryTheory.Square.evaluation₂.obj sq = sq.X₂
-- CategoryTheory.Square.evaluation₃_obj
@[simps]
def evaluation₃ : Square C ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: CategoryTheory.Square.evaluation₃.obj sq = sq.X₃
-- CategoryTheory.Square.evaluation₃_map
@[simps]
def evaluation₃ : Square C ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), CategoryTheory.Square.evaluation₃.map φ = φ.τ₃
-- CategoryTheory.Square.evaluation₄_map
@[simps]
def evaluation₄ : Square C ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), CategoryTheory.Square.evaluation₄.map φ = φ.τ₄
-- CategoryTheory.Square.evaluation₄_obj
@[simps]
def evaluation₄ : Square C ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: CategoryTheory.Square.evaluation₄.obj sq = sq.X₄
-- CategoryTheory.Square.op_f₃₄
@[simps]
protected def op (sq : Square C) : Square Cᵒᵖ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: sq.op.f₃₄ = sq.f₁₃.op
-- CategoryTheory.Square.op_X₃
@[simps]
protected def op (sq : Square C) : Square Cᵒᵖ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: sq.op.X₃ = Opposite.op sq.X₃
-- CategoryTheory.Square.op_f₁₂
@[simps]
protected def op (sq : Square C) : Square Cᵒᵖ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: sq.op.f₁₂ = sq.f₂₄.op
-- CategoryTheory.Square.op_f₁₃
@[simps]
protected def op (sq : Square C) : Square Cᵒᵖ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: sq.op.f₁₃ = sq.f₃₄.op
-- CategoryTheory.Square.op_X₄
@[simps]
protected def op (sq : Square C) : Square Cᵒᵖ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: sq.op.X₄ = Opposite.op sq.X₁
-- CategoryTheory.Square.op_X₁
@[simps]
protected def op (sq : Square C) : Square Cᵒᵖ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: sq.op.X₁ = Opposite.op sq.X₄
-- CategoryTheory.Square.op_X₂
@[simps]
protected def op (sq : Square C) : Square Cᵒᵖ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: sq.op.X₂ = Opposite.op sq.X₂
-- CategoryTheory.Square.op_f₂₄
@[simps]
protected def op (sq : Square C) : Square Cᵒᵖ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C)
Goal: sq.op.f₂₄ = sq.f₁₂.op
-- CategoryTheory.Square.unop_X₁
@[simps]
protected def unop (sq : Square Cᵒᵖ) : Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square Cᵒᵖ)
Goal: sq.unop.X₁ = Opposite.unop sq.X₄
-- CategoryTheory.Square.unop_f₁₂
@[simps]
protected def unop (sq : Square Cᵒᵖ) : Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square Cᵒᵖ)
Goal: sq.unop.f₁₂ = sq.f₂₄.unop
-- CategoryTheory.Square.unop_f₂₄
@[simps]
protected def unop (sq : Square Cᵒᵖ) : Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square Cᵒᵖ)
Goal: sq.unop.f₂₄ = sq.f₁₂.unop
-- CategoryTheory.Square.unop_X₃
@[simps]
protected def unop (sq : Square Cᵒᵖ) : Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square Cᵒᵖ)
Goal: sq.unop.X₃ = Opposite.unop sq.X₃
-- CategoryTheory.Square.unop_X₄
@[simps]
protected def unop (sq : Square Cᵒᵖ) : Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square Cᵒᵖ)
Goal: sq.unop.X₄ = Opposite.unop sq.X₁
-- CategoryTheory.Square.unop_f₃₄
@[simps]
protected def unop (sq : Square Cᵒᵖ) : Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square Cᵒᵖ)
Goal: sq.unop.f₃₄ = sq.f₁₃.unop
-- CategoryTheory.Square.unop_f₁₃
@[simps]
protected def unop (sq : Square Cᵒᵖ) : Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square Cᵒᵖ)
Goal: sq.unop.f₁₃ = sq.f₃₄.unop
-- CategoryTheory.Square.unop_X₂
@[simps]
protected def unop (sq : Square Cᵒᵖ) : Square C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square Cᵒᵖ)
Goal: sq.unop.X₂ = Opposite.unop sq.X₂
-- CategoryTheory.Square.opFunctor_obj
@[simps]
def opFunctor : (Square C)ᵒᵖ ⥤ Square Cᵒᵖ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : (CategoryTheory.Square C)ᵒᵖ)
Goal: CategoryTheory.Square.opFunctor.obj sq = (Opposite.unop sq).op
-- CategoryTheory.Square.opFunctor_map_τ₃
@[simps]
def opFunctor : (Square C)ᵒᵖ ⥤ Square Cᵒᵖ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : (CategoryTheory.Square C)ᵒᵖ} (φ : X ⟶ Y), (CategoryTheory.Square.opFunctor.map φ).τ₃ = φ.unop.τ₃.op
-- CategoryTheory.Square.opFunctor_map_τ₄
@[simps]
def opFunctor : (Square C)ᵒᵖ ⥤ Square Cᵒᵖ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : (CategoryTheory.Square C)ᵒᵖ} (φ : X ⟶ Y), (CategoryTheory.Square.opFunctor.map φ).τ₄ = φ.unop.τ₁.op
-- CategoryTheory.Square.opFunctor_map_τ₂
@[simps]
def opFunctor : (Square C)ᵒᵖ ⥤ Square Cᵒᵖ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : (CategoryTheory.Square C)ᵒᵖ} (φ : X ⟶ Y), (CategoryTheory.Square.opFunctor.map φ).τ₂ = φ.unop.τ₂.op
-- CategoryTheory.Square.opFunctor_map_τ₁
@[simps]
def opFunctor : (Square C)ᵒᵖ ⥤ Square Cᵒᵖ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C]
Goal: ∀ {X Y : (CategoryTheory.Square C)ᵒᵖ} (φ : X ⟶ Y), (CategoryTheory.Square.opFunctor.map φ).τ₁ = φ.unop.τ₄.op
-- CategoryTheory.Square.map_f₁₃
@[simps]
def map (sq : Square C) (F : C ⥤ D) : Square D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (sq : CategoryTheory.Square C) (F : CategoryTheory.Functor C D)
Goal: (sq.map F).f₁₃ = F.map sq.f₁₃
-- CategoryTheory.Square.map_f₃₄
@[simps]
def map (sq : Square C) (F : C ⥤ D) : Square D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (sq : CategoryTheory.Square C) (F : CategoryTheory.Functor C D)
Goal: (sq.map F).f₃₄ = F.map sq.f₃₄
-- CategoryTheory.Square.map_f₂₄
@[simps]
def map (sq : Square C) (F : C ⥤ D) : Square D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (sq : CategoryTheory.Square C) (F : CategoryTheory.Functor C D)
Goal: (sq.map F).f₂₄ = F.map sq.f₂₄
-- CategoryTheory.Square.map_f₁₂
@[simps]
def map (sq : Square C) (F : C ⥤ D) : Square D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (sq : CategoryTheory.Square C) (F : CategoryTheory.Functor C D)
Goal: (sq.map F).f₁₂ = F.map sq.f₁₂
-- CategoryTheory.Square.map_X₃
@[simps]
def map (sq : Square C) (F : C ⥤ D) : Square D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (sq : CategoryTheory.Square C) (F : CategoryTheory.Functor C D)
Goal: (sq.map F).X₃ = F.obj sq.X₃
-- CategoryTheory.Square.map_X₁
@[simps]
def map (sq : Square C) (F : C ⥤ D) : Square D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (sq : CategoryTheory.Square C) (F : CategoryTheory.Functor C D)
Goal: (sq.map F).X₁ = F.obj sq.X₁
-- CategoryTheory.Square.map_X₄
@[simps]
def map (sq : Square C) (F : C ⥤ D) : Square D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (sq : CategoryTheory.Square C) (F : CategoryTheory.Functor C D)
Goal: (sq.map F).X₄ = F.obj sq.X₄
-- CategoryTheory.Square.map_X₂
@[simps]
def map (sq : Square C) (F : C ⥤ D) : Square D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (sq : CategoryTheory.Square C) (F : CategoryTheory.Functor C D)
Goal: (sq.map F).X₂ = F.obj sq.X₂
-- CategoryTheory.Functor.mapSquare_map_τ₁
@[simps]
def mapSquare (F : C ⥤ D) : Square C ⥤ Square D 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (F : CategoryTheory.Functor C D)
Goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), ((CategoryTheory.Functor.mapSquare C F).map φ).τ₁ = F.map φ.τ₁
-- CategoryTheory.Functor.mapSquare_map_τ₂
@[simps]
def mapSquare (F : C ⥤ D) : Square C ⥤ Square D 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (F : CategoryTheory.Functor C D)
Goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), ((CategoryTheory.Functor.mapSquare C F).map φ).τ₂ = F.map φ.τ₂
-- CategoryTheory.Functor.mapSquare_map_τ₃
@[simps]
def mapSquare (F : C ⥤ D) : Square C ⥤ Square D 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (F : CategoryTheory.Functor C D)
Goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), ((CategoryTheory.Functor.mapSquare C F).map φ).τ₃ = F.map φ.τ₃
-- CategoryTheory.Functor.mapSquare_map_τ₄
@[simps]
def mapSquare (F : C ⥤ D) : Square C ⥤ Square D 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (F : CategoryTheory.Functor C D)
Goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), ((CategoryTheory.Functor.mapSquare C F).map φ).τ₄ = F.map φ.τ₄
-- CategoryTheory.Functor.mapSquare_obj
@[simps]
def mapSquare (F : C ⥤ D) : Square C ⥤ Square D 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (F : CategoryTheory.Functor C D) (sq : CategoryTheory.Square C)
Goal: (CategoryTheory.Functor.mapSquare C F).obj sq = sq.map F
-- CategoryTheory.yoneda_obj_obj
@[simps]
def yoneda : C ⥤ Cᵒᵖ ⥤ Type v₁ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : C) (Y : Cᵒᵖ)
Goal: (CategoryTheory.yoneda.obj X).obj Y = (Opposite.unop Y ⟶ X)
-- CategoryTheory.yoneda_obj_map
@[simps]
def yoneda : C ⥤ Cᵒᵖ ⥤ Type v₁ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : C)
Goal: ∀ {X_1 Y : Cᵒᵖ} (f : X_1 ⟶ Y) (g : Opposite.unop X_1 ⟶ X),
  (CategoryTheory.yoneda.obj X).map f g = CategoryTheory.CategoryStruct.comp f.unop g
-- CategoryTheory.yoneda_map_app
@[simps]
def yoneda : C ⥤ Cᵒᵖ ⥤ Type v₁ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C]
Goal: ∀ {X Y : C} (f : X ⟶ Y) (Y_1 : Cᵒᵖ)
  (g :
    ((fun X =>
            { obj := fun Y => Opposite.unop Y ⟶ X,
              map := fun {X_1 Y} f g => CategoryTheory.CategoryStruct.comp f.unop g, map_id := ⋯, map_comp := ⋯ })
          X).obj
      Y_1),
  (CategoryTheory.yoneda.map f).app Y_1 g = CategoryTheory.CategoryStruct.comp g f
-- CategoryTheory.coyoneda_map_app
@[simps]
def coyoneda : Cᵒᵖ ⥤ C ⥤ Type v₁ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C]
Goal: ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y) (Y_1 : C)
  (g :
    ((fun X =>
            { obj := fun Y => Opposite.unop X ⟶ Y, map := fun {X_1 Y} f g => CategoryTheory.CategoryStruct.comp g f,
              map_id := ⋯, map_comp := ⋯ })
          X).obj
      Y_1),
  (CategoryTheory.coyoneda.map f).app Y_1 g = CategoryTheory.CategoryStruct.comp f.unop g
-- CategoryTheory.coyoneda_obj_map
@[simps]
def coyoneda : Cᵒᵖ ⥤ C ⥤ Type v₁ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : Cᵒᵖ)
Goal: ∀ {X_1 Y : C} (f : X_1 ⟶ Y) (g : Opposite.unop X ⟶ X_1),
  (CategoryTheory.coyoneda.obj X).map f g = CategoryTheory.CategoryStruct.comp g f
-- CategoryTheory.coyoneda_obj_obj
@[simps]
def coyoneda : Cᵒᵖ ⥤ C ⥤ Type v₁ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X : Cᵒᵖ) (Y : C)
Goal: (CategoryTheory.coyoneda.obj X).obj Y = (Opposite.unop X ⟶ Y)
-- CategoryTheory.Yoneda.obj_map_id
theorem obj_map_id {X Y : C} (f : op X ⟶ op Y) :
    (yoneda.obj X).map f (𝟙 X) = (yoneda.map f.unop).app (op Y) (𝟙 Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Opposite.op X ⟶ Opposite.op Y)
Goal: (CategoryTheory.yoneda.obj X).map f (CategoryTheory.CategoryStruct.id X) =
  (CategoryTheory.yoneda.map f.unop).app (Opposite.op Y) (CategoryTheory.CategoryStruct.id Y)
-- CategoryTheory.Yoneda.naturality
@[simp]
theorem naturality {X Y : C} (α : yoneda.obj X ⟶ yoneda.obj Y) {Z Z' : C} (f : Z ⟶ Z')
    (h : Z' ⟶ X) : f ≫ α.app (op Z') h = α.app (op Z) (f ≫ h) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (α : CategoryTheory.yoneda.obj X ⟶ CategoryTheory.yoneda.obj Y) {Z Z' : C} (f : Z ⟶ Z') (h : Z' ⟶ X)
Goal: CategoryTheory.CategoryStruct.comp f (α.app (Opposite.op Z') h) =
  α.app (Opposite.op Z) (CategoryTheory.CategoryStruct.comp f h)
-- CategoryTheory.Yoneda.fullyFaithful_preimage
lemma fullyFaithful_preimage {X Y : C} (f : yoneda.obj X ⟶ yoneda.obj Y) :
    fullyFaithful.preimage f = f.app (op X) (𝟙 X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : CategoryTheory.yoneda.obj X ⟶ CategoryTheory.yoneda.obj Y)
Goal: CategoryTheory.Yoneda.fullyFaithful.preimage f = f.app (Opposite.op X) (CategoryTheory.CategoryStruct.id X)
-- CategoryTheory.Yoneda.isIso
theorem isIso {X Y : C} (f : X ⟶ Y) [IsIso (yoneda.map f)] : IsIso f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.IsIso (CategoryTheory.yoneda.map f)]
Goal: CategoryTheory.IsIso f
-- CategoryTheory.Coyoneda.naturality
@[simp]
theorem naturality {X Y : Cᵒᵖ} (α : coyoneda.obj X ⟶ coyoneda.obj Y) {Z Z' : C} (f : Z' ⟶ Z)
    (h : unop X ⟶ Z') : α.app Z' h ≫ f = α.app Z (h ≫ f) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (α : CategoryTheory.coyoneda.obj X ⟶ CategoryTheory.coyoneda.obj Y) {Z Z' : C} (f : Z' ⟶ Z) (h : Opposite.unop X ⟶ Z')
Goal: CategoryTheory.CategoryStruct.comp (α.app Z' h) f = α.app Z (CategoryTheory.CategoryStruct.comp h f)