File: Mathlib/CategoryTheory/Sites/DenseSubsite.lean

full_name: CategoryTheory.Presieve.CoverByImageStructure.obj
code: /-- An auxiliary structure that witnesses the fact that `f` factors through an image object of `G`.
-/
-- Porting note(#5171): removed `@[nolint has_nonempty_instance]`
structure Presieve.CoverByImageStructure (G : C ⥤ D) {V U : D} (f : V ⟶ U) where
  obj : C
  lift : V ⟶ G.obj obj
  map : G.obj obj ⟶ U
  fac : lift ≫ map = f := by aesop_cat
goal: C

full_name: CategoryTheory.Presieve.CoverByImageStructure.map
code: /-- An auxiliary structure that witnesses the fact that `f` factors through an image object of `G`.
-/
-- Porting note(#5171): removed `@[nolint has_nonempty_instance]`
structure Presieve.CoverByImageStructure (G : C ⥤ D) {V U : D} (f : V ⟶ U) where
  obj : C
  lift : V ⟶ G.obj obj
  map : G.obj obj ⟶ U
  fac : lift ≫ map = f := by aesop_cat
goal: G.obj self.obj ⟶ U

full_name: CategoryTheory.Presieve.CoverByImageStructure
code: /-- An auxiliary structure that witnesses the fact that `f` factors through an image object of `G`.
-/
-- Porting note(#5171): removed `@[nolint has_nonempty_instance]`
structure Presieve.CoverByImageStructure (G : C ⥤ D) {V U : D} (f : V ⟶ U) where
  obj : C
  lift : V ⟶ G.obj obj
  map : G.obj obj ⟶ U
  fac : lift ≫ map = f := by aesop_cat
goal: Type (max u_1 u_5)

full_name: CategoryTheory.Presieve.CoverByImageStructure.fac
code: /-- An auxiliary structure that witnesses the fact that `f` factors through an image object of `G`.
-/
-- Porting note(#5171): removed `@[nolint has_nonempty_instance]`
structure Presieve.CoverByImageStructure (G : C ⥤ D) {V U : D} (f : V ⟶ U) where
  obj : C
  lift : V ⟶ G.obj obj
  map : G.obj obj ⟶ U
  fac : lift ≫ map = f := by aesop_cat
goal: CategoryTheory.CategoryStruct.comp self.lift self.map = f

full_name: CategoryTheory.Presieve.CoverByImageStructure.lift
code: /-- An auxiliary structure that witnesses the fact that `f` factors through an image object of `G`.
-/
-- Porting note(#5171): removed `@[nolint has_nonempty_instance]`
structure Presieve.CoverByImageStructure (G : C ⥤ D) {V U : D} (f : V ⟶ U) where
  obj : C
  lift : V ⟶ G.obj obj
  map : G.obj obj ⟶ U
  fac : lift ≫ map = f := by aesop_cat
goal: V ⟶ G.obj self.obj

full_name: CategoryTheory.Presieve.coverByImage
code: /-- For a functor `G : C ⥤ D`, and an object `U : D`, `Presieve.coverByImage G U` is the presieve
of `U` consisting of those arrows that factor through images of `G`.
-/
def Presieve.coverByImage (G : C ⥤ D) (U : D) : Presieve U 
goal: CategoryTheory.Presieve U

full_name: CategoryTheory.Sieve.coverByImage
code: /-- For a functor `G : C ⥤ D`, and an object `U : D`, `Sieve.coverByImage G U` is the sieve of `U`
consisting of those arrows that factor through images of `G`.
-/
def Sieve.coverByImage (G : C ⥤ D) (U : D) : Sieve U 
goal: CategoryTheory.Sieve U

full_name: CategoryTheory.Presieve.in_coverByImage
code: theorem Presieve.in_coverByImage (G : C ⥤ D) {X : D} {Y : C} (f : G.obj Y ⟶ X) :
    Presieve.coverByImage G X f 
goal: CategoryTheory.Presieve.coverByImage G X f

full_name: CategoryTheory.Functor.IsCoverDense.is_cover
code: /-- A functor `G : (C, J) ⥤ (D, K)` is cover dense if for each object in `D`,
  there exists a covering sieve in `D` that factors through images of `G`.

This definition can be found in https://ncatlab.org/nlab/show/dense+sub-site Definition 2.2.
-/
class Functor.IsCoverDense (G : C ⥤ D) (K : GrothendieckTopology D) : Prop where
  is_cover : ∀ U : D, Sieve.coverByImage G U ∈ K U
goal: CategoryTheory.Sieve.coverByImage G U ∈ K.sieves U

full_name: CategoryTheory.Functor.IsCoverDense
code: /-- A functor `G : (C, J) ⥤ (D, K)` is cover dense if for each object in `D`,
  there exists a covering sieve in `D` that factors through images of `G`.

This definition can be found in https://ncatlab.org/nlab/show/dense+sub-site Definition 2.2.
-/
class Functor.IsCoverDense (G : C ⥤ D) (K : GrothendieckTopology D) : Prop where
  is_cover : ∀ U : D, Sieve.coverByImage G U ∈ K U
goal: Prop

full_name: CategoryTheory.Functor.is_cover_of_isCoverDense
code: lemma Functor.is_cover_of_isCoverDense (G : C ⥤ D) (K : GrothendieckTopology D)
    [G.IsCoverDense K] (U : D) : Sieve.coverByImage G U ∈ K U 
goal: CategoryTheory.Sieve.coverByImage G U ∈ K.sieves U

full_name: CategoryTheory.Functor.isCoverDense_of_generate_singleton_functor_π_mem
code: lemma Functor.isCoverDense_of_generate_singleton_functor_π_mem (G : C ⥤ D)
    (K : GrothendieckTopology D)
    (h : ∀ B, ∃ (X : C) (f : G.obj X ⟶ B), Sieve.generate (Presieve.singleton f) ∈ K B) :
    G.IsCoverDense K 
goal: G.IsCoverDense K

full_name: CategoryTheory.Functor.IsCoverDense.ext
code: theorem ext (ℱ : SheafOfTypes K) (X : D) {s t : ℱ.val.obj (op X)}
    (h : ∀ ⦃Y : C⦄ (f : G.obj Y ⟶ X), ℱ.val.map f.op s = ℱ.val.map f.op t) : s = t 
goal: s = t

full_name: CategoryTheory.Functor.IsCoverDense.functorPullback_pushforward_covering
code: theorem functorPullback_pushforward_covering [G.IsLocallyFull K] {X : C}
    (T : K (G.obj X)) : (T.val.functorPullback G).functorPushforward G ∈ K (G.obj X) 
goal: CategoryTheory.Sieve.functorPushforward G (CategoryTheory.Sieve.functorPullback G ↑T) ∈ K.sieves (G.obj X)

full_name: CategoryTheory.Functor.IsCoverDense.homOver
code: /-- (Implementation). Given a hom between the pullbacks of two sheaves, we can whisker it with
`coyoneda` to obtain a hom between the pullbacks of the sheaves of maps from `X`.
-/
@[simps!]
def homOver {ℱ : Dᵒᵖ ⥤ A} {ℱ' : Sheaf K A} (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) (X : A) :
    G.op ⋙ ℱ ⋙ coyoneda.obj (op X) ⟶ G.op ⋙ (sheafOver ℱ' X).val 
goal: G.op.comp (ℱ.comp (CategoryTheory.coyoneda.obj (Opposite.op X))) ⟶ G.op.comp (CategoryTheory.sheafOver ℱ' X).val

full_name: CategoryTheory.Functor.IsCoverDense.homOver_app
code: /-- (Implementation). Given a hom between the pullbacks of two sheaves, we can whisker it with
`coyoneda` to obtain a hom between the pullbacks of the sheaves of maps from `X`.
-/
@[simps!]
def homOver {ℱ : Dᵒᵖ ⥤ A} {ℱ' : Sheaf K A} (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) (X : A) :
    G.op ⋙ ℱ ⋙ coyoneda.obj (op X) ⟶ G.op ⋙ (sheafOver ℱ' X).val 
goal: ∀ (X_1 : Cᵒᵖ) (a : (CategoryTheory.coyoneda.obj (Opposite.op X)).obj ((G.op.comp ℱ).obj X_1)),
  (CategoryTheory.Functor.IsCoverDense.homOver α X).app X_1 a = CategoryTheory.CategoryStruct.comp a (α.app X_1)

full_name: CategoryTheory.Functor.IsCoverDense.isoOver_inv_app
code: /-- (Implementation). Given an iso between the pullbacks of two sheaves, we can whisker it with
`coyoneda` to obtain an iso between the pullbacks of the sheaves of maps from `X`.
-/
@[simps!]
def isoOver {ℱ ℱ' : Sheaf K A} (α : G.op ⋙ ℱ.val ≅ G.op ⋙ ℱ'.val) (X : A) :
    G.op ⋙ (sheafOver ℱ X).val ≅ G.op ⋙ (sheafOver ℱ' X).val 
goal: ∀ (X_1 : Cᵒᵖ) (a : (CategoryTheory.coyoneda.obj (Opposite.op X)).obj ((G.op.comp ℱ'.val).obj X_1)),
  (CategoryTheory.Functor.IsCoverDense.isoOver α X).inv.app X_1 a = CategoryTheory.CategoryStruct.comp a (α.inv.app X_1)

full_name: CategoryTheory.Functor.IsCoverDense.isoOver_hom_app
code: /-- (Implementation). Given an iso between the pullbacks of two sheaves, we can whisker it with
`coyoneda` to obtain an iso between the pullbacks of the sheaves of maps from `X`.
-/
@[simps!]
def isoOver {ℱ ℱ' : Sheaf K A} (α : G.op ⋙ ℱ.val ≅ G.op ⋙ ℱ'.val) (X : A) :
    G.op ⋙ (sheafOver ℱ X).val ≅ G.op ⋙ (sheafOver ℱ' X).val 
goal: ∀ (X_1 : Cᵒᵖ) (a : (CategoryTheory.coyoneda.obj (Opposite.op X)).obj ((G.op.comp ℱ.val).obj X_1)),
  (CategoryTheory.Functor.IsCoverDense.isoOver α X).hom.app X_1 a = CategoryTheory.CategoryStruct.comp a (α.hom.app X_1)

full_name: CategoryTheory.Functor.IsCoverDense.isoOver
code: /-- (Implementation). Given an iso between the pullbacks of two sheaves, we can whisker it with
`coyoneda` to obtain an iso between the pullbacks of the sheaves of maps from `X`.
-/
@[simps!]
def isoOver {ℱ ℱ' : Sheaf K A} (α : G.op ⋙ ℱ.val ≅ G.op ⋙ ℱ'.val) (X : A) :
    G.op ⋙ (sheafOver ℱ X).val ≅ G.op ⋙ (sheafOver ℱ' X).val 
goal: G.op.comp (CategoryTheory.sheafOver ℱ X).val ≅ G.op.comp (CategoryTheory.sheafOver ℱ' X).val

full_name: CategoryTheory.Functor.IsCoverDense.sheaf_eq_amalgamation
code: theorem sheaf_eq_amalgamation (ℱ : Sheaf K A) {X : A} {U : D} {T : Sieve U} (hT)
    (x : FamilyOfElements _ T) (hx) (t) (h : x.IsAmalgamation t) :
    t = (ℱ.cond X T hT).amalgamate x hx 
goal: t = ⋯.amalgamate x hx

full_name: CategoryTheory.Functor.IsCoverDense.Types.naturality_apply
code: theorem naturality_apply {X Y : C} (i : G.obj X ⟶ G.obj Y) (x) :
    ℱ'.1.map i.op (α.app _ x) = α.app _ (ℱ.map i.op x) 
goal: ℱ'.val.map i.op (α.app (Opposite.op Y) x) = α.app (Opposite.op X) (ℱ.map i.op x)

full_name: CategoryTheory.Functor.IsCoverDense.Types.naturality
code: @[reassoc]
theorem naturality {X Y : C} (i : G.obj X ⟶ G.obj Y) :
    α.app _ ≫ ℱ'.1.map i.op = ℱ.map i.op ≫ α.app _ 
goal: CategoryTheory.CategoryStruct.comp (α.app (Opposite.op Y)) (ℱ'.val.map i.op) =
  CategoryTheory.CategoryStruct.comp (ℱ.map i.op) (α.app (Opposite.op X))

full_name: CategoryTheory.Functor.IsCoverDense.Types.pushforwardFamily
code: /--
(Implementation). Given a section of `ℱ` on `X`, we can obtain a family of elements valued in `ℱ'`
that is defined on a cover generated by the images of `G`. -/
-- Porting note: removed `@[simp, nolint unused_arguments]`
noncomputable def pushforwardFamily {X} (x : ℱ.obj (op X)) :
    FamilyOfElements ℱ'.val (coverByImage G X) 
goal: CategoryTheory.Presieve.FamilyOfElements ℱ'.val (CategoryTheory.Presieve.coverByImage G X)

full_name: CategoryTheory.Functor.IsCoverDense.Types.pushforwardFamily_def
code: @[simp] theorem pushforwardFamily_def {X} (x : ℱ.obj (op X)) :
    pushforwardFamily α x = fun _ _ hf =>
  ℱ'.val.map hf.some.lift.op <| α.app (op _) (ℱ.map hf.some.map.op x : _) 
goal: CategoryTheory.Functor.IsCoverDense.Types.pushforwardFamily α x = fun x_1 x_2 hf =>
  ℱ'.val.map (Nonempty.some hf).lift.op (α.app (Opposite.op (Nonempty.some hf).1) (ℱ.map (Nonempty.some hf).map.op x))

full_name: CategoryTheory.Functor.IsCoverDense.Types.pushforwardFamily_compatible
code: /-- (Implementation). The `pushforwardFamily` defined is compatible. -/
theorem pushforwardFamily_compatible {X} (x : ℱ.obj (op X)) :
    (pushforwardFamily α x).Compatible 
goal: (CategoryTheory.Functor.IsCoverDense.Types.pushforwardFamily α x).Compatible

full_name: CategoryTheory.Functor.IsCoverDense.Types.appHom
code: /-- (Implementation). The morphism `ℱ(X) ⟶ ℱ'(X)` given by gluing the `pushforwardFamily`. -/
noncomputable def appHom (X : D) : ℱ.obj (op X) ⟶ ℱ'.val.obj (op X) 
goal: ℱ.obj (Opposite.op X) ⟶ ℱ'.val.obj (Opposite.op X)

full_name: CategoryTheory.Functor.IsCoverDense.Types.pushforwardFamily_apply
code: @[simp]
theorem pushforwardFamily_apply {X} (x : ℱ.obj (op X)) {Y : C} (f : G.obj Y ⟶ X) :
    pushforwardFamily α x f (Presieve.in_coverByImage G f) = α.app (op Y) (ℱ.map f.op x) 
goal: CategoryTheory.Functor.IsCoverDense.Types.pushforwardFamily α x f ⋯ = α.app (Opposite.op Y) (ℱ.map f.op x)

full_name: CategoryTheory.Functor.IsCoverDense.Types.appHom_restrict
code: @[simp]
theorem appHom_restrict {X : D} {Y : C} (f : op X ⟶ op (G.obj Y)) (x) :
    ℱ'.val.map f (appHom α X x) = α.app (op Y) (ℱ.map f x) 
goal: ℱ'.val.map f (CategoryTheory.Functor.IsCoverDense.Types.appHom α X x) = α.app (Opposite.op Y) (ℱ.map f x)

full_name: CategoryTheory.Functor.IsCoverDense.Types.appHom_valid_glue
code: @[simp]
theorem appHom_valid_glue {X : D} {Y : C} (f : op X ⟶ op (G.obj Y)) :
    appHom α X ≫ ℱ'.val.map f = ℱ.map f ≫ α.app (op Y) 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.IsCoverDense.Types.appHom α X) (ℱ'.val.map f) =
  CategoryTheory.CategoryStruct.comp (ℱ.map f) (α.app (Opposite.op Y))

full_name: CategoryTheory.Functor.IsCoverDense.Types.appIso_inv
code: /--
(Implementation). The maps given in `appIso` is inverse to each other and gives a `ℱ(X) ≅ ℱ'(X)`.
-/
@[simps]
noncomputable def appIso {ℱ ℱ' : SheafOfTypes.{v} K} (i : G.op ⋙ ℱ.val ≅ G.op ⋙ ℱ'.val)
    (X : D) : ℱ.val.obj (op X) ≅ ℱ'.val.obj (op X) 
goal: ∀ (a : ℱ'.val.obj (Opposite.op X)),
  (CategoryTheory.Functor.IsCoverDense.Types.appIso i X).inv a =
    CategoryTheory.Functor.IsCoverDense.Types.appHom i.inv X a

full_name: CategoryTheory.Functor.IsCoverDense.Types.appIso
code: /--
(Implementation). The maps given in `appIso` is inverse to each other and gives a `ℱ(X) ≅ ℱ'(X)`.
-/
@[simps]
noncomputable def appIso {ℱ ℱ' : SheafOfTypes.{v} K} (i : G.op ⋙ ℱ.val ≅ G.op ⋙ ℱ'.val)
    (X : D) : ℱ.val.obj (op X) ≅ ℱ'.val.obj (op X) 
goal: ℱ.val.obj (Opposite.op X) ≅ ℱ'.val.obj (Opposite.op X)

full_name: CategoryTheory.Functor.IsCoverDense.Types.appIso_hom
code: /--
(Implementation). The maps given in `appIso` is inverse to each other and gives a `ℱ(X) ≅ ℱ'(X)`.
-/
@[simps]
noncomputable def appIso {ℱ ℱ' : SheafOfTypes.{v} K} (i : G.op ⋙ ℱ.val ≅ G.op ⋙ ℱ'.val)
    (X : D) : ℱ.val.obj (op X) ≅ ℱ'.val.obj (op X) 
goal: ∀ (a : ℱ.val.obj (Opposite.op X)),
  (CategoryTheory.Functor.IsCoverDense.Types.appIso i X).hom a =
    CategoryTheory.Functor.IsCoverDense.Types.appHom i.hom X a

full_name: CategoryTheory.Functor.IsCoverDense.Types.presheafHom
code: /--
Given a natural transformation `G ⋙ ℱ ⟶ G ⋙ ℱ'` between presheaves of types,
where `G` is locally-full and cover-dense, and `ℱ'` is a sheaf,
we may obtain a natural transformation between sheaves.
-/
@[simps]
noncomputable def presheafHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) : ℱ ⟶ ℱ'.val 
goal: ℱ ⟶ ℱ'.val

full_name: CategoryTheory.Functor.IsCoverDense.Types.presheafHom_app
code: /--
Given a natural transformation `G ⋙ ℱ ⟶ G ⋙ ℱ'` between presheaves of types,
where `G` is locally-full and cover-dense, and `ℱ'` is a sheaf,
we may obtain a natural transformation between sheaves.
-/
@[simps]
noncomputable def presheafHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) : ℱ ⟶ ℱ'.val 
goal: ∀ (a : ℱ.obj (Opposite.op (Opposite.unop X))),
  (CategoryTheory.Functor.IsCoverDense.Types.presheafHom α).app X a =
    CategoryTheory.Functor.IsCoverDense.Types.appHom α (Opposite.unop X) a

full_name: CategoryTheory.Functor.IsCoverDense.Types.presheafIso_hom_app
code: /--
Given a natural isomorphism `G ⋙ ℱ ≅ G ⋙ ℱ'` between presheaves of types,
where `G` is locally-full and cover-dense, and `ℱ, ℱ'` are sheaves,
we may obtain a natural isomorphism between presheaves.
-/
@[simps!]
noncomputable def presheafIso {ℱ ℱ' : SheafOfTypes.{v} K} (i : G.op ⋙ ℱ.val ≅ G.op ⋙ ℱ'.val) :
    ℱ.val ≅ ℱ'.val 
goal: ∀ (a : ℱ.val.obj X),
  (CategoryTheory.Functor.IsCoverDense.Types.presheafIso i).hom.app X a =
    CategoryTheory.Functor.IsCoverDense.Types.appHom i.hom (Opposite.unop X) a

full_name: CategoryTheory.Functor.IsCoverDense.Types.presheafIso
code: /--
Given a natural isomorphism `G ⋙ ℱ ≅ G ⋙ ℱ'` between presheaves of types,
where `G` is locally-full and cover-dense, and `ℱ, ℱ'` are sheaves,
we may obtain a natural isomorphism between presheaves.
-/
@[simps!]
noncomputable def presheafIso {ℱ ℱ' : SheafOfTypes.{v} K} (i : G.op ⋙ ℱ.val ≅ G.op ⋙ ℱ'.val) :
    ℱ.val ≅ ℱ'.val 
goal: ℱ.val ≅ ℱ'.val

full_name: CategoryTheory.Functor.IsCoverDense.Types.presheafIso_inv_app
code: /--
Given a natural isomorphism `G ⋙ ℱ ≅ G ⋙ ℱ'` between presheaves of types,
where `G` is locally-full and cover-dense, and `ℱ, ℱ'` are sheaves,
we may obtain a natural isomorphism between presheaves.
-/
@[simps!]
noncomputable def presheafIso {ℱ ℱ' : SheafOfTypes.{v} K} (i : G.op ⋙ ℱ.val ≅ G.op ⋙ ℱ'.val) :
    ℱ.val ≅ ℱ'.val 
goal: ∀ (a : ℱ'.val.obj X),
  (CategoryTheory.Functor.IsCoverDense.Types.presheafIso i).inv.app X a =
    CategoryTheory.Functor.IsCoverDense.Types.appHom i.inv (Opposite.unop X) a

full_name: CategoryTheory.Functor.IsCoverDense.Types.sheafIso_hom_val
code: /--
Given a natural isomorphism `G ⋙ ℱ ≅ G ⋙ ℱ'` between presheaves of types,
where `G` is locally-full and cover-dense, and `ℱ, ℱ'` are sheaves,
we may obtain a natural isomorphism between sheaves.
-/
@[simps]
noncomputable def sheafIso {ℱ ℱ' : SheafOfTypes.{v} K} (i : G.op ⋙ ℱ.val ≅ G.op ⋙ ℱ'.val) :
    ℱ ≅ ℱ' 
goal: (CategoryTheory.Functor.IsCoverDense.Types.sheafIso i).hom.val =
  (CategoryTheory.Functor.IsCoverDense.Types.presheafIso i).hom

full_name: CategoryTheory.Functor.IsCoverDense.Types.sheafIso
code: /--
Given a natural isomorphism `G ⋙ ℱ ≅ G ⋙ ℱ'` between presheaves of types,
where `G` is locally-full and cover-dense, and `ℱ, ℱ'` are sheaves,
we may obtain a natural isomorphism between sheaves.
-/
@[simps]
noncomputable def sheafIso {ℱ ℱ' : SheafOfTypes.{v} K} (i : G.op ⋙ ℱ.val ≅ G.op ⋙ ℱ'.val) :
    ℱ ≅ ℱ' 
goal: ℱ ≅ ℱ'

full_name: CategoryTheory.Functor.IsCoverDense.Types.sheafIso_inv_val
code: /--
Given a natural isomorphism `G ⋙ ℱ ≅ G ⋙ ℱ'` between presheaves of types,
where `G` is locally-full and cover-dense, and `ℱ, ℱ'` are sheaves,
we may obtain a natural isomorphism between sheaves.
-/
@[simps]
noncomputable def sheafIso {ℱ ℱ' : SheafOfTypes.{v} K} (i : G.op ⋙ ℱ.val ≅ G.op ⋙ ℱ'.val) :
    ℱ ≅ ℱ' 
goal: (CategoryTheory.Functor.IsCoverDense.Types.sheafIso i).inv.val =
  (CategoryTheory.Functor.IsCoverDense.Types.presheafIso i).inv

full_name: CategoryTheory.Functor.IsCoverDense.sheafCoyonedaHom_app
code: /-- (Implementation). The sheaf map given in `types.sheaf_hom` is natural in terms of `X`. -/
@[simps]
noncomputable def sheafCoyonedaHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ ⟶
      coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ'.val 
goal: (CategoryTheory.Functor.IsCoverDense.sheafCoyonedaHom α).app X =
  CategoryTheory.Functor.IsCoverDense.Types.presheafHom
    (CategoryTheory.Functor.IsCoverDense.homOver α (Opposite.unop X))

full_name: CategoryTheory.Functor.IsCoverDense.sheafCoyonedaHom
code: /-- (Implementation). The sheaf map given in `types.sheaf_hom` is natural in terms of `X`. -/
@[simps]
noncomputable def sheafCoyonedaHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ ⟶
      coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ'.val 
goal: CategoryTheory.coyoneda.comp ((CategoryTheory.whiskeringLeft Dᵒᵖ A (Type u_7)).obj ℱ) ⟶
  CategoryTheory.coyoneda.comp ((CategoryTheory.whiskeringLeft Dᵒᵖ A (Type u_7)).obj ℱ'.val)

full_name: CategoryTheory.Functor.IsCoverDense.sheafYonedaHom
code: /--
(Implementation). `sheafCoyonedaHom` but the order of the arguments of the functor are swapped.
-/
noncomputable def sheafYonedaHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    ℱ ⋙ yoneda ⟶ ℱ'.val ⋙ yoneda 
goal: ℱ.comp CategoryTheory.yoneda ⟶ ℱ'.val.comp CategoryTheory.yoneda

full_name: CategoryTheory.Functor.IsCoverDense.sheafHom
code: /--
Given a natural transformation `G ⋙ ℱ ⟶ G ⋙ ℱ'` between presheaves of arbitrary category,
where `G` is locally-full and cover-dense, and `ℱ'` is a sheaf, we may obtain a natural
transformation between presheaves.
-/
noncomputable def sheafHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) : ℱ ⟶ ℱ'.val 
goal: ℱ ⟶ ℱ'.val

full_name: CategoryTheory.Functor.IsCoverDense.presheafIso
code: /--
Given a natural isomorphism `G ⋙ ℱ ≅ G ⋙ ℱ'` between presheaves of arbitrary category,
where `G` is locally-full and cover-dense, and `ℱ', ℱ` are sheaves,
we may obtain a natural isomorphism between presheaves.
-/
@[simps!]
noncomputable def presheafIso {ℱ ℱ' : Sheaf K A} (i : G.op ⋙ ℱ.val ≅ G.op ⋙ ℱ'.val) :
    ℱ.val ≅ ℱ'.val 
goal: ℱ.val ≅ ℱ'.val

full_name: CategoryTheory.Functor.IsCoverDense.presheafIso_hom_app
code: /--
Given a natural isomorphism `G ⋙ ℱ ≅ G ⋙ ℱ'` between presheaves of arbitrary category,
where `G` is locally-full and cover-dense, and `ℱ', ℱ` are sheaves,
we may obtain a natural isomorphism between presheaves.
-/
@[simps!]
noncomputable def presheafIso {ℱ ℱ' : Sheaf K A} (i : G.op ⋙ ℱ.val ≅ G.op ⋙ ℱ'.val) :
    ℱ.val ≅ ℱ'.val 
goal: (CategoryTheory.Functor.IsCoverDense.presheafIso i).hom.app X =
  CategoryTheory.yoneda.preimage ((CategoryTheory.Functor.IsCoverDense.sheafYonedaHom i.hom).app X)

full_name: CategoryTheory.Functor.IsCoverDense.presheafIso_inv
code: /--
Given a natural isomorphism `G ⋙ ℱ ≅ G ⋙ ℱ'` between presheaves of arbitrary category,
where `G` is locally-full and cover-dense, and `ℱ', ℱ` are sheaves,
we may obtain a natural isomorphism between presheaves.
-/
@[simps!]
noncomputable def presheafIso {ℱ ℱ' : Sheaf K A} (i : G.op ⋙ ℱ.val ≅ G.op ⋙ ℱ'.val) :
    ℱ.val ≅ ℱ'.val 
goal: (CategoryTheory.Functor.IsCoverDense.presheafIso i).inv =
  CategoryTheory.inv (CategoryTheory.Functor.IsCoverDense.sheafHom i.hom)

full_name: CategoryTheory.Functor.IsCoverDense.sheafIso_inv_val
code: /--
Given a natural isomorphism `G ⋙ ℱ ≅ G ⋙ ℱ'` between presheaves of arbitrary category,
where `G` is locally-full and cover-dense, and `ℱ', ℱ` are sheaves,
we may obtain a natural isomorphism between presheaves.
-/
@[simps]
noncomputable def sheafIso {ℱ ℱ' : Sheaf K A} (i : G.op ⋙ ℱ.val ≅ G.op ⋙ ℱ'.val) : ℱ ≅ ℱ' 
goal: (CategoryTheory.Functor.IsCoverDense.sheafIso i).inv.val = (CategoryTheory.Functor.IsCoverDense.presheafIso i).inv

full_name: CategoryTheory.Functor.IsCoverDense.sheafIso
code: /--
Given a natural isomorphism `G ⋙ ℱ ≅ G ⋙ ℱ'` between presheaves of arbitrary category,
where `G` is locally-full and cover-dense, and `ℱ', ℱ` are sheaves,
we may obtain a natural isomorphism between presheaves.
-/
@[simps]
noncomputable def sheafIso {ℱ ℱ' : Sheaf K A} (i : G.op ⋙ ℱ.val ≅ G.op ⋙ ℱ'.val) : ℱ ≅ ℱ' 
goal: ℱ ≅ ℱ'

full_name: CategoryTheory.Functor.IsCoverDense.sheafIso_hom_val
code: /--
Given a natural isomorphism `G ⋙ ℱ ≅ G ⋙ ℱ'` between presheaves of arbitrary category,
where `G` is locally-full and cover-dense, and `ℱ', ℱ` are sheaves,
we may obtain a natural isomorphism between presheaves.
-/
@[simps]
noncomputable def sheafIso {ℱ ℱ' : Sheaf K A} (i : G.op ⋙ ℱ.val ≅ G.op ⋙ ℱ'.val) : ℱ ≅ ℱ' 
goal: (CategoryTheory.Functor.IsCoverDense.sheafIso i).hom.val = (CategoryTheory.Functor.IsCoverDense.presheafIso i).hom

full_name: CategoryTheory.Functor.IsCoverDense.sheafHom_restrict_eq
code: /-- The constructed `sheafHom α` is equal to `α` when restricted onto `C`. -/
theorem sheafHom_restrict_eq (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    whiskerLeft G.op (sheafHom α) = α 
goal: CategoryTheory.whiskerLeft G.op (CategoryTheory.Functor.IsCoverDense.sheafHom α) = α

full_name: CategoryTheory.Functor.IsCoverDense.sheafHom_eq
code: /--
If the pullback map is obtained via whiskering,
then the result `sheaf_hom (whisker_left G.op α)` is equal to `α`.
-/
theorem sheafHom_eq (α : ℱ ⟶ ℱ'.val) : sheafHom (whiskerLeft G.op α) = α 
goal: CategoryTheory.Functor.IsCoverDense.sheafHom (CategoryTheory.whiskerLeft G.op α) = α

full_name: CategoryTheory.Functor.IsCoverDense.restrictHomEquivHom
code: /--
A locally-full and cover-dense functor `G` induces an equivalence between morphisms into a sheaf and
morphisms over the restrictions via `G`.
-/
noncomputable def restrictHomEquivHom : (G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) ≃ (ℱ ⟶ ℱ'.val) 
goal: (G.op.comp ℱ ⟶ G.op.comp ℱ'.val) ≃ (ℱ ⟶ ℱ'.val)

full_name: CategoryTheory.Functor.IsCoverDense.iso_of_restrict_iso
code: /-- Given a locally-full and cover-dense functor `G` and a natural transformation of sheaves
`α : ℱ ⟶ ℱ'`, if the pullback of `α` along `G` is iso, then `α` is also iso.
-/
theorem iso_of_restrict_iso {ℱ ℱ' : Sheaf K A} (α : ℱ ⟶ ℱ') (i : IsIso (whiskerLeft G.op α.val)) :
    IsIso α 
goal: CategoryTheory.IsIso α

full_name: CategoryTheory.Functor.IsCoverDense.compatiblePreserving
code: /-- A locally-fully-faithful and cover-dense functor preserves compatible families. -/
lemma compatiblePreserving [G.IsLocallyFaithful K] : CompatiblePreserving K G 
goal: CategoryTheory.CompatiblePreserving K G

full_name: CategoryTheory.Functor.IsCoverDense.isContinuous
code: lemma isContinuous [G.IsLocallyFaithful K] (Hp : CoverPreserving J K G) : G.IsContinuous J K 
goal: G.IsContinuous J K

full_name: CategoryTheory.Functor.IsCoverDense.full_sheafPushforwardContinuous
code: instance full_sheafPushforwardContinuous [G.IsContinuous J K] :
    Full (G.sheafPushforwardContinuous A J K) 
goal: (G.sheafPushforwardContinuous A J K).Full

full_name: CategoryTheory.Functor.IsCoverDense.faithful_sheafPushforwardContinuous
code: instance faithful_sheafPushforwardContinuous [G.IsContinuous J K] :
    Faithful (G.sheafPushforwardContinuous A J K) 
goal: (G.sheafPushforwardContinuous A J K).Faithful

full_name: CategoryTheory.Functor.whiskerLeft_obj_map_bijective_of_isCoverDense
code: /-- If `G : C ⥤ D` is cover dense and full, then the
map `(P ⟶ Q) → (G.op ⋙ P ⟶ G.op ⋙ Q)` is bijective when `Q` is a sheaf`. -/
lemma whiskerLeft_obj_map_bijective_of_isCoverDense (G : C ⥤ D)
    [G.IsCoverDense K] [G.IsLocallyFull K] {A : Type*} [Category A]
    (P Q : Dᵒᵖ ⥤ A) (hQ : Presheaf.IsSheaf K Q) :
    Function.Bijective (((whiskeringLeft Cᵒᵖ Dᵒᵖ A).obj G.op).map : (P ⟶ Q) → _) 
goal: Function.Bijective ((CategoryTheory.whiskeringLeft Cᵒᵖ Dᵒᵖ A).obj G.op).map

full_name: CategoryTheory.Functor.IsDenseSubsite.isCoverDense'
code: /-- The functor `G : C ⥤ D` exhibits `(C, J)` as a dense subsite of `(D, K)`
if `G` is cover-dense, locally fully-faithful,
and `S` is a cover of `C` if and only if the image of `S` in `D` is a cover. -/
class IsDenseSubsite : Prop where
  isCoverDense' : G.IsCoverDense K := by infer_instance
  isLocallyFull' : G.IsLocallyFull K := by infer_instance
  isLocallyFaithful' : G.IsLocallyFaithful K := by infer_instance
  functorPushforward_mem_iff : ∀ {X : C} {S : Sieve X}, S.functorPushforward G ∈ K _ ↔ S ∈ J _
goal: G.IsCoverDense K

full_name: CategoryTheory.Functor.IsDenseSubsite.isLocallyFull'
code: /-- The functor `G : C ⥤ D` exhibits `(C, J)` as a dense subsite of `(D, K)`
if `G` is cover-dense, locally fully-faithful,
and `S` is a cover of `C` if and only if the image of `S` in `D` is a cover. -/
class IsDenseSubsite : Prop where
  isCoverDense' : G.IsCoverDense K := by infer_instance
  isLocallyFull' : G.IsLocallyFull K := by infer_instance
  isLocallyFaithful' : G.IsLocallyFaithful K := by infer_instance
  functorPushforward_mem_iff : ∀ {X : C} {S : Sieve X}, S.functorPushforward G ∈ K _ ↔ S ∈ J _
goal: G.IsLocallyFull K

full_name: CategoryTheory.Functor.IsDenseSubsite.isLocallyFaithful'
code: /-- The functor `G : C ⥤ D` exhibits `(C, J)` as a dense subsite of `(D, K)`
if `G` is cover-dense, locally fully-faithful,
and `S` is a cover of `C` if and only if the image of `S` in `D` is a cover. -/
class IsDenseSubsite : Prop where
  isCoverDense' : G.IsCoverDense K := by infer_instance
  isLocallyFull' : G.IsLocallyFull K := by infer_instance
  isLocallyFaithful' : G.IsLocallyFaithful K := by infer_instance
  functorPushforward_mem_iff : ∀ {X : C} {S : Sieve X}, S.functorPushforward G ∈ K _ ↔ S ∈ J _
goal: G.IsLocallyFaithful K

full_name: CategoryTheory.Functor.IsDenseSubsite.functorPushforward_mem_iff
code: /-- The functor `G : C ⥤ D` exhibits `(C, J)` as a dense subsite of `(D, K)`
if `G` is cover-dense, locally fully-faithful,
and `S` is a cover of `C` if and only if the image of `S` in `D` is a cover. -/
class IsDenseSubsite : Prop where
  isCoverDense' : G.IsCoverDense K := by infer_instance
  isLocallyFull' : G.IsLocallyFull K := by infer_instance
  isLocallyFaithful' : G.IsLocallyFaithful K := by infer_instance
  functorPushforward_mem_iff : ∀ {X : C} {S : Sieve X}, S.functorPushforward G ∈ K _ ↔ S ∈ J _
goal: CategoryTheory.Sieve.functorPushforward G S ∈ K.sieves (G.obj X) ↔ S ∈ J.sieves X

full_name: CategoryTheory.Functor.IsDenseSubsite
code: /-- The functor `G : C ⥤ D` exhibits `(C, J)` as a dense subsite of `(D, K)`
if `G` is cover-dense, locally fully-faithful,
and `S` is a cover of `C` if and only if the image of `S` in `D` is a cover. -/
class IsDenseSubsite : Prop where
  isCoverDense' : G.IsCoverDense K := by infer_instance
  isLocallyFull' : G.IsLocallyFull K := by infer_instance
  isLocallyFaithful' : G.IsLocallyFaithful K := by infer_instance
  functorPushforward_mem_iff : ∀ {X : C} {S : Sieve X}, S.functorPushforward G ∈ K _ ↔ S ∈ J _
goal: Prop

full_name: CategoryTheory.Functor.IsDenseSubsite.isCoverDense
code: lemma isCoverDense : G.IsCoverDense K 
goal: G.IsCoverDense K

full_name: CategoryTheory.Functor.IsDenseSubsite.isLocallyFull
code: lemma isLocallyFull : G.IsLocallyFull K 
goal: G.IsLocallyFull K

full_name: CategoryTheory.Functor.IsDenseSubsite.isLocallyFaithful
code: lemma isLocallyFaithful : G.IsLocallyFaithful K 
goal: G.IsLocallyFaithful K

full_name: CategoryTheory.Functor.IsDenseSubsite.coverPreserving
code: lemma coverPreserving [G.IsDenseSubsite J K] : CoverPreserving J K G 
goal: CategoryTheory.CoverPreserving J K G

full_name: CategoryTheory.Functor.IsDenseSubsite.instIsContinuous
code: instance (priority := 900) [G.IsDenseSubsite J K] : G.IsContinuous J K 
goal: G.IsContinuous J K

full_name: CategoryTheory.Functor.IsDenseSubsite.instIsCocontinuous
code: instance (priority := 900) [G.IsDenseSubsite J K] : G.IsCocontinuous J K 
goal: G.IsCocontinuous J K

full_name: CategoryTheory.Functor.IsDenseSubsite.full_sheafPushforwardContinuous
code: instance full_sheafPushforwardContinuous [G.IsDenseSubsite J K] :
    Full (G.sheafPushforwardContinuous A J K) 
goal: (G.sheafPushforwardContinuous A J K).Full

full_name: CategoryTheory.Functor.IsDenseSubsite.faithful_sheafPushforwardContinuous
code: instance faithful_sheafPushforwardContinuous [G.IsDenseSubsite J K] :
    Faithful (G.sheafPushforwardContinuous A J K) 
goal: (G.sheafPushforwardContinuous A J K).Faithful

full_name: CategoryTheory.Functor.IsDenseSubsite.imageSieve_mem
code: lemma imageSieve_mem [G.IsDenseSubsite J K] {U V} (f : G.obj U ⟶ G.obj V) :
    G.imageSieve f ∈ J _ 
goal: G.imageSieve f ∈ J.sieves U

full_name: CategoryTheory.Functor.IsDenseSubsite.equalizer_mem
code: lemma equalizer_mem [G.IsDenseSubsite J K] {U V} (f₁ f₂ : U ⟶ V) (e : G.map f₁ = G.map f₂) :
    Sieve.equalizer f₁ f₂ ∈ J _ 
goal: CategoryTheory.Sieve.equalizer f₁ f₂ ∈ J.sieves U

full_name: CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite
code: lemma isIso_ranCounit_app_of_isDenseSubsite (Y : Sheaf J A) (U X) :
    IsIso ((yoneda.map ((G.op.ranCounit.app Y.val).app (op U))).app (op X)) 
goal: CategoryTheory.IsIso ((CategoryTheory.yoneda.map ((G.op.ranCounit.app Y.val).app (Opposite.op U))).app (Opposite.op X))

full_name: CategoryTheory.Functor.IsDenseSubsite.instIsIsoSheafAppCounitSheafAdjunctionCocontinuous
code: instance (Y : Sheaf J A) : IsIso ((G.sheafAdjunctionCocontinuous A J K).counit.app Y) 
goal: CategoryTheory.IsIso ((G.sheafAdjunctionCocontinuous A J K).counit.app Y)

full_name: CategoryTheory.Functor.IsDenseSubsite.sheafEquiv
code: /--
If `G : C ⥤ D` exhibits `(C, J)` as a dense subsite of `(D, K)`,
it induces an equivalence of category of sheaves valued in a category with suitable limits.
-/
@[simps! functor inverse]
noncomputable def sheafEquiv : Sheaf J A ≌ Sheaf K A 
goal: CategoryTheory.Sheaf J A ≌ CategoryTheory.Sheaf K A

full_name: CategoryTheory.Functor.IsDenseSubsite.sheafEquiv_functor
code: /--
If `G : C ⥤ D` exhibits `(C, J)` as a dense subsite of `(D, K)`,
it induces an equivalence of category of sheaves valued in a category with suitable limits.
-/
@[simps! functor inverse]
noncomputable def sheafEquiv : Sheaf J A ≌ Sheaf K A 
goal: (CategoryTheory.Functor.IsDenseSubsite.sheafEquiv G J K A).functor = G.sheafPushforwardCocontinuous A J K

full_name: CategoryTheory.Functor.IsDenseSubsite.sheafEquiv_inverse
code: /--
If `G : C ⥤ D` exhibits `(C, J)` as a dense subsite of `(D, K)`,
it induces an equivalence of category of sheaves valued in a category with suitable limits.
-/
@[simps! functor inverse]
noncomputable def sheafEquiv : Sheaf J A ≌ Sheaf K A 
goal: (CategoryTheory.Functor.IsDenseSubsite.sheafEquiv G J K A).inverse = G.sheafPushforwardContinuous A J K

full_name: CategoryTheory.Functor.IsDenseSubsite.sheafEquivSheafificationCompatibility
code: /-- The natural isomorphism exhibiting the compatibility of
`IsDenseSubsite.sheafEquiv` with sheafification. -/
noncomputable
abbrev sheafEquivSheafificationCompatibility :
    (whiskeringLeft _ _ A).obj G.op ⋙ presheafToSheaf _ _ ≅
      presheafToSheaf _ _ ⋙ (sheafEquiv G J K A).inverse 
goal: ((CategoryTheory.whiskeringLeft Cᵒᵖ Dᵒᵖ A).obj G.op).comp (CategoryTheory.presheafToSheaf J A) ≅
  (CategoryTheory.presheafToSheaf K A).comp (CategoryTheory.Functor.IsDenseSubsite.sheafEquiv G J K A).inverse