File: Mathlib/CategoryTheory/Category/ULift.lean

full_name: CategoryTheory.ULift.upFunctor
code: /-- The functorial version of `ULift.up`. -/
@[simps]
def ULift.upFunctor : C ⥤ ULift.{u₂} C 
goal: CategoryTheory.Functor C (ULift.{u₂, u₁} C)

full_name: CategoryTheory.ULift.upFunctor_obj_down
code: /-- The functorial version of `ULift.up`. -/
@[simps]
def ULift.upFunctor : C ⥤ ULift.{u₂} C 
goal: (CategoryTheory.ULift.upFunctor.obj down).down = down

full_name: CategoryTheory.ULift.upFunctor_map
code: /-- The functorial version of `ULift.up`. -/
@[simps]
def ULift.upFunctor : C ⥤ ULift.{u₂} C 
goal: ∀ {X Y : C} (f : X ⟶ Y), CategoryTheory.ULift.upFunctor.map f = f

full_name: CategoryTheory.ULift.downFunctor
code: /-- The functorial version of `ULift.down`. -/
@[simps]
def ULift.downFunctor : ULift.{u₂} C ⥤ C 
goal: CategoryTheory.Functor (ULift.{u₂, u₁} C) C

full_name: CategoryTheory.ULift.downFunctor_map
code: /-- The functorial version of `ULift.down`. -/
@[simps]
def ULift.downFunctor : ULift.{u₂} C ⥤ C 
goal: ∀ {X Y : ULift.{u₂, u₁} C} (f : X ⟶ Y), CategoryTheory.ULift.downFunctor.map f = f

full_name: CategoryTheory.ULift.downFunctor_obj
code: /-- The functorial version of `ULift.down`. -/
@[simps]
def ULift.downFunctor : ULift.{u₂} C ⥤ C 
goal: CategoryTheory.ULift.downFunctor.obj self = self.down

full_name: CategoryTheory.ULift.equivalence_counitIso_hom_app
code: /-- The categorical equivalence between `C` and `ULift C`. -/
@[simps]
def ULift.equivalence : C ≌ ULift.{u₂} C 
goal: CategoryTheory.ULift.equivalence.counitIso.hom.app X =
  CategoryTheory.CategoryStruct.id ((CategoryTheory.ULift.downFunctor.comp CategoryTheory.ULift.upFunctor).obj X)

full_name: CategoryTheory.ULift.equivalence_functor
code: /-- The categorical equivalence between `C` and `ULift C`. -/
@[simps]
def ULift.equivalence : C ≌ ULift.{u₂} C 
goal: CategoryTheory.ULift.equivalence.functor = CategoryTheory.ULift.upFunctor

full_name: CategoryTheory.ULift.equivalence_inverse
code: /-- The categorical equivalence between `C` and `ULift C`. -/
@[simps]
def ULift.equivalence : C ≌ ULift.{u₂} C 
goal: CategoryTheory.ULift.equivalence.inverse = CategoryTheory.ULift.downFunctor

full_name: CategoryTheory.ULift.equivalence_unitIso_inv
code: /-- The categorical equivalence between `C` and `ULift C`. -/
@[simps]
def ULift.equivalence : C ≌ ULift.{u₂} C 
goal: CategoryTheory.ULift.equivalence.unitIso.inv =
  CategoryTheory.CategoryStruct.id (CategoryTheory.ULift.upFunctor.comp CategoryTheory.ULift.downFunctor)

full_name: CategoryTheory.ULift.equivalence
code: /-- The categorical equivalence between `C` and `ULift C`. -/
@[simps]
def ULift.equivalence : C ≌ ULift.{u₂} C 
goal: C ≌ ULift.{u₂, u₁} C

full_name: CategoryTheory.ULift.equivalence_unitIso_hom
code: /-- The categorical equivalence between `C` and `ULift C`. -/
@[simps]
def ULift.equivalence : C ≌ ULift.{u₂} C 
goal: CategoryTheory.ULift.equivalence.unitIso.hom = CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.id C)

full_name: CategoryTheory.ULift.equivalence_counitIso_inv_app
code: /-- The categorical equivalence between `C` and `ULift C`. -/
@[simps]
def ULift.equivalence : C ≌ ULift.{u₂} C 
goal: CategoryTheory.ULift.equivalence.counitIso.inv.app X =
  CategoryTheory.CategoryStruct.id ((CategoryTheory.Functor.id (ULift.{u₂, u₁} C)).obj X)

