File: Mathlib/CategoryTheory/FullSubcategory.lean

full_name: CategoryTheory.InducedCategory
code: /-- `InducedCategory D F`, where `F : C → D`, is a typeclass synonym for `C`,
which provides a category structure so that the morphisms `X ⟶ Y` are the morphisms
in `D` from `F X` to `F Y`.
-/
-- Porting note(#5171): removed @[nolint has_nonempty_instance]
@[nolint unusedArguments]
def InducedCategory (_F : C → D) : Type u₁ 
goal: Type u₁

full_name: CategoryTheory.InducedCategory.hasCoeToSort
code: instance InducedCategory.hasCoeToSort {α : Sort*} [CoeSort D α] :
    CoeSort (InducedCategory D F) α 
goal: CoeSort (CategoryTheory.InducedCategory D F) α

full_name: CategoryTheory.InducedCategory.category
code: instance InducedCategory.category : Category.{v} (InducedCategory D F) 
goal: CategoryTheory.Category.{v, u₁} (CategoryTheory.InducedCategory D F)

full_name: CategoryTheory.inducedFunctor_obj
code: /-- The forgetful functor from an induced category to the original category,
forgetting the extra data.
-/
@[simps]
def inducedFunctor : InducedCategory D F ⥤ D 
goal: ∀ (a : C), (CategoryTheory.inducedFunctor F).obj a = F a

full_name: CategoryTheory.inducedFunctor_map
code: /-- The forgetful functor from an induced category to the original category,
forgetting the extra data.
-/
@[simps]
def inducedFunctor : InducedCategory D F ⥤ D 
goal: ∀ {X Y : CategoryTheory.InducedCategory D F} (f : X ⟶ Y), (CategoryTheory.inducedFunctor F).map f = f

full_name: CategoryTheory.inducedFunctor
code: /-- The forgetful functor from an induced category to the original category,
forgetting the extra data.
-/
@[simps]
def inducedFunctor : InducedCategory D F ⥤ D 
goal: CategoryTheory.Functor (CategoryTheory.InducedCategory D F) D

full_name: CategoryTheory.fullyFaithfulInducedFunctor
code: /-- The induced functor `inducedFunctor F : InducedCategory D F ⥤ D` is fully faithful. -/
def fullyFaithfulInducedFunctor : (inducedFunctor F).FullyFaithful 
goal: (CategoryTheory.inducedFunctor F).FullyFaithful

full_name: CategoryTheory.InducedCategory.full
code: instance InducedCategory.full : (inducedFunctor F).Full 
goal: (CategoryTheory.inducedFunctor F).Full

full_name: CategoryTheory.InducedCategory.faithful
code: instance InducedCategory.faithful : (inducedFunctor F).Faithful 
goal: (CategoryTheory.inducedFunctor F).Faithful

full_name: CategoryTheory.FullSubcategory.property
code: /--
A subtype-like structure for full subcategories. Morphisms just ignore the property. We don't use
actual subtypes since the simp-normal form `↑X` of `X.val` does not work well for full
subcategories.

See <https://stacks.math.columbia.edu/tag/001D>. We do not define 'strictly full' subcategories.
-/
@[ext]
structure FullSubcategory where
  /-- The category of which this is a full subcategory-/
  obj : C
  /-- The predicate satisfied by all objects in this subcategory-/
  property : Z obj
goal: Z self.obj

full_name: CategoryTheory.FullSubcategory.obj
code: /--
A subtype-like structure for full subcategories. Morphisms just ignore the property. We don't use
actual subtypes since the simp-normal form `↑X` of `X.val` does not work well for full
subcategories.

See <https://stacks.math.columbia.edu/tag/001D>. We do not define 'strictly full' subcategories.
-/
@[ext]
structure FullSubcategory where
  /-- The category of which this is a full subcategory-/
  obj : C
  /-- The predicate satisfied by all objects in this subcategory-/
  property : Z obj
goal: C

full_name: CategoryTheory.FullSubcategory
code: /--
A subtype-like structure for full subcategories. Morphisms just ignore the property. We don't use
actual subtypes since the simp-normal form `↑X` of `X.val` does not work well for full
subcategories.

See <https://stacks.math.columbia.edu/tag/001D>. We do not define 'strictly full' subcategories.
-/
@[ext]
structure FullSubcategory where
  /-- The category of which this is a full subcategory-/
  obj : C
  /-- The predicate satisfied by all objects in this subcategory-/
  property : Z obj
goal: Type u₁

full_name: CategoryTheory.FullSubcategory.category
code: instance FullSubcategory.category : Category.{v} (FullSubcategory Z) 
goal: CategoryTheory.Category.{v, u₁} (CategoryTheory.FullSubcategory Z)

full_name: CategoryTheory.FullSubcategory.id_def
code: lemma FullSubcategory.id_def (X : FullSubcategory Z) : 𝟙 X = 𝟙 X.obj 
goal: CategoryTheory.CategoryStruct.id X = CategoryTheory.CategoryStruct.id X.obj

full_name: CategoryTheory.FullSubcategory.comp_def
code: lemma FullSubcategory.comp_def {X Y Z : FullSubcategory Z} (f : X ⟶ Y) (g : Y ⟶ Z) :
    f ≫ g = (f ≫ g : X.obj ⟶ Z.obj) 
goal: ∀ {Z_1 : CategoryTheory.FullSubcategory Z} (f : X ⟶ Y) (g : Y ⟶ Z_1),
  CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f g

full_name: CategoryTheory.fullSubcategoryInclusion
code: /-- The forgetful functor from a full subcategory into the original category
("forgetting" the condition).
-/
def fullSubcategoryInclusion : FullSubcategory Z ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.FullSubcategory Z) C

