ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.PullbackCone.toPullbackObj_coe_fst
@[simps coe_fst coe_snd]
def toPullbackObj (x : c.pt) : Types.PullbackObj f g 
Arguments: {X Y S : Type v} {f : X ⟶ S} {g : Y ⟶ S} (c : CategoryTheory.Limits.PullbackCone f g) (x : c.pt)
Goal: (↑(c.toPullbackObj x)).1 = c.fst x
-- CategoryTheory.Limits.PullbackCone.toPullbackObj_coe_snd
@[simps coe_fst coe_snd]
def toPullbackObj (x : c.pt) : Types.PullbackObj f g 
Arguments: {X Y S : Type v} {f : X ⟶ S} {g : Y ⟶ S} (c : CategoryTheory.Limits.PullbackCone f g) (x : c.pt)
Goal: (↑(c.toPullbackObj x)).2 = c.snd x
-- CategoryTheory.Limits.Types.pullbackIsoPullback_hom_fst
@[simp]
theorem pullbackIsoPullback_hom_fst (p : pullback f g) :
    ((pullbackIsoPullback f g).hom p : X × Y).fst = (pullback.fst f g) p 
Arguments: {X Y Z : Type u} (f : X ⟶ Z) (g : Y ⟶ Z) (p : CategoryTheory.Limits.pullback f g)
Goal: (↑((CategoryTheory.Limits.Types.pullbackIsoPullback f g).hom p)).1 = CategoryTheory.Limits.pullback.fst f g p
-- CategoryTheory.Limits.Types.pullbackIsoPullback_hom_snd
@[simp]
theorem pullbackIsoPullback_hom_snd (p : pullback f g) :
    ((pullbackIsoPullback f g).hom p : X × Y).snd = (pullback.snd f g) p 
Arguments: {X Y Z : Type u} (f : X ⟶ Z) (g : Y ⟶ Z) (p : CategoryTheory.Limits.pullback f g)
Goal: (↑((CategoryTheory.Limits.Types.pullbackIsoPullback f g).hom p)).2 = CategoryTheory.Limits.pullback.snd f g p
-- CategoryTheory.Limits.Types.pullbackIsoPullback_inv_fst_apply
@[simp]
theorem pullbackIsoPullback_inv_fst_apply (x : (Types.pullbackCone f g).pt) :
    (pullback.fst f g) ((pullbackIsoPullback f g).inv x) = (fun p => (p.1 : X × Y).fst) x 
Arguments: {X Y Z : Type u} (f : X ⟶ Z) (g : Y ⟶ Z) (x : (CategoryTheory.Limits.Types.pullbackCone f g).pt)
Goal: CategoryTheory.Limits.pullback.fst f g ((CategoryTheory.Limits.Types.pullbackIsoPullback f g).inv x) =
  (fun p => (↑p).1) x
-- CategoryTheory.Limits.Types.pullbackIsoPullback_inv_snd_apply
@[simp]
theorem pullbackIsoPullback_inv_snd_apply (x : (Types.pullbackCone f g).pt) :
    (pullback.snd f g) ((pullbackIsoPullback f g).inv x) = (fun p => (p.1 : X × Y).snd) x 
Arguments: {X Y Z : Type u} (f : X ⟶ Z) (g : Y ⟶ Z) (x : (CategoryTheory.Limits.Types.pullbackCone f g).pt)
Goal: CategoryTheory.Limits.pullback.snd f g ((CategoryTheory.Limits.Types.pullbackIsoPullback f g).inv x) =
  (fun p => (↑p).2) x
-- CategoryTheory.Limits.Types.pullbackIsoPullback_inv_fst
@[simp]
theorem pullbackIsoPullback_inv_fst :
    (pullbackIsoPullback f g).inv ≫ pullback.fst _ _ = fun p => (p.1 : X × Y).fst 
Arguments: {X Y Z : Type u} (f : X ⟶ Z) (g : Y ⟶ Z)
Goal: (CategoryTheory.Limits.Types.pullbackIsoPullback f g).inv ≫ CategoryTheory.Limits.pullback.fst f g = fun p => (↑p).1
-- CategoryTheory.Limits.Types.pullbackIsoPullback_inv_snd
@[simp]
theorem pullbackIsoPullback_inv_snd :
    (pullbackIsoPullback f g).inv ≫ pullback.snd _ _ = fun p => (p.1 : X × Y).snd 
