Full and faithful functors #

We define typeclasses Full and Faithful, decorating functors.

Main definitions and results #

Use F.map_injective to retrieve the fact that F.map is injective when [Faithful F].
Similarly, F.map_surjective states that F.map is surjective when [Full F].
Use F.preimage to obtain preimages of morphisms when [Full F].
We prove some basic "cancellation" lemmas for full and/or faithful functors, as well as a construction for "dividing" a functor by a faithful functor, see Faithful.div.
Full F carries data, so definitional properties of the preimage can be used when using F.preimage. To obtain an instance of Full F non-constructively, you can use fullOfExists and fullOfSurjective.

See CategoryTheory.Equivalence.of_fullyFaithful_ess_surj for the fact that a functor is an equivalence if and only if it is fully faithful and essentially surjective.

source

class CategoryTheory.Full {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) :

Type (max (max u₁ v₁) v₂)

preimage : {X Y : C} → (F.obj X ⟶ F.obj Y) → (X ⟶ Y)
The data of a preimage for every f : F.obj X ⟶ F.obj Y.
witness : ∀ {X Y : C} (f : F.obj X ⟶ F.obj Y), F.map (CategoryTheory.Full.preimage f) = f
The property that Full.preimage f of maps to f via F.map.

A functor F : C ⥤ D is full if for each X Y : C, F.map is surjective. In fact, we use a constructive definition, so the Full F typeclass contains data, specifying a particular preimage of each f : F.obj X ⟶ F.obj Y.

See https://stacks.math.columbia.edu/tag/001C.

Instances

source

class CategoryTheory.Faithful {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) :

Prop

map_injective : ∀ {X Y : C}, Function.Injective F.map
F.map is injective for each X Y : C.

A functor F : C ⥤ D is faithful if for each X Y : C, F.map is injective.

See https://stacks.math.columbia.edu/tag/001C.

Instances

source

theorem CategoryTheory.Functor.map_injective {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : C} {Y : C} (F : CategoryTheory.Functor C D) [CategoryTheory.Faithful F] :

Function.Injective F.map

source

theorem CategoryTheory.Functor.mapIso_injective {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : C} {Y : C} (F : CategoryTheory.Functor C D) [CategoryTheory.Faithful F] :

Function.Injective F.mapIso

source

def CategoryTheory.Functor.preimage {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : C} {Y : C} (F : CategoryTheory.Functor C D) [CategoryTheory.Full F] (f : F.obj X ⟶ F.obj Y) :

X ⟶ Y

The specified preimage of a morphism under a full functor.

Equations

F.preimage f = CategoryTheory.Full.preimage f

Instances For

source

@[simp]

theorem CategoryTheory.Functor.image_preimage {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.Full F] {X : C} {Y : C} (f : F.obj X ⟶ F.obj Y) :

F.map (F.preimage f) = f

source

theorem CategoryTheory.Functor.map_surjective {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : C} {Y : C} (F : CategoryTheory.Functor C D) [CategoryTheory.Full F] :

Function.Surjective F.map

source

