ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.sum.inverseAssociator_obj_inr_inl
@[simp]
theorem inverseAssociator_obj_inr_inl (X) :
    (inverseAssociator C D E).obj (inr (inl X)) = inl (inr X) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u) [CategoryTheory.Category.{v, u} D] (E : Type u) [CategoryTheory.Category.{v, u} E] (X : D)
Goal: (CategoryTheory.sum.inverseAssociator C D E).obj (Sum.inr (Sum.inl X)) = Sum.inl (Sum.inr X)
-- CategoryTheory.sum.inverseAssociator_obj_inr_inr
@[simp]
theorem inverseAssociator_obj_inr_inr (X) : (inverseAssociator C D E).obj (inr (inr X)) = inr X 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u) [CategoryTheory.Category.{v, u} D] (E : Type u) [CategoryTheory.Category.{v, u} E] (X : E)
Goal: (CategoryTheory.sum.inverseAssociator C D E).obj (Sum.inr (Sum.inr X)) = Sum.inr X
-- CategoryTheory.sum.inverseAssociator_map_inl
@[simp]
theorem inverseAssociator_map_inl {X Y : C} (f : inl X ⟶ inl Y) :
    (inverseAssociator C D E).map f = f 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u) [CategoryTheory.Category.{v, u} D] (E : Type u) [CategoryTheory.Category.{v, u} E] {X Y : C} (f : Sum.inl X ⟶ Sum.inl Y)
Goal: (CategoryTheory.sum.inverseAssociator C D E).map f = f
-- CategoryTheory.sum.inverseAssociator_map_inr_inl
@[simp]
theorem inverseAssociator_map_inr_inl {X Y : D} (f : inr (inl X) ⟶ inr (inl Y)) :
    (inverseAssociator C D E).map f = f 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u) [CategoryTheory.Category.{v, u} D] (E : Type u) [CategoryTheory.Category.{v, u} E] {X Y : D} (f : Sum.inr (Sum.inl X) ⟶ Sum.inr (Sum.inl Y))
Goal: (CategoryTheory.sum.inverseAssociator C D E).map f = f
-- CategoryTheory.sum.inverseAssociator_map_inr_inr
@[simp]
theorem inverseAssociator_map_inr_inr {X Y : E} (f : inr (inr X) ⟶ inr (inr Y)) :
    (inverseAssociator C D E).map f = f 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] (D : Type u) [CategoryTheory.Category.{v, u} D] (E : Type u) [CategoryTheory.Category.{v, u} E] {X Y : E} (f : Sum.inr (Sum.inr X) ⟶ Sum.inr (Sum.inr Y))
Goal: (CategoryTheory.sum.inverseAssociator C D E).map f = f
-- CategoryTheory.Functor.Elements.ext
lemma Functor.Elements.ext {F : C ⥤ Type w} (x y : F.Elements) (h₁ : x.fst = y.fst)
    (h₂ : F.map (eqToHom h₁) x.snd = y.snd) : x = y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C (Type w)} (x y : F.Elements) (h₁ : x.fst = y.fst) (h₂ : F.map (CategoryTheory.eqToHom h₁) x.snd = y.snd)
Goal: x = y
-- CategoryTheory.CategoryOfElements.homMk_coe
@[simps]
def homMk {F : C ⥤ Type w} (x y : F.Elements) (f : x.1 ⟶ y.1) (hf : F.map f x.snd = y.snd) :
    x ⟶ y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C (Type w)} (x y : F.Elements) (f : x.fst ⟶ y.fst) (hf : F.map f x.snd = y.snd)
Goal: ↑(CategoryTheory.CategoryOfElements.homMk x y f hf) = f
-- CategoryTheory.CategoryOfElements.ext
@[ext]
theorem ext (F : C ⥤ Type w) {x y : F.Elements} (f g : x ⟶ y) (w : f.val = g.val) : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)) {x y : F.Elements} (f g : x ⟶ y) (w : ↑f = ↑g)
Goal: f = g
-- CategoryTheory.CategoryOfElements.comp_val
@[simp]
theorem comp_val {F : C ⥤ Type w} {p q r : F.Elements} {f : p ⟶ q} {g : q ⟶ r} :
    (f ≫ g).val = f.val ≫ g.val 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C (Type w)} {p q r : F.Elements} {f : p ⟶ q} {g : q ⟶ r}
