ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/CategoryTheory/Localization/Equivalence.lean

full_name: CategoryTheory.Localization.equivalence
code: /-- Basic constructor of an equivalence between localized categories -/
noncomputable def equivalence : D₁ ≌ D₂ 
goal: D₁ ≌ D₂

full_name: CategoryTheory.Localization.equivalence_counitIso_app
code: @[simp]
lemma equivalence_counitIso_app (X : C₂) :
    (equivalence L₁ W₁ L₂ W₂ G G' F F' α β).counitIso.app (L₂.obj X) =
      (Lifting.iso L₂ W₂ (F ⋙ G') (F' ⋙ G')).app X ≪≫ β.app X 
goal: (CategoryTheory.Localization.equivalence L₁ W₁ L₂ W₂ G G' F F' α β).counitIso.app (L₂.obj X) =
  (CategoryTheory.Localization.Lifting.iso L₂ W₂ (F.comp G') (F'.comp G')).app X ≪≫ β.app X

full_name: CategoryTheory.Localization.isEquivalence
code: /-- Basic constructor of an equivalence between localized categories -/
lemma isEquivalence : G'.IsEquivalence 
goal: G'.IsEquivalence

full_name: CategoryTheory.Functor.IsLocalization.of_equivalence_source
code: /-- If `L₁ : C₁ ⥤ D` is a localization functor for `W₁ : MorphismProperty C₁`, then it is also
the case of a functor `L₂ : C₂ ⥤ D` for a suitable `W₂ : MorphismProperty C₂` when
we have an equivalence of category `E : C₁ ≌ C₂` and an isomorphism `E.functor ⋙ L₂ ≅ L₁`. -/
lemma of_equivalence_source (L₁ : C₁ ⥤ D) (W₁ : MorphismProperty C₁)
    (L₂ : C₂ ⥤ D) (W₂ : MorphismProperty C₂)
    (E : C₁ ≌ C₂) (hW₁ : W₁ ≤ W₂.isoClosure.inverseImage E.functor) (hW₂ : W₂.IsInvertedBy L₂)
    [L₁.IsLocalization W₁] (iso : E.functor ⋙ L₂ ≅ L₁) : L₂.IsLocalization W₂ 
goal: L₂.IsLocalization W₂

full_name: CategoryTheory.Functor.IsLocalization.of_equivalences
code: /-- If `L₁ : C₁ ⥤ D₁` is a localization functor for `W₁ : MorphismProperty C₁`, then if we
transport this functor `L₁` via equivalences `C₁ ≌ C₂` and `D₁ ≌ D₂` to get a functor
`L₂ : C₂ ⥤ D₂`, then `L₂` is also a localization functor for
a suitable `W₂ : MorphismProperty C₂`. -/
lemma of_equivalences (L₁ : C₁ ⥤ D₁) (W₁ : MorphismProperty C₁) [L₁.IsLocalization W₁]
    (L₂ : C₂ ⥤ D₂) (W₂ : MorphismProperty C₂)
    (E : C₁ ≌ C₂) (E' : D₁ ≌ D₂) [CatCommSq E.functor L₁ L₂ E'.functor]
    (hW₁ : W₁ ≤ W₂.isoClosure.inverseImage E.functor) (hW₂ : W₂.IsInvertedBy L₂) :
    L₂.IsLocalization W₂ 
goal: L₂.IsLocalization W₂
File: Mathlib/CategoryTheory/Preadditive/FunctorCategory.lean

full_name: CategoryTheory.instZeroHomFunctor
code: instance {F G : C ⥤ D} : Zero (F ⟶ G) 
goal: Zero (F ⟶ G)

full_name: CategoryTheory.instAddHomFunctor
code: instance {F G : C ⥤ D} : Add (F ⟶ G) 
goal: Add (F ⟶ G)

full_name: CategoryTheory.instNegHomFunctor
code: instance {F G : C ⥤ D} : Neg (F ⟶ G) 
goal: Neg (F ⟶ G)

full_name: CategoryTheory.functorCategoryPreadditive
code: instance functorCategoryPreadditive : Preadditive (C ⥤ D) 
goal: CategoryTheory.Preadditive (CategoryTheory.Functor C D)

full_name: CategoryTheory.NatTrans.appHom
code: /-- Application of a natural transformation at a fixed object,
as group homomorphism -/
@[simps]
def appHom (X : C) : (F ⟶ G) →+ (F.obj X ⟶ G.obj X) 
goal: (F ⟶ G) →+ (F.obj X ⟶ G.obj X)

full_name: CategoryTheory.NatTrans.appHom_apply
code: /-- Application of a natural transformation at a fixed object,
as group homomorphism -/
@[simps]
def appHom (X : C) : (F ⟶ G) →+ (F.obj X ⟶ G.obj X) 
goal: (CategoryTheory.NatTrans.appHom X) α = α.app X

full_name: CategoryTheory.NatTrans.app_zero
code: @[simp]
theorem app_zero (X : C) : (0 : F ⟶ G).app X = 0 
goal: CategoryTheory.NatTrans.app 0 X = 0

full_name: CategoryTheory.NatTrans.app_add
code: @[simp]
theorem app_add (X : C) (α β : F ⟶ G) : (α + β).app X = α.app X + β.app X 
goal: (α + β).app X = α.app X + β.app X

full_name: CategoryTheory.NatTrans.app_sub
code: @[simp]
theorem app_sub (X : C) (α β : F ⟶ G) : (α - β).app X = α.app X - β.app X 
goal: (α - β).app X = α.app X - β.app X

full_name: CategoryTheory.NatTrans.app_neg
code: @[simp]
theorem app_neg (X : C) (α : F ⟶ G) : (-α).app X = -α.app X 
goal: (-α).app X = -α.app X

full_name: CategoryTheory.NatTrans.app_nsmul
code: @[simp]
theorem app_nsmul (X : C) (α : F ⟶ G) (n : ℕ) : (n • α).app X = n • α.app X 
goal: (n • α).app X = n • α.app X

full_name: CategoryTheory.NatTrans.app_zsmul
code: @[simp]
theorem app_zsmul (X : C) (α : F ⟶ G) (n : ℤ) : (n • α).app X = n • α.app X 
goal: (n • α).app X = n • α.app X

full_name: CategoryTheory.NatTrans.app_units_zsmul
code: @[simp]
theorem app_units_zsmul (X : C) (α : F ⟶ G) (n : ℤˣ) : (n • α).app X = n • α.app X 
goal: (n • α).app X = n • α.app X

full_name: CategoryTheory.NatTrans.app_sum
code: @[simp]
theorem app_sum {ι : Type*} (s : Finset ι) (X : C) (α : ι → (F ⟶ G)) :
    (∑ i ∈ s, α i).app X = ∑ i ∈ s, (α i).app X 
goal: (∑ i ∈ s, α i).app X = ∑ i ∈ s, (α i).app X
File: Mathlib/CategoryTheory/Localization/Opposite.lean

full_name: CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.op
code: /-- If `L : C ⥤ D` satisfies the universal property of the localisation
for `W : MorphismProperty C`, then `L.op` also does. -/
def StrictUniversalPropertyFixedTarget.op {E : Type*} [Category E]
    (h : StrictUniversalPropertyFixedTarget L W Eᵒᵖ) :
    StrictUniversalPropertyFixedTarget L.op W.op E 
goal: CategoryTheory.Localization.StrictUniversalPropertyFixedTarget L.op W.op E

full_name: CategoryTheory.Localization.isLocalization_op
code: instance isLocalization_op : W.Q.op.IsLocalization W.op 
goal: W.Q.op.IsLocalization W.op

full_name: CategoryTheory.Functor.IsLocalization.op
code: instance IsLocalization.op : L.op.IsLocalization W.op 
goal: L.op.IsLocalization W.op

full_name: CategoryTheory.Localization.isoOfHom_unop
code: lemma isoOfHom_unop  {X Y : Cᵒᵖ} (w : X ⟶ Y) (hw : W.op w) :
    (isoOfHom L.op W.op w hw).unop = (isoOfHom L W w.unop hw) 
goal: (CategoryTheory.Localization.isoOfHom L.op W.op w hw).unop = CategoryTheory.Localization.isoOfHom L W w.unop hw

full_name: CategoryTheory.Localization.isoOfHom_op_inv
code: lemma isoOfHom_op_inv {X Y : Cᵒᵖ} (w : X ⟶ Y) (hw : W.op w) :
    (isoOfHom L.op W.op w hw).inv = (isoOfHom L W w.unop hw).inv.op 
goal: (CategoryTheory.Localization.isoOfHom L.op W.op w hw).inv = (CategoryTheory.Localization.isoOfHom L W w.unop hw).inv.op
File: Mathlib/CategoryTheory/Localization/Composition.lean

full_name: CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.comp
code: /-- Under some conditions on the `MorphismProperty`, functors satisfying the strict
universal property of the localization are stable under composition -/
def StrictUniversalPropertyFixedTarget.comp
    (h₁ : StrictUniversalPropertyFixedTarget L₁ W₁ E)
    (h₂ : StrictUniversalPropertyFixedTarget L₂ W₂ E)
    (W₃ : MorphismProperty C₁) (hW₃ : W₃.IsInvertedBy (L₁ ⋙ L₂))
    (hW₁₃ : W₁ ≤ W₃) (hW₂₃ : W₂ ≤ W₃.map L₁) :
    StrictUniversalPropertyFixedTarget (L₁ ⋙ L₂) W₃ E 
goal: CategoryTheory.Localization.StrictUniversalPropertyFixedTarget (L₁.comp L₂) W₃ E

full_name: CategoryTheory.Functor.IsLocalization.comp
code: lemma comp [L₁.IsLocalization W₁] [L₂.IsLocalization W₂]
    (W₃ : MorphismProperty C₁) (hW₃ : W₃.IsInvertedBy (L₁ ⋙ L₂))
    (hW₁₃ : W₁ ≤ W₃) (hW₂₃ : W₂ ≤ W₃.map L₁) :
    (L₁ ⋙ L₂).IsLocalization W₃ 
goal: (L₁.comp L₂).IsLocalization W₃

full_name: CategoryTheory.Functor.IsLocalization.of_comp
code: lemma of_comp (W₃ : MorphismProperty C₁)
    [L₁.IsLocalization W₁] [(L₁ ⋙ L₂).IsLocalization W₃]
    (hW₁₃ : W₁ ≤ W₃) (hW₂₃ : W₂ = W₃.map L₁) :
    L₂.IsLocalization W₂ 
goal: L₂.IsLocalization W₂
File: Mathlib/CategoryTheory/Localization/Prod.lean

full_name: CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prod_uniq
code: lemma prod_uniq (F₁ F₂ : (W₁.Localization × W₂.Localization ⥤ E))
    (h : (W₁.Q.prod W₂.Q) ⋙ F₁ = (W₁.Q.prod W₂.Q) ⋙ F₂) :
      F₁ = F₂ 
goal: F₁ = F₂

full_name: CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prodLift₁
code: /-- Auxiliary definition for `prodLift`. -/
noncomputable def prodLift₁ [W₂.ContainsIdentities]
    (hF : (W₁.prod W₂).IsInvertedBy F) :
    W₁.Localization ⥤ C₂ ⥤ E 
goal: CategoryTheory.Functor W₁.Localization (CategoryTheory.Functor C₂ E)

full_name: CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prod_fac₁
code: lemma prod_fac₁ [W₂.ContainsIdentities] :
    W₁.Q ⋙ prodLift₁ F hF = curry.obj F 
goal: W₁.Q.comp (CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prodLift₁ F hF) = CategoryTheory.curry.obj F

full_name: CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prodLift
code: /-- The lifting of a functor `F : C₁ × C₂ ⥤ E` inverting `W₁.prod W₂` to a functor
`W₁.Localization × W₂.Localization ⥤ E` -/
noncomputable def prodLift :
    W₁.Localization × W₂.Localization ⥤ E 
goal: CategoryTheory.Functor (W₁.Localization × W₂.Localization) E

full_name: CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prod_fac₂
code: lemma prod_fac₂ :
    W₂.Q ⋙ (curry.obj (prodLift F hF)).flip = (prodLift₁ F hF).flip 
goal: W₂.Q.comp
    (CategoryTheory.curry.obj (CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prodLift F hF)).flip =
  (CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prodLift₁ F hF).flip

full_name: CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prod_fac
code: lemma prod_fac :
    (W₁.Q.prod W₂.Q) ⋙ prodLift F hF = F 
goal: (W₁.Q.prod W₂.Q).comp (CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prodLift F hF) = F

full_name: CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prod
code: /-- The product of two (constructed) localized categories satisfies the universal
property of the localized category of the product. -/
noncomputable def prod :
    StrictUniversalPropertyFixedTarget (W₁.Q.prod W₂.Q) (W₁.prod W₂) E 
goal: CategoryTheory.Localization.StrictUniversalPropertyFixedTarget (W₁.Q.prod W₂.Q) (W₁.prod W₂) E

full_name: CategoryTheory.Localization.Construction.prodIsLocalization
code: lemma Construction.prodIsLocalization :
    (W₁.Q.prod W₂.Q).IsLocalization (W₁.prod W₂) 
goal: (W₁.Q.prod W₂.Q).IsLocalization (W₁.prod W₂)

full_name: CategoryTheory.Functor.IsLocalization.prod
code: /-- If `L₁ : C₁ ⥤ D₁` and `L₂ : C₂ ⥤ D₂` are localization functors
for `W₁ : MorphismProperty C₁` and `W₂ : MorphismProperty C₂` respectively,
and if both `W₁` and `W₂` contain identites, then the product
functor `L₁.prod L₂ : C₁ × C₂ ⥤ D₁ × D₂` is a localization functor for `W₁.prod W₂`. -/
instance prod [L₁.IsLocalization W₁] [L₂.IsLocalization W₂] :
    (L₁.prod L₂).IsLocalization (W₁.prod W₂) 
goal: (L₁.prod L₂).IsLocalization (W₁.prod W₂)
File: Mathlib/CategoryTheory/Localization/StructuredArrow.lean

full_name: CategoryTheory.Localization.structuredArrowEquiv
code: /-- The bijection `StructuredArrow (L.obj X) L ≃ StructuredArrow (L'.obj X) L'`
when `L` and `L'` are two localization functors for the same class of morphisms. -/
@[simps]
noncomputable def structuredArrowEquiv :
    StructuredArrow (L.obj X) L ≃ StructuredArrow (L'.obj X) L' 
goal: CategoryTheory.StructuredArrow (L.obj X) L ≃ CategoryTheory.StructuredArrow (L'.obj X) L'

full_name: CategoryTheory.Localization.structuredArrowEquiv_apply
code: /-- The bijection `StructuredArrow (L.obj X) L ≃ StructuredArrow (L'.obj X) L'`
when `L` and `L'` are two localization functors for the same class of morphisms. -/
@[simps]
noncomputable def structuredArrowEquiv :
    StructuredArrow (L.obj X) L ≃ StructuredArrow (L'.obj X) L' 
goal: (CategoryTheory.Localization.structuredArrowEquiv W L L') f =
  CategoryTheory.StructuredArrow.mk ((CategoryTheory.Localization.homEquiv W L L') f.hom)

full_name: CategoryTheory.Localization.structuredArrowEquiv_symm_apply
code: /-- The bijection `StructuredArrow (L.obj X) L ≃ StructuredArrow (L'.obj X) L'`
when `L` and `L'` are two localization functors for the same class of morphisms. -/
@[simps]
noncomputable def structuredArrowEquiv :
    StructuredArrow (L.obj X) L ≃ StructuredArrow (L'.obj X) L' 
goal: (CategoryTheory.Localization.structuredArrowEquiv W L L').symm f =
  CategoryTheory.StructuredArrow.mk ((CategoryTheory.Localization.homEquiv W L' L) f.hom)

full_name: _private.Mathlib.CategoryTheory.Localization.StructuredArrow.0.CategoryTheory.Localization.induction_structuredArrow'
code: private lemma induction_structuredArrow' (g : StructuredArrow (W.Q.obj X) W.Q) : P g 
goal: P g

full_name: CategoryTheory.Localization.induction_structuredArrow
code: @[elab_as_elim]
lemma induction_structuredArrow (g : StructuredArrow (L.obj X) L) : P g 
goal: P g

full_name: CategoryTheory.Localization.induction_costructuredArrow
code: @[elab_as_elim]
lemma induction_costructuredArrow (g : CostructuredArrow L (L.obj Y)) : P g 
goal: P g
File: Mathlib/CategoryTheory/Localization/HasLocalization.lean

full_name: CategoryTheory.MorphismProperty.HasLocalization.hD
code: /-- The data of a localized category with a given universe
for the morphisms.  -/
class HasLocalization where
  /-- the objects of the localized category. -/
  {D : Type u}
  /-- the category structure. -/
  [hD : Category.{w} D]
  /-- the localization functor. -/
  L : C ⥤ D
  [hL : L.IsLocalization W]
goal: CategoryTheory.Category.{w, u} (CategoryTheory.MorphismProperty.HasLocalization.D W)

full_name: CategoryTheory.MorphismProperty.HasLocalization
code: /-- The data of a localized category with a given universe
for the morphisms.  -/
class HasLocalization where
  /-- the objects of the localized category. -/
  {D : Type u}
  /-- the category structure. -/
  [hD : Category.{w} D]
  /-- the localization functor. -/
  L : C ⥤ D
  [hL : L.IsLocalization W]
goal: Type (max (max (u + 1) v) (w + 1))

full_name: CategoryTheory.MorphismProperty.HasLocalization.D
code: /-- The data of a localized category with a given universe
for the morphisms.  -/
class HasLocalization where
  /-- the objects of the localized category. -/
  {D : Type u}
  /-- the category structure. -/
  [hD : Category.{w} D]
  /-- the localization functor. -/
  L : C ⥤ D
  [hL : L.IsLocalization W]
goal: Type u

full_name: CategoryTheory.MorphismProperty.HasLocalization.L
code: /-- The data of a localized category with a given universe
for the morphisms.  -/
class HasLocalization where
  /-- the objects of the localized category. -/
  {D : Type u}
  /-- the category structure. -/
  [hD : Category.{w} D]
  /-- the localization functor. -/
  L : C ⥤ D
  [hL : L.IsLocalization W]
goal: CategoryTheory.Functor C (CategoryTheory.MorphismProperty.HasLocalization.D W)

full_name: CategoryTheory.MorphismProperty.HasLocalization.hL
code: /-- The data of a localized category with a given universe
for the morphisms.  -/
class HasLocalization where
  /-- the objects of the localized category. -/
  {D : Type u}
  /-- the category structure. -/
  [hD : Category.{w} D]
  /-- the localization functor. -/
  L : C ⥤ D
  [hL : L.IsLocalization W]
goal: CategoryTheory.MorphismProperty.HasLocalization.L.IsLocalization W

full_name: CategoryTheory.MorphismProperty.Localization'
code: /-- The localized category for `W : MorphismProperty C`
that is fixed by the `[HasLocalization W]` instance. -/
def Localization' 
goal: Type u

full_name: CategoryTheory.MorphismProperty.instCategoryLocalization'
code: instance : Category W.Localization' 
goal: CategoryTheory.Category.{w, u} W.Localization'

full_name: CategoryTheory.MorphismProperty.Q'
code: /-- The localization functor `C ⥤ W.Localization'`
that is fixed by the `[HasLocalization W]` instance. -/
def Q' : C ⥤ W.Localization' 
goal: CategoryTheory.Functor C W.Localization'

full_name: CategoryTheory.MorphismProperty.instIsLocalizationLocalization'Q'
code: instance : W.Q'.IsLocalization W 
goal: W.Q'.IsLocalization W

full_name: CategoryTheory.MorphismProperty.HasLocalization.standard
code: /-- The constructed localized category. -/
def HasLocalization.standard : HasLocalization.{max u v} W 
goal: W.HasLocalization
File: Mathlib/CategoryTheory/Localization/Pi.lean

full_name: CategoryTheory.Functor.IsLocalization.pi
code: instance pi {J : Type w} [Finite J] {C : J → Type u₁} {D : J → Type u₂}
    [∀ j, Category.{v₁} (C j)] [∀ j, Category.{v₂} (D j)]
    (L : ∀ j, C j ⥤ D j) (W : ∀ j, MorphismProperty (C j))
    [∀ j, (W j).ContainsIdentities] [∀ j, (L j).IsLocalization (W j)] :
    (Functor.pi L).IsLocalization (MorphismProperty.pi W) 
goal: (CategoryTheory.Functor.pi L).IsLocalization (CategoryTheory.MorphismProperty.pi W)

full_name: CategoryTheory.Functor.IsLocalization.instDiscreteObjWhiskeringRightFunctorCategoryOfFiniteOfContainsIdentities
code: /-- If `L : C ⥤ D` is a localization functor for `W : MorphismProperty C`, then
the induced functor `(Discrete J ⥤ C) ⥤ (Discrete J ⥤ D)` is also a localization
for `W.functorCategory (Discrete J)` if `W` contains identities. -/
instance {J : Type} [Finite J] {C : Type u₁} {D : Type u₂} [Category.{v₁} C] [Category.{v₂} D]
    (L : C ⥤ D) (W : MorphismProperty C) [W.ContainsIdentities] [L.IsLocalization W]  :
    ((whiskeringRight (Discrete J) C D).obj L).IsLocalization
      (W.functorCategory (Discrete J)) 
goal: ((CategoryTheory.whiskeringRight (CategoryTheory.Discrete J) C D).obj L).IsLocalization
  (W.functorCategory (CategoryTheory.Discrete J))
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions/ComposableArrows.lean

full_name: CategoryTheory.Localization.essSurj_mapComposableArrows_of_hasRightCalculusOfFractions
code: lemma essSurj_mapComposableArrows_of_hasRightCalculusOfFractions
    [W.HasRightCalculusOfFractions] (n : ℕ) :
    (L.mapComposableArrows n).EssSurj 
goal: (L.mapComposableArrows n).EssSurj

full_name: CategoryTheory.Localization.essSurj_mapComposableArrows
code: lemma essSurj_mapComposableArrows [W.HasLeftCalculusOfFractions] (n : ℕ) :
    (L.mapComposableArrows n).EssSurj 
goal: (L.mapComposableArrows n).EssSurj
File: Mathlib/CategoryTheory/PEmpty.lean

full_name: CategoryTheory.instIsEmptyDiscrete
code: instance (α : Type*) [IsEmpty α] : IsEmpty (Discrete α) 
goal: IsEmpty (CategoryTheory.Discrete α)

full_name: CategoryTheory.functorOfIsEmpty
code: /-- The (unique) functor from an empty category. -/
def functorOfIsEmpty [IsEmpty C] : C ⥤ D 
goal: CategoryTheory.Functor C D

full_name: CategoryTheory.Functor.isEmptyExt
code: /-- Any two functors out of an empty category are isomorphic. -/
def Functor.isEmptyExt [IsEmpty C] (F G : C ⥤ D) : F ≅ G 
goal: F ≅ G

full_name: CategoryTheory.equivalenceOfIsEmpty
code: /-- The equivalence between two empty categories. -/
def equivalenceOfIsEmpty [IsEmpty C] [IsEmpty D] : C ≌ D 
goal: C ≌ D

full_name: CategoryTheory.emptyEquivalence
code: /-- Equivalence between two empty categories. -/
def emptyEquivalence : Discrete.{w} PEmpty ≌ Discrete.{v} PEmpty 
goal: CategoryTheory.Discrete PEmpty.{w + 1} ≌ CategoryTheory.Discrete PEmpty.{v + 1}

full_name: CategoryTheory.Functor.empty
code: /-- The canonical functor out of the empty category. -/
def empty : Discrete.{w} PEmpty ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.Discrete PEmpty.{w + 1}) C

full_name: CategoryTheory.Functor.emptyExt
code: /-- Any two functors out of the empty category are isomorphic. -/
def emptyExt (F G : Discrete.{w} PEmpty ⥤ C) : F ≅ G 
goal: F ≅ G

full_name: CategoryTheory.Functor.uniqueFromEmpty
code: /-- Any functor out of the empty category is isomorphic to the canonical functor from the empty
category.
-/
def uniqueFromEmpty (F : Discrete.{w} PEmpty ⥤ C) : F ≅ empty C 
goal: F ≅ CategoryTheory.Functor.empty C

full_name: CategoryTheory.Functor.empty_ext'
code: /-- Any two functors out of the empty category are *equal*. You probably want to use
`emptyExt` instead of this.
-/
theorem empty_ext' (F G : Discrete.{w} PEmpty ⥤ C) : F = G 
goal: F = G
File: Mathlib/CategoryTheory/Shift/Predicate.lean

full_name: CategoryTheory.PredicateShift
code: /-- Given a predicate `P : C → Prop` on objects of a category equipped with a shift by `A`,
this is the predicate which is satisfied by `X` if `P (X⟦a⟧)`. -/
def PredicateShift (a : A) : C → Prop 
goal: C → Prop

full_name: CategoryTheory.predicateShift_iff
code: lemma predicateShift_iff (a : A) (X : C) : PredicateShift P a X ↔ P (X⟦a⟧) 
goal: CategoryTheory.PredicateShift P a X ↔ P ((CategoryTheory.shiftFunctor C a).obj X)

full_name: CategoryTheory.predicateShift_closedUnderIsomorphisms
code: instance predicateShift_closedUnderIsomorphisms (a : A) [ClosedUnderIsomorphisms P] :
    ClosedUnderIsomorphisms (PredicateShift P a) 
goal: CategoryTheory.ClosedUnderIsomorphisms (CategoryTheory.PredicateShift P a)

full_name: CategoryTheory.predicateShift_zero
code: @[simp]
lemma predicateShift_zero [ClosedUnderIsomorphisms P] : PredicateShift P (0 : A) = P 
goal: CategoryTheory.PredicateShift P 0 = P

full_name: CategoryTheory.predicateShift_predicateShift
code: lemma predicateShift_predicateShift (a b c : A) (h : a + b = c) [ClosedUnderIsomorphisms P] :
    PredicateShift (PredicateShift P b) a = PredicateShift P c 
goal: CategoryTheory.PredicateShift (CategoryTheory.PredicateShift P b) a = CategoryTheory.PredicateShift P c
File: Mathlib/CategoryTheory/Limits/EpiMono.lean

full_name: CategoryTheory.mono_iff_fst_eq_snd
code: lemma mono_iff_fst_eq_snd (hc : IsLimit c) : Mono f ↔ c.fst = c.snd 
goal: CategoryTheory.Mono f ↔ c.fst = c.snd

full_name: CategoryTheory.mono_iff_isIso_fst
code: lemma mono_iff_isIso_fst (hc : IsLimit c) : Mono f ↔ IsIso c.fst 
goal: CategoryTheory.Mono f ↔ CategoryTheory.IsIso c.fst

full_name: CategoryTheory.mono_iff_isIso_snd
code: lemma mono_iff_isIso_snd (hc : IsLimit c) : Mono f ↔ IsIso c.snd 
goal: CategoryTheory.Mono f ↔ CategoryTheory.IsIso c.snd

full_name: CategoryTheory.mono_iff_isPullback
code: lemma mono_iff_isPullback : Mono f ↔ IsPullback (𝟙 X) (𝟙 X) f f 
goal: CategoryTheory.Mono f ↔
  CategoryTheory.IsPullback (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X) f f

full_name: CategoryTheory.epi_iff_inl_eq_inr
code: lemma epi_iff_inl_eq_inr (hc : IsColimit c) : Epi f ↔ c.inl = c.inr 
goal: CategoryTheory.Epi f ↔ c.inl = c.inr

full_name: CategoryTheory.epi_iff_isIso_inl
code: lemma epi_iff_isIso_inl (hc : IsColimit c) : Epi f ↔ IsIso c.inl 
goal: CategoryTheory.Epi f ↔ CategoryTheory.IsIso c.inl

full_name: CategoryTheory.epi_iff_isIso_inr
code: lemma epi_iff_isIso_inr (hc : IsColimit c) : Epi f ↔ IsIso c.inr 
goal: CategoryTheory.Epi f ↔ CategoryTheory.IsIso c.inr

full_name: CategoryTheory.epi_iff_isPushout
code: lemma epi_iff_isPushout : Epi f ↔ IsPushout f f (𝟙 Y) (𝟙 Y) 
goal: CategoryTheory.Epi f ↔
  CategoryTheory.IsPushout f f (CategoryTheory.CategoryStruct.id Y) (CategoryTheory.CategoryStruct.id Y)
File: Mathlib/CategoryTheory/Limits/SmallComplete.lean

full_name: CategoryTheory.instIsThin
code: /-- A small category with products is a thin category.

in Lean, a preorder category is one where the morphisms are in Prop, which is weaker than the usual
notion of a preorder/thin category which says that each homset is subsingleton; we show the latter
rather than providing a `Preorder C` instance.
-/
instance (priority := 100) : Quiver.IsThin C 
goal: Quiver.IsThin C