noncomputable def CategoryTheory.Functor.fullOfExists {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (h : ∀ (X Y : C) (f : F.obj X ⟶ F.obj Y), ∃ p, F.map p = f) :

CategoryTheory.Full F

Deduce that F is full from the existence of preimages, using choice.

Equations

One or more equations did not get rendered due to their size.

Instances For

source

noncomputable def CategoryTheory.Functor.fullOfSurjective {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (h : ∀ (X Y : C), Function.Surjective F.map) :

CategoryTheory.Full F

Deduce that F is full from surjectivity of F.map, using choice.

Equations

CategoryTheory.Functor.fullOfSurjective F h = CategoryTheory.Functor.fullOfExists F h

Instances For

source

@[simp]

theorem CategoryTheory.preimage_id {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} [CategoryTheory.Full F] [CategoryTheory.Faithful F] {X : C} :

F.preimage (CategoryTheory.CategoryStruct.id (F.obj X)) = CategoryTheory.CategoryStruct.id X

source

@[simp]

theorem CategoryTheory.preimage_comp {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} [CategoryTheory.Full F] [CategoryTheory.Faithful F] {X : C} {Y : C} {Z : C} (f : F.obj X ⟶ F.obj Y) (g : F.obj Y ⟶ F.obj Z) :

F.preimage (CategoryTheory.CategoryStruct.comp f g) = CategoryTheory.CategoryStruct.comp (F.preimage f) (F.preimage g)

source

@[simp]

theorem CategoryTheory.preimage_map {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} [CategoryTheory.Full F] [CategoryTheory.Faithful F] {X : C} {Y : C} (f : X ⟶ Y) :

F.preimage (F.map f) = f

source

@[simp]

theorem CategoryTheory.Functor.preimageIso_inv {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.Full F] [CategoryTheory.Faithful F] {X : C} {Y : C} (f : F.obj X ≅ F.obj Y) :

(CategoryTheory.Functor.preimageIso F f).inv = F.preimage f.inv

source

@[simp]

theorem CategoryTheory.Functor.preimageIso_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.Full F] [CategoryTheory.Faithful F] {X : C} {Y : C} (f : F.obj X ≅ F.obj Y) :

(CategoryTheory.Functor.preimageIso F f).hom = F.preimage f.hom

source

def CategoryTheory.Functor.preimageIso {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.Full F] [CategoryTheory.Faithful F] {X : C} {Y : C} (f : F.obj X ≅ F.obj Y) :

X ≅ Y

If F : C ⥤ D is fully faithful, every isomorphism F.obj X ≅ F.obj Y has a preimage.

Equations

CategoryTheory.Functor.preimageIso F f = CategoryTheory.Iso.mk (F.preimage f.hom) (F.preimage f.inv)

Instances For

source

@[simp]

theorem CategoryTheory.Functor.preimageIso_mapIso {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.Full F] [CategoryTheory.Faithful F] {X : C} {Y : C} (f : X ≅ Y) :

CategoryTheory.Functor.preimageIso F (F.mapIso f) = f

source

theorem CategoryTheory.isIso_of_fully_faithful {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.Full F] [CategoryTheory.Faithful F] {X : C} {Y : C} (f : X ⟶ Y) [CategoryTheory.IsIso (F.map f)] :

CategoryTheory.IsIso f

If the image of a morphism under a fully faithful functor in an isomorphism, then the original morphisms is also an isomorphism.

source

@[simp]

theorem CategoryTheory.equivOfFullyFaithful_symm_apply {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.Full F] [CategoryTheory.Faithful F] {X : C} {Y : C} (f : F.obj X ⟶ F.obj Y) :

↑(CategoryTheory.equivOfFullyFaithful F).symm f = F.preimage f

source

@[simp]

theorem CategoryTheory.equivOfFullyFaithful_apply {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.Full F] [CategoryTheory.Faithful F] {X : C} {Y : C} (f : X ⟶ Y) :

↑(CategoryTheory.equivOfFullyFaithful F) f = F.map f

source

def CategoryTheory.equivOfFullyFaithful {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.Full F] [CategoryTheory.Faithful F] {X : C} {Y : C} :

(X ⟶ Y) ≃ (F.obj X ⟶ F.obj Y)

If F is fully faithful, we have an equivalence of hom-sets X ⟶ Y and F X ⟶ F Y.

Equations

One or more equations did not get rendered due to their size.

Instances For

source

@[simp]

theorem CategoryTheory.isoEquivOfFullyFaithful_apply {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.Full F] [CategoryTheory.Faithful F] {X : C} {Y : C} (f : X ≅ Y) :

↑(CategoryTheory.isoEquivOfFullyFaithful F) f = F.mapIso f

source

@[simp]

theorem CategoryTheory.isoEquivOfFullyFaithful_symm_apply {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.Full F] [CategoryTheory.Faithful F] {X : C} {Y : C} (f : F.obj X ≅ F.obj Y) :

↑(CategoryTheory.isoEquivOfFullyFaithful F).symm f = CategoryTheory.Functor.preimageIso F f

source

def CategoryTheory.isoEquivOfFullyFaithful {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [CategoryTheory.Full F] [CategoryTheory.Faithful F] {X : C} {Y : C} :

(X ≅ Y) ≃ (F.obj X ≅ F.obj Y)

If F is fully faithful, we have an equivalence of iso-sets X ≅ Y and F X ≅ F Y.

Equations

One or more equations did not get rendered due to their size.

Instances For

source

@[simp]

theorem CategoryTheory.natTransOfCompFullyFaithful_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor C D} (H : CategoryTheory.Functor D E) [CategoryTheory.Full H] [CategoryTheory.Faithful H] (α : CategoryTheory.Functor.comp F H ⟶ CategoryTheory.Functor.comp G H) (X : C) :

(CategoryTheory.natTransOfCompFullyFaithful H α).app X = ↑(CategoryTheory.equivOfFullyFaithful H).symm (α.app X)

source

def CategoryTheory.natTransOfCompFullyFaithful {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor C D} (H : CategoryTheory.Functor D E) [CategoryTheory.Full H] [CategoryTheory.Faithful H] (α : CategoryTheory.Functor.comp F H ⟶ CategoryTheory.Functor.comp G H) :

F ⟶ G

We can construct a natural transformation between functors by constructing a natural transformation between those functors composed with a fully faithful functor.

Equations

CategoryTheory.natTransOfCompFullyFaithful H α = CategoryTheory.NatTrans.mk fun X => ↑(CategoryTheory.equivOfFullyFaithful H).symm (α.app X)

Instances For

source

@[simp]

theorem CategoryTheory.natIsoOfCompFullyFaithful_hom_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor C D} (H : CategoryTheory.Functor D E) [CategoryTheory.Full H] [CategoryTheory.Faithful H] (i : CategoryTheory.Functor.comp F H ≅ CategoryTheory.Functor.comp G H) (X : C) :