Arguments: {X Y Z : Type u} (f : X ⟶ Z) (g : Y ⟶ Z)
Goal: (CategoryTheory.Limits.Types.pullbackIsoPullback f g).inv ≫ CategoryTheory.Limits.pullback.snd f g = fun p => (↑p).2
-- CategoryTheory.Limits.Types.Pushout.condition
lemma condition : f ≫ inl f g = g ≫ inr f g 
Arguments: {S X₁ X₂ : Type u} (f : S ⟶ X₁) (g : S ⟶ X₂)
Goal: f ≫ CategoryTheory.Limits.Types.Pushout.inl f g = g ≫ CategoryTheory.Limits.Types.Pushout.inr f g
-- CategoryTheory.Limits.Types.Pushout.cocone_ι_app
@[simps!]
def cocone : PushoutCocone f g 
Arguments: {S X₁ X₂ : Type u} (f : S ⟶ X₁) (g : S ⟶ X₂) (j : CategoryTheory.Limits.WalkingSpan)
Goal: ∀ (a : (CategoryTheory.Limits.span f g).obj j),
  (CategoryTheory.Limits.Types.Pushout.cocone f g).ι.app j a =
    Option.rec (f ≫ CategoryTheory.Limits.Types.Pushout.inl f g)
      (fun val =>
        CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Limits.Types.Pushout.inl f g)
          (CategoryTheory.Limits.Types.Pushout.inr f g) val)
      j a
-- CategoryTheory.Limits.Types.Pushout.cocone_pt
@[simps!]
def cocone : PushoutCocone f g 
Arguments: {S X₁ X₂ : Type u} (f : S ⟶ X₁) (g : S ⟶ X₂)
Goal: (CategoryTheory.Limits.Types.Pushout.cocone f g).pt = CategoryTheory.Limits.Types.Pushout f g
-- CategoryTheory.Limits.Types.Pushout.inl_rel'_inl_iff
@[simp]
lemma inl_rel'_inl_iff (x₁ y₁ : X₁) :
    Rel' f g (Sum.inl x₁) (Sum.inl y₁) ↔ x₁ = y₁ ∨
      ∃ (x₀ y₀ : S) (_ : g x₀ = g y₀), x₁ = f x₀ ∧ y₁ = f y₀ 
Arguments: {S X₁ X₂ : Type u} (f : S ⟶ X₁) (g : S ⟶ X₂) (x₁ y₁ : X₁)
Goal: CategoryTheory.Limits.Types.Pushout.Rel' f g (Sum.inl x₁) (Sum.inl y₁) ↔
  x₁ = y₁ ∨ ∃ x₀ y₀, ∃ (_ : g x₀ = g y₀), x₁ = f x₀ ∧ y₁ = f y₀
-- CategoryTheory.Limits.Types.Pushout.inl_rel'_inr_iff
@[simp]
lemma inl_rel'_inr_iff (x₁ : X₁) (x₂ : X₂) :
    Rel' f g (Sum.inl x₁) (Sum.inr x₂) ↔
      ∃ (s : S), x₁ = f s ∧ x₂ = g s 
Arguments: {S X₁ X₂ : Type u} (f : S ⟶ X₁) (g : S ⟶ X₂) (x₁ : X₁) (x₂ : X₂)
Goal: CategoryTheory.Limits.Types.Pushout.Rel' f g (Sum.inl x₁) (Sum.inr x₂) ↔ ∃ s, x₁ = f s ∧ x₂ = g s
-- CategoryTheory.Limits.Types.Pushout.inr_rel'_inr_iff
@[simp]
lemma inr_rel'_inr_iff (x₂ y₂ : X₂) :
    Rel' f g (Sum.inr x₂) (Sum.inr y₂) ↔ x₂ = y₂ 
Arguments: {S X₁ X₂ : Type u} (f : S ⟶ X₁) (g : S ⟶ X₂) (x₂ y₂ : X₂)
Goal: CategoryTheory.Limits.Types.Pushout.Rel' f g (Sum.inr x₂) (Sum.inr y₂) ↔ x₂ = y₂
-- CategoryTheory.Limits.Types.Pushout.Rel'.symm
lemma Rel'.symm {x y : X₁ ⊕ X₂} (h : Rel' f g x y) :
    Rel' f g y x 