Goal: ↑(CategoryTheory.CategoryStruct.comp f g) = CategoryTheory.CategoryStruct.comp ↑f ↑g
-- CategoryTheory.CategoryOfElements.id_val
@[simp]
theorem id_val {F : C ⥤ Type w} {p : F.Elements} : (𝟙 p : p ⟶ p).val = 𝟙 p.1 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C (Type w)} {p : F.Elements}
Goal: ↑(CategoryTheory.CategoryStruct.id p) = CategoryTheory.CategoryStruct.id p.fst
-- CategoryTheory.CategoryOfElements.map_snd
@[simp]
theorem map_snd {F : C ⥤ Type w} {p q : F.Elements} (f : p ⟶ q) : (F.map f.val) p.2 = q.2 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C (Type w)} {p q : F.Elements} (f : p ⟶ q)
Goal: F.map (↑f) p.snd = q.snd
-- CategoryTheory.CategoryOfElements.π_obj
@[simps]
def π : F.Elements ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)) (X : F.Elements)
Goal: (CategoryTheory.CategoryOfElements.π F).obj X = X.fst
-- CategoryTheory.CategoryOfElements.π_map
@[simps]
def π : F.Elements ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w))
Goal: ∀ {X Y : F.Elements} (f : X ⟶ Y), (CategoryTheory.CategoryOfElements.π F).map f = ↑f
-- CategoryTheory.CategoryOfElements.map_obj_fst
@[simps]
def map {F₁ F₂ : C ⥤ Type w} (α : F₁ ⟶ F₂) : F₁.Elements ⥤ F₂.Elements 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F₁ F₂ : CategoryTheory.Functor C (Type w)} (α : F₁ ⟶ F₂) (t : F₁.Elements)
Goal: ((CategoryTheory.CategoryOfElements.map α).obj t).fst = t.fst
-- CategoryTheory.CategoryOfElements.map_obj_snd
@[simps]
def map {F₁ F₂ : C ⥤ Type w} (α : F₁ ⟶ F₂) : F₁.Elements ⥤ F₂.Elements 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F₁ F₂ : CategoryTheory.Functor C (Type w)} (α : F₁ ⟶ F₂) (t : F₁.Elements)
Goal: ((CategoryTheory.CategoryOfElements.map α).obj t).snd = α.app t.fst t.snd
-- CategoryTheory.CategoryOfElements.map_map_coe
@[simps]
def map {F₁ F₂ : C ⥤ Type w} (α : F₁ ⟶ F₂) : F₁.Elements ⥤ F₂.Elements 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F₁ F₂ : CategoryTheory.Functor C (Type w)} (α : F₁ ⟶ F₂) {t₁ t₂ : F₁.Elements} (k : t₁ ⟶ t₂)
Goal: ↑((CategoryTheory.CategoryOfElements.map α).map k) = ↑k
-- CategoryTheory.CategoryOfElements.map_π
@[simp]
theorem map_π {F₁ F₂ : C ⥤ Type w} (α : F₁ ⟶ F₂) : map α ⋙ π F₂ = π F₁ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F₁ F₂ : CategoryTheory.Functor C (Type w)} (α : F₁ ⟶ F₂)
Goal: (CategoryTheory.CategoryOfElements.map α).comp (CategoryTheory.CategoryOfElements.π F₂) =
  CategoryTheory.CategoryOfElements.π F₁
-- CategoryTheory.CategoryOfElements.toStructuredArrow_obj
@[simp]
theorem toStructuredArrow_obj (X) :
    (toStructuredArrow F).obj X =
      { left := ⟨⟨⟩⟩
        right := X.1
        hom := fun _ => X.2 } 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)) (X : F.Elements)
Goal: (CategoryTheory.CategoryOfElements.toStructuredArrow F).obj X =
  { left := { as := PUnit.unit }, right := X.fst, hom := fun x => X.snd }
-- CategoryTheory.CategoryOfElements.to_comma_map_right
@[simp]
theorem to_comma_map_right {X Y} (f : X ⟶ Y) : ((toStructuredArrow F).map f).right = f.val 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)) {X Y : F.Elements} (f : X ⟶ Y)
Goal: ((CategoryTheory.CategoryOfElements.toStructuredArrow F).map f).right = ↑f
-- CategoryTheory.CategoryOfElements.fromStructuredArrow_obj
@[simp]
theorem fromStructuredArrow_obj (X) : (fromStructuredArrow F).obj X = ⟨X.right, X.hom PUnit.unit⟩ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)) (X : CategoryTheory.StructuredArrow PUnit.{w + 1} F)
Goal: (CategoryTheory.CategoryOfElements.fromStructuredArrow F).obj X = ⟨X.right, X.hom PUnit.unit⟩
-- CategoryTheory.CategoryOfElements.fromStructuredArrow_map
@[simp]
theorem fromStructuredArrow_map {X Y} (f : X ⟶ Y) :
    (fromStructuredArrow F).map f = ⟨f.right, congr_fun f.w.symm PUnit.unit⟩ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)) {X Y : CategoryTheory.StructuredArrow PUnit.{w + 1} F} (f : X ⟶ Y)