full_name: CategoryTheory.fullSubcategoryInclusion.obj
code: @[simp]
theorem fullSubcategoryInclusion.obj {X} : (fullSubcategoryInclusion Z).obj X = X.obj 
goal: (CategoryTheory.fullSubcategoryInclusion Z).obj X = X.obj

full_name: CategoryTheory.fullSubcategoryInclusion.map
code: @[simp]
theorem fullSubcategoryInclusion.map {X Y} {f : X ⟶ Y} : (fullSubcategoryInclusion Z).map f = f 
goal: (CategoryTheory.fullSubcategoryInclusion Z).map f = f

full_name: CategoryTheory.fullyFaithfulFullSubcategoryInclusion
code: /-- The inclusion of a full subcategory is fully faithful. -/
abbrev fullyFaithfulFullSubcategoryInclusion :
    (fullSubcategoryInclusion Z).FullyFaithful 
goal: (CategoryTheory.fullSubcategoryInclusion Z).FullyFaithful

full_name: CategoryTheory.FullSubcategory.full
code: instance FullSubcategory.full : (fullSubcategoryInclusion Z).Full 
goal: (CategoryTheory.fullSubcategoryInclusion Z).Full

full_name: CategoryTheory.FullSubcategory.faithful
code: instance FullSubcategory.faithful : (fullSubcategoryInclusion Z).Faithful 
goal: (CategoryTheory.fullSubcategoryInclusion Z).Faithful

