File: Mathlib/CategoryTheory/Sites/Closed.lean

full_name: CategoryTheory.GrothendieckTopology.close
code: /-- The `J`-closure of a sieve is the collection of arrows which it covers. -/
@[simps]
def close {X : C} (S : Sieve X) : Sieve X 
goal: CategoryTheory.Sieve X

full_name: CategoryTheory.GrothendieckTopology.close_apply
code: /-- The `J`-closure of a sieve is the collection of arrows which it covers. -/
@[simps]
def close {X : C} (S : Sieve X) : Sieve X 
goal: ∀ (x : C) (f : x ⟶ X), (J₁.close S).arrows f = J₁.Covers S f

full_name: CategoryTheory.GrothendieckTopology.le_close
code: /-- Any sieve is smaller than its closure. -/
theorem le_close {X : C} (S : Sieve X) : S ≤ J₁.close S 
goal: S ≤ J₁.close S

full_name: CategoryTheory.GrothendieckTopology.IsClosed
code: /-- A sieve is closed for the Grothendieck topology if it contains every arrow it covers.
In the case of the usual topology on a topological space, this means that the open cover contains
every open set which it covers.

Note this has no relation to a closed subset of a topological space.
-/
def IsClosed {X : C} (S : Sieve X) : Prop 
goal: Prop

full_name: CategoryTheory.GrothendieckTopology.covers_iff_mem_of_isClosed
code: /-- If `S` is `J₁`-closed, then `S` covers exactly the arrows it contains. -/
theorem covers_iff_mem_of_isClosed {X : C} {S : Sieve X} (h : J₁.IsClosed S) {Y : C} (f : Y ⟶ X) :
    J₁.Covers S f ↔ S f 
goal: J₁.Covers S f ↔ S.arrows f

full_name: CategoryTheory.GrothendieckTopology.isClosed_pullback
code: /-- Being `J`-closed is stable under pullback. -/
theorem isClosed_pullback {X Y : C} (f : Y ⟶ X) (S : Sieve X) :
    J₁.IsClosed S → J₁.IsClosed (S.pullback f) 
goal: J₁.IsClosed S → J₁.IsClosed (CategoryTheory.Sieve.pullback f S)

full_name: CategoryTheory.GrothendieckTopology.le_close_of_isClosed
code: /-- The closure of a sieve `S` is the largest closed sieve which contains `S` (justifying the name
"closure").
-/
theorem le_close_of_isClosed {X : C} {S T : Sieve X} (h : S ≤ T) (hT : J₁.IsClosed T) :
    J₁.close S ≤ T 
goal: J₁.close S ≤ T

full_name: CategoryTheory.GrothendieckTopology.close_isClosed
code: /-- The closure of a sieve is closed. -/
theorem close_isClosed {X : C} (S : Sieve X) : J₁.IsClosed (J₁.close S) 
goal: J₁.IsClosed (J₁.close S)

full_name: CategoryTheory.GrothendieckTopology.closureOperator
code: /-- A Grothendieck topology induces a natural family of closure operators on sieves. -/
@[simps! isClosed]
def closureOperator (X : C) : ClosureOperator (Sieve X) 
goal: ClosureOperator (CategoryTheory.Sieve X)

full_name: CategoryTheory.GrothendieckTopology.closureOperator_isClosed
code: /-- A Grothendieck topology induces a natural family of closure operators on sieves. -/
@[simps! isClosed]
def closureOperator (X : C) : ClosureOperator (Sieve X) 
goal: (J₁.closureOperator X).IsClosed S = J₁.IsClosed S

full_name: CategoryTheory.GrothendieckTopology.isClosed_iff_close_eq_self
code: /-- The sieve `S` is closed iff its closure is equal to itself. -/
theorem isClosed_iff_close_eq_self {X : C} (S : Sieve X) : J₁.IsClosed S ↔ J₁.close S = S 
goal: J₁.IsClosed S ↔ J₁.close S = S

full_name: CategoryTheory.GrothendieckTopology.close_eq_self_of_isClosed
code: theorem close_eq_self_of_isClosed {X : C} {S : Sieve X} (hS : J₁.IsClosed S) : J₁.close S = S 
goal: J₁.close S = S

full_name: CategoryTheory.GrothendieckTopology.pullback_close
code: /-- Closing under `J` is stable under pullback. -/
theorem pullback_close {X Y : C} (f : Y ⟶ X) (S : Sieve X) :
    J₁.close (S.pullback f) = (J₁.close S).pullback f 
goal: J₁.close (CategoryTheory.Sieve.pullback f S) = CategoryTheory.Sieve.pullback f (J₁.close S)

full_name: CategoryTheory.GrothendieckTopology.monotone_close
code: @[mono]
theorem monotone_close {X : C} : Monotone (J₁.close : Sieve X → Sieve X) 
goal: Monotone J₁.close

full_name: CategoryTheory.GrothendieckTopology.close_close
code: @[simp]
theorem close_close {X : C} (S : Sieve X) : J₁.close (J₁.close S) = J₁.close S 
goal: J₁.close (J₁.close S) = J₁.close S

full_name: CategoryTheory.GrothendieckTopology.close_eq_top_iff_mem
code: /--
The sieve `S` is in the topology iff its closure is the maximal sieve. This shows that the closure
operator determines the topology.
-/
theorem close_eq_top_iff_mem {X : C} (S : Sieve X) : J₁.close S = ⊤ ↔ S ∈ J₁ X 
goal: J₁.close S = ⊤ ↔ S ∈ J₁.sieves X