full_name: CategoryTheory.ULiftHom
code: /-- `ULiftHom.{w} C` is an alias for `C`, which is endowed with a category instance
  whose morphisms are obtained by applying `ULift.{w}` to the morphisms from `C`.
-/
def ULiftHom.{w,u} (C : Type u) : Type u 
goal: Type u

full_name: CategoryTheory.instInhabitedULiftHom
code: instance {C} [Inhabited C] : Inhabited (ULiftHom C) 
goal: Inhabited (CategoryTheory.ULiftHom C)

full_name: CategoryTheory.ULiftHom.objDown
code: /-- The obvious function `ULiftHom C → C`. -/
def ULiftHom.objDown {C} (A : ULiftHom C) : C 
goal: C

full_name: CategoryTheory.ULiftHom.objUp
code: /-- The obvious function `C → ULiftHom C`. -/
def ULiftHom.objUp {C} (A : C) : ULiftHom C 
goal: CategoryTheory.ULiftHom C

full_name: CategoryTheory.objDown_objUp
code: @[simp]
theorem objDown_objUp {C} (A : C) : (ULiftHom.objUp A).objDown = A 
goal: (CategoryTheory.ULiftHom.objUp A).objDown = A

full_name: CategoryTheory.objUp_objDown
code: @[simp]
theorem objUp_objDown {C} (A : ULiftHom C) : ULiftHom.objUp A.objDown = A 
goal: CategoryTheory.ULiftHom.objUp A.objDown = A

full_name: CategoryTheory.ULiftHom.category
code: instance ULiftHom.category : Category.{max v₂ v₁} (ULiftHom.{v₂} C) 
goal: CategoryTheory.Category.{max v₂ v₁, u₁} (CategoryTheory.ULiftHom C)

full_name: CategoryTheory.ULiftHom.up
code: /-- One half of the quivalence between `C` and `ULiftHom C`. -/
@[simps]
def ULiftHom.up : C ⥤ ULiftHom C 
goal: CategoryTheory.Functor C (CategoryTheory.ULiftHom C)

full_name: CategoryTheory.ULiftHom.up_obj
code: /-- One half of the quivalence between `C` and `ULiftHom C`. -/
@[simps]
def ULiftHom.up : C ⥤ ULiftHom C 
goal: CategoryTheory.ULiftHom.up.obj A = CategoryTheory.ULiftHom.objUp A

full_name: CategoryTheory.ULiftHom.up_map_down
code: /-- One half of the quivalence between `C` and `ULiftHom C`. -/
@[simps]
def ULiftHom.up : C ⥤ ULiftHom C 
goal: ∀ {X Y : C} (f : X ⟶ Y), (CategoryTheory.ULiftHom.up.map f).down = f

full_name: CategoryTheory.ULiftHom.down_map
code: /-- One half of the quivalence between `C` and `ULiftHom C`. -/
@[simps]
def ULiftHom.down : ULiftHom C ⥤ C 
goal: ∀ {X Y : CategoryTheory.ULiftHom C} (f : X ⟶ Y), CategoryTheory.ULiftHom.down.map f = f.down

full_name: CategoryTheory.ULiftHom.down_obj
code: /-- One half of the quivalence between `C` and `ULiftHom C`. -/
@[simps]
def ULiftHom.down : ULiftHom C ⥤ C 
goal: CategoryTheory.ULiftHom.down.obj A = A.objDown

full_name: CategoryTheory.ULiftHom.down
code: /-- One half of the quivalence between `C` and `ULiftHom C`. -/
@[simps]
def ULiftHom.down : ULiftHom C ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.ULiftHom C) C

full_name: CategoryTheory.ULiftHom.equiv
code: /-- The equivalence between `C` and `ULiftHom C`. -/
def ULiftHom.equiv : C ≌ ULiftHom C 
goal: C ≌ CategoryTheory.ULiftHom C

full_name: CategoryTheory.AsSmall
code: /-- `AsSmall C` is a small category equivalent to `C`.
  More specifically, if `C : Type u` is endowed with `Category.{v} C`, then
  `AsSmall.{w} C : Type (max w v u)` is endowed with an instance of a small category.

  The objects and morphisms of `AsSmall C` are defined by applying `ULift` to the
  objects and morphisms of `C`.

  Note: We require a category instance for this definition in order to have direct
  access to the universe level `v`.