Goal: (CategoryTheory.CategoryOfElements.fromStructuredArrow F).map f = ⟨f.right, ⋯⟩
-- CategoryTheory.CategoryOfElements.structuredArrowEquivalence_functor_obj
@[simps! functor_obj functor_map inverse_obj inverse_map unitIso_hom
  unitIso_inv counitIso_hom counitIso_inv]
def structuredArrowEquivalence : F.Elements ≌ StructuredArrow PUnit F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)) (X : F.Elements)
Goal: (CategoryTheory.CategoryOfElements.structuredArrowEquivalence F).functor.obj X =
  CategoryTheory.StructuredArrow.mk fun x => X.snd
-- CategoryTheory.CategoryOfElements.structuredArrowEquivalence_counitIso_inv
@[simps! functor_obj functor_map inverse_obj inverse_map unitIso_hom
  unitIso_inv counitIso_hom counitIso_inv]
def structuredArrowEquivalence : F.Elements ≌ StructuredArrow PUnit F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w))
Goal: (CategoryTheory.CategoryOfElements.structuredArrowEquivalence F).counitIso.inv =
  { app := fun X => (CategoryTheory.StructuredArrow.isoMk (CategoryTheory.Iso.refl X.right) ⋯).inv, naturality := ⋯ }
-- CategoryTheory.CategoryOfElements.structuredArrowEquivalence_unitIso_hom
@[simps! functor_obj functor_map inverse_obj inverse_map unitIso_hom
  unitIso_inv counitIso_hom counitIso_inv]
def structuredArrowEquivalence : F.Elements ≌ StructuredArrow PUnit F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w))
Goal: (CategoryTheory.CategoryOfElements.structuredArrowEquivalence F).unitIso.hom =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.NatIso.ofComponents (fun X => CategoryTheory.Iso.refl X) ⋯).hom
    (CategoryTheory.CategoryStruct.comp
      (CategoryTheory.whiskerLeft (CategoryTheory.CategoryOfElements.toStructuredArrow F)
        (CategoryTheory.CategoryOfElements.fromStructuredArrow F).leftUnitor.inv)
      (CategoryTheory.CategoryStruct.comp
        (CategoryTheory.whiskerLeft (CategoryTheory.CategoryOfElements.toStructuredArrow F)
          (CategoryTheory.whiskerRight
            (CategoryTheory.NatIso.ofComponents
                (fun X => CategoryTheory.StructuredArrow.isoMk (CategoryTheory.Iso.refl X.right) ⋯) ⋯).inv
            (CategoryTheory.CategoryOfElements.fromStructuredArrow F)))
        (CategoryTheory.CategoryStruct.comp
          (CategoryTheory.whiskerLeft (CategoryTheory.CategoryOfElements.toStructuredArrow F)
            ((CategoryTheory.CategoryOfElements.fromStructuredArrow F).associator
                (CategoryTheory.CategoryOfElements.toStructuredArrow F)
                (CategoryTheory.CategoryOfElements.fromStructuredArrow F)).hom)
          (CategoryTheory.CategoryStruct.comp
            ((CategoryTheory.CategoryOfElements.toStructuredArrow F).associator
                (CategoryTheory.CategoryOfElements.fromStructuredArrow F)
                ((CategoryTheory.CategoryOfElements.toStructuredArrow F).comp
                  (CategoryTheory.CategoryOfElements.fromStructuredArrow F))).inv
            (CategoryTheory.CategoryStruct.comp
              (CategoryTheory.whiskerRight
                (CategoryTheory.NatIso.ofComponents (fun X => CategoryTheory.Iso.refl X) ⋯).inv
                ((CategoryTheory.CategoryOfElements.toStructuredArrow F).comp
                  (CategoryTheory.CategoryOfElements.fromStructuredArrow F)))
              ((CategoryTheory.CategoryOfElements.toStructuredArrow F).comp
                    (CategoryTheory.CategoryOfElements.fromStructuredArrow F)).leftUnitor.hom)))))