full_name: CategoryTheory.Functor.closedSieves
code: /--
The presheaf sending each object to the set of `J`-closed sieves on it. This presheaf is a `J`-sheaf
(and will turn out to be a subobject classifier for the category of `J`-sheaves).
-/
@[simps]
def Functor.closedSieves : Cᵒᵖ ⥤ Type max v u 
goal: CategoryTheory.Functor Cᵒᵖ (Type (max v u))

full_name: CategoryTheory.Functor.closedSieves_obj
code: /--
The presheaf sending each object to the set of `J`-closed sieves on it. This presheaf is a `J`-sheaf
(and will turn out to be a subobject classifier for the category of `J`-sheaves).
-/
@[simps]
def Functor.closedSieves : Cᵒᵖ ⥤ Type max v u 
goal: (CategoryTheory.Functor.closedSieves J₁).obj X = { S // J₁.IsClosed S }

full_name: CategoryTheory.Functor.closedSieves_map_coe
code: /--
The presheaf sending each object to the set of `J`-closed sieves on it. This presheaf is a `J`-sheaf
(and will turn out to be a subobject classifier for the category of `J`-sheaves).
-/
@[simps]
def Functor.closedSieves : Cᵒᵖ ⥤ Type max v u 
goal: ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y) (S : { S // J₁.IsClosed S }),
  ↑((CategoryTheory.Functor.closedSieves J₁).map f S) = CategoryTheory.Sieve.pullback f.unop ↑S

full_name: CategoryTheory.classifier_isSheaf
code: /-- The presheaf of `J`-closed sieves is a `J`-sheaf.
The proof of this is adapted from [MM92], Chapter III, Section 7, Lemma 1.
-/
theorem classifier_isSheaf : Presieve.IsSheaf J₁ (Functor.closedSieves J₁) 
goal: CategoryTheory.Presieve.IsSheaf J₁ (CategoryTheory.Functor.closedSieves J₁)

full_name: CategoryTheory.le_topology_of_closedSieves_isSheaf
code: /-- If presheaf of `J₁`-closed sieves is a `J₂`-sheaf then `J₁ ≤ J₂`. Note the converse is true by
`classifier_isSheaf` and `isSheaf_of_le`.
-/
theorem le_topology_of_closedSieves_isSheaf {J₁ J₂ : GrothendieckTopology C}
    (h : Presieve.IsSheaf J₁ (Functor.closedSieves J₂)) : J₁ ≤ J₂ 
goal: J₁ ≤ J₂

full_name: CategoryTheory.topology_eq_iff_same_sheaves
code: /-- If being a sheaf for `J₁` is equivalent to being a sheaf for `J₂`, then `J₁ = J₂`. -/
theorem topology_eq_iff_same_sheaves {J₁ J₂ : GrothendieckTopology C} :
    J₁ = J₂ ↔ ∀ P : Cᵒᵖ ⥤ Type max v u, Presieve.IsSheaf J₁ P ↔ Presieve.IsSheaf J₂ P 
goal: J₁ = J₂ ↔
  ∀ (P : CategoryTheory.Functor Cᵒᵖ (Type (max v u))),
    CategoryTheory.Presieve.IsSheaf J₁ P ↔ CategoryTheory.Presieve.IsSheaf J₂ P

full_name: CategoryTheory.topologyOfClosureOperator_sieves
code: /--
A closure (increasing, inflationary and idempotent) operation on sieves that commutes with pullback
induces a Grothendieck topology.
In fact, such operations are in bijection with Grothendieck topologies.
-/
@[simps]
def topologyOfClosureOperator (c : ∀ X : C, ClosureOperator (Sieve X))
    (hc : ∀ ⦃X Y : C⦄ (f : Y ⟶ X) (S : Sieve X), c _ (S.pullback f) = (c _ S).pullback f) :
    GrothendieckTopology C 
goal: (CategoryTheory.topologyOfClosureOperator c hc).sieves X = {S | (c X) S = ⊤}

full_name: CategoryTheory.topologyOfClosureOperator
code: /--
A closure (increasing, inflationary and idempotent) operation on sieves that commutes with pullback
induces a Grothendieck topology.
In fact, such operations are in bijection with Grothendieck topologies.
-/
@[simps]
def topologyOfClosureOperator (c : ∀ X : C, ClosureOperator (Sieve X))
    (hc : ∀ ⦃X Y : C⦄ (f : Y ⟶ X) (S : Sieve X), c _ (S.pullback f) = (c _ S).pullback f) :
    GrothendieckTopology C 
goal: CategoryTheory.GrothendieckTopology C

full_name: CategoryTheory.topologyOfClosureOperator_self
code: /--
The topology given by the closure operator `J.close` on a Grothendieck topology is the same as `J`.
-/
theorem topologyOfClosureOperator_self :
    (topologyOfClosureOperator J₁.closureOperator fun X Y => J₁.pullback_close) = J₁ 
goal: CategoryTheory.topologyOfClosureOperator J₁.closureOperator ⋯ = J₁

full_name: CategoryTheory.topologyOfClosureOperator_close
code: theorem topologyOfClosureOperator_close (c : ∀ X : C, ClosureOperator (Sieve X))
    (pb : ∀ ⦃X Y : C⦄ (f : Y ⟶ X) (S : Sieve X), c Y (S.pullback f) = (c X S).pullback f) (X : C)
    (S : Sieve X) : (topologyOfClosureOperator c pb).close S = c X S 
goal: (CategoryTheory.topologyOfClosureOperator c pb).close S = (c X) S