File: Mathlib/CategoryTheory/Sites/Coherent/Equivalence.lean

full_name: CategoryTheory.Equivalence.precoherent
code: /-- `Precoherent` is preserved by equivalence of categories. -/
theorem precoherent : Precoherent D 
goal: CategoryTheory.Precoherent D

full_name: CategoryTheory.Equivalence.instPrecoherentSmallModel
code: instance [EssentiallySmall C] :
    Precoherent (SmallModel C) 
goal: CategoryTheory.Precoherent (CategoryTheory.SmallModel.{u_3, u_4, u_1} C)

full_name: CategoryTheory.Equivalence.instTransportsGrothendieckTopologyCoherentTopology
code: instance : haveI := precoherent e
    e.TransportsGrothendieckTopology (coherentTopology C) (coherentTopology D) 
goal: CategoryTheory.Equivalence.TransportsGrothendieckTopology (CategoryTheory.coherentTopology C)
  (CategoryTheory.coherentTopology D) e

full_name: CategoryTheory.Equivalence.sheafCongrPrecoherent_counitIso_inv_app_val_app
code: /--
Equivalent precoherent categories give equivalent coherent toposes.
-/
@[simps!]
def sheafCongrPrecoherent : haveI := e.precoherent
    Sheaf (coherentTopology C) A ≌ Sheaf (coherentTopology D) A 
goal: ∀ (X_1 : Dᵒᵖ),
  ((e.sheafCongrPrecoherent A).counitIso.inv.app X).val.app X_1 = X.val.map (e.counitIso.hom.app (Opposite.unop X_1)).op

full_name: CategoryTheory.Equivalence.sheafCongrPrecoherent_inverse_obj_val_map
code: /--
Equivalent precoherent categories give equivalent coherent toposes.
-/
@[simps!]
def sheafCongrPrecoherent : haveI := e.precoherent
    Sheaf (coherentTopology C) A ≌ Sheaf (coherentTopology D) A 
goal: ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y), ((e.sheafCongrPrecoherent A).inverse.obj F).val.map f = F.val.map (e.functor.map f.unop).op

full_name: CategoryTheory.Equivalence.sheafCongrPrecoherent
code: /--
Equivalent precoherent categories give equivalent coherent toposes.
-/
@[simps!]
def sheafCongrPrecoherent : haveI := e.precoherent
    Sheaf (coherentTopology C) A ≌ Sheaf (coherentTopology D) A 
goal: CategoryTheory.Sheaf (CategoryTheory.coherentTopology C) A ≌ CategoryTheory.Sheaf (CategoryTheory.coherentTopology D) A

full_name: CategoryTheory.Equivalence.sheafCongrPrecoherent_inverse_obj_val_obj
code: /--
Equivalent precoherent categories give equivalent coherent toposes.
-/
@[simps!]
def sheafCongrPrecoherent : haveI := e.precoherent
    Sheaf (coherentTopology C) A ≌ Sheaf (coherentTopology D) A 
goal: ((e.sheafCongrPrecoherent A).inverse.obj F).val.obj X = F.val.obj (Opposite.op (e.functor.obj (Opposite.unop X)))

full_name: CategoryTheory.Equivalence.sheafCongrPrecoherent_unitIso_inv_app_val_app
code: /--
Equivalent precoherent categories give equivalent coherent toposes.
-/
@[simps!]
def sheafCongrPrecoherent : haveI := e.precoherent
    Sheaf (coherentTopology C) A ≌ Sheaf (coherentTopology D) A 
goal: ∀ (X_1 : Cᵒᵖ),
  ((e.sheafCongrPrecoherent A).unitIso.inv.app X).val.app X_1 = X.val.map (e.unitIso.hom.app (Opposite.unop X_1)).op

full_name: CategoryTheory.Equivalence.sheafCongrPrecoherent_functor_map_val_app
code: /--
Equivalent precoherent categories give equivalent coherent toposes.
-/
@[simps!]
def sheafCongrPrecoherent : haveI := e.precoherent
    Sheaf (coherentTopology C) A ≌ Sheaf (coherentTopology D) A 
goal: ∀ {X Y : CategoryTheory.Sheaf (CategoryTheory.coherentTopology C) A} (f : X ⟶ Y) (X_1 : Dᵒᵖ),
  ((e.sheafCongrPrecoherent A).functor.map f).val.app X_1 = f.val.app (Opposite.op (e.inverse.obj (Opposite.unop X_1)))

