Documentation

Mathlib.CategoryTheory.MorphismProperty.Representable

Relatively representable morphisms #

In this file we define and develop basic results about relatively representable morphisms.

Classically, a morphism f : F ⟶ G of presheaves is said to be representable if for any morphism g : yoneda.obj X ⟶ G, there exists a pullback square of the following form

  yoneda.obj Y --yoneda.map snd--> yoneda.obj X
      |                                |
     fst                               g
      |                                |
      v                                v
      F ------------ f --------------> G

In this file, we define a notion of relative representability which works with respect to any functor, and not just yoneda. The fact that a morphism f : F ⟶ G between presheaves is representable in the classical case will then be given by yoneda.relativelyRepresentable f.

Main definitions #

Throughout this file, F : C ⥤ D is a functor between categories C and D.

  F.obj b --F.map snd--> F.obj a
      |                     |
     fst                    g
      |                     |
      v                     v
      X ------- f --------> Y

API #

Given hf : relativelyRepresentable f, with f : X ⟶ Y and g : F.obj a ⟶ Y, we provide:

We also provide some basic API for dealing with triple pullbacks, i.e. given hf₁ : relativelyRepresentable f₁, f₂ : F.obj A₂ ⟶ X and f₃ : F.obj A₃ ⟶ X, we define hf₁.pullback₃ f₂ f₃ to be the pullback of (A₁ ×_X A₂) ×_{A₁} (A₁ ×_X A₃). We then develop some API for working with this object, mirroring the usual API for pullbacks, but where as much as possible is phrased internally to C.

Main results #

A morphism f : X ⟶ Y in D is said to be relatively representable if for any g : F.obj a ⟶ Y, there exists a pullback square of the following form

F.obj b --F.map snd--> F.obj a
    |                     |
   fst                    g
    |                     |
    v                     v
    X ------- f --------> Y