Arguments: {S X₁ X₂ : Type u} {f : S ⟶ X₁} {g : S ⟶ X₂} {x y : X₁ ⊕ X₂} (h : CategoryTheory.Limits.Types.Pushout.Rel' f g x y)
Goal: CategoryTheory.Limits.Types.Pushout.Rel' f g y x
-- CategoryTheory.Limits.Types.Pushout.equivalence_rel'
lemma equivalence_rel' [Mono f] : _root_.Equivalence (Rel' f g) 
Arguments: {S X₁ X₂ : Type u} (f : S ⟶ X₁) (g : S ⟶ X₂) [CategoryTheory.Mono f]
Goal: Equivalence (CategoryTheory.Limits.Types.Pushout.Rel' f g)
-- CategoryTheory.Limits.Types.Pushout.quot_mk_eq_iff
lemma quot_mk_eq_iff [Mono f] (a b : X₁ ⊕ X₂) :
    (Quot.mk _ a : Pushout f g) = Quot.mk _ b ↔ Rel' f g a b 
Arguments: {S X₁ X₂ : Type u} (f : S ⟶ X₁) (g : S ⟶ X₂) [CategoryTheory.Mono f] (a b : X₁ ⊕ X₂)
Goal: Quot.mk (CategoryTheory.Limits.Types.Pushout.Rel f g) a = Quot.mk (CategoryTheory.Limits.Types.Pushout.Rel f g) b ↔
  CategoryTheory.Limits.Types.Pushout.Rel' f g a b
-- CategoryTheory.Limits.Types.Pushout.inl_eq_inr_iff
lemma inl_eq_inr_iff [Mono f] (x₁ : X₁) (x₂ : X₂) :
    (inl f g x₁ = inr f g x₂) ↔
      ∃ (s : S), f s = x₁ ∧ g s = x₂ 
Arguments: {S X₁ X₂ : Type u} (f : S ⟶ X₁) (g : S ⟶ X₂) [CategoryTheory.Mono f] (x₁ : X₁) (x₂ : X₂)
Goal: CategoryTheory.Limits.Types.Pushout.inl f g x₁ = CategoryTheory.Limits.Types.Pushout.inr f g x₂ ↔
  ∃ s, f s = x₁ ∧ g s = x₂
-- CategoryTheory.Limits.Types.pushoutCocone_inl_eq_inr_imp_of_iso
lemma pushoutCocone_inl_eq_inr_imp_of_iso {c c' : PushoutCocone f g} (e : c ≅ c')
    (x₁ : X₁) (x₂ : X₂) (h : c.inl x₁ = c.inr x₂) :
    c'.inl x₁ = c'.inr x₂ 
Arguments: {S X₁ X₂ : Type u} {f : S ⟶ X₁} {g : S ⟶ X₂} {c c' : CategoryTheory.Limits.PushoutCocone f g} (e : c ≅ c') (x₁ : X₁) (x₂ : X₂) (h : c.inl x₁ = c.inr x₂)
Goal: c'.inl x₁ = c'.inr x₂
-- CategoryTheory.Limits.Types.pushoutCocone_inl_eq_inr_iff_of_iso
lemma pushoutCocone_inl_eq_inr_iff_of_iso {c c' : PushoutCocone f g} (e : c ≅ c')
    (x₁ : X₁) (x₂ : X₂) :
    c.inl x₁ = c.inr x₂ ↔ c'.inl x₁ = c'.inr x₂ 
Arguments: {S X₁ X₂ : Type u} {f : S ⟶ X₁} {g : S ⟶ X₂} {c c' : CategoryTheory.Limits.PushoutCocone f g} (e : c ≅ c') (x₁ : X₁) (x₂ : X₂)
Goal: c.inl x₁ = c.inr x₂ ↔ c'.inl x₁ = c'.inr x₂
-- CategoryTheory.Limits.Types.pushoutCocone_inl_eq_inr_iff_of_isColimit
lemma pushoutCocone_inl_eq_inr_iff_of_isColimit {c : PushoutCocone f g} (hc : IsColimit c)
    (h₁ : Function.Injective f) (x₁ : X₁) (x₂ : X₂) :
    c.inl x₁ = c.inr x₂ ↔ ∃ (s : S), f s = x₁ ∧ g s = x₂ 
Arguments: {S X₁ X₂ : Type u} {f : S ⟶ X₁} {g : S ⟶ X₂} {c : CategoryTheory.Limits.PushoutCocone f g} (hc : CategoryTheory.Limits.IsColimit c) (h₁ : Function.Injective f) (x₁ : X₁) (x₂ : X₂)
Goal: c.inl x₁ = c.inr x₂ ↔ ∃ s, f s = x₁ ∧ g s = x₂
-- CategoryTheory.Limits.MulticospanIndex.sections.property
@[ext]
structure MulticospanIndex.sections where
    val (i : I.L) : I.left i
  property (r : I.R) : I.fst r (val _) = I.snd r (val _)
Arguments: {I : CategoryTheory.Limits.MulticospanIndex (Type u)} (self : I.sections) (r : I.R)
Goal: I.fst r (self.val (I.fstTo r)) = I.snd r (self.val (I.sndTo r))
-- CategoryTheory.Limits.MulticospanIndex.sectionsEquiv_symm_apply_val
@[simps]
def MulticospanIndex.sectionsEquiv :
    I.sections ≃ I.multicospan.sections 
Arguments: (I : CategoryTheory.Limits.MulticospanIndex (Type u)) (s : ↑I.multicospan.sections) (i : I.L)
Goal: (I.sectionsEquiv.symm s).val i = ↑s (CategoryTheory.Limits.WalkingMulticospan.left i)
-- CategoryTheory.Limits.MulticospanIndex.sectionsEquiv_apply_coe
@[simps]
def MulticospanIndex.sectionsEquiv :
    I.sections ≃ I.multicospan.sections 
Arguments: (I : CategoryTheory.Limits.MulticospanIndex (Type u)) (s : I.sections) (i : CategoryTheory.Limits.WalkingMulticospan I.fstTo I.sndTo)
Goal: ↑(I.sectionsEquiv s) i =
  match i with
  | CategoryTheory.Limits.WalkingMulticospan.left i => s.val i
  | CategoryTheory.Limits.WalkingMulticospan.right j => I.fst j (s.val (I.fstTo j))
-- CategoryTheory.Limits.Multifork.toSections_val
@[simps]
def toSections (x : c.pt) : I.sections 
Arguments: {I : CategoryTheory.Limits.MulticospanIndex (Type u)} (c : CategoryTheory.Limits.Multifork I) (x : c.pt) (i : I.L)
Goal: (c.toSections x).val i = c.ι i x
-- CategoryTheory.Limits.Multifork.toSections_fac
lemma toSections_fac : I.sectionsEquiv.symm ∘ Types.sectionOfCone c = c.toSections 
Arguments: {I : CategoryTheory.Limits.MulticospanIndex (Type u)} (c : CategoryTheory.Limits.Multifork I)
Goal: ⇑I.sectionsEquiv.symm ∘ CategoryTheory.Limits.Types.sectionOfCone c = c.toSections
-- CategoryTheory.Limits.Multifork.isLimit_types_iff
lemma isLimit_types_iff : Nonempty (IsLimit c) ↔ Function.Bijective c.toSections 
Arguments: {I : CategoryTheory.Limits.MulticospanIndex (Type u)} (c : CategoryTheory.Limits.Multifork I)
Goal: Nonempty (CategoryTheory.Limits.IsLimit c) ↔ Function.Bijective c.toSections
-- CategoryTheory.Limits.Multifork.IsLimit.sectionsEquiv_symm_apply_val
@[simp]
lemma sectionsEquiv_symm_apply_val (x : c.pt) (i : I.L) :
    ((sectionsEquiv hc).symm x).val i = c.ι i x 
Arguments: {I : CategoryTheory.Limits.MulticospanIndex (Type u)} {c : CategoryTheory.Limits.Multifork I} (hc : CategoryTheory.Limits.IsLimit c) (x : c.pt) (i : I.L)
Goal: ((CategoryTheory.Limits.Multifork.IsLimit.sectionsEquiv hc).symm x).val i = c.ι i x
-- CategoryTheory.Limits.Multifork.IsLimit.sectionsEquiv_apply_val
@[simp]
lemma sectionsEquiv_apply_val (s : I.sections) (i : I.L) :
    c.ι i (sectionsEquiv hc s) = s.val i 
Arguments: {I : CategoryTheory.Limits.MulticospanIndex (Type u)} {c : CategoryTheory.Limits.Multifork I} (hc : CategoryTheory.Limits.IsLimit c) (s : I.sections) (i : I.L)
Goal: c.ι i ((CategoryTheory.Limits.Multifork.IsLimit.sectionsEquiv hc) s) = s.val i
-- CategoryTheory.Presheaf.restrictedYoneda_obj_obj
@[simps!]
def restrictedYoneda : ℰ ⥤ Cᵒᵖ ⥤ Type v₁ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {ℰ : Type u₂} [CategoryTheory.Category.{v₁, u₂} ℰ] (A : CategoryTheory.Functor C ℰ) (X : ℰ)
Goal: ∀ (X_1 : Cᵒᵖ), ((CategoryTheory.Presheaf.restrictedYoneda A).obj X).obj X_1 = (A.obj (Opposite.unop X_1) ⟶ X)
-- CategoryTheory.Presheaf.restrictedYoneda_map_app
@[simps!]
def restrictedYoneda : ℰ ⥤ Cᵒᵖ ⥤ Type v₁ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {ℰ : Type u₂} [CategoryTheory.Category.{v₁, u₂} ℰ] (A : CategoryTheory.Functor C ℰ)
Goal: ∀ {X Y : ℰ} (f : X ⟶ Y) (X_1 : Cᵒᵖ) (a : (CategoryTheory.yoneda.obj X).obj (A.op.obj X_1)),
  ((CategoryTheory.Presheaf.restrictedYoneda A).map f).app X_1 a = CategoryTheory.CategoryStruct.comp a f
-- CategoryTheory.Presheaf.restrictedYoneda_obj_map
@[simps!]
def restrictedYoneda : ℰ ⥤ Cᵒᵖ ⥤ Type v₁ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {ℰ : Type u₂} [CategoryTheory.Category.{v₁, u₂} ℰ] (A : CategoryTheory.Functor C ℰ) (X : ℰ)
Goal: ∀ {X_1 Y : Cᵒᵖ} (f : X_1 ⟶ Y) (a : (CategoryTheory.yoneda.obj X).obj (A.op.obj X_1)),
  ((CategoryTheory.Presheaf.restrictedYoneda A).obj X).map f a = CategoryTheory.CategoryStruct.comp (A.map f.unop) a
-- CategoryTheory.Presheaf.isIso_of_isLeftKanExtension
lemma isIso_of_isLeftKanExtension : IsIso α 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {ℰ : Type u₂} [CategoryTheory.Category.{v₁, u₂} ℰ] {A : CategoryTheory.Functor C ℰ} [CategoryTheory.yoneda.HasPointwiseLeftKanExtension A] (L : CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ (Type v₁)) ℰ) (α : A ⟶ CategoryTheory.yoneda.comp L) [L.IsLeftKanExtension α]
Goal: CategoryTheory.IsIso α
-- CategoryTheory.Presheaf.coconeOfRepresentable_pt
@[simps]
noncomputable def coconeOfRepresentable (P : Cᵒᵖ ⥤ Type v₁) :
    Cocone (functorToRepresentables P) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (P : CategoryTheory.Functor Cᵒᵖ (Type v₁))