full_name: CategoryTheory.Equivalence.sheafCongrPrecoherent_counitIso_hom_app_val_app
code: /--
Equivalent precoherent categories give equivalent coherent toposes.
-/
@[simps!]
def sheafCongrPrecoherent : haveI := e.precoherent
    Sheaf (coherentTopology C) A ≌ Sheaf (coherentTopology D) A 
goal: ∀ (X_1 : Dᵒᵖ),
  ((e.sheafCongrPrecoherent A).counitIso.hom.app X).val.app X_1 = X.val.map (e.counitIso.inv.app (Opposite.unop X_1)).op

full_name: CategoryTheory.Equivalence.sheafCongrPrecoherent_unitIso_hom_app_val_app
code: /--
Equivalent precoherent categories give equivalent coherent toposes.
-/
@[simps!]
def sheafCongrPrecoherent : haveI := e.precoherent
    Sheaf (coherentTopology C) A ≌ Sheaf (coherentTopology D) A 
goal: ∀ (X_1 : Cᵒᵖ),
  ((e.sheafCongrPrecoherent A).unitIso.hom.app X).val.app X_1 = X.val.map (e.unitIso.inv.app (Opposite.unop X_1)).op

full_name: CategoryTheory.Equivalence.sheafCongrPrecoherent_functor_obj_val_map
code: /--
Equivalent precoherent categories give equivalent coherent toposes.
-/
@[simps!]
def sheafCongrPrecoherent : haveI := e.precoherent
    Sheaf (coherentTopology C) A ≌ Sheaf (coherentTopology D) A 
goal: ∀ {X Y : Dᵒᵖ} (f : X ⟶ Y), ((e.sheafCongrPrecoherent A).functor.obj F).val.map f = F.val.map (e.inverse.map f.unop).op

full_name: CategoryTheory.Equivalence.sheafCongrPrecoherent_functor_obj_val_obj
code: /--
Equivalent precoherent categories give equivalent coherent toposes.
-/
@[simps!]
def sheafCongrPrecoherent : haveI := e.precoherent
    Sheaf (coherentTopology C) A ≌ Sheaf (coherentTopology D) A 
goal: ((e.sheafCongrPrecoherent A).functor.obj F).val.obj X = F.val.obj (Opposite.op (e.inverse.obj (Opposite.unop X)))

full_name: CategoryTheory.Equivalence.sheafCongrPrecoherent_inverse_map_val_app
code: /--
Equivalent precoherent categories give equivalent coherent toposes.
-/
@[simps!]
def sheafCongrPrecoherent : haveI := e.precoherent
    Sheaf (coherentTopology C) A ≌ Sheaf (coherentTopology D) A 
goal: ∀ {X Y : CategoryTheory.Sheaf (CategoryTheory.coherentTopology D) A} (f : X ⟶ Y) (X_1 : Cᵒᵖ),
  ((e.sheafCongrPrecoherent A).inverse.map f).val.app X_1 = f.val.app (Opposite.op (e.functor.obj (Opposite.unop X_1)))

full_name: CategoryTheory.Equivalence.precoherent_isSheaf_iff
code: /--
The coherent sheaf condition can be checked after precomposing with the equivalence.
-/
theorem precoherent_isSheaf_iff (F : Cᵒᵖ ⥤ A) : haveI := e.precoherent
    IsSheaf (coherentTopology C) F ↔ IsSheaf (coherentTopology D) (e.inverse.op ⋙ F) 
goal: CategoryTheory.Presheaf.IsSheaf (CategoryTheory.coherentTopology C) F ↔
  CategoryTheory.Presheaf.IsSheaf (CategoryTheory.coherentTopology D) (e.inverse.op.comp F)

full_name: CategoryTheory.Equivalence.precoherent_isSheaf_iff_of_essentiallySmall
code: /--
The coherent sheaf condition on an essentially small site can be checked after precomposing with
the equivalence with a small category.
-/
theorem precoherent_isSheaf_iff_of_essentiallySmall [EssentiallySmall C] (F : Cᵒᵖ ⥤ A) :
    IsSheaf (coherentTopology C) F ↔
      IsSheaf (coherentTopology (SmallModel C)) ((equivSmallModel C).inverse.op ⋙ F) 