-- CategoryTheory.CategoryOfElements.structuredArrowEquivalence_functor_map
@[simps! functor_obj functor_map inverse_obj inverse_map unitIso_hom
  unitIso_inv counitIso_hom counitIso_inv]
def structuredArrowEquivalence : F.Elements ≌ StructuredArrow PUnit F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)) {X Y : F.Elements} (f : X ⟶ Y)
Goal: (CategoryTheory.CategoryOfElements.structuredArrowEquivalence F).functor.map f =
  CategoryTheory.StructuredArrow.homMk ↑f ⋯
-- CategoryTheory.CategoryOfElements.structuredArrowEquivalence_unitIso_inv
@[simps! functor_obj functor_map inverse_obj inverse_map unitIso_hom
  unitIso_inv counitIso_hom counitIso_inv]
def structuredArrowEquivalence : F.Elements ≌ StructuredArrow PUnit F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w))
Goal: (CategoryTheory.CategoryOfElements.structuredArrowEquivalence F).unitIso.inv =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.CategoryOfElements.toStructuredArrow F).comp
          (CategoryTheory.CategoryOfElements.fromStructuredArrow F)).leftUnitor.inv
    (CategoryTheory.CategoryStruct.comp
      (CategoryTheory.whiskerRight (CategoryTheory.NatIso.ofComponents (fun X => CategoryTheory.Iso.refl X) ⋯).hom
        ((CategoryTheory.CategoryOfElements.toStructuredArrow F).comp
          (CategoryTheory.CategoryOfElements.fromStructuredArrow F)))
      (CategoryTheory.CategoryStruct.comp
        ((CategoryTheory.CategoryOfElements.toStructuredArrow F).associator
            (CategoryTheory.CategoryOfElements.fromStructuredArrow F)
            ((CategoryTheory.CategoryOfElements.toStructuredArrow F).comp
              (CategoryTheory.CategoryOfElements.fromStructuredArrow F))).hom
        (CategoryTheory.CategoryStruct.comp
          (CategoryTheory.whiskerLeft (CategoryTheory.CategoryOfElements.toStructuredArrow F)
            ((CategoryTheory.CategoryOfElements.fromStructuredArrow F).associator
                (CategoryTheory.CategoryOfElements.toStructuredArrow F)
                (CategoryTheory.CategoryOfElements.fromStructuredArrow F)).inv)
          (CategoryTheory.CategoryStruct.comp
            (CategoryTheory.whiskerLeft (CategoryTheory.CategoryOfElements.toStructuredArrow F)
              (CategoryTheory.whiskerRight
                (CategoryTheory.NatIso.ofComponents
                    (fun X => CategoryTheory.StructuredArrow.isoMk (CategoryTheory.Iso.refl X.right) ⋯) ⋯).hom
                (CategoryTheory.CategoryOfElements.fromStructuredArrow F)))
            (CategoryTheory.CategoryStruct.comp
              (CategoryTheory.whiskerLeft (CategoryTheory.CategoryOfElements.toStructuredArrow F)
                (CategoryTheory.CategoryOfElements.fromStructuredArrow F).leftUnitor.hom)
              (CategoryTheory.NatIso.ofComponents (fun X => CategoryTheory.Iso.refl X) ⋯).inv)))))
-- CategoryTheory.CategoryOfElements.structuredArrowEquivalence_inverse_obj
@[simps! functor_obj functor_map inverse_obj inverse_map unitIso_hom
  unitIso_inv counitIso_hom counitIso_inv]
def structuredArrowEquivalence : F.Elements ≌ StructuredArrow PUnit F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)) (X : CategoryTheory.StructuredArrow PUnit.{w + 1} F)
Goal: (CategoryTheory.CategoryOfElements.structuredArrowEquivalence F).inverse.obj X = ⟨X.right, X.hom PUnit.unit⟩
-- CategoryTheory.CategoryOfElements.structuredArrowEquivalence_counitIso_hom
@[simps! functor_obj functor_map inverse_obj inverse_map unitIso_hom
  unitIso_inv counitIso_hom counitIso_inv]
def structuredArrowEquivalence : F.Elements ≌ StructuredArrow PUnit F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w))
Goal: (CategoryTheory.CategoryOfElements.structuredArrowEquivalence F).counitIso.hom =
  { app := fun X => (CategoryTheory.StructuredArrow.isoMk (CategoryTheory.Iso.refl X.right) ⋯).hom, naturality := ⋯ }
