File: Mathlib/CategoryTheory/Sites/Equivalence.lean

full_name: CategoryTheory.Equivalence.instIsCoverDenseOfIsEquivalence
code: instance (priority := 900) [G.IsEquivalence] : IsCoverDense G J 
goal: G.IsCoverDense J

full_name: CategoryTheory.Equivalence.instIsDenseSubsiteInducedTopologyInverseFunctor
code: instance : e.functor.IsDenseSubsite J (e.inverse.inducedTopology J) 
goal: CategoryTheory.Functor.IsDenseSubsite J (e.inverse.inducedTopology J) e.functor

full_name: CategoryTheory.Equivalence.coverPreserving
code: theorem coverPreserving : CoverPreserving J (e.inverse.inducedTopology J) e.functor 
goal: CategoryTheory.CoverPreserving J (e.inverse.inducedTopology J) e.functor

full_name: CategoryTheory.Equivalence.TransportsGrothendieckTopology
code: /-- A class saying that the equivalence `e` transports the Grothendieck topology `J` to `K`. -/
class TransportsGrothendieckTopology : Prop where
  /-- `K` is equal to the induced topology. -/
  eq_inducedTopology : K = e.inverse.inducedTopology J
goal: Prop

full_name: CategoryTheory.Equivalence.TransportsGrothendieckTopology.eq_inducedTopology
code: /-- A class saying that the equivalence `e` transports the Grothendieck topology `J` to `K`. -/
class TransportsGrothendieckTopology : Prop where
  /-- `K` is equal to the induced topology. -/
  eq_inducedTopology : K = e.inverse.inducedTopology J
goal: K = e.inverse.inducedTopology J

full_name: CategoryTheory.Equivalence.instTransportsGrothendieckTopologyInducedTopologyInverse
code: instance : e.TransportsGrothendieckTopology J (e.inverse.inducedTopology J) 
goal: CategoryTheory.Equivalence.TransportsGrothendieckTopology J (e.inverse.inducedTopology J) e

full_name: CategoryTheory.Equivalence.eq_inducedTopology_of_transports
code: theorem eq_inducedTopology_of_transports : K = e.inverse.inducedTopology J 
goal: K = e.inverse.inducedTopology J

full_name: CategoryTheory.Equivalence.instIsContinuousFunctor
code: instance : IsContinuous e.functor J K 
goal: e.functor.IsContinuous J K

full_name: CategoryTheory.Equivalence.instIsContinuousInverse
code: instance : IsContinuous e.inverse K J 
goal: e.inverse.IsContinuous K J

full_name: CategoryTheory.Equivalence.sheafCongr.functor_obj_val_map
code: /-- The functor in the equivalence of sheaf categories. -/
@[simps!]
def sheafCongr.functor : Sheaf J A ⥤ Sheaf K A 
goal: ∀ {X Y : Dᵒᵖ} (f : X ⟶ Y),
  ((CategoryTheory.Equivalence.sheafCongr.functor J K e A).obj F).val.map f = F.val.map (e.inverse.map f.unop).op

full_name: CategoryTheory.Equivalence.sheafCongr.functor_obj_val_obj
code: /-- The functor in the equivalence of sheaf categories. -/
@[simps!]
def sheafCongr.functor : Sheaf J A ⥤ Sheaf K A 
goal: ((CategoryTheory.Equivalence.sheafCongr.functor J K e A).obj F).val.obj X =
  F.val.obj (Opposite.op (e.inverse.obj (Opposite.unop X)))

full_name: CategoryTheory.Equivalence.sheafCongr.functor_map_val_app
code: /-- The functor in the equivalence of sheaf categories. -/
@[simps!]
def sheafCongr.functor : Sheaf J A ⥤ Sheaf K A 
goal: ∀ {X Y : CategoryTheory.Sheaf J A} (f : X ⟶ Y) (X_1 : Dᵒᵖ),
  ((CategoryTheory.Equivalence.sheafCongr.functor J K e A).map f).val.app X_1 =
    f.val.app (Opposite.op (e.inverse.obj (Opposite.unop X_1)))

full_name: CategoryTheory.Equivalence.sheafCongr.functor
code: /-- The functor in the equivalence of sheaf categories. -/
@[simps!]
def sheafCongr.functor : Sheaf J A ⥤ Sheaf K A 
goal: CategoryTheory.Functor (CategoryTheory.Sheaf J A) (CategoryTheory.Sheaf K A)

full_name: CategoryTheory.Equivalence.sheafCongr.inverse_obj_val_obj
code: /-- The inverse in the equivalence of sheaf categories. -/
@[simps!]
def sheafCongr.inverse : Sheaf K A ⥤ Sheaf J A 
goal: ((CategoryTheory.Equivalence.sheafCongr.inverse J K e A).obj F).val.obj X =
  F.val.obj (Opposite.op (e.functor.obj (Opposite.unop X)))

full_name: CategoryTheory.Equivalence.sheafCongr.inverse_obj_val_map
code: /-- The inverse in the equivalence of sheaf categories. -/
@[simps!]
def sheafCongr.inverse : Sheaf K A ⥤ Sheaf J A 
goal: ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y),
  ((CategoryTheory.Equivalence.sheafCongr.inverse J K e A).obj F).val.map f = F.val.map (e.functor.map f.unop).op