Goal: (CategoryTheory.Presheaf.coconeOfRepresentable P).pt = P
-- CategoryTheory.Presheaf.coconeOfRepresentable_ι_app
@[simps]
noncomputable def coconeOfRepresentable (P : Cᵒᵖ ⥤ Type v₁) :
    Cocone (functorToRepresentables P) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (P : CategoryTheory.Functor Cᵒᵖ (Type v₁)) (x : P.Elementsᵒᵖ)
Goal: (CategoryTheory.Presheaf.coconeOfRepresentable P).ι.app x = CategoryTheory.yonedaEquiv.symm (Opposite.unop x).snd
-- CategoryTheory.Presheaf.coconeOfRepresentable_naturality
theorem coconeOfRepresentable_naturality {P₁ P₂ : Cᵒᵖ ⥤ Type v₁} (α : P₁ ⟶ P₂) (j : P₁.Elementsᵒᵖ) :
    (coconeOfRepresentable P₁).ι.app j ≫ α =
      (coconeOfRepresentable P₂).ι.app ((CategoryOfElements.map α).op.obj j) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P₁ P₂ : CategoryTheory.Functor Cᵒᵖ (Type v₁)} (α : P₁ ⟶ P₂) (j : P₁.Elementsᵒᵖ)
Goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.Presheaf.coconeOfRepresentable P₁).ι.app j) α =
  (CategoryTheory.Presheaf.coconeOfRepresentable P₂).ι.app ((CategoryTheory.CategoryOfElements.map α).op.obj j)