full_name: CategoryTheory.FullSubcategory.map
code: /-- An implication of predicates `Z → Z'` induces a functor between full subcategories. -/
@[simps]
def FullSubcategory.map (h : ∀ ⦃X⦄, Z X → Z' X) : FullSubcategory Z ⥤ FullSubcategory Z' 
goal: CategoryTheory.Functor (CategoryTheory.FullSubcategory Z) (CategoryTheory.FullSubcategory Z')

full_name: CategoryTheory.FullSubcategory.map_obj_obj
code: /-- An implication of predicates `Z → Z'` induces a functor between full subcategories. -/
@[simps]
def FullSubcategory.map (h : ∀ ⦃X⦄, Z X → Z' X) : FullSubcategory Z ⥤ FullSubcategory Z' 
goal: ((CategoryTheory.FullSubcategory.map h).obj X).obj = X.obj

full_name: CategoryTheory.FullSubcategory.map_map
code: /-- An implication of predicates `Z → Z'` induces a functor between full subcategories. -/
@[simps]
def FullSubcategory.map (h : ∀ ⦃X⦄, Z X → Z' X) : FullSubcategory Z ⥤ FullSubcategory Z' 
goal: ∀ {X Y : CategoryTheory.FullSubcategory Z} (f : X ⟶ Y), (CategoryTheory.FullSubcategory.map h).map f = f

full_name: CategoryTheory.FullSubcategory.full_map
code: instance FullSubcategory.full_map (h : ∀ ⦃X⦄, Z X → Z' X) :
  (FullSubcategory.map h).Full 
goal: (CategoryTheory.FullSubcategory.map h).Full

full_name: CategoryTheory.FullSubcategory.faithful_map
code: instance FullSubcategory.faithful_map (h : ∀ ⦃X⦄, Z X → Z' X) :
  (FullSubcategory.map h).Faithful 
goal: (CategoryTheory.FullSubcategory.map h).Faithful

full_name: CategoryTheory.FullSubcategory.map_inclusion
code: @[simp]
theorem FullSubcategory.map_inclusion (h : ∀ ⦃X⦄, Z X → Z' X) :
    FullSubcategory.map h ⋙ fullSubcategoryInclusion Z' = fullSubcategoryInclusion Z 
goal: (CategoryTheory.FullSubcategory.map h).comp (CategoryTheory.fullSubcategoryInclusion Z') =
  CategoryTheory.fullSubcategoryInclusion Z

full_name: CategoryTheory.FullSubcategory.lift_obj_obj
code: /-- A functor which maps objects to objects satisfying a certain property induces a lift through
    the full subcategory of objects satisfying that property. -/
@[simps]
def FullSubcategory.lift (F : C ⥤ D) (hF : ∀ X, P (F.obj X)) : C ⥤ FullSubcategory P 
goal: ((CategoryTheory.FullSubcategory.lift P F hF).obj X).obj = F.obj X

full_name: CategoryTheory.FullSubcategory.lift_map
code: /-- A functor which maps objects to objects satisfying a certain property induces a lift through
    the full subcategory of objects satisfying that property. -/
@[simps]
def FullSubcategory.lift (F : C ⥤ D) (hF : ∀ X, P (F.obj X)) : C ⥤ FullSubcategory P 
goal: ∀ {X Y : C} (f : X ⟶ Y), (CategoryTheory.FullSubcategory.lift P F hF).map f = F.map f

full_name: CategoryTheory.FullSubcategory.lift
code: /-- A functor which maps objects to objects satisfying a certain property induces a lift through
    the full subcategory of objects satisfying that property. -/
@[simps]
def FullSubcategory.lift (F : C ⥤ D) (hF : ∀ X, P (F.obj X)) : C ⥤ FullSubcategory P 
goal: CategoryTheory.Functor C (CategoryTheory.FullSubcategory P)

full_name: CategoryTheory.FullSubcategory.lift_comp_inclusion_eq
code: @[simp]
theorem FullSubcategory.lift_comp_inclusion_eq (F : C ⥤ D) (hF : ∀ X, P (F.obj X)) :
    FullSubcategory.lift P F hF ⋙ fullSubcategoryInclusion P = F 
goal: (CategoryTheory.FullSubcategory.lift P F hF).comp (CategoryTheory.fullSubcategoryInclusion P) = F

full_name: CategoryTheory.FullSubcategory.lift_comp_inclusion
code: /-- Composing the lift of a functor through a full subcategory with the inclusion yields the
    original functor. This is actually true definitionally. -/
def FullSubcategory.lift_comp_inclusion (F : C ⥤ D) (hF : ∀ X, P (F.obj X)) :
    FullSubcategory.lift P F hF ⋙ fullSubcategoryInclusion P ≅ F 
goal: (CategoryTheory.FullSubcategory.lift P F hF).comp (CategoryTheory.fullSubcategoryInclusion P) ≅ F

full_name: CategoryTheory.fullSubcategoryInclusion_obj_lift_obj
code: @[simp]
theorem fullSubcategoryInclusion_obj_lift_obj (F : C ⥤ D) (hF : ∀ X, P (F.obj X)) {X : C} :
    (fullSubcategoryInclusion P).obj ((FullSubcategory.lift P F hF).obj X) = F.obj X 
goal: (CategoryTheory.fullSubcategoryInclusion P).obj ((CategoryTheory.FullSubcategory.lift P F hF).obj X) = F.obj X

full_name: CategoryTheory.fullSubcategoryInclusion_map_lift_map
code: @[simp]
theorem fullSubcategoryInclusion_map_lift_map (F : C ⥤ D) (hF : ∀ X, P (F.obj X)) {X Y : C}
    (f : X ⟶ Y) :
    (fullSubcategoryInclusion P).map ((FullSubcategory.lift P F hF).map f) = F.map f 
goal: (CategoryTheory.fullSubcategoryInclusion P).map ((CategoryTheory.FullSubcategory.lift P F hF).map f) = F.map f

full_name: CategoryTheory.instFaithfulFullSubcategoryLift
code: instance (F : C ⥤ D) (hF : ∀ X, P (F.obj X)) [F.Faithful] :
    (FullSubcategory.lift P F hF).Faithful 
goal: (CategoryTheory.FullSubcategory.lift P F hF).Faithful

full_name: CategoryTheory.instFullFullSubcategoryLift
code: instance (F : C ⥤ D) (hF : ∀ X, P (F.obj X)) [F.Full] : (FullSubcategory.lift P F hF).Full 
goal: (CategoryTheory.FullSubcategory.lift P F hF).Full

full_name: CategoryTheory.FullSubcategory.lift_comp_map
code: @[simp]
theorem FullSubcategory.lift_comp_map (F : C ⥤ D) (hF : ∀ X, P (F.obj X)) (h : ∀ ⦃X⦄, P X → Q X) :
    FullSubcategory.lift P F hF ⋙ FullSubcategory.map h =
      FullSubcategory.lift Q F fun X => h (hF X) 
goal: (CategoryTheory.FullSubcategory.lift P F hF).comp (CategoryTheory.FullSubcategory.map h) =
  CategoryTheory.FullSubcategory.lift Q F ⋯