Equations
    Instances For
      noncomputable def CategoryTheory.Functor.relativelyRepresentable.pullback {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {X Y : D} {f : X Y} (hf : F.relativelyRepresentable f) {a : C} (g : F.obj a Y) :
      C

      Let f : X ⟶ Y be a relatively representable morphism in D. Then, for any g : F.obj a ⟶ Y, hf.pullback g denotes the (choice of) a corresponding object in C such that there is a pullback square of the following form

      hf.pullback g --F.map snd--> F.obj a
          |                          |
         fst                         g
          |                          |
          v                          v
          X ---------- f ----------> Y
      
      Equations
        Instances For
          @[reducible, inline]
          noncomputable abbrev CategoryTheory.Functor.relativelyRepresentable.snd {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {X Y : D} {f : X Y} (hf : F.relativelyRepresentable f) {a : C} (g : F.obj a Y) :
          hf.pullback g a

          Given a representable morphism f : X ⟶ Y, then for any g : F.obj a ⟶ Y, hf.snd g denotes the morphism in C giving rise to the following diagram

          hf.pullback g --F.map (hf.snd g)--> F.obj a
              |                                 |
             fst                                g
              |                                 |
              v                                 v
              X -------------- f -------------> Y
          
          Equations
            Instances For
              @[reducible, inline]
              noncomputable abbrev CategoryTheory.Functor.relativelyRepresentable.fst {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {X Y : D} {f : X Y} (hf : F.relativelyRepresentable f) {a : C} (g : F.obj a Y) :
              F.obj (hf.pullback g) X

              Given a relatively representable morphism f : X ⟶ Y, then for any g : F.obj a ⟶ Y, hf.fst g denotes the first projection in the following diagram, given by the defining property of f being relatively representable

              hf.pullback g --F.map (hf.snd g)--> F.obj a
                  |                                 |
              hf.fst g                              g
                  |                                 |
                  v                                 v
                  X -------------- f -------------> Y
              
              Equations
                Instances For
                  @[reducible, inline]
                  noncomputable abbrev CategoryTheory.Functor.relativelyRepresentable.fst' {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {Y : D} {b : C} {f' : F.obj b Y} (hf' : F.relativelyRepresentable f') {a : C} (g : F.obj a Y) [F.Full] :
                  hf'.pullback g b

                  When F is full, given a representable morphism f' : F.obj b ⟶ Y, then hf'.fst' g denotes the preimage of hf'.fst g under F.

                  Equations
                    Instances For
                      theorem CategoryTheory.Functor.relativelyRepresentable.map_fst' {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {Y : D} {b : C} {f' : F.obj b Y} (hf' : F.relativelyRepresentable f') {a : C} (g : F.obj a Y) [F.Full] :
                      F.map (hf'.fst' g) = hf'.fst g
                      theorem CategoryTheory.Functor.relativelyRepresentable.isPullback {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {X Y : D} {f : X Y} (hf : F.relativelyRepresentable f) {a : C} (g : F.obj a Y) :
                      IsPullback (hf.fst g) (F.map (hf.snd g)) f g
                      theorem CategoryTheory.Functor.relativelyRepresentable.w {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {X Y : D} {f : X Y} (hf : F.relativelyRepresentable f) {a : C} (g : F.obj a Y) :
                      theorem CategoryTheory.Functor.relativelyRepresentable.w_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {X Y : D} {f : X Y} (hf : F.relativelyRepresentable f) {a : C} (g : F.obj a Y) {Z : D} (h : Y Z) :
                      theorem CategoryTheory.Functor.relativelyRepresentable.isPullback' {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {Y : D} {b : C} {f' : F.obj b Y} (hf' : F.relativelyRepresentable f') {a : C} (g : F.obj a Y) [F.Full] :
                      IsPullback (F.map (hf'.fst' g)) (F.map (hf'.snd g)) f' g

                      Variant of the pullback square when F is full, and given f' : F.obj b ⟶ Y.

                      theorem CategoryTheory.Functor.relativelyRepresentable.w' {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {X Y Z : C} {f : X Z} (hf : F.relativelyRepresentable (F.map f)) (g : Y Z) [F.Full] [F.Faithful] :
                      theorem CategoryTheory.Functor.relativelyRepresentable.w'_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {X Y Z : C} {f : X Z} (hf : F.relativelyRepresentable (F.map f)) (g : Y Z) [F.Full] [F.Faithful] {Z✝ : C} (h : Z Z✝) :
                      theorem CategoryTheory.Functor.relativelyRepresentable.isPullback_of_map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {X Y Z : C} {f : X Z} (hf : F.relativelyRepresentable (F.map f)) (g : Y Z) [F.Full] [F.Faithful] :
                      IsPullback (hf.fst' (F.map g)) (hf.snd (F.map g)) f g
                      theorem CategoryTheory.Functor.relativelyRepresentable.hom_ext {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {X Y : D} {f : X Y} (hf : F.relativelyRepresentable f) {a : C} {g : F.obj a Y} [F.Faithful] {c : C} {a✝ b : c hf.pullback g} (h₁ : CategoryStruct.comp (F.map a✝) (hf.fst g) = CategoryStruct.comp (F.map b) (hf.fst g)) (h₂ : CategoryStruct.comp a✝ (hf.snd g) = CategoryStruct.comp b (hf.snd g)) :
                      a✝ = b

                      Two morphisms a b : c ⟶ hf.pullback g are equal if

                      • Their compositions (in C) with hf.snd g : hf.pullback ⟶ X are equal.
                      • The compositions of F.map a and F.map b with hf.fst g are equal.
                      theorem CategoryTheory.Functor.relativelyRepresentable.hom_ext_iff {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {X Y : D} {f : X Y} {hf : F.relativelyRepresentable f} {a : C} {g : F.obj a Y} [F.Faithful] {c : C} {a✝ b : c hf.pullback g} :
                      a✝ = b CategoryStruct.comp (F.map a✝) (hf.fst g) = CategoryStruct.comp (F.map b) (hf.fst g) CategoryStruct.comp a✝ (hf.snd g) = CategoryStruct.comp b (hf.snd g)
                      theorem CategoryTheory.Functor.relativelyRepresentable.hom_ext' {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {Y : D} {b : C} {f' : F.obj b Y} (hf' : F.relativelyRepresentable f') {a : C} {g : F.obj a Y} [F.Full] [F.Faithful] {c : C} {a✝ b✝ : c hf'.pullback g} (h₁ : CategoryStruct.comp a✝ (hf'.fst' g) = CategoryStruct.comp b✝ (hf'.fst' g)) (h₂ : CategoryStruct.comp a✝ (hf'.snd g) = CategoryStruct.comp b✝ (hf'.snd g)) :
                      a✝ = b✝

                      In the case of a representable morphism f' : F.obj Y ⟶ G, whose codomain lies in the image of F, we get that two morphism a b : Z ⟶ hf.pullback g are equal if

                      • Their compositions (in C) with hf'.snd g : hf.pullback ⟶ X are equal.
                      • Their compositions (in C) with hf'.fst' g : hf.pullback ⟶ Y are equal.
                      theorem CategoryTheory.Functor.relativelyRepresentable.hom_ext'_iff {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {Y : D} {b : C} {f' : F.obj b Y} {hf' : F.relativelyRepresentable f'} {a : C} {g : F.obj a Y} [F.Full] [F.Faithful] {c : C} {a✝ b✝ : c hf'.pullback g} :
                      a✝ = b✝ CategoryStruct.comp a✝ (hf'.fst' g) = CategoryStruct.comp b✝ (hf'.fst' g) CategoryStruct.comp a✝ (hf'.snd g) = CategoryStruct.comp b✝ (hf'.snd g)
                      noncomputable def CategoryTheory.Functor.relativelyRepresentable.lift {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {X Y : D} {f : X Y} (hf : F.relativelyRepresentable f) {a : C} {g : F.obj a Y} {c : C} (i : F.obj c X) (h : c a) (hi : CategoryStruct.comp i f = CategoryStruct.comp (F.map h) g) [F.Full] :
                      c hf.pullback g

                      The lift (in C) obtained from the universal property of F.obj (hf.pullback g), in the case when the cone point is in the image of F.obj.

                      Equations
                        Instances For
                          @[simp]
                          theorem CategoryTheory.Functor.relativelyRepresentable.lift_fst {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {X Y : D} {f : X Y} (hf : F.relativelyRepresentable f) {a : C} {g : F.obj a Y} {c : C} (i : F.obj c X) (h : c a) (hi : CategoryStruct.comp i f = CategoryStruct.comp (F.map h) g) [F.Full] :
                          CategoryStruct.comp (F.map (hf.lift i h hi)) (hf.fst g) = i
                          @[simp]
                          theorem CategoryTheory.Functor.relativelyRepresentable.lift_fst_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {X Y : D} {f : X Y} (hf : F.relativelyRepresentable f) {a : C} {g : F.obj a Y} {c : C} (i : F.obj c X) (h : c a) (hi : CategoryStruct.comp i f = CategoryStruct.comp (F.map h) g) [F.Full] {Z : D} (h✝ : X Z) :
                          @[simp]
                          theorem CategoryTheory.Functor.relativelyRepresentable.lift_snd {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {X Y : D} {f : X Y} (hf : F.relativelyRepresentable f) {a : C} {g : F.obj a Y} {c : C} (i : F.obj c X) (h : c a) (hi : CategoryStruct.comp i f = CategoryStruct.comp (F.map h) g) [F.Full] [F.Faithful] :
                          CategoryStruct.comp (hf.lift i h hi) (hf.snd g) = h
                          @[simp]
                          theorem CategoryTheory.Functor.relativelyRepresentable.lift_snd_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {X Y : D} {f : X Y} (hf : F.relativelyRepresentable f) {a : C} {g : F.obj a Y} {c : C} (i : F.obj c X) (h : c a) (hi : CategoryStruct.comp i f = CategoryStruct.comp (F.map h) g) [F.Full] [F.Faithful] {Z : C} (h✝ : a Z) :
                          noncomputable def CategoryTheory.Functor.relativelyRepresentable.lift' {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {Y : D} {b : C} {f' : F.obj b Y} (hf' : F.relativelyRepresentable f') {a : C} {g : F.obj a Y} {c : C} (i : c b) (h : c a) (hi : CategoryStruct.comp (F.map i) f' = CategoryStruct.comp (F.map h) g) [F.Full] :
                          c hf'.pullback g

                          Variant of lift in the case when the domain of f lies in the image of F.obj. Thus, in this case, one can obtain the lift directly by giving two morphisms in C.

                          Equations
                            Instances For
                              @[simp]
                              theorem CategoryTheory.Functor.relativelyRepresentable.lift'_fst {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {Y : D} {b : C} {f' : F.obj b Y} (hf' : F.relativelyRepresentable f') {a : C} {g : F.obj a Y} {c : C} (i : c b) (h : c a) (hi : CategoryStruct.comp (F.map i) f' = CategoryStruct.comp (F.map h) g) [F.Full] [F.Faithful] :
                              CategoryStruct.comp (hf'.lift' i h hi) (hf'.fst' g) = i
                              @[simp]
                              theorem CategoryTheory.Functor.relativelyRepresentable.lift'_fst_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {Y : D} {b : C} {f' : F.obj b Y} (hf' : F.relativelyRepresentable f') {a : C} {g : F.obj a Y} {c : C} (i : c b) (h : c a) (hi : CategoryStruct.comp (F.map i) f' = CategoryStruct.comp (F.map h) g) [F.Full] [F.Faithful] {Z : C} (h✝ : b Z) :
                              @[simp]
                              theorem CategoryTheory.Functor.relativelyRepresentable.lift'_snd {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {Y : D} {b : C} {f' : F.obj b Y} (hf' : F.relativelyRepresentable f') {a : C} {g : F.obj a Y} {c : C} (i : c b) (h : c a) (hi : CategoryStruct.comp (F.map i) f' = CategoryStruct.comp (F.map h) g) [F.Full] [F.Faithful] :
                              CategoryStruct.comp (hf'.lift' i h hi) (hf'.snd g) = h
                              @[simp]
                              theorem CategoryTheory.Functor.relativelyRepresentable.lift'_snd_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {Y : D} {b : C} {f' : F.obj b Y} (hf' : F.relativelyRepresentable f') {a : C} {g : F.obj a Y} {c : C} (i : c b) (h : c a) (hi : CategoryStruct.comp (F.map i) f' = CategoryStruct.comp (F.map h) g) [F.Full] [F.Faithful] {Z : C} (h✝ : a Z) :
                              noncomputable def CategoryTheory.Functor.relativelyRepresentable.symmetry {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {Y : D} {b : C} {f' : F.obj b Y} (hf' : F.relativelyRepresentable f') {a : C} {g : F.obj a Y} (hg : F.relativelyRepresentable g) [F.Full] :
                              hf'.pullback g hg.pullback f'

                              Given two representable morphisms f' : F.obj b ⟶ Y and g : F.obj a ⟶ Y, we obtain an isomorphism hf'.pullback g ⟶ hg.pullback f'.

                              Equations
                                Instances For
                                  @[simp]
                                  theorem CategoryTheory.Functor.relativelyRepresentable.symmetry_fst {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {Y : D} {b : C} {f' : F.obj b Y} (hf' : F.relativelyRepresentable f') {a : C} {g : F.obj a Y} (hg : F.relativelyRepresentable g) [F.Full] [F.Faithful] :
                                  CategoryStruct.comp (hf'.symmetry hg) (hg.fst' f') = hf'.snd g
                                  @[simp]
                                  theorem CategoryTheory.Functor.relativelyRepresentable.symmetry_fst_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {Y : D} {b : C} {f' : F.obj b Y} (hf' : F.relativelyRepresentable f') {a : C} {g : F.obj a Y} (hg : F.relativelyRepresentable g) [F.Full] [F.Faithful] {Z : C} (h : a Z) :
                                  @[simp]
                                  theorem CategoryTheory.Functor.relativelyRepresentable.symmetry_snd {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {Y : D} {b : C} {f' : F.obj b Y} (hf' : F.relativelyRepresentable f') {a : C} {g : F.obj a Y} (hg : F.relativelyRepresentable g) [F.Full] [F.Faithful] :
                                  CategoryStruct.comp (hf'.symmetry hg) (hg.snd f') = hf'.fst' g
                                  @[simp]
                                  theorem CategoryTheory.Functor.relativelyRepresentable.symmetry_snd_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {Y : D} {b : C} {f' : F.obj b Y} (hf' : F.relativelyRepresentable f') {a : C} {g : F.obj a Y} (hg : F.relativelyRepresentable g) [F.Full] [F.Faithful] {Z : C} (h : b Z) :
                                  @[simp]
                                  theorem CategoryTheory.Functor.relativelyRepresentable.symmetry_symmetry {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {Y : D} {b : C} {f' : F.obj b Y} (hf' : F.relativelyRepresentable f') {a : C} {g : F.obj a Y} (hg : F.relativelyRepresentable g) [F.Full] [F.Faithful] :
                                  @[simp]
                                  theorem CategoryTheory.Functor.relativelyRepresentable.symmetry_symmetry_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {Y : D} {b : C} {f' : F.obj b Y} (hf' : F.relativelyRepresentable f') {a : C} {g : F.obj a Y} (hg : F.relativelyRepresentable g) [F.Full] [F.Faithful] {Z : C} (h : hf'.pullback g Z) :
                                  noncomputable def CategoryTheory.Functor.relativelyRepresentable.symmetryIso {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {Y : D} {b : C} {f' : F.obj b Y} (hf' : F.relativelyRepresentable f') {a : C} {g : F.obj a Y} (hg : F.relativelyRepresentable g) [F.Full] [F.Faithful] :
                                  hf'.pullback g hg.pullback f'

                                  The isomorphism given by Presheaf.representable.symmetry.

                                  Equations
                                    Instances For
                                      @[simp]
                                      theorem CategoryTheory.Functor.relativelyRepresentable.symmetryIso_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {Y : D} {b : C} {f' : F.obj b Y} (hf' : F.relativelyRepresentable f') {a : C} {g : F.obj a Y} (hg : F.relativelyRepresentable g) [F.Full] [F.Faithful] :
                                      (hf'.symmetryIso hg).hom = hf'.symmetry hg
                                      @[simp]
                                      theorem CategoryTheory.Functor.relativelyRepresentable.symmetryIso_inv {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {Y : D} {b : C} {f' : F.obj b Y} (hf' : F.relativelyRepresentable f') {a : C} {g : F.obj a Y} (hg : F.relativelyRepresentable g) [F.Full] [F.Faithful] :
                                      (hf'.symmetryIso hg).inv = hg.symmetry hf'
                                      instance CategoryTheory.Functor.relativelyRepresentable.instIsIsoSymmetryOfFaithful {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {Y : D} {b : C} {f' : F.obj b Y} (hf' : F.relativelyRepresentable f') {a : C} {g : F.obj a Y} (hg : F.relativelyRepresentable g) [F.Full] [F.Faithful] :
                                      IsIso (hf'.symmetry hg)
                                      theorem CategoryTheory.Functor.relativelyRepresentable.map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) [F.Full] [Limits.HasPullbacks C] {a b : C} (f : a b) [∀ (c : C) (g : c b), Limits.PreservesLimit (Limits.cospan f g) F] :

                                      When C has pullbacks, then F.map f is representable with respect to F for any f : a ⟶ b in C.

                                      Given a morphism property P in a category C, a functor F : C ⥤ D and a morphism f : X ⟶ Y in D. Then f satisfies the morphism property P.relative with respect to F iff:

                                      • The morphism is representable with respect to F
                                      • For any morphism g : F.obj a ⟶ Y, the property P holds for any represented pullback of f by g.
                                      Equations
                                        Instances For
                                          @[reducible, inline]

                                          Given a morphism property P in a category C, a morphism f : F ⟶ G of presheaves in the category Cᵒᵖ ⥤ Type v satisfies the morphism property P.presheaf iff:

                                          • The morphism is representable.
                                          • For any morphism g : F.obj a ⟶ G, the property P holds for any represented pullback of f by g. This is implemented as a special case of the more general notion of P.relative, to the case when the functor F is yoneda.
                                          Equations
                                            Instances For
                                              theorem CategoryTheory.MorphismProperty.relative.rep {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {X Y : D} {P : MorphismProperty C} {f : X Y} (hf : relative F P f) :

                                              A morphism satisfying P.relative is representable.

                                              theorem CategoryTheory.MorphismProperty.relative.property {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {X Y : D} {P : MorphismProperty C} {f : X Y} (hf : relative F P f) a b : C (g : F.obj a Y) (fst : F.obj b X) (snd : b a) :
                                              IsPullback fst (F.map snd) f gP snd
                                              theorem CategoryTheory.MorphismProperty.relative.property_snd {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {X Y : D} {P : MorphismProperty C} {f : X Y} (hf : relative F P f) {a : C} (g : F.obj a Y) :
                                              P (.snd g)
                                              theorem CategoryTheory.MorphismProperty.relative.of_exists {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {X Y : D} {P : MorphismProperty C} [F.Faithful] [F.Full] [P.RespectsIso] {f : X Y} (h₀ : ∀ ⦃a : C⦄ (g : F.obj a Y), ∃ (b : C) (fst : F.obj b X) (snd : b a) (_ : IsPullback fst (F.map snd) f g), P snd) :
                                              relative F P f

                                              Given a morphism property P which respects isomorphisms, then to show that a morphism f : X ⟶ Y satisfies P.relative it suffices to show that:

                                              • The morphism is representable.
                                              • For any morphism g : F.obj a ⟶ G, the property P holds for some represented pullback of f by g.
                                              theorem CategoryTheory.MorphismProperty.relative_of_snd {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {X Y : D} {P : MorphismProperty C} [F.Faithful] [F.Full] [P.RespectsIso] {f : X Y} (hf : F.relativelyRepresentable f) (h : ∀ ⦃a : C⦄ (g : F.obj a Y), P (hf.snd g)) :
                                              relative F P f
                                              theorem CategoryTheory.MorphismProperty.relative_map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {P : MorphismProperty C} [F.Faithful] [F.Full] [Limits.HasPullbacks C] [P.IsStableUnderBaseChange] {a b : C} {f : a b} [∀ (c : C) (g : c b), Limits.PreservesLimit (Limits.cospan f g) F] (hf : P f) :
                                              relative F P (F.map f)

                                              If P : MorphismProperty C is stable under base change, F is fully faithful and preserves pullbacks, and C has all pullbacks, then for any f : a ⟶ b in C, F.map f satisfies P.relative if f satisfies P.

                                              theorem CategoryTheory.MorphismProperty.of_relative_map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} {P : MorphismProperty C} {a b : C} {f : a b} (hf : relative F P (F.map f)) :
                                              P f

                                              If P' : MorphismProperty C is satisfied whenever P is, then also P'.relative is satisfied whenever P.relative is.

                                              Morphisms satisfying (monomorphism C).presheaf are in particular monomorphisms.

                                              theorem CategoryTheory.MorphismProperty.fst'_self_eq_snd {C : Type u₁} [Category.{v₁, u₁} C] {P : MorphismProperty C} {G : Functor Cᵒᵖ (Type v₁)} (hP : P monomorphisms C) {X : C} {f : yoneda.obj X G} (hf : P.presheaf f) :
                                              .fst' f = .snd f
                                              theorem CategoryTheory.MorphismProperty.isIso_fst'_self {C : Type u₁} [Category.{v₁, u₁} C] {P : MorphismProperty C} {G : Functor Cᵒᵖ (Type v₁)} (hP : P monomorphisms C) {X : C} {f : yoneda.obj X G} (hf : P.presheaf f) :
                                              IsIso (.fst' f)
                                              noncomputable def CategoryTheory.Functor.relativelyRepresentable.pullback₃ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] :
                                              C

                                              The pullback (A₁ ×_X A₂) ×_{A₁} (A₁ ×_X A₃).

                                              Equations
                                                Instances For
                                                  noncomputable def CategoryTheory.Functor.relativelyRepresentable.pullback₃.p₁ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] :
                                                  hf₁.pullback₃ f₂ f₃ A₁

                                                  The morphism (A₁ ×_X A₂) ×_{A₁} (A₁ ×_X A₃) ⟶ A₁.

                                                  Equations
                                                    Instances For
                                                      noncomputable def CategoryTheory.Functor.relativelyRepresentable.pullback₃.p₂ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] :
                                                      hf₁.pullback₃ f₂ f₃ A₂

                                                      The morphism (A₁ ×_X A₂) ×_{A₁} (A₁ ×_X A₃) ⟶ A₂.

                                                      Equations
                                                        Instances For
                                                          noncomputable def CategoryTheory.Functor.relativelyRepresentable.pullback₃.p₃ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] :
                                                          hf₁.pullback₃ f₂ f₃ A₃

                                                          The morphism (A₁ ×_X A₂) ×_{A₁} (A₁ ×_X A₃) ⟶ A₃.

                                                          Equations
                                                            Instances For
                                                              noncomputable def CategoryTheory.Functor.relativelyRepresentable.pullback₃.π {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] :
                                                              F.obj (hf₁.pullback₃ f₂ f₃) X

                                                              The morphism F.obj (A₁ ×_X A₂) ×_{A₁} (A₁ ×_X A₃) ⟶ X.

                                                              Equations
                                                                Instances For
                                                                  @[simp]
                                                                  theorem CategoryTheory.Functor.relativelyRepresentable.pullback₃.map_p₁_comp {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] :
                                                                  CategoryStruct.comp (F.map (p₁ hf₁ f₂ f₃)) f₁ = π hf₁ f₂ f₃
                                                                  @[simp]
                                                                  theorem CategoryTheory.Functor.relativelyRepresentable.pullback₃.map_p₁_comp_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] {Z : D} (h : X Z) :
                                                                  CategoryStruct.comp (F.map (p₁ hf₁ f₂ f₃)) (CategoryStruct.comp f₁ h) = CategoryStruct.comp (π hf₁ f₂ f₃) h
                                                                  @[simp]
                                                                  theorem CategoryTheory.Functor.relativelyRepresentable.pullback₃.map_p₂_comp {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] :
                                                                  CategoryStruct.comp (F.map (p₂ hf₁ f₂ f₃)) f₂ = π hf₁ f₂ f₃
                                                                  @[simp]
                                                                  theorem CategoryTheory.Functor.relativelyRepresentable.pullback₃.map_p₂_comp_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] {Z : D} (h : X Z) :
                                                                  CategoryStruct.comp (F.map (p₂ hf₁ f₂ f₃)) (CategoryStruct.comp f₂ h) = CategoryStruct.comp (π hf₁ f₂ f₃) h
                                                                  @[simp]
                                                                  theorem CategoryTheory.Functor.relativelyRepresentable.pullback₃.map_p₃_comp {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] :
                                                                  CategoryStruct.comp (F.map (p₃ hf₁ f₂ f₃)) f₃ = π hf₁ f₂ f₃
                                                                  @[simp]
                                                                  theorem CategoryTheory.Functor.relativelyRepresentable.pullback₃.map_p₃_comp_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] {Z : D} (h : X Z) :
                                                                  CategoryStruct.comp (F.map (p₃ hf₁ f₂ f₃)) (CategoryStruct.comp f₃ h) = CategoryStruct.comp (π hf₁ f₂ f₃) h
                                                                  noncomputable def CategoryTheory.Functor.relativelyRepresentable.lift₃ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] [F.Faithful] {Z : C} (x₁ : Z A₁) (x₂ : Z A₂) (x₃ : Z A₃) (h₁₂ : CategoryStruct.comp (F.map x₁) f₁ = CategoryStruct.comp (F.map x₂) f₂) (h₁₃ : CategoryStruct.comp (F.map x₁) f₁ = CategoryStruct.comp (F.map x₃) f₃) :
                                                                  Z hf₁.pullback₃ f₂ f₃

                                                                  The lift obtained from the universal property of (A₁ ×_X A₂) ×_{A₁} (A₁ ×_X A₃).

                                                                  Equations
                                                                    Instances For
                                                                      @[simp]
                                                                      theorem CategoryTheory.Functor.relativelyRepresentable.lift₃_p₁ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] [F.Faithful] {Z : C} (x₁ : Z A₁) (x₂ : Z A₂) (x₃ : Z A₃) (h₁₂ : CategoryStruct.comp (F.map x₁) f₁ = CategoryStruct.comp (F.map x₂) f₂) (h₁₃ : CategoryStruct.comp (F.map x₁) f₁ = CategoryStruct.comp (F.map x₃) f₃) :
                                                                      CategoryStruct.comp (hf₁.lift₃ f₂ f₃ x₁ x₂ x₃ h₁₂ h₁₃) (pullback₃.p₁ hf₁ f₂ f₃) = x₁
                                                                      @[simp]
                                                                      theorem CategoryTheory.Functor.relativelyRepresentable.lift₃_p₁_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] [F.Faithful] {Z : C} (x₁ : Z A₁) (x₂ : Z A₂) (x₃ : Z A₃) (h₁₂ : CategoryStruct.comp (F.map x₁) f₁ = CategoryStruct.comp (F.map x₂) f₂) (h₁₃ : CategoryStruct.comp (F.map x₁) f₁ = CategoryStruct.comp (F.map x₃) f₃) {Z✝ : C} (h : A₁ Z✝) :
                                                                      CategoryStruct.comp (hf₁.lift₃ f₂ f₃ x₁ x₂ x₃ h₁₂ h₁₃) (CategoryStruct.comp (pullback₃.p₁ hf₁ f₂ f₃) h) = CategoryStruct.comp x₁ h
                                                                      @[simp]
                                                                      theorem CategoryTheory.Functor.relativelyRepresentable.lift₃_p₂ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] [F.Faithful] {Z : C} (x₁ : Z A₁) (x₂ : Z A₂) (x₃ : Z A₃) (h₁₂ : CategoryStruct.comp (F.map x₁) f₁ = CategoryStruct.comp (F.map x₂) f₂) (h₁₃ : CategoryStruct.comp (F.map x₁) f₁ = CategoryStruct.comp (F.map x₃) f₃) :
                                                                      CategoryStruct.comp (hf₁.lift₃ f₂ f₃ x₁ x₂ x₃ h₁₂ h₁₃) (pullback₃.p₂ hf₁ f₂ f₃) = x₂
                                                                      @[simp]
                                                                      theorem CategoryTheory.Functor.relativelyRepresentable.lift₃_p₂_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] [F.Faithful] {Z : C} (x₁ : Z A₁) (x₂ : Z A₂) (x₃ : Z A₃) (h₁₂ : CategoryStruct.comp (F.map x₁) f₁ = CategoryStruct.comp (F.map x₂) f₂) (h₁₃ : CategoryStruct.comp (F.map x₁) f₁ = CategoryStruct.comp (F.map x₃) f₃) {Z✝ : C} (h : A₂ Z✝) :
                                                                      CategoryStruct.comp (hf₁.lift₃ f₂ f₃ x₁ x₂ x₃ h₁₂ h₁₃) (CategoryStruct.comp (pullback₃.p₂ hf₁ f₂ f₃) h) = CategoryStruct.comp x₂ h
                                                                      @[simp]
                                                                      theorem CategoryTheory.Functor.relativelyRepresentable.lift₃_p₃ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] [F.Faithful] {Z : C} (x₁ : Z A₁) (x₂ : Z A₂) (x₃ : Z A₃) (h₁₂ : CategoryStruct.comp (F.map x₁) f₁ = CategoryStruct.comp (F.map x₂) f₂) (h₁₃ : CategoryStruct.comp (F.map x₁) f₁ = CategoryStruct.comp (F.map x₃) f₃) :
                                                                      CategoryStruct.comp (hf₁.lift₃ f₂ f₃ x₁ x₂ x₃ h₁₂ h₁₃) (pullback₃.p₃ hf₁ f₂ f₃) = x₃
                                                                      @[simp]
                                                                      theorem CategoryTheory.Functor.relativelyRepresentable.lift₃_p₃_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] [F.Faithful] {Z : C} (x₁ : Z A₁) (x₂ : Z A₂) (x₃ : Z A₃) (h₁₂ : CategoryStruct.comp (F.map x₁) f₁ = CategoryStruct.comp (F.map x₂) f₂) (h₁₃ : CategoryStruct.comp (F.map x₁) f₁ = CategoryStruct.comp (F.map x₃) f₃) {Z✝ : C} (h : A₃ Z✝) :
                                                                      CategoryStruct.comp (hf₁.lift₃ f₂ f₃ x₁ x₂ x₃ h₁₂ h₁₃) (CategoryStruct.comp (pullback₃.p₃ hf₁ f₂ f₃) h) = CategoryStruct.comp x₃ h
                                                                      @[simp]
                                                                      theorem CategoryTheory.Functor.relativelyRepresentable.pullback₃.fst_fst'_eq_p₁ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] :
                                                                      CategoryStruct.comp (Limits.pullback.fst (hf₁.fst' f₂) (hf₁.fst' f₃)) (hf₁.fst' f₂) = p₁ hf₁ f₂ f₃
                                                                      @[simp]
                                                                      theorem CategoryTheory.Functor.relativelyRepresentable.pullback₃.fst_fst'_eq_p₁_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] {Z : C} (h : A₁ Z) :
                                                                      CategoryStruct.comp (Limits.pullback.fst (hf₁.fst' f₂) (hf₁.fst' f₃)) (CategoryStruct.comp (hf₁.fst' f₂) h) = CategoryStruct.comp (p₁ hf₁ f₂ f₃) h
                                                                      @[simp]
                                                                      theorem CategoryTheory.Functor.relativelyRepresentable.pullback₃.fst_snd_eq_p₂ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] :
                                                                      CategoryStruct.comp (Limits.pullback.fst (hf₁.fst' f₂) (hf₁.fst' f₃)) (hf₁.snd f₂) = p₂ hf₁ f₂ f₃
                                                                      @[simp]
                                                                      theorem CategoryTheory.Functor.relativelyRepresentable.pullback₃.fst_snd_eq_p₂_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] {Z : C} (h : A₂ Z) :
                                                                      CategoryStruct.comp (Limits.pullback.fst (hf₁.fst' f₂) (hf₁.fst' f₃)) (CategoryStruct.comp (hf₁.snd f₂) h) = CategoryStruct.comp (p₂ hf₁ f₂ f₃) h
                                                                      @[simp]
                                                                      theorem CategoryTheory.Functor.relativelyRepresentable.pullback₃.snd_snd_eq_p₃ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] :
                                                                      CategoryStruct.comp (Limits.pullback.snd (hf₁.fst' f₂) (hf₁.fst' f₃)) (hf₁.snd f₃) = p₃ hf₁ f₂ f₃
                                                                      @[simp]
                                                                      theorem CategoryTheory.Functor.relativelyRepresentable.pullback₃.snd_snd_eq_p₃_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] {Z : C} (h : A₃ Z) :
                                                                      CategoryStruct.comp (Limits.pullback.snd (hf₁.fst' f₂) (hf₁.fst' f₃)) (CategoryStruct.comp (hf₁.snd f₃) h) = CategoryStruct.comp (p₃ hf₁ f₂ f₃) h
                                                                      @[simp]
                                                                      theorem CategoryTheory.Functor.relativelyRepresentable.pullback₃.snd_fst'_eq_p₁ {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] :
                                                                      CategoryStruct.comp (Limits.pullback.snd (hf₁.fst' f₂) (hf₁.fst' f₃)) (hf₁.fst' f₃) = p₁ hf₁ f₂ f₃
                                                                      @[simp]
                                                                      theorem CategoryTheory.Functor.relativelyRepresentable.pullback₃.snd_fst'_eq_p₁_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} (hf₁ : F.relativelyRepresentable f₁) (f₂ : F.obj A₂ X) (f₃ : F.obj A₃ X) [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] {Z : C} (h : A₁ Z) :
                                                                      CategoryStruct.comp (Limits.pullback.snd (hf₁.fst' f₂) (hf₁.fst' f₃)) (CategoryStruct.comp (hf₁.fst' f₃) h) = CategoryStruct.comp (p₁ hf₁ f₂ f₃) h
                                                                      theorem CategoryTheory.Functor.relativelyRepresentable.pullback₃.hom_ext {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} {hf₁ : F.relativelyRepresentable f₁} {f₂ : F.obj A₂ X} {f₃ : F.obj A₃ X} [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] [F.Faithful] {Z : C} {φ φ' : Z hf₁.pullback₃ f₂ f₃} (h₁ : CategoryStruct.comp φ (p₁ hf₁ f₂ f₃) = CategoryStruct.comp φ' (p₁ hf₁ f₂ f₃)) (h₂ : CategoryStruct.comp φ (p₂ hf₁ f₂ f₃) = CategoryStruct.comp φ' (p₂ hf₁ f₂ f₃)) (h₃ : CategoryStruct.comp φ (p₃ hf₁ f₂ f₃) = CategoryStruct.comp φ' (p₃ hf₁ f₂ f₃)) :
                                                                      φ = φ'
                                                                      theorem CategoryTheory.Functor.relativelyRepresentable.pullback₃.hom_ext_iff {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F : Functor C D} [F.Full] {A₁ A₂ A₃ : C} {X : D} {f₁ : F.obj A₁ X} {hf₁ : F.relativelyRepresentable f₁} {f₂ : F.obj A₂ X} {f₃ : F.obj A₃ X} [Limits.HasPullback (hf₁.fst' f₂) (hf₁.fst' f₃)] [F.Faithful] {Z : C} {φ φ' : Z hf₁.pullback₃ f₂ f₃} :
                                                                      φ = φ' CategoryStruct.comp φ (p₁ hf₁ f₂ f₃) = CategoryStruct.comp φ' (p₁ hf₁ f₂ f₃) CategoryStruct.comp φ (p₂ hf₁ f₂ f₃) = CategoryStruct.comp φ' (p₂ hf₁ f₂ f₃) CategoryStruct.comp φ (p₃ hf₁ f₂ f₃) = CategoryStruct.comp φ' (p₃ hf₁ f₂ f₃)