-- CategoryTheory.Presheaf.isLeftKanExtension_along_yoneda_iff
lemma isLeftKanExtension_along_yoneda_iff :
    L.IsLeftKanExtension α ↔
      (IsIso α ∧ Nonempty (PreservesColimitsOfSize.{v₁, max u₁ v₁} L)) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {ℰ : Type u₂} [CategoryTheory.Category.{v₁, u₂} ℰ] {A : CategoryTheory.Functor C ℰ} [CategoryTheory.yoneda.HasPointwiseLeftKanExtension A] (L : CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ (Type v₁)) ℰ) (α : A ⟶ CategoryTheory.yoneda.comp L)
Goal: L.IsLeftKanExtension α ↔
  CategoryTheory.IsIso α ∧
    Nonempty (CategoryTheory.Limits.PreservesColimitsOfSize.{v₁, max u₁ v₁, max u₁ v₁, v₁, max u₁ (v₁ + 1), u₂} L)
-- CategoryTheory.Presheaf.isLeftKanExtension_of_preservesColimits
lemma isLeftKanExtension_of_preservesColimits
    (L : (Cᵒᵖ ⥤ Type v₁) ⥤ ℰ) (e : A ≅ yoneda ⋙ L)
    [PreservesColimitsOfSize.{v₁, max u₁ v₁} L] :
    L.IsLeftKanExtension e.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {ℰ : Type u₂} [CategoryTheory.Category.{v₁, u₂} ℰ] {A : CategoryTheory.Functor C ℰ} [CategoryTheory.yoneda.HasPointwiseLeftKanExtension A] (L : CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ (Type v₁)) ℰ) (e : A ≅ CategoryTheory.yoneda.comp L) [CategoryTheory.Limits.PreservesColimitsOfSize.{v₁, max u₁ v₁, max u₁ v₁, v₁, max u₁ (v₁ + 1), u₂} L]