(CategoryTheory.natIsoOfCompFullyFaithful H i).hom.app X = H.preimage (i.hom.app X)

source

@[simp]

theorem CategoryTheory.natIsoOfCompFullyFaithful_inv_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor C D} (H : CategoryTheory.Functor D E) [CategoryTheory.Full H] [CategoryTheory.Faithful H] (i : CategoryTheory.Functor.comp F H ≅ CategoryTheory.Functor.comp G H) (X : C) :

(CategoryTheory.natIsoOfCompFullyFaithful H i).inv.app X = H.preimage (i.inv.app X)

source

def CategoryTheory.natIsoOfCompFullyFaithful {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor C D} (H : CategoryTheory.Functor D E) [CategoryTheory.Full H] [CategoryTheory.Faithful H] (i : CategoryTheory.Functor.comp F H ≅ CategoryTheory.Functor.comp G H) :

F ≅ G

We can construct a natural isomorphism between functors by constructing a natural isomorphism between those functors composed with a fully faithful functor.

Equations

CategoryTheory.natIsoOfCompFullyFaithful H i = CategoryTheory.NatIso.ofComponents fun X => ↑(CategoryTheory.isoEquivOfFullyFaithful H).symm (i.app X)

Instances For

source

theorem CategoryTheory.natIsoOfCompFullyFaithful_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor C D} (H : CategoryTheory.Functor D E) [CategoryTheory.Full H] [CategoryTheory.Faithful H] (i : CategoryTheory.Functor.comp F H ≅ CategoryTheory.Functor.comp G H) :

(CategoryTheory.natIsoOfCompFullyFaithful H i).hom = CategoryTheory.natTransOfCompFullyFaithful H i.hom

source

theorem CategoryTheory.natIsoOfCompFullyFaithful_inv {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor C D} (H : CategoryTheory.Functor D E) [CategoryTheory.Full H] [CategoryTheory.Faithful H] (i : CategoryTheory.Functor.comp F H ≅ CategoryTheory.Functor.comp G H) :

(CategoryTheory.natIsoOfCompFullyFaithful H i).inv = CategoryTheory.natTransOfCompFullyFaithful H i.inv

source

@[simp]

theorem CategoryTheory.NatTrans.equivOfCompFullyFaithful_apply {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor C D} (H : CategoryTheory.Functor D E) [CategoryTheory.Full H] [CategoryTheory.Faithful H] (α : F ⟶ G) :

↑(CategoryTheory.NatTrans.equivOfCompFullyFaithful H) α = α ◫ CategoryTheory.CategoryStruct.id H

source

@[simp]

theorem CategoryTheory.NatTrans.equivOfCompFullyFaithful_symm_apply {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor C D} (H : CategoryTheory.Functor D E) [CategoryTheory.Full H] [CategoryTheory.Faithful H] (α : CategoryTheory.Functor.comp F H ⟶ CategoryTheory.Functor.comp G H) :

↑(CategoryTheory.NatTrans.equivOfCompFullyFaithful H).symm α = CategoryTheory.natTransOfCompFullyFaithful H α

source

def CategoryTheory.NatTrans.equivOfCompFullyFaithful {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor C D} (H : CategoryTheory.Functor D E) [CategoryTheory.Full H] [CategoryTheory.Faithful H] :