-- CategoryTheory.CategoryOfElements.structuredArrowEquivalence_inverse_map
@[simps! functor_obj functor_map inverse_obj inverse_map unitIso_hom
  unitIso_inv counitIso_hom counitIso_inv]
def structuredArrowEquivalence : F.Elements ≌ StructuredArrow PUnit F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w))
Goal: ∀ {X Y : CategoryTheory.StructuredArrow PUnit.{w + 1} F} (f : X ⟶ Y),
  (CategoryTheory.CategoryOfElements.structuredArrowEquivalence F).inverse.map f = ⟨f.right, ⋯⟩
-- CategoryTheory.CategoryOfElements.toCostructuredArrow_map
@[simps]
def toCostructuredArrow (F : Cᵒᵖ ⥤ Type v) : F.Elementsᵒᵖ ⥤ CostructuredArrow yoneda F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor Cᵒᵖ (Type v))
Goal: ∀ {X Y : F.Elementsᵒᵖ} (f : X ⟶ Y),
  (CategoryTheory.CategoryOfElements.toCostructuredArrow F).map f =
    CategoryTheory.CostructuredArrow.homMk (↑f.unop).unop ⋯
-- CategoryTheory.CategoryOfElements.toCostructuredArrow_obj
@[simps]
def toCostructuredArrow (F : Cᵒᵖ ⥤ Type v) : F.Elementsᵒᵖ ⥤ CostructuredArrow yoneda F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor Cᵒᵖ (Type v)) (X : F.Elementsᵒᵖ)
Goal: (CategoryTheory.CategoryOfElements.toCostructuredArrow F).obj X =
  CategoryTheory.CostructuredArrow.mk (CategoryTheory.yonedaEquiv.symm (Opposite.unop X).snd)
-- CategoryTheory.CategoryOfElements.fromCostructuredArrow_obj_fst
@[simps]
def fromCostructuredArrow (F : Cᵒᵖ ⥤ Type v) : (CostructuredArrow yoneda F)ᵒᵖ ⥤ F.Elements 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor Cᵒᵖ (Type v)) (X : (CategoryTheory.CostructuredArrow CategoryTheory.yoneda F)ᵒᵖ)
Goal: ((CategoryTheory.CategoryOfElements.fromCostructuredArrow F).obj X).fst = Opposite.op (Opposite.unop X).left
-- CategoryTheory.CategoryOfElements.fromCostructuredArrow_obj_snd
@[simps]
def fromCostructuredArrow (F : Cᵒᵖ ⥤ Type v) : (CostructuredArrow yoneda F)ᵒᵖ ⥤ F.Elements 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor Cᵒᵖ (Type v)) (X : (CategoryTheory.CostructuredArrow CategoryTheory.yoneda F)ᵒᵖ)
Goal: ((CategoryTheory.CategoryOfElements.fromCostructuredArrow F).obj X).snd =
  CategoryTheory.yonedaEquiv.toFun (Opposite.unop X).hom
-- CategoryTheory.CategoryOfElements.fromCostructuredArrow_map_coe
@[simps]
def fromCostructuredArrow (F : Cᵒᵖ ⥤ Type v) : (CostructuredArrow yoneda F)ᵒᵖ ⥤ F.Elements 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor Cᵒᵖ (Type v)) {X Y : (CategoryTheory.CostructuredArrow CategoryTheory.yoneda F)ᵒᵖ} (f : X ⟶ Y)
Goal: ↑((CategoryTheory.CategoryOfElements.fromCostructuredArrow F).map f) = f.unop.left.op
-- CategoryTheory.CategoryOfElements.fromCostructuredArrow_obj_mk
@[simp]
theorem fromCostructuredArrow_obj_mk (F : Cᵒᵖ ⥤ Type v) {X : C} (f : yoneda.obj X ⟶ F) :
    (fromCostructuredArrow F).obj (op (CostructuredArrow.mk f)) = ⟨op X, yonedaEquiv.1 f⟩ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor Cᵒᵖ (Type v)) {X : C} (f : CategoryTheory.yoneda.obj X ⟶ F)
Goal: (CategoryTheory.CategoryOfElements.fromCostructuredArrow F).obj (Opposite.op (CategoryTheory.CostructuredArrow.mk f)) =
  ⟨Opposite.op X, CategoryTheory.yonedaEquiv.toFun f⟩