Goal: L.IsLeftKanExtension e.hom
-- CategoryTheory.Presheaf.isLeftAdjoint_of_preservesColimits
lemma isLeftAdjoint_of_preservesColimits (L : (C ⥤ Type v₁) ⥤ ℰ)
    [PreservesColimitsOfSize.{v₁, max u₁ v₁} L]
    [yoneda.HasPointwiseLeftKanExtension
      (yoneda ⋙ (opOpEquivalence C).congrLeft.functor.comp L)] :
    L.IsLeftAdjoint 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {ℰ : Type u₂} [CategoryTheory.Category.{v₁, u₂} ℰ] (L : CategoryTheory.Functor (CategoryTheory.Functor C (Type v₁)) ℰ) [CategoryTheory.Limits.PreservesColimitsOfSize.{v₁, max u₁ v₁, max u₁ v₁, v₁, max u₁ (v₁ + 1), u₂} L] [CategoryTheory.yoneda.HasPointwiseLeftKanExtension
    (CategoryTheory.yoneda.comp ((CategoryTheory.opOpEquivalence C).congrLeft.functor.comp L))]
Goal: L.IsLeftAdjoint
-- CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan_inv_app_app_apply_eq_id
@[simp]
lemma compYonedaIsoYonedaCompLan_inv_app_app_apply_eq_id (X : C) :
    ((compYonedaIsoYonedaCompLan F).inv.app X).app (Opposite.op (F.obj X))
      ((F.op.lanUnit.app (yoneda.obj X)).app _ (𝟙 X)) = 𝟙 _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₁, u₂} D] (F : CategoryTheory.Functor C D) [∀ (P : CategoryTheory.Functor Cᵒᵖ (Type v₁)), F.op.HasLeftKanExtension P] (X : C)