goal: CategoryTheory.Presheaf.IsSheaf (CategoryTheory.coherentTopology C) F ↔
  CategoryTheory.Presheaf.IsSheaf (CategoryTheory.coherentTopology (CategoryTheory.SmallModel.{u_4, u_5, u_1} C))
    ((CategoryTheory.equivSmallModel C).inverse.op.comp F)

full_name: CategoryTheory.Equivalence.preregular
code: /-- `Preregular` is preserved by equivalence of categories. -/
theorem preregular : Preregular D 
goal: CategoryTheory.Preregular D

full_name: CategoryTheory.Equivalence.instPreregularSmallModel
code: instance [EssentiallySmall C] :
    Preregular (SmallModel C) 
goal: CategoryTheory.Preregular (CategoryTheory.SmallModel.{u_3, u_4, u_1} C)

full_name: CategoryTheory.Equivalence.instTransportsGrothendieckTopologyRegularTopology
code: instance : haveI := preregular e
    e.TransportsGrothendieckTopology (regularTopology C) (regularTopology D) 
goal: CategoryTheory.Equivalence.TransportsGrothendieckTopology (CategoryTheory.regularTopology C)
  (CategoryTheory.regularTopology D) e

full_name: CategoryTheory.Equivalence.sheafCongrPreregular
code: /--
Equivalent preregular categories give equivalent regular toposes.
-/
@[simps!]
def sheafCongrPreregular : haveI := e.preregular
    Sheaf (regularTopology C) A ≌ Sheaf (regularTopology D) A 
goal: CategoryTheory.Sheaf (CategoryTheory.regularTopology C) A ≌ CategoryTheory.Sheaf (CategoryTheory.regularTopology D) A

full_name: CategoryTheory.Equivalence.sheafCongrPreregular_functor_obj_val_obj
code: /--
Equivalent preregular categories give equivalent regular toposes.
-/
@[simps!]
def sheafCongrPreregular : haveI := e.preregular
    Sheaf (regularTopology C) A ≌ Sheaf (regularTopology D) A 
goal: ((e.sheafCongrPreregular A).functor.obj F).val.obj X = F.val.obj (Opposite.op (e.inverse.obj (Opposite.unop X)))

full_name: CategoryTheory.Equivalence.sheafCongrPreregular_unitIso_hom_app_val_app
code: /--
Equivalent preregular categories give equivalent regular toposes.
-/
@[simps!]
def sheafCongrPreregular : haveI := e.preregular
    Sheaf (regularTopology C) A ≌ Sheaf (regularTopology D) A 
goal: ∀ (X_1 : Cᵒᵖ),
  ((e.sheafCongrPreregular A).unitIso.hom.app X).val.app X_1 = X.val.map (e.unitIso.inv.app (Opposite.unop X_1)).op

full_name: CategoryTheory.Equivalence.sheafCongrPreregular_functor_obj_val_map
code: /--
Equivalent preregular categories give equivalent regular toposes.
-/
@[simps!]
def sheafCongrPreregular : haveI := e.preregular
    Sheaf (regularTopology C) A ≌ Sheaf (regularTopology D) A 
goal: ∀ {X Y : Dᵒᵖ} (f : X ⟶ Y), ((e.sheafCongrPreregular A).functor.obj F).val.map f = F.val.map (e.inverse.map f.unop).op

full_name: CategoryTheory.Equivalence.sheafCongrPreregular_inverse_obj_val_map
code: /--
Equivalent preregular categories give equivalent regular toposes.
-/
@[simps!]
def sheafCongrPreregular : haveI := e.preregular
    Sheaf (regularTopology C) A ≌ Sheaf (regularTopology D) A 
goal: ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y), ((e.sheafCongrPreregular A).inverse.obj F).val.map f = F.val.map (e.functor.map f.unop).op

full_name: CategoryTheory.Equivalence.sheafCongrPreregular_counitIso_inv_app_val_app
code: /--
Equivalent preregular categories give equivalent regular toposes.
-/
@[simps!]
def sheafCongrPreregular : haveI := e.preregular
    Sheaf (regularTopology C) A ≌ Sheaf (regularTopology D) A 
goal: ∀ (X_1 : Dᵒᵖ),
  ((e.sheafCongrPreregular A).counitIso.inv.app X).val.app X_1 = X.val.map (e.counitIso.hom.app (Opposite.unop X_1)).op

