ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/CategoryTheory/Adjunction/Whiskering.lean

full_name: CategoryTheory.Adjunction.whiskerRight_unit_app_app
code: /-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringRight C _ _).obj F ⊣ (whiskeringRight C _ _).obj G`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerRight (adj : F ⊣ G) :
    (whiskeringRight C D E).obj F ⊣ (whiskeringRight C E D).obj G 
goal: ∀ (X_1 : C), ((CategoryTheory.Adjunction.whiskerRight C adj).unit.app X).app X_1 = adj.unit.app (X.obj X_1)

full_name: CategoryTheory.Adjunction.whiskerRight_counit_app_app
code: /-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringRight C _ _).obj F ⊣ (whiskeringRight C _ _).obj G`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerRight (adj : F ⊣ G) :
    (whiskeringRight C D E).obj F ⊣ (whiskeringRight C E D).obj G 
goal: ∀ (X_1 : C), ((CategoryTheory.Adjunction.whiskerRight C adj).counit.app X).app X_1 = adj.counit.app (X.obj X_1)

full_name: CategoryTheory.Adjunction.whiskerRight
code: /-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringRight C _ _).obj F ⊣ (whiskeringRight C _ _).obj G`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerRight (adj : F ⊣ G) :
    (whiskeringRight C D E).obj F ⊣ (whiskeringRight C E D).obj G 
goal: (CategoryTheory.whiskeringRight C D E).obj F ⊣ (CategoryTheory.whiskeringRight C E D).obj G

full_name: CategoryTheory.Adjunction.whiskerLeft_counit_app_app
code: /-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringLeft _ _ C).obj G ⊣ (whiskeringLeft _ _ C).obj F`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerLeft (adj : F ⊣ G) :
    (whiskeringLeft E D C).obj G ⊣ (whiskeringLeft D E C).obj F 
goal: ∀ (X_1 : E), ((CategoryTheory.Adjunction.whiskerLeft C adj).counit.app X).app X_1 = X.map (adj.counit.app X_1)

full_name: CategoryTheory.Adjunction.whiskerLeft_unit_app_app
code: /-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringLeft _ _ C).obj G ⊣ (whiskeringLeft _ _ C).obj F`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerLeft (adj : F ⊣ G) :
    (whiskeringLeft E D C).obj G ⊣ (whiskeringLeft D E C).obj F 
goal: ∀ (X_1 : D), ((CategoryTheory.Adjunction.whiskerLeft C adj).unit.app X).app X_1 = X.map (adj.unit.app X_1)

full_name: CategoryTheory.Adjunction.whiskerLeft
code: /-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringLeft _ _ C).obj G ⊣ (whiskeringLeft _ _ C).obj F`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerLeft (adj : F ⊣ G) :
    (whiskeringLeft E D C).obj G ⊣ (whiskeringLeft D E C).obj F 
goal: (CategoryTheory.whiskeringLeft E D C).obj G ⊣ (CategoryTheory.whiskeringLeft D E C).obj F
File: Mathlib/CategoryTheory/Adjunction/Restrict.lean

full_name: CategoryTheory.Adjunction.restrictFullyFaithful
code: /-- If `C` is a full subcategory of `C'` and `D` is a full subcategory of `D'`, then we can restrict
an adjunction `L' ⊣ R'` where `L' : C' ⥤ D'` and `R' : D' ⥤ C'` to `C` and `D`.
The construction here is slightly more general, in that `C` is required only to have a full and
faithful "inclusion" functor `iC : C ⥤ C'` (and similarly `iD : D ⥤ D'`) which commute (up to
natural isomorphism) with the proposed restrictions.
-/
noncomputable def restrictFullyFaithful : L ⊣ R 
goal: L ⊣ R

full_name: CategoryTheory.Adjunction.map_restrictFullyFaithful_unit_app
code: @[simp, reassoc]
lemma map_restrictFullyFaithful_unit_app (X : C) :
    iC.map ((adj.restrictFullyFaithful hiC hiD comm1 comm2).unit.app X) =
    adj.unit.app (iC.obj X) ≫ R'.map (comm1.hom.app X) ≫ comm2.hom.app (L.obj X) 