(F ⟶ G) ≃ (CategoryTheory.Functor.comp F H ⟶ CategoryTheory.Functor.comp G H)

Horizontal composition with a fully faithful functor induces a bijection on natural transformations.

Equations

One or more equations did not get rendered due to their size.

Instances For

source

@[simp]

theorem CategoryTheory.NatIso.equivOfCompFullyFaithful_apply {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor C D} (H : CategoryTheory.Functor D E) [CategoryTheory.Full H] [CategoryTheory.Faithful H] (e : F ≅ G) :

↑(CategoryTheory.NatIso.equivOfCompFullyFaithful H) e = CategoryTheory.NatIso.hcomp e (CategoryTheory.Iso.refl H)

source

@[simp]

theorem CategoryTheory.NatIso.equivOfCompFullyFaithful_symm_apply {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor C D} (H : CategoryTheory.Functor D E) [CategoryTheory.Full H] [CategoryTheory.Faithful H] (i : CategoryTheory.Functor.comp F H ≅ CategoryTheory.Functor.comp G H) :

↑(CategoryTheory.NatIso.equivOfCompFullyFaithful H).symm i = CategoryTheory.natIsoOfCompFullyFaithful H i

source

def CategoryTheory.NatIso.equivOfCompFullyFaithful {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor C D} (H : CategoryTheory.Functor D E) [CategoryTheory.Full H] [CategoryTheory.Faithful H] :

(F ≅ G) ≃ (CategoryTheory.Functor.comp F H ≅ CategoryTheory.Functor.comp G H)

Horizontal composition with a fully faithful functor induces a bijection on natural isomorphisms.

Equations

One or more equations did not get rendered due to their size.

Instances For

source

instance CategoryTheory.Full.id {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] :

CategoryTheory.Full (CategoryTheory.Functor.id C)

Equations

CategoryTheory.Full.id = CategoryTheory.Full.mk fun {X Y} f => f

source

instance CategoryTheory.Faithful.id {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] :

CategoryTheory.Faithful (CategoryTheory.Functor.id C)

Equations

@CategoryTheory.Faithful.id = @CategoryTheory.Faithful.id.proof_1

source

instance CategoryTheory.Faithful.comp {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [CategoryTheory.Faithful F] [CategoryTheory.Faithful G] :

CategoryTheory.Faithful (CategoryTheory.Functor.comp F G)

Equations

@CategoryTheory.Faithful.comp = @CategoryTheory.Faithful.comp.proof_1

source

theorem CategoryTheory.Faithful.of_comp {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [CategoryTheory.Faithful (CategoryTheory.Functor.comp F G)] :

CategoryTheory.Faithful F

source

def CategoryTheory.Full.ofIso {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {F' : CategoryTheory.Functor C D} [CategoryTheory.Full F] (α : F ≅ F') :

CategoryTheory.Full F'

If F is full, and naturally isomorphic to some F', then F' is also full.

Equations

CategoryTheory.Full.ofIso α = CategoryTheory.Full.mk fun {X Y} f => F.preimage (CategoryTheory.CategoryStruct.comp (α.app X).hom (CategoryTheory.CategoryStruct.comp f (α.app Y).inv))

Instances For

source

theorem CategoryTheory.Faithful.of_iso {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {F' : CategoryTheory.Functor C D} [CategoryTheory.Faithful F] (α : F ≅ F') :

CategoryTheory.Faithful F'

source

theorem CategoryTheory.Faithful.of_comp_iso {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D E} {H : CategoryTheory.Functor C E} [CategoryTheory.Faithful H] (h : CategoryTheory.Functor.comp F G ≅ H) :

CategoryTheory.Faithful F

source

theorem CategoryTheory.Iso.faithful_of_comp {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D E} {H : CategoryTheory.Functor C E} [CategoryTheory.Faithful H] (h : CategoryTheory.Functor.comp F G ≅ H) :

CategoryTheory.Faithful F

Alias of CategoryTheory.Faithful.of_comp_iso.

source

theorem CategoryTheory.Faithful.of_comp_eq {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D E} {H : CategoryTheory.Functor C E} [ℋ : CategoryTheory.Faithful H] (h : CategoryTheory.Functor.comp F G = H) :

CategoryTheory.Faithful F

source

theorem Eq.faithful_of_comp {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D E} {H : CategoryTheory.Functor C E} [ℋ : CategoryTheory.Faithful H] (h : CategoryTheory.Functor.comp F G = H) :

CategoryTheory.Faithful F

Alias of CategoryTheory.Faithful.of_comp_eq.

source

def CategoryTheory.Faithful.div {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C E) (G : CategoryTheory.Functor D E) [CategoryTheory.Faithful G] (obj : C → D) (h_obj : ∀ (X : C), G.obj (obj X) = F.obj X) (map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)) (h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map X Y f)) (F.map f)) :

CategoryTheory.Functor C D

“Divide” a functor by a faithful functor.

Equations

CategoryTheory.Faithful.div F G obj h_obj map h_map = CategoryTheory.Functor.mk { obj := obj, map := map }

Instances For

source

theorem CategoryTheory.Faithful.div_comp {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C E) [CategoryTheory.Faithful F] (G : CategoryTheory.Functor D E) [CategoryTheory.Faithful G] (obj : C → D) (h_obj : ∀ (X : C), G.obj (obj X) = F.obj X) (map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)) (h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map X Y f)) (F.map f)) :