full_name: CategoryTheory.Equivalence.sheafCongr.inverse_map_val_app
code: /-- The inverse in the equivalence of sheaf categories. -/
@[simps!]
def sheafCongr.inverse : Sheaf K A ⥤ Sheaf J A 
goal: ∀ {X Y : CategoryTheory.Sheaf K A} (f : X ⟶ Y) (X_1 : Cᵒᵖ),
  ((CategoryTheory.Equivalence.sheafCongr.inverse J K e A).map f).val.app X_1 =
    f.val.app (Opposite.op (e.functor.obj (Opposite.unop X_1)))

full_name: CategoryTheory.Equivalence.sheafCongr.inverse
code: /-- The inverse in the equivalence of sheaf categories. -/
@[simps!]
def sheafCongr.inverse : Sheaf K A ⥤ Sheaf J A 
goal: CategoryTheory.Functor (CategoryTheory.Sheaf K A) (CategoryTheory.Sheaf J A)

full_name: CategoryTheory.Equivalence.sheafCongr.unitIso_inv_app_val_app
code: /-- The unit iso in the equivalence of sheaf categories. -/
@[simps!]
def sheafCongr.unitIso : 𝟭 (Sheaf J A) ≅ functor J K e A ⋙ inverse J K e A 
goal: ∀ (X_1 : Cᵒᵖ),
  ((CategoryTheory.Equivalence.sheafCongr.unitIso J K e A).inv.app X).val.app X_1 =
    X.val.map (e.unitIso.hom.app (Opposite.unop X_1)).op

full_name: CategoryTheory.Equivalence.sheafCongr.unitIso
code: /-- The unit iso in the equivalence of sheaf categories. -/
@[simps!]
def sheafCongr.unitIso : 𝟭 (Sheaf J A) ≅ functor J K e A ⋙ inverse J K e A 
goal: CategoryTheory.Functor.id (CategoryTheory.Sheaf J A) ≅
  (CategoryTheory.Equivalence.sheafCongr.functor J K e A).comp (CategoryTheory.Equivalence.sheafCongr.inverse J K e A)

full_name: CategoryTheory.Equivalence.sheafCongr.unitIso_hom_app_val_app
code: /-- The unit iso in the equivalence of sheaf categories. -/
@[simps!]
def sheafCongr.unitIso : 𝟭 (Sheaf J A) ≅ functor J K e A ⋙ inverse J K e A 
goal: ∀ (X_1 : Cᵒᵖ),
  ((CategoryTheory.Equivalence.sheafCongr.unitIso J K e A).hom.app X).val.app X_1 =
    X.val.map (e.unitIso.inv.app (Opposite.unop X_1)).op

full_name: CategoryTheory.Equivalence.sheafCongr.counitIso_inv_app_val_app
code: /-- The counit iso in the equivalence of sheaf categories. -/
@[simps!]
def sheafCongr.counitIso : inverse J K e A ⋙ functor J K e A ≅ 𝟭 (Sheaf _ A) 
goal: ∀ (X_1 : Dᵒᵖ),
  ((CategoryTheory.Equivalence.sheafCongr.counitIso J K e A).inv.app X).val.app X_1 =
    X.val.map (e.counitIso.hom.app (Opposite.unop X_1)).op

full_name: CategoryTheory.Equivalence.sheafCongr.counitIso
code: /-- The counit iso in the equivalence of sheaf categories. -/
@[simps!]
def sheafCongr.counitIso : inverse J K e A ⋙ functor J K e A ≅ 𝟭 (Sheaf _ A) 
goal: (CategoryTheory.Equivalence.sheafCongr.inverse J K e A).comp (CategoryTheory.Equivalence.sheafCongr.functor J K e A) ≅
  CategoryTheory.Functor.id (CategoryTheory.Sheaf K A)

full_name: CategoryTheory.Equivalence.sheafCongr.counitIso_hom_app_val_app
code: /-- The counit iso in the equivalence of sheaf categories. -/
@[simps!]
def sheafCongr.counitIso : inverse J K e A ⋙ functor J K e A ≅ 𝟭 (Sheaf _ A) 
goal: ∀ (X_1 : Dᵒᵖ),
  ((CategoryTheory.Equivalence.sheafCongr.counitIso J K e A).hom.app X).val.app X_1 =
    X.val.map (e.counitIso.inv.app (Opposite.unop X_1)).op

full_name: CategoryTheory.Equivalence.sheafCongr
code: /-- The equivalence of sheaf categories. -/
def sheafCongr : Sheaf J A ≌ Sheaf K A 
goal: CategoryTheory.Sheaf J A ≌ CategoryTheory.Sheaf K A

full_name: CategoryTheory.Equivalence.transportAndSheafify
code: /-- Transport a presheaf to the equivalent category and sheafify there. -/
noncomputable
def transportAndSheafify : (Cᵒᵖ ⥤ A) ⥤ Sheaf J A 
goal: CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ A) (CategoryTheory.Sheaf J A)