-/
@[nolint unusedArguments]
def AsSmall.{w, v, u} (D : Type u) [Category.{v} D] 
goal: Type (max u w v)

full_name: CategoryTheory.instSmallCategoryAsSmall
code: instance : SmallCategory (AsSmall.{w₁} C) 
goal: CategoryTheory.SmallCategory (CategoryTheory.AsSmall C)

full_name: CategoryTheory.AsSmall.up_obj_down
code: /-- One half of the equivalence between `C` and `AsSmall C`. -/
@[simps]
def AsSmall.up : C ⥤ AsSmall C 
goal: (CategoryTheory.AsSmall.up.obj X).down = X

full_name: CategoryTheory.AsSmall.up_map_down
code: /-- One half of the equivalence between `C` and `AsSmall C`. -/
@[simps]
def AsSmall.up : C ⥤ AsSmall C 
goal: ∀ {X Y : C} (f : X ⟶ Y), (CategoryTheory.AsSmall.up.map f).down = f

full_name: CategoryTheory.AsSmall.up
code: /-- One half of the equivalence between `C` and `AsSmall C`. -/
@[simps]
def AsSmall.up : C ⥤ AsSmall C 
goal: CategoryTheory.Functor C (CategoryTheory.AsSmall C)

full_name: CategoryTheory.AsSmall.down
code: /-- One half of the equivalence between `C` and `AsSmall C`. -/
@[simps]
def AsSmall.down : AsSmall C ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.AsSmall C) C

full_name: CategoryTheory.AsSmall.down_obj
code: /-- One half of the equivalence between `C` and `AsSmall C`. -/
@[simps]
def AsSmall.down : AsSmall C ⥤ C 
goal: CategoryTheory.AsSmall.down.obj X = X.down

full_name: CategoryTheory.AsSmall.down_map
code: /-- One half of the equivalence between `C` and `AsSmall C`. -/
@[simps]
def AsSmall.down : AsSmall C ⥤ C 
goal: ∀ {X Y : CategoryTheory.AsSmall C} (f : X ⟶ Y), CategoryTheory.AsSmall.down.map f = f.down

full_name: CategoryTheory.AsSmall.equiv
code: /-- The equivalence between `C` and `AsSmall C`. -/
@[simps]
def AsSmall.equiv : C ≌ AsSmall C 
goal: C ≌ CategoryTheory.AsSmall C

full_name: CategoryTheory.AsSmall.equiv_counitIso
code: /-- The equivalence between `C` and `AsSmall C`. -/
@[simps]
def AsSmall.equiv : C ≌ AsSmall C 
goal: CategoryTheory.AsSmall.equiv.counitIso = CategoryTheory.NatIso.ofComponents (fun X => CategoryTheory.eqToIso ⋯) ⋯

full_name: CategoryTheory.AsSmall.equiv_unitIso
code: /-- The equivalence between `C` and `AsSmall C`. -/
@[simps]
def AsSmall.equiv : C ≌ AsSmall C 
goal: CategoryTheory.AsSmall.equiv.unitIso = CategoryTheory.NatIso.ofComponents (fun X => CategoryTheory.eqToIso ⋯) ⋯

full_name: CategoryTheory.AsSmall.equiv_functor
code: /-- The equivalence between `C` and `AsSmall C`. -/
@[simps]
def AsSmall.equiv : C ≌ AsSmall C 
goal: CategoryTheory.AsSmall.equiv.functor = CategoryTheory.AsSmall.up

full_name: CategoryTheory.AsSmall.equiv_inverse
code: /-- The equivalence between `C` and `AsSmall C`. -/
@[simps]
def AsSmall.equiv : C ≌ AsSmall C 
goal: CategoryTheory.AsSmall.equiv.inverse = CategoryTheory.AsSmall.down

full_name: CategoryTheory.instInhabitedAsSmall
code: instance [Inhabited C] : Inhabited (AsSmall C) 
goal: Inhabited (CategoryTheory.AsSmall C)

full_name: CategoryTheory.ULiftHomULiftCategory.equiv
code: /-- The equivalence between `C` and `ULiftHom (ULift C)`. -/
def ULiftHomULiftCategory.equiv.{v', u', v, u} (C : Type u) [Category.{v} C] :
    C ≌ ULiftHom.{v'} (ULift.{u'} C) 
goal: C ≌ CategoryTheory.ULiftHom (ULift.{u', u} C)