goal: iC.map ((adj.restrictFullyFaithful hiC hiD comm1 comm2).unit.app X) =
  CategoryTheory.CategoryStruct.comp (adj.unit.app (iC.obj X))
    (CategoryTheory.CategoryStruct.comp (R'.map (comm1.hom.app X)) (comm2.hom.app (L.obj X)))

full_name: CategoryTheory.Adjunction.map_restrictFullyFaithful_counit_app
code: @[simp, reassoc]
lemma map_restrictFullyFaithful_counit_app (X : D) :
    iD.map ((adj.restrictFullyFaithful hiC hiD comm1 comm2).counit.app X) =
    comm1.inv.app (R.obj X) ≫ L'.map (comm2.inv.app X) ≫ adj.counit.app (iD.obj X) 
goal: iD.map ((adj.restrictFullyFaithful hiC hiD comm1 comm2).counit.app X) =
  CategoryTheory.CategoryStruct.comp (comm1.inv.app (R.obj X))
    (CategoryTheory.CategoryStruct.comp (L'.map (comm2.inv.app X)) (adj.counit.app (iD.obj X)))

full_name: CategoryTheory.Adjunction.restrictFullyFaithful_homEquiv_apply
code: lemma restrictFullyFaithful_homEquiv_apply {X : C} {Y : D} (f : L.obj X ⟶ Y) :
    (adj.restrictFullyFaithful hiC hiD comm1 comm2).homEquiv X Y f =
      hiC.preimage (adj.unit.app (iC.obj X) ≫ R'.map (comm1.hom.app X) ≫
        R'.map (iD.map f) ≫ comm2.hom.app Y) 
goal: ((adj.restrictFullyFaithful hiC hiD comm1 comm2).homEquiv X Y) f =
  hiC.preimage
    (CategoryTheory.CategoryStruct.comp (adj.unit.app (iC.obj X))
      (CategoryTheory.CategoryStruct.comp (R'.map (comm1.hom.app X))
        (CategoryTheory.CategoryStruct.comp (R'.map (iD.map f)) (comm2.hom.app Y))))
File: Mathlib/CategoryTheory/EffectiveEpi/Extensive.lean

full_name: CategoryTheory.effectiveEpi_desc_iff_effectiveEpiFamily
code: theorem effectiveEpi_desc_iff_effectiveEpiFamily {α : Type} [Finite α]
    {B : C} (X : α → C) (π : (a : α) → X a ⟶ B) :
    EffectiveEpi (Sigma.desc π) ↔ EffectiveEpiFamily X π 
goal: CategoryTheory.EffectiveEpi (CategoryTheory.Limits.Sigma.desc π) ↔ CategoryTheory.EffectiveEpiFamily X π

full_name: CategoryTheory.instReflectsFiniteEffectiveEpiFamiliesOfReflectsEffectiveEpis
code: instance [F.ReflectsEffectiveEpis] : F.ReflectsFiniteEffectiveEpiFamilies 
goal: F.ReflectsFiniteEffectiveEpiFamilies

full_name: CategoryTheory.instPreservesFiniteEffectiveEpiFamiliesOfPreservesEffectiveEpis
code: instance [F.PreservesEffectiveEpis] : F.PreservesFiniteEffectiveEpiFamilies 
goal: F.PreservesFiniteEffectiveEpiFamilies
File: Mathlib/CategoryTheory/EffectiveEpi/RegularEpi.lean

full_name: CategoryTheory.effectiveEpiStructOfRegularEpi
code: /-- The data of an `EffectiveEpi` structure on a `RegularEpi`. -/
def effectiveEpiStructOfRegularEpi {B X : C} (f : X ⟶ B) [RegularEpi f] :
    EffectiveEpiStruct f 
goal: CategoryTheory.EffectiveEpiStruct f

full_name: CategoryTheory.instEffectiveEpiOfRegularEpi
code: instance {B X : C} (f : X ⟶ B) [RegularEpi f] : EffectiveEpi f 
goal: CategoryTheory.EffectiveEpi f

full_name: CategoryTheory.effectiveEpiOfKernelPair
code: /-- A morphism which is a coequalizer for its kernel pair is an effective epi. -/
theorem effectiveEpiOfKernelPair {B X : C} (f : X ⟶ B) [HasPullback f f]
    (hc : IsColimit (Cofork.ofπ f pullback.condition)) : EffectiveEpi f 
goal: CategoryTheory.EffectiveEpi f

full_name: CategoryTheory.regularEpiOfEffectiveEpi
code: /-- An effective epi which has a kernel pair is a regular epi. -/
noncomputable instance regularEpiOfEffectiveEpi {B X : C} (f : X ⟶ B) [HasPullback f f]
    [EffectiveEpi f] : RegularEpi f 
goal: CategoryTheory.RegularEpi f
File: Mathlib/CategoryTheory/IsomorphismClasses.lean

full_name: CategoryTheory.IsIsomorphic
code: /-- An object `X` is isomorphic to an object `Y`, if `X ≅ Y` is not empty. -/
def IsIsomorphic : C → C → Prop 
goal: C → C → Prop

full_name: CategoryTheory.isIsomorphicSetoid
code: /-- `IsIsomorphic` defines a setoid. -/
def isIsomorphicSetoid : Setoid C 
goal: Setoid C

full_name: CategoryTheory.isomorphismClasses
code: /-- The functor that sends each category to the quotient space of its objects up to an isomorphism.
-/
def isomorphismClasses : Cat.{v, u} ⥤ Type u 
goal: CategoryTheory.Functor CategoryTheory.Cat (Type u)

full_name: CategoryTheory.Groupoid.isIsomorphic_iff_nonempty_hom
code: theorem Groupoid.isIsomorphic_iff_nonempty_hom {C : Type u} [Groupoid.{v} C] {X Y : C} :
    IsIsomorphic X Y ↔ Nonempty (X ⟶ Y) 
goal: CategoryTheory.IsIsomorphic X Y ↔ Nonempty (X ⟶ Y)
File: Mathlib/CategoryTheory/Filtered/Connected.lean

full_name: CategoryTheory.IsFilteredOrEmpty.isPreconnected
code: theorem IsFilteredOrEmpty.isPreconnected [IsFilteredOrEmpty C] : IsPreconnected C 
goal: CategoryTheory.IsPreconnected C

full_name: CategoryTheory.IsCofilteredOrEmpty.isPreconnected
code: theorem IsCofilteredOrEmpty.isPreconnected [IsCofilteredOrEmpty C] : IsPreconnected C 
goal: CategoryTheory.IsPreconnected C

full_name: CategoryTheory.IsFiltered.isConnected
code: theorem IsFiltered.isConnected [IsFiltered C] : IsConnected C 
goal: CategoryTheory.IsConnected C

full_name: CategoryTheory.IsCofiltered.isConnected
code: theorem IsCofiltered.isConnected [IsCofiltered C] : IsConnected C 
goal: CategoryTheory.IsConnected C
File: Mathlib/CategoryTheory/Products/Bifunctor.lean

full_name: CategoryTheory.Bifunctor.map_id
code: @[simp]
theorem map_id (F : C × D ⥤ E) (X : C) (Y : D) :
    F.map ((𝟙 X, 𝟙 Y) : (X, Y) ⟶ (X, Y)) = 𝟙 (F.obj (X, Y)) 
goal: F.map (𝟙 X, 𝟙 Y) = 𝟙 (F.obj (X, Y))

full_name: CategoryTheory.Bifunctor.map_id_comp
code: @[simp]
theorem map_id_comp (F : C × D ⥤ E) (W : C) {X Y Z : D} (f : X ⟶ Y) (g : Y ⟶ Z) :
    F.map ((𝟙 W, f ≫ g) : (W, X) ⟶ (W, Z)) =
      F.map ((𝟙 W, f) : (W, X) ⟶ (W, Y)) ≫ F.map ((𝟙 W, g) : (W, Y) ⟶ (W, Z)) 
goal: F.map (𝟙 W, f ≫ g) = F.map (𝟙 W, f) ≫ F.map (𝟙 W, g)

full_name: CategoryTheory.Bifunctor.map_comp_id
code: @[simp]
theorem map_comp_id (F : C × D ⥤ E) (X Y Z : C) (W : D) (f : X ⟶ Y) (g : Y ⟶ Z) :
    F.map ((f ≫ g, 𝟙 W) : (X, W) ⟶ (Z, W)) =
      F.map ((f, 𝟙 W) : (X, W) ⟶ (Y, W)) ≫ F.map ((g, 𝟙 W) : (Y, W) ⟶ (Z, W)) 
goal: F.map (f ≫ g, 𝟙 W) = F.map (f, 𝟙 W) ≫ F.map (g, 𝟙 W)

full_name: CategoryTheory.Bifunctor.diagonal
code: @[simp]
theorem diagonal (F : C × D ⥤ E) (X X' : C) (f : X ⟶ X') (Y Y' : D) (g : Y ⟶ Y') :
    F.map ((𝟙 X, g) : (X, Y) ⟶ (X, Y')) ≫ F.map ((f, 𝟙 Y') : (X, Y') ⟶ (X', Y')) =
      F.map ((f, g) : (X, Y) ⟶ (X', Y')) 
goal: F.map (𝟙 X, g) ≫ F.map (f, 𝟙 Y') = F.map (f, g)

full_name: CategoryTheory.Bifunctor.diagonal'
code: @[simp]
theorem diagonal' (F : C × D ⥤ E) (X X' : C) (f : X ⟶ X') (Y Y' : D) (g : Y ⟶ Y') :
    F.map ((f, 𝟙 Y) : (X, Y) ⟶ (X', Y)) ≫ F.map ((𝟙 X', g) : (X', Y) ⟶ (X', Y')) =
      F.map ((f, g) : (X, Y) ⟶ (X', Y')) 
goal: F.map (f, 𝟙 Y) ≫ F.map (𝟙 X', g) = F.map (f, g)
File: Mathlib/CategoryTheory/Thin.lean

full_name: CategoryTheory.thin_category
code: /-- Construct a category instance from a category_struct, using the fact that
    hom spaces are subsingletons to prove the axioms. -/
def thin_category : Category C 
goal: CategoryTheory.Category.{v₁, u₁} C

full_name: CategoryTheory.functor_thin
code: /-- If `C` is a thin category, then `D ⥤ C` is a thin category. -/
instance functor_thin : Quiver.IsThin (D ⥤ C) 
goal: Quiver.IsThin (CategoryTheory.Functor D C)

full_name: CategoryTheory.iso_of_both_ways
code: /-- To show `X ≅ Y` in a thin category, it suffices to just give any morphism in each direction. -/
def iso_of_both_ways {X Y : C} (f : X ⟶ Y) (g : Y ⟶ X) :
    X ≅ Y 
goal: X ≅ Y

full_name: CategoryTheory.subsingleton_iso
code: instance subsingleton_iso {X Y : C} : Subsingleton (X ≅ Y) 
goal: Subsingleton (X ≅ Y)
File: Mathlib/CategoryTheory/Products/Associator.lean

full_name: CategoryTheory.prod.associator
code: /-- The associator functor `(C × D) × E ⥤ C × (D × E)`.
-/
@[simps]
def associator : (C × D) × E ⥤ C × D × E 
goal: (C × D) × E ⥤ C × D × E

full_name: CategoryTheory.prod.associator_obj
code: /-- The associator functor `(C × D) × E ⥤ C × (D × E)`.
-/
@[simps]
def associator : (C × D) × E ⥤ C × D × E 
goal: (CategoryTheory.prod.associator C D E).obj X = (X.1.1, X.1.2, X.2)

full_name: CategoryTheory.prod.associator_map
code: /-- The associator functor `(C × D) × E ⥤ C × (D × E)`.
-/
@[simps]
def associator : (C × D) × E ⥤ C × D × E 
goal: ∀ (x x_1 : (C × D) × E) (f : x ⟶ x_1), (CategoryTheory.prod.associator C D E).map f = (f.1.1, f.1.2, f.2)

full_name: CategoryTheory.prod.inverseAssociator_obj
code: /-- The inverse associator functor `C × (D × E) ⥤ (C × D) × E `.
-/
@[simps]
def inverseAssociator : C × D × E ⥤ (C × D) × E 
goal: (CategoryTheory.prod.inverseAssociator C D E).obj X = ((X.1, X.2.1), X.2.2)

full_name: CategoryTheory.prod.inverseAssociator_map
code: /-- The inverse associator functor `C × (D × E) ⥤ (C × D) × E `.
-/
@[simps]
def inverseAssociator : C × D × E ⥤ (C × D) × E 
goal: ∀ (x x_1 : C × D × E) (f : x ⟶ x_1), (CategoryTheory.prod.inverseAssociator C D E).map f = ((f.1, f.2.1), f.2.2)

full_name: CategoryTheory.prod.inverseAssociator
code: /-- The inverse associator functor `C × (D × E) ⥤ (C × D) × E `.
-/
@[simps]
def inverseAssociator : C × D × E ⥤ (C × D) × E 
goal: C × D × E ⥤ (C × D) × E

full_name: CategoryTheory.prod.associativity
code: /-- The equivalence of categories expressing associativity of products of categories.
-/
def associativity : (C × D) × E ≌ C × D × E 
goal: (C × D) × E ≌ C × D × E

full_name: CategoryTheory.prod.associatorIsEquivalence
code: instance associatorIsEquivalence : (associator C D E).IsEquivalence 
goal: (CategoryTheory.prod.associator C D E).IsEquivalence

full_name: CategoryTheory.prod.inverseAssociatorIsEquivalence
code: instance inverseAssociatorIsEquivalence : (inverseAssociator C D E).IsEquivalence 
goal: (CategoryTheory.prod.inverseAssociator C D E).IsEquivalence
File: Mathlib/CategoryTheory/Category/GaloisConnection.lean

full_name: GaloisConnection.adjunction
code: /-- A galois connection between preorders induces an adjunction between the associated categories.
-/
def GaloisConnection.adjunction {l : X → Y} {u : Y → X} (gc : GaloisConnection l u) :
    gc.monotone_l.functor ⊣ gc.monotone_u.functor 
goal: ⋯.functor ⊣ ⋯.functor

full_name: CategoryTheory.Adjunction.gc
code: /-- An adjunction between preorder categories induces a galois connection.
-/
theorem Adjunction.gc {L : X ⥤ Y} {R : Y ⥤ X} (adj : L ⊣ R) : GaloisConnection L.obj R.obj 
goal: GaloisConnection L.obj R.obj
File: Mathlib/CategoryTheory/Category/Init.lean

full_name: initFn._@.Mathlib.CategoryTheory.Category.Init._hyg.5
code: declare_aesop_rule_sets [CategoryTheory]
goal: IO Unit
File: Mathlib/CategoryTheory/Category/KleisliCat.lean

full_name: CategoryTheory.KleisliCat
code: /-- The Kleisli category on the (type-)monad `m`. Note that the monad is not assumed to be lawful
yet. -/
@[nolint unusedArguments]
def KleisliCat (_ : Type u → Type v) 
goal: (Type u → Type v) → Type (u + 1)

full_name: CategoryTheory.KleisliCat.mk
code: /-- Construct an object of the Kleisli category from a type. -/
def KleisliCat.mk (m) (α : Type u) : KleisliCat m 
goal: CategoryTheory.KleisliCat m

full_name: CategoryTheory.KleisliCat.categoryStruct
code: instance KleisliCat.categoryStruct {m} [Monad.{u, v} m] :
    CategoryStruct (KleisliCat m) 
goal: CategoryTheory.CategoryStruct.{max u v, u + 1} (CategoryTheory.KleisliCat m)

full_name: CategoryTheory.KleisliCat.category
code: instance KleisliCat.category {m} [Monad.{u, v} m] [LawfulMonad m] : Category (KleisliCat m) 
goal: CategoryTheory.Category.{max u v, u + 1} (CategoryTheory.KleisliCat m)

full_name: CategoryTheory.KleisliCat.id_def
code: @[simp]
theorem KleisliCat.id_def {m} [Monad m] (α : KleisliCat m) : 𝟙 α = @pure m _ α 
goal: CategoryTheory.CategoryStruct.id α = pure

full_name: CategoryTheory.KleisliCat.comp_def
code: theorem KleisliCat.comp_def {m} [Monad m] (α β γ : KleisliCat m) (xs : α ⟶ β) (ys : β ⟶ γ) (a : α) :
    (xs ≫ ys) a = xs a >>= ys 
goal: CategoryTheory.CategoryStruct.comp xs ys a = xs a >>= ys

full_name: CategoryTheory.instInhabitedKleisliCatId
code: instance : Inhabited (KleisliCat id) 
goal: Inhabited (CategoryTheory.KleisliCat id)

full_name: CategoryTheory.instInhabitedMkId
code: instance {α : Type u} [Inhabited α] : Inhabited (KleisliCat.mk id α) 
goal: Inhabited (CategoryTheory.KleisliCat.mk id α)
File: Mathlib/CategoryTheory/LiftingProperties/Adjunction.lean

full_name: CategoryTheory.CommSq.right_adjoint
code: /-- When we have an adjunction `G ⊣ F`, any commutative square where the left
map is of the form `G.map i` and the right map is `p` has an "adjoint" commutative
square whose left map is `i` and whose right map is `F.map p`. -/
theorem right_adjoint (sq : CommSq u (G.map i) p v) (adj : G ⊣ F) :
    CommSq (adj.homEquiv _ _ u) i (F.map p) (adj.homEquiv _ _ v) 
goal: CategoryTheory.CommSq ((adj.homEquiv A X) u) i (F.map p) ((adj.homEquiv B Y) v)

full_name: CategoryTheory.CommSq.rightAdjointLiftStructEquiv
code: /-- The liftings of a commutative are in bijection with the liftings of its (right)
adjoint square. -/
def rightAdjointLiftStructEquiv : sq.LiftStruct ≃ (sq.right_adjoint adj).LiftStruct 
goal: sq.LiftStruct ≃ ⋯.LiftStruct

full_name: CategoryTheory.CommSq.right_adjoint_hasLift_iff
code: /-- A square has a lifting if and only if its (right) adjoint square has a lifting. -/
theorem right_adjoint_hasLift_iff : HasLift (sq.right_adjoint adj) ↔ HasLift sq 
goal: ⋯.HasLift ↔ sq.HasLift

full_name: CategoryTheory.CommSq.instHasLift
code: instance [HasLift sq] : HasLift (sq.right_adjoint adj) 
goal: ⋯.HasLift

full_name: CategoryTheory.CommSq.left_adjoint
code: /-- When we have an adjunction `G ⊣ F`, any commutative square where the left
map is of the form `i` and the right map is `F.map p` has an "adjoint" commutative
square whose left map is `G.map i` and whose right map is `p`. -/
theorem left_adjoint (sq : CommSq u i (F.map p) v) (adj : G ⊣ F) :
    CommSq ((adj.homEquiv _ _).symm u) (G.map i) p ((adj.homEquiv _ _).symm v) 
goal: CategoryTheory.CommSq ((adj.homEquiv A X).symm u) (G.map i) p ((adj.homEquiv B Y).symm v)

full_name: CategoryTheory.CommSq.leftAdjointLiftStructEquiv
code: /-- The liftings of a commutative are in bijection with the liftings of its (left)
adjoint square. -/
def leftAdjointLiftStructEquiv :
    sq.LiftStruct ≃ (sq.left_adjoint adj).LiftStruct 
goal: sq.LiftStruct ≃ ⋯.LiftStruct

full_name: CategoryTheory.CommSq.left_adjoint_hasLift_iff
code: /-- A (left) adjoint square has a lifting if and only if the original square has a lifting. -/
theorem left_adjoint_hasLift_iff : HasLift (sq.left_adjoint adj) ↔ HasLift sq 
goal: ⋯.HasLift ↔ sq.HasLift

full_name: CategoryTheory.CommSq.instHasLift_1
code: instance [HasLift sq] : HasLift (sq.left_adjoint adj) 
goal: ⋯.HasLift

full_name: CategoryTheory.Adjunction.hasLiftingProperty_iff
code: theorem hasLiftingProperty_iff (adj : G ⊣ F) {A B : C} {X Y : D} (i : A ⟶ B) (p : X ⟶ Y) :
    HasLiftingProperty (G.map i) p ↔ HasLiftingProperty i (F.map p) 
goal: CategoryTheory.HasLiftingProperty (G.map i) p ↔ CategoryTheory.HasLiftingProperty i (F.map p)
File: Mathlib/CategoryTheory/Idempotents/SimplicialObject.lean

full_name: CategoryTheory.Idempotents.instIsIdempotentCompleteSimplicialObject
code: instance : IsIdempotentComplete (SimplicialObject C) 
goal: CategoryTheory.IsIdempotentComplete (CategoryTheory.SimplicialObject C)

full_name: CategoryTheory.Idempotents.instIsIdempotentCompleteCosimplicialObject
code: instance : IsIdempotentComplete (CosimplicialObject C) 
goal: CategoryTheory.IsIdempotentComplete (CategoryTheory.CosimplicialObject C)
File: Mathlib/CategoryTheory/UnivLE.lean

full_name: UnivLE.ofEssSurj
code: theorem UnivLE.ofEssSurj (w : (uliftFunctor.{u, v} : Type v ⥤ Type max u v).EssSurj) :
    UnivLE.{max u v, v} 
goal: UnivLE.{max u v, v}

full_name: EssSurj.ofUnivLE
code: instance EssSurj.ofUnivLE [UnivLE.{max u v, v}] :
    (uliftFunctor.{u, v} : Type v ⥤ Type max u v).EssSurj 
goal: CategoryTheory.uliftFunctor.{u, v}.EssSurj

full_name: UnivLE_iff_essSurj
code: theorem UnivLE_iff_essSurj :
    UnivLE.{max u v, v} ↔ (uliftFunctor.{u, v} : Type v ⥤ Type max u v).EssSurj 
goal: UnivLE.{max u v, v} ↔ CategoryTheory.uliftFunctor.{u, v}.EssSurj

full_name: instIsEquivalenceUliftFunctorOfUnivLE
code: instance [UnivLE.{max u v, v}] : uliftFunctor.{u, v}.IsEquivalence 
goal: CategoryTheory.uliftFunctor.{u, v}.IsEquivalence

full_name: UnivLE.witness
code: def UnivLE.witness [UnivLE.{max u v, v}] : Type u ⥤ Type v 
goal: Type u ⥤ Type v

full_name: instFaithfulWitness
code: instance [UnivLE.{max u v, v}] : UnivLE.witness.{u, v}.Faithful 
goal: UnivLE.witness.Faithful

full_name: instFullWitness
code: instance [UnivLE.{max u v, v}] : UnivLE.witness.{u, v}.Full 
goal: UnivLE.witness.Full
File: Mathlib/CategoryTheory/FinCategory/Basic.lean

full_name: CategoryTheory.discreteFintype
code: instance discreteFintype {α : Type*} [Fintype α] : Fintype (Discrete α) 
goal: Fintype (CategoryTheory.Discrete α)

full_name: CategoryTheory.discreteHomFintype
code: instance discreteHomFintype {α : Type*} (X Y : Discrete α) : Fintype (X ⟶ Y) 
goal: Fintype (X ⟶ Y)

full_name: CategoryTheory.FinCategory.fintypeObj
code: /-- A category with a `Fintype` of objects, and a `Fintype` for each morphism space. -/
class FinCategory (J : Type v) [SmallCategory J] where
  fintypeObj : Fintype J := by infer_instance
  fintypeHom : ∀ j j' : J, Fintype (j ⟶ j') := by infer_instance
goal: Fintype J

full_name: CategoryTheory.FinCategory
code: /-- A category with a `Fintype` of objects, and a `Fintype` for each morphism space. -/
class FinCategory (J : Type v) [SmallCategory J] where
  fintypeObj : Fintype J := by infer_instance
  fintypeHom : ∀ j j' : J, Fintype (j ⟶ j') := by infer_instance
goal: Type v

full_name: CategoryTheory.FinCategory.fintypeHom
code: /-- A category with a `Fintype` of objects, and a `Fintype` for each morphism space. -/
class FinCategory (J : Type v) [SmallCategory J] where
  fintypeObj : Fintype J := by infer_instance
  fintypeHom : ∀ j j' : J, Fintype (j ⟶ j') := by infer_instance
goal: Fintype (j ⟶ j')

full_name: CategoryTheory.finCategoryDiscreteOfFintype
code: instance finCategoryDiscreteOfFintype (J : Type v) [Fintype J] : FinCategory (Discrete J) 
goal: CategoryTheory.FinCategory (CategoryTheory.Discrete J)

full_name: CategoryTheory.finCategoryOpposite
code: /-- The opposite of a finite category is finite.
-/
instance finCategoryOpposite {J : Type v} [SmallCategory J] [FinCategory J] : FinCategory Jᵒᵖ 
goal: CategoryTheory.FinCategory Jᵒᵖ

full_name: CategoryTheory.finCategoryUlift
code: /-- Applying `ULift` to morphisms and objects of a category preserves finiteness. -/
instance finCategoryUlift {J : Type v} [SmallCategory J] [FinCategory J] :
    FinCategory.{max w v} (ULiftHom.{w, max w v} (ULift.{w, v} J)) 
goal: CategoryTheory.FinCategory (CategoryTheory.ULiftHom (ULift.{w, v} J))