-- CategoryTheory.CategoryOfElements.from_toCostructuredArrow_eq
theorem from_toCostructuredArrow_eq (F : Cᵒᵖ ⥤ Type v) :
    (toCostructuredArrow F).rightOp ⋙ fromCostructuredArrow F = 𝟭 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor Cᵒᵖ (Type v))
Goal: (CategoryTheory.CategoryOfElements.toCostructuredArrow F).rightOp.comp
    (CategoryTheory.CategoryOfElements.fromCostructuredArrow F) =
  CategoryTheory.Functor.id F.Elements
-- CategoryTheory.CategoryOfElements.to_fromCostructuredArrow_eq
theorem to_fromCostructuredArrow_eq (F : Cᵒᵖ ⥤ Type v) :
    (fromCostructuredArrow F).rightOp ⋙ toCostructuredArrow F = 𝟭 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor Cᵒᵖ (Type v))
Goal: (CategoryTheory.CategoryOfElements.fromCostructuredArrow F).rightOp.comp
    (CategoryTheory.CategoryOfElements.toCostructuredArrow F) =
  CategoryTheory.Functor.id (CategoryTheory.CostructuredArrow CategoryTheory.yoneda F)
-- CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalence_counitIso_inv
@[simps! functor_obj functor_map inverse_obj inverse_map unitIso_inv counitIso_hom counitIso_inv]
def costructuredArrowYonedaEquivalence (F : Cᵒᵖ ⥤ Type v) :
    F.Elementsᵒᵖ ≌ CostructuredArrow yoneda F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor Cᵒᵖ (Type v))
Goal: (CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalence F).counitIso.inv = CategoryTheory.eqToHom ⋯
-- CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalence_inverse_map
@[simps! functor_obj functor_map inverse_obj inverse_map unitIso_inv counitIso_hom counitIso_inv]
def costructuredArrowYonedaEquivalence (F : Cᵒᵖ ⥤ Type v) :
    F.Elementsᵒᵖ ≌ CostructuredArrow yoneda F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor Cᵒᵖ (Type v))
Goal: ∀ {X Y : CategoryTheory.CostructuredArrow CategoryTheory.yoneda F} (f : X ⟶ Y),
  (CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalence F).inverse.map f =
    ((CategoryTheory.CategoryOfElements.fromCostructuredArrow F).map f.op).op
-- CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalence_inverse_obj
@[simps! functor_obj functor_map inverse_obj inverse_map unitIso_inv counitIso_hom counitIso_inv]
def costructuredArrowYonedaEquivalence (F : Cᵒᵖ ⥤ Type v) :
    F.Elementsᵒᵖ ≌ CostructuredArrow yoneda F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor Cᵒᵖ (Type v)) (X : CategoryTheory.CostructuredArrow CategoryTheory.yoneda F)
Goal: (CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalence F).inverse.obj X =
  Opposite.op ((CategoryTheory.CategoryOfElements.fromCostructuredArrow F).obj (Opposite.op X))
-- CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalence_counitIso_hom
@[simps! functor_obj functor_map inverse_obj inverse_map unitIso_inv counitIso_hom counitIso_inv]
def costructuredArrowYonedaEquivalence (F : Cᵒᵖ ⥤ Type v) :
    F.Elementsᵒᵖ ≌ CostructuredArrow yoneda F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor Cᵒᵖ (Type v))
Goal: (CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalence F).counitIso.hom = CategoryTheory.eqToHom ⋯
-- CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalence_functor_map
@[simps! functor_obj functor_map inverse_obj inverse_map unitIso_inv counitIso_hom counitIso_inv]
def costructuredArrowYonedaEquivalence (F : Cᵒᵖ ⥤ Type v) :
    F.Elementsᵒᵖ ≌ CostructuredArrow yoneda F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor Cᵒᵖ (Type v))
Goal: ∀ {X Y : F.Elementsᵒᵖ} (f : X ⟶ Y),
  (CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalence F).functor.map f =
    CategoryTheory.CostructuredArrow.homMk (↑f.unop).unop ⋯
-- CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalence_functor_obj
@[simps! functor_obj functor_map inverse_obj inverse_map unitIso_inv counitIso_hom counitIso_inv]
def costructuredArrowYonedaEquivalence (F : Cᵒᵖ ⥤ Type v) :
    F.Elementsᵒᵖ ≌ CostructuredArrow yoneda F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor Cᵒᵖ (Type v)) (X : F.Elementsᵒᵖ)
Goal: (CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalence F).functor.obj X =
  CategoryTheory.CostructuredArrow.mk (CategoryTheory.yonedaEquiv.symm (Opposite.unop X).snd)