Goal: ((CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan F).inv.app X).app (Opposite.op (F.obj X))
    ((F.op.lanUnit.app (CategoryTheory.yoneda.obj X)).app (Opposite.op X) (CategoryTheory.CategoryStruct.id X)) =
  CategoryTheory.CategoryStruct.id (Opposite.unop (Opposite.op (F.obj X)))
-- CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.coconeApp_naturality
@[reassoc (attr := simp)]
lemma coconeApp_naturality {P : Cᵒᵖ ⥤ Type v₁} {x y : P.Elements} (f : x ⟶ y) :
    yoneda.map f.1.unop ≫ coconeApp φ x = coconeApp φ y 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₁, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ (Type v₁)) (CategoryTheory.Functor Dᵒᵖ (Type v₁))} (φ : F.comp CategoryTheory.yoneda ⟶ CategoryTheory.yoneda.comp G) {P : CategoryTheory.Functor Cᵒᵖ (Type v₁)} {x y : P.Elements} (f : x ⟶ y)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.yoneda.map (↑f).unop)
    (CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.coconeApp φ x) =
  CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.coconeApp φ y
-- CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.yonedaEquiv_ι_presheafHom
lemma yonedaEquiv_ι_presheafHom (P : Cᵒᵖ ⥤ Type v₁) {X : C} (f : yoneda.obj X ⟶ P) :
    yonedaEquiv (f ≫ presheafHom φ P) =
      (G.map f).app (Opposite.op (F.obj X)) ((φ.app X).app _ (𝟙 _)) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₁, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ (Type v₁)) (CategoryTheory.Functor Dᵒᵖ (Type v₁))} (φ : F.comp CategoryTheory.yoneda ⟶ CategoryTheory.yoneda.comp G) (P : CategoryTheory.Functor Cᵒᵖ (Type v₁)) {X : C} (f : CategoryTheory.yoneda.obj X ⟶ P)
Goal: CategoryTheory.yonedaEquiv
    (CategoryTheory.CategoryStruct.comp f (CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.presheafHom φ P)) =
  (G.map f).app (Opposite.op (F.obj X))
    ((φ.app X).app (Opposite.op (F.obj X)) (CategoryTheory.CategoryStruct.id (Opposite.unop (Opposite.op (F.obj X)))))
-- CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.yonedaEquiv_presheafHom_yoneda_obj
lemma yonedaEquiv_presheafHom_yoneda_obj (X : C) :
    yonedaEquiv (presheafHom φ (yoneda.obj X)) =
      ((φ.app X).app (F.op.obj (Opposite.op X)) (𝟙 _)) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₁, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ (Type v₁)) (CategoryTheory.Functor Dᵒᵖ (Type v₁))} (φ : F.comp CategoryTheory.yoneda ⟶ CategoryTheory.yoneda.comp G) (X : C)
Goal: CategoryTheory.yonedaEquiv
    (CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.presheafHom φ (CategoryTheory.yoneda.obj X)) =
  (φ.app X).app (F.op.obj (Opposite.op X)) (CategoryTheory.CategoryStruct.id (Opposite.unop (F.op.obj (Opposite.op X))))
-- CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.presheafHom_naturality
@[reassoc (attr := simp)]
lemma presheafHom_naturality {P Q : Cᵒᵖ ⥤ Type v₁} (f : P ⟶ Q) :
    presheafHom φ P ≫ whiskerLeft F.op (G.map f) = f ≫ presheafHom φ Q 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₁, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ (Type v₁)) (CategoryTheory.Functor Dᵒᵖ (Type v₁))} (φ : F.comp CategoryTheory.yoneda ⟶ CategoryTheory.yoneda.comp G) {P Q : CategoryTheory.Functor Cᵒᵖ (Type v₁)} (f : P ⟶ Q)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.presheafHom φ P)
    (CategoryTheory.whiskerLeft F.op (G.map f)) =
  CategoryTheory.CategoryStruct.comp f (CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.presheafHom φ Q)
-- CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.natTrans_app_yoneda_obj
lemma natTrans_app_yoneda_obj (X : C) : (natTrans φ).app (yoneda.obj X) =
    (compYonedaIsoYonedaCompLan F).inv.app X ≫ φ.app X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₁, u₂} D] {F : CategoryTheory.Functor C D} [∀ (P : CategoryTheory.Functor Cᵒᵖ (Type v₁)), F.op.HasLeftKanExtension P] {G : CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ (Type v₁)) (CategoryTheory.Functor Dᵒᵖ (Type v₁))} (φ : F.comp CategoryTheory.yoneda ⟶ CategoryTheory.yoneda.comp G) (X : C)
Goal: (CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.natTrans φ).app (CategoryTheory.yoneda.obj X) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan F).inv.app X) (φ.app X)
-- CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan.hom_ext
@[ext]
lemma hom_ext {Φ : yoneda.LeftExtension (F ⋙ yoneda)}
    (f g : Functor.LeftExtension.mk F.op.lan (compYonedaIsoYonedaCompLan F).hom ⟶ Φ) :
    f = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₁, u₂} D] {F : CategoryTheory.Functor C D} [∀ (P : CategoryTheory.Functor Cᵒᵖ (Type v₁)), F.op.HasLeftKanExtension P] {Φ : CategoryTheory.yoneda.LeftExtension (F.comp CategoryTheory.yoneda)} (f g : CategoryTheory.Functor.LeftExtension.mk F.op.lan (CategoryTheory.Presheaf.compYonedaIsoYonedaCompLan F).hom ⟶ Φ)
Goal: f = g
-- CategoryTheory.Presheaf.tautologicalCocone_pt
@[simps]
def tautologicalCocone : Cocone (CostructuredArrow.proj yoneda P ⋙ yoneda) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (P : CategoryTheory.Functor Cᵒᵖ (Type v₁))
Goal: (CategoryTheory.Presheaf.tautologicalCocone P).pt = P
-- CategoryTheory.Presheaf.tautologicalCocone_ι_app
@[simps]
def tautologicalCocone : Cocone (CostructuredArrow.proj yoneda P ⋙ yoneda) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (P : CategoryTheory.Functor Cᵒᵖ (Type v₁)) (X : CategoryTheory.CostructuredArrow CategoryTheory.yoneda P)
Goal: (CategoryTheory.Presheaf.tautologicalCocone P).ι.app X = X.hom
-- CategoryTheory.Presheaf.final_toCostructuredArrow_comp_pre
theorem final_toCostructuredArrow_comp_pre {c : Cocone (F ⋙ yoneda)} (hc : IsColimit c) :
    Functor.Final (c.toCostructuredArrow ⋙ CostructuredArrow.pre F yoneda c.pt) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {I : Type v₁} [CategoryTheory.SmallCategory I] (F : CategoryTheory.Functor I C) {c : CategoryTheory.Limits.Cocone (F.comp CategoryTheory.yoneda)} (hc : CategoryTheory.Limits.IsColimit c)
Goal: (c.toCostructuredArrow.comp (CategoryTheory.CostructuredArrow.pre F CategoryTheory.yoneda c.pt)).Final
-- CategoryTheory.Limits.HasZeroMorphisms.zero_comp
class HasZeroMorphisms where
    [zero : ∀ X Y : C, Zero (X ⟶ Y)]
    comp_zero : ∀ {X Y : C} (f : X ⟶ Y) (Z : C), f ≫ (0 : Y ⟶ Z) = (0 : X ⟶ Z) := by aesop_cat
    zero_comp : ∀ (X : C) {Y Z : C} (f : Y ⟶ Z), (0 : X ⟶ Y) ≫ f = (0 : X ⟶ Z) := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Limits.HasZeroMorphisms C] (X : C) {Y Z : C} (f : Y ⟶ Z)
Goal: 0 ≫ f = 0
-- CategoryTheory.Limits.HasZeroMorphisms.comp_zero
class HasZeroMorphisms where
    [zero : ∀ X Y : C, Zero (X ⟶ Y)]
    comp_zero : ∀ {X Y : C} (f : X ⟶ Y) (Z : C), f ≫ (0 : Y ⟶ Z) = (0 : X ⟶ Z) := by aesop_cat
    zero_comp : ∀ (X : C) {Y Z : C} (f : Y ⟶ Z), (0 : X ⟶ Y) ≫ f = (0 : X ⟶ Z) := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C} (f : X ⟶ Y) (Z : C)
Goal: f ≫ 0 = 0