full_name: CategoryTheory.Equivalence.transportIsoSheafToPresheaf
code: /-- An auxiliary definition for the sheafification adjunction. -/
noncomputable
def transportIsoSheafToPresheaf : (e.sheafCongr J K A).functor ⋙
    sheafToPresheaf K A ⋙ e.op.congrLeft.inverse ≅ sheafToPresheaf J A 
goal: (CategoryTheory.Equivalence.sheafCongr J K e A).functor.comp
    ((CategoryTheory.sheafToPresheaf K A).comp e.op.congrLeft.inverse) ≅
  CategoryTheory.sheafToPresheaf J A

full_name: CategoryTheory.Equivalence.transportSheafificationAdjunction
code: /-- Transporting and sheafifying is left adjoint to taking the underlying presheaf. -/
noncomputable
def transportSheafificationAdjunction : transportAndSheafify J K e A ⊣ sheafToPresheaf J A 
goal: CategoryTheory.Equivalence.transportAndSheafify J K e A ⊣ CategoryTheory.sheafToPresheaf J A

full_name: CategoryTheory.Equivalence.instPreservesFiniteLimitsFunctorOppositeSheafTransportAndSheafify
code: noncomputable instance : PreservesFiniteLimits <| transportAndSheafify J K e A 
goal: CategoryTheory.Limits.PreservesFiniteLimits (CategoryTheory.Equivalence.transportAndSheafify J K e A)

full_name: CategoryTheory.Equivalence.hasSheafify
code: /-- Transport `HasSheafify` along an equivalence of sites. -/
theorem hasSheafify : HasSheafify J A 
goal: CategoryTheory.HasSheafify J A

full_name: CategoryTheory.Equivalence.hasSheafCompose
code: theorem hasSheafCompose : J.HasSheafCompose F 
goal: J.HasSheafCompose F

full_name: CategoryTheory.smallSheafify
code: /-- Transport to a small model and sheafify there. -/
noncomputable
def smallSheafify : (Cᵒᵖ ⥤ A) ⥤ Sheaf J A 
goal: CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ A) (CategoryTheory.Sheaf J A)

full_name: CategoryTheory.smallSheafificationAdjunction
code: /--
Transporting to a small model and sheafifying there is left adjoint to the underlying presheaf
functor
-/
noncomputable
def smallSheafificationAdjunction : smallSheafify J A ⊣ sheafToPresheaf J A 
goal: CategoryTheory.smallSheafify J A ⊣ CategoryTheory.sheafToPresheaf J A

full_name: CategoryTheory.hasSheafifyEssentiallySmallSite
code: noncomputable instance hasSheafifyEssentiallySmallSite : HasSheafify J A 
goal: CategoryTheory.HasSheafify J A

full_name: CategoryTheory.hasSheafComposeEssentiallySmallSite
code: instance hasSheafComposeEssentiallySmallSite : HasSheafCompose J F 
goal: J.HasSheafCompose F

full_name: CategoryTheory.hasLimitsEssentiallySmallSite
code: instance hasLimitsEssentiallySmallSite
    [HasLimits <| Sheaf ((equivSmallModel C).inverse.inducedTopology J) A] :
    HasLimitsOfSize.{max v₃ w, max v₃ w} <| Sheaf J A 
goal: CategoryTheory.Limits.HasLimitsOfSize.{max v₃ w, max v₃ w, max u₁ v₃, max (max (max u₃ u₁) v₃) v₁}
  (CategoryTheory.Sheaf J A)

full_name: CategoryTheory.hasColimitsEssentiallySmallSite
code: instance hasColimitsEssentiallySmallSite
    [HasColimits <| Sheaf ((equivSmallModel C).inverse.inducedTopology J) A] :
    HasColimitsOfSize.{max v₃ w, max v₃ w} <| Sheaf J A 
goal: CategoryTheory.Limits.HasColimitsOfSize.{max v₃ w, max v₃ w, max u₁ v₃, max (max (max u₃ u₁) v₃) v₁}
  (CategoryTheory.Sheaf J A)

full_name: CategoryTheory.GrothendieckTopology.W_inverseImage_whiskeringLeft
code: lemma W_inverseImage_whiskeringLeft :
    K.W.inverseImage ((whiskeringLeft Dᵒᵖ Cᵒᵖ A).obj G.op) = J.W 
goal: K.W.inverseImage ((CategoryTheory.whiskeringLeft Dᵒᵖ Cᵒᵖ A).obj G.op) = J.W

full_name: CategoryTheory.GrothendieckTopology.W_whiskerLeft_iff
code: lemma W_whiskerLeft_iff {P Q : Cᵒᵖ ⥤ A} (f : P ⟶ Q) :
    K.W (whiskerLeft G.op f) ↔ J.W f 
goal: K.W (CategoryTheory.whiskerLeft G.op f) ↔ J.W f

full_name: CategoryTheory.GrothendieckTopology.WEqualsLocallyBijective.transport
code: lemma WEqualsLocallyBijective.transport : J.WEqualsLocallyBijective A 
goal: J.WEqualsLocallyBijective A