full_name: CategoryTheory.Equivalence.sheafCongrPreregular_functor_map_val_app
code: /--
Equivalent preregular categories give equivalent regular toposes.
-/
@[simps!]
def sheafCongrPreregular : haveI := e.preregular
    Sheaf (regularTopology C) A ≌ Sheaf (regularTopology D) A 
goal: ∀ {X Y : CategoryTheory.Sheaf (CategoryTheory.regularTopology C) A} (f : X ⟶ Y) (X_1 : Dᵒᵖ),
  ((e.sheafCongrPreregular A).functor.map f).val.app X_1 = f.val.app (Opposite.op (e.inverse.obj (Opposite.unop X_1)))

full_name: CategoryTheory.Equivalence.sheafCongrPreregular_inverse_obj_val_obj
code: /--
Equivalent preregular categories give equivalent regular toposes.
-/
@[simps!]
def sheafCongrPreregular : haveI := e.preregular
    Sheaf (regularTopology C) A ≌ Sheaf (regularTopology D) A 
goal: ((e.sheafCongrPreregular A).inverse.obj F).val.obj X = F.val.obj (Opposite.op (e.functor.obj (Opposite.unop X)))

full_name: CategoryTheory.Equivalence.sheafCongrPreregular_inverse_map_val_app
code: /--
Equivalent preregular categories give equivalent regular toposes.
-/
@[simps!]
def sheafCongrPreregular : haveI := e.preregular
    Sheaf (regularTopology C) A ≌ Sheaf (regularTopology D) A 
goal: ∀ {X Y : CategoryTheory.Sheaf (CategoryTheory.regularTopology D) A} (f : X ⟶ Y) (X_1 : Cᵒᵖ),
  ((e.sheafCongrPreregular A).inverse.map f).val.app X_1 = f.val.app (Opposite.op (e.functor.obj (Opposite.unop X_1)))

full_name: CategoryTheory.Equivalence.sheafCongrPreregular_unitIso_inv_app_val_app
code: /--
Equivalent preregular categories give equivalent regular toposes.
-/
@[simps!]
def sheafCongrPreregular : haveI := e.preregular
    Sheaf (regularTopology C) A ≌ Sheaf (regularTopology D) A 
goal: ∀ (X_1 : Cᵒᵖ),
  ((e.sheafCongrPreregular A).unitIso.inv.app X).val.app X_1 = X.val.map (e.unitIso.hom.app (Opposite.unop X_1)).op

full_name: CategoryTheory.Equivalence.sheafCongrPreregular_counitIso_hom_app_val_app
code: /--
Equivalent preregular categories give equivalent regular toposes.
-/
@[simps!]
def sheafCongrPreregular : haveI := e.preregular
    Sheaf (regularTopology C) A ≌ Sheaf (regularTopology D) A 
goal: ∀ (X_1 : Dᵒᵖ),
  ((e.sheafCongrPreregular A).counitIso.hom.app X).val.app X_1 = X.val.map (e.counitIso.inv.app (Opposite.unop X_1)).op

full_name: CategoryTheory.Equivalence.preregular_isSheaf_iff
code: /--
The regular sheaf condition can be checked after precomposing with the equivalence.
-/
theorem preregular_isSheaf_iff (F : Cᵒᵖ ⥤ A) : haveI := e.preregular
    IsSheaf (regularTopology C) F ↔ IsSheaf (regularTopology D) (e.inverse.op ⋙ F) 
goal: CategoryTheory.Presheaf.IsSheaf (CategoryTheory.regularTopology C) F ↔
  CategoryTheory.Presheaf.IsSheaf (CategoryTheory.regularTopology D) (e.inverse.op.comp F)

full_name: CategoryTheory.Equivalence.preregular_isSheaf_iff_of_essentiallySmall
code: /--
The regular sheaf condition on an essentially small site can be checked after precomposing with
the equivalence with a small category.
-/
theorem preregular_isSheaf_iff_of_essentiallySmall [EssentiallySmall C] (F : Cᵒᵖ ⥤ A) :
    IsSheaf (regularTopology C) F ↔ IsSheaf (regularTopology (SmallModel C))
    ((equivSmallModel C).inverse.op ⋙ F) 
goal: CategoryTheory.Presheaf.IsSheaf (CategoryTheory.regularTopology C) F ↔
  CategoryTheory.Presheaf.IsSheaf (CategoryTheory.regularTopology (CategoryTheory.SmallModel.{u_4, u_5, u_1} C))
    ((CategoryTheory.equivSmallModel C).inverse.op.comp F)