CategoryTheory.Functor.comp (CategoryTheory.Faithful.div F G obj h_obj map h_map) G = F

source

theorem CategoryTheory.Faithful.div_faithful {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C E) [CategoryTheory.Faithful F] (G : CategoryTheory.Functor D E) [CategoryTheory.Faithful G] (obj : C → D) (h_obj : ∀ (X : C), G.obj (obj X) = F.obj X) (map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)) (h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map X Y f)) (F.map f)) :

CategoryTheory.Faithful (CategoryTheory.Faithful.div F G obj h_obj map h_map)

source

instance CategoryTheory.Full.comp {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [CategoryTheory.Full F] [CategoryTheory.Full G] :

CategoryTheory.Full (CategoryTheory.Functor.comp F G)

Equations

CategoryTheory.Full.comp F G = CategoryTheory.Full.mk fun {X Y} f => F.preimage (G.preimage f)

source

def CategoryTheory.Full.ofCompFaithful {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [CategoryTheory.Full (CategoryTheory.Functor.comp F G)] [CategoryTheory.Faithful G] :

CategoryTheory.Full F

If F ⋙ G is full and G is faithful, then F is full.

Equations

CategoryTheory.Full.ofCompFaithful F G = CategoryTheory.Full.mk fun {X Y} f => (CategoryTheory.Functor.comp F G).preimage (G.map f)

Instances For

source

def CategoryTheory.Full.ofCompFaithfulIso {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D E} {H : CategoryTheory.Functor C E} [CategoryTheory.Full H] [CategoryTheory.Faithful G] (h : CategoryTheory.Functor.comp F G ≅ H) :

CategoryTheory.Full F

If F ⋙ G is full and G is faithful, then F is full.

Equations

CategoryTheory.Full.ofCompFaithfulIso h = CategoryTheory.Full.ofCompFaithful F G

Instances For

source

def CategoryTheory.fullyFaithfulCancelRight {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor C D} (H : CategoryTheory.Functor D E) [CategoryTheory.Full H] [CategoryTheory.Faithful H] (comp_iso : CategoryTheory.Functor.comp F H ≅ CategoryTheory.Functor.comp G H) :

F ≅ G

Given a natural isomorphism between F ⋙ H and G ⋙ H for a fully faithful functor H, we can 'cancel' it to give a natural iso between F and G.

Equations

CategoryTheory.fullyFaithfulCancelRight H comp_iso = CategoryTheory.NatIso.ofComponents fun X => CategoryTheory.Functor.preimageIso H (comp_iso.app X)

Instances For

source

@[simp]

theorem CategoryTheory.fullyFaithfulCancelRight_hom_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor C D} {H : CategoryTheory.Functor D E} [CategoryTheory.Full H] [CategoryTheory.Faithful H] (comp_iso : CategoryTheory.Functor.comp F H ≅ CategoryTheory.Functor.comp G H) (X : C) :

(CategoryTheory.fullyFaithfulCancelRight H comp_iso).hom.app X = H.preimage (comp_iso.hom.app X)

source

@[simp]

theorem CategoryTheory.fullyFaithfulCancelRight_inv_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor C D} {H : CategoryTheory.Functor D E} [CategoryTheory.Full H] [CategoryTheory.Faithful H] (comp_iso : CategoryTheory.Functor.comp F H ≅ CategoryTheory.Functor.comp G H) (X : C) :

(CategoryTheory.fullyFaithfulCancelRight H comp_iso).inv.app X = H.preimage (comp_iso.inv.app X)