Documentation

Mathlib.CategoryTheory.Sites.Grothendieck

Grothendieck topologies #

Definition and lemmas about Grothendieck topologies. A Grothendieck topology for a category C is a set of sieves on each object X satisfying certain closure conditions.

Alternate versions of the axioms (in arrow form) are also described. Two explicit examples of Grothendieck topologies are given:

A pretopology, or a basis for a topology is defined in Mathlib/CategoryTheory/Sites/Pretopology.lean. The topology associated to a topological space is defined in Mathlib/CategoryTheory/Sites/Spaces.lean.

Tags #

Grothendieck topology, coverage, pretopology, site

References #

Implementation notes #

We use the definition of [nlab] and [MM92][] (Chapter III, Section 2), where Grothendieck topologies are saturated collections of morphisms, rather than the notions of the Stacks project (00VG) and the Elephant, in which topologies are allowed to be unsaturated, and are then completed. TODO (BM): Add the definition from Stacks, as a pretopology, and complete to a topology.

This is so that we can produce a bijective correspondence between Grothendieck topologies on a small category and Lawvere-Tierney topologies on its presheaf topos, as well as the equivalence between Grothendieck topoi and left exact reflective subcategories of presheaf toposes.

The definition of a Grothendieck topology: a set of sieves J X on each object X satisfying three axioms:

  1. For every object X, the maximal sieve is in J X.
  2. If S ∈ J X then its pullback along any h : Y ⟶ X is in J Y.
  3. If S ∈ J X and R is a sieve on X, then provided that the pullback of R along any arrow f : Y ⟶ X in S is in J Y, we have that R itself is in J X.

A sieve S on X is referred to as J-covering, (or just covering), if S ∈ J X.

See https://stacks.math.columbia.edu/tag/00Z4, or [nlab], or [MM92][] Chapter III, Section 2, Definition 1.

Instances For

    The sieves associated to each object must contain the top sieve. Use GrothendieckTopology.top_mem.

    theorem CategoryTheory.GrothendieckTopology.pullback_stable' {C : Type u} [CategoryTheory.Category.{v, u} C] (self : CategoryTheory.GrothendieckTopology C) ⦃X : C ⦃Y : C ⦃S : CategoryTheory.Sieve X (f : Y X) :
    S self.sieves XCategoryTheory.Sieve.pullback f S self.sieves Y

    Stability under pullback. Use GrothendieckTopology.pullback_stable.

    theorem CategoryTheory.GrothendieckTopology.transitive' {C : Type u} [CategoryTheory.Category.{v, u} C] (self : CategoryTheory.GrothendieckTopology C) ⦃X : C ⦃S : CategoryTheory.Sieve X :
    S self.sieves X∀ (R : CategoryTheory.Sieve X), (∀ ⦃Y : C⦄ ⦃f : Y X⦄, S.arrows fCategoryTheory.Sieve.pullback f R self.sieves Y)R self.sieves X

    Transitivity of sieves in a Grothendieck topology. Use GrothendieckTopology.transitive.

    An extensionality lemma in terms of the coercion to a pi-type. We prove this explicitly rather than deriving it so that it is in terms of the coercion rather than the projection .sieves.

    @[simp]

    Also known as the maximality axiom.

    @[simp]

    Also known as the stability axiom.

    theorem CategoryTheory.GrothendieckTopology.transitive {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {S : CategoryTheory.Sieve X} (J : CategoryTheory.GrothendieckTopology C) (hS : S J.sieves X) (R : CategoryTheory.Sieve X) (h : ∀ ⦃Y : C⦄ ⦃f : Y X⦄, S.arrows fCategoryTheory.Sieve.pullback f R J.sieves Y) :
    R J.sieves X

    If S is a subset of R, and S is covering, then R is covering as well.

    See https://stacks.math.columbia.edu/tag/00Z5 (2), or discussion after [MM92] Chapter III, Section 2, Definition 1.

    The intersection of two covering sieves is covering.

    See https://stacks.math.columbia.edu/tag/00Z5 (1), or [MM92] Chapter III, Section 2, Definition 1 (iv).

    theorem CategoryTheory.GrothendieckTopology.bind_covering {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} (J : CategoryTheory.GrothendieckTopology C) {S : CategoryTheory.Sieve X} {R : Y : C⦄ → f : Y X⦄ → S.arrows fCategoryTheory.Sieve Y} (hS : S J.sieves X) (hR : ∀ ⦃Y : C⦄ ⦃f : Y X⦄ (H : S.arrows f), R H J.sieves Y) :
    CategoryTheory.Sieve.bind S.arrows R J.sieves X

    The sieve S on X J-covers an arrow f to X if S.pullback f ∈ J Y. This definition is an alternate way of presenting a Grothendieck topology.

    Equations
    Instances For
      theorem CategoryTheory.GrothendieckTopology.arrow_max {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} (J : CategoryTheory.GrothendieckTopology C) (f : Y X) (S : CategoryTheory.Sieve X) (hf : S.arrows f) :
      J.Covers S f

      The maximality axiom in 'arrow' form: Any arrow f in S is covered by S.

      theorem CategoryTheory.GrothendieckTopology.arrow_stable {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} (J : CategoryTheory.GrothendieckTopology C) (f : Y X) (S : CategoryTheory.Sieve X) (h : J.Covers S f) {Z : C} (g : Z Y) :

      The stability axiom in 'arrow' form: If S covers f then S covers g ≫ f for any g.

      theorem CategoryTheory.GrothendieckTopology.arrow_trans {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} (J : CategoryTheory.GrothendieckTopology C) (f : Y X) (S : CategoryTheory.Sieve X) (R : CategoryTheory.Sieve X) (h : J.Covers S f) :
      (∀ {Z : C} (g : Z X), S.arrows gJ.Covers R g)J.Covers R f

      The transitivity axiom in 'arrow' form: If S covers f and every arrow in S is covered by R, then R covers f.

      theorem CategoryTheory.GrothendieckTopology.arrow_intersect {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} (J : CategoryTheory.GrothendieckTopology C) (f : Y X) (S : CategoryTheory.Sieve X) (R : CategoryTheory.Sieve X) (hS : J.Covers S f) (hR : J.Covers R f) :
      J.Covers (S R) f

      The trivial Grothendieck topology, in which only the maximal sieve is covering. This topology is also known as the indiscrete, coarse, or chaotic topology.

      See [MM92] Chapter III, Section 2, example (a), or https://en.wikipedia.org/wiki/Grothendieck_topology#The_discrete_and_indiscrete_topologies

      Equations
      Instances For

        The discrete Grothendieck topology, in which every sieve is covering.

        See https://en.wikipedia.org/wiki/Grothendieck_topology#The_discrete_and_indiscrete_topologies.

        Equations
        Instances For

          See https://stacks.math.columbia.edu/tag/00Z6

          Equations

          See https://stacks.math.columbia.edu/tag/00Z6

          Equations
          • CategoryTheory.GrothendieckTopology.instPartialOrder = let __src := CategoryTheory.GrothendieckTopology.instLEGrothendieckTopology; PartialOrder.mk

          Construct a complete lattice from the Inf, but make the trivial and discrete topologies definitionally equal to the bottom and top respectively.

          Equations
          • One or more equations did not get rendered due to their size.
          Equations
          • CategoryTheory.GrothendieckTopology.instInhabited = { default := }
          theorem CategoryTheory.GrothendieckTopology.bot_covers {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} (S : CategoryTheory.Sieve X) (f : Y X) :
          .Covers S f S.arrows f
          @[simp]
          theorem CategoryTheory.GrothendieckTopology.top_covers {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} (S : CategoryTheory.Sieve X) (f : Y X) :
          .Covers S f

          The dense Grothendieck topology.

          See https://ncatlab.org/nlab/show/dense+topology, or [MM92] Chapter III, Section 2, example (e).

          Equations
          • One or more equations did not get rendered due to their size.
          Instances For
            theorem CategoryTheory.GrothendieckTopology.dense_covering {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {S : CategoryTheory.Sieve X} :
            S CategoryTheory.GrothendieckTopology.dense.sieves X ∀ {Y : C} (f : Y X), ∃ (Z : C) (g : Z Y), S.arrows (CategoryTheory.CategoryStruct.comp g f)

            A category satisfies the right Ore condition if any span can be completed to a commutative square. NB. Any category with pullbacks obviously satisfies the right Ore condition, see right_ore_of_pullbacks.

            Equations
            • One or more equations did not get rendered due to their size.
            Instances For

              The atomic Grothendieck topology: a sieve is covering iff it is nonempty. For the pullback stability condition, we need the right Ore condition to hold.

              See https://ncatlab.org/nlab/show/atomic+site, or [MM92] Chapter III, Section 2, example (f).

              Equations
              • One or more equations did not get rendered due to their size.
              Instances For

                J.Cover X denotes the poset of covers of X with respect to the Grothendieck topology J.

                Equations
                Instances For
                  Equations
                  • J.instPreorderCover X = let_fun this := inferInstance; this

                  The sieve associated to a term of J.Cover X.

                  Equations
                  • S.sieve = S
                  Instances For
                    instance CategoryTheory.GrothendieckTopology.Cover.instCoeFunForallForallHomProp {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} :
                    CoeFun (J.Cover X) fun (x : J.Cover X) => Y : C⦄ → (Y X)Prop
                    Equations
                    • CategoryTheory.GrothendieckTopology.Cover.instCoeFunForallForallHomProp = { coe := fun (S : J.Cover X) => S.sieve.arrows }
                    theorem CategoryTheory.GrothendieckTopology.Cover.ext {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} (S : J.Cover X) (T : J.Cover X) (h : ∀ ⦃Y : C⦄ (f : Y X), S.sieve.arrows f T.sieve.arrows f) :
                    S = T
                    Equations
                    • CategoryTheory.GrothendieckTopology.Cover.instOrderTop = let __src := inferInstance; OrderTop.mk
                    Equations
                    • CategoryTheory.GrothendieckTopology.Cover.instSemilatticeInf = let __src := inferInstance; SemilatticeInf.mk
                    Equations
                    • CategoryTheory.GrothendieckTopology.Cover.instInhabited = { default := }
                    theorem CategoryTheory.GrothendieckTopology.Cover.Arrow.ext_iff {C : Type u} :
                    ∀ {inst : CategoryTheory.Category.{v, u} C} {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (x y : S.Arrow), x = y x.Y = y.Y HEq x.f y.f
                    theorem CategoryTheory.GrothendieckTopology.Cover.Arrow.ext {C : Type u} :
                    ∀ {inst : CategoryTheory.Category.{v, u} C} {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (x y : S.Arrow), x.Y = y.YHEq x.f y.fx = y

                    An auxiliary structure, used to define S.index.

                    • Y : C

                      The source of the arrow.

                    • f : self.Y X

                      The arrow itself.

                    • hf : S.sieve.arrows self.f

                      The given arrow is contained in the given sieve.

                    Instances For
                      theorem CategoryTheory.GrothendieckTopology.Cover.Arrow.hf {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (self : S.Arrow) :
                      S.sieve.arrows self.f

                      The given arrow is contained in the given sieve.

                      theorem CategoryTheory.GrothendieckTopology.Cover.Relation.ext_iff {C : Type u} :
                      ∀ {inst : CategoryTheory.Category.{v, u} C} {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (x y : S.Relation), x = y x.Y₁ = y.Y₁ x.Y₂ = y.Y₂ x.Z = y.Z HEq x.g₁ y.g₁ HEq x.g₂ y.g₂ HEq x.f₁ y.f₁ HEq x.f₂ y.f₂
                      theorem CategoryTheory.GrothendieckTopology.Cover.Relation.ext {C : Type u} :
                      ∀ {inst : CategoryTheory.Category.{v, u} C} {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (x y : S.Relation), x.Y₁ = y.Y₁x.Y₂ = y.Y₂x.Z = y.ZHEq x.g₁ y.g₁HEq x.g₂ y.g₂HEq x.f₁ y.f₁HEq x.f₂ y.f₂x = y

                      An auxiliary structure, used to define S.index.

                      • Y₁ : C

                        The source of the first arrow.

                      • Y₂ : C

                        The source of the second arrow.

                      • Z : C

                        The source of the arrows defining the relation.

                      • g₁ : self.Z self.Y₁

                        The first arrow defining the relation.

                      • g₂ : self.Z self.Y₂

                        The second arrow defining the relation.

                      • f₁ : self.Y₁ X

                        The first arrow which is part of the relation.

                      • f₂ : self.Y₂ X

                        The second arrow which is part of the relation.

                      • h₁ : S.sieve.arrows self.f₁

                        The first arrow which is part of the relation is contained in the given sieve.

                      • h₂ : S.sieve.arrows self.f₂

                        The second arrow which is part of the relation is contained in the given sieve.

                      • w : CategoryTheory.CategoryStruct.comp self.g₁ self.f₁ = CategoryTheory.CategoryStruct.comp self.g₂ self.f₂

                        The relation itself.

                      Instances For
                        theorem CategoryTheory.GrothendieckTopology.Cover.Relation.h₁ {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (self : S.Relation) :
                        S.sieve.arrows self.f₁

                        The first arrow which is part of the relation is contained in the given sieve.

                        theorem CategoryTheory.GrothendieckTopology.Cover.Relation.h₂ {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (self : S.Relation) :
                        S.sieve.arrows self.f₂

                        The second arrow which is part of the relation is contained in the given sieve.

                        The relation itself.

                        @[simp]
                        theorem CategoryTheory.GrothendieckTopology.Cover.Arrow.map_Y {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {T : J.Cover X} (I : S.Arrow) (f : S T) :
                        (I.map f).Y = I.Y
                        @[simp]
                        theorem CategoryTheory.GrothendieckTopology.Cover.Arrow.map_f {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {T : J.Cover X} (I : S.Arrow) (f : S T) :
                        (I.map f).f = I.f
                        def CategoryTheory.GrothendieckTopology.Cover.Arrow.map {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {T : J.Cover X} (I : S.Arrow) (f : S T) :
                        T.Arrow

                        Map an Arrow along a refinement S ⟶ T.

                        Equations
                        • I.map f = { Y := I.Y, f := I.f, hf := }
                        Instances For
                          @[simp]
                          theorem CategoryTheory.GrothendieckTopology.Cover.Relation.map_Z {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {T : J.Cover X} (I : S.Relation) (f : S T) :
                          (I.map f).Z = I.Z
                          @[simp]
                          theorem CategoryTheory.GrothendieckTopology.Cover.Relation.map_g₂ {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {T : J.Cover X} (I : S.Relation) (f : S T) :
                          (I.map f).g₂ = I.g₂
                          @[simp]
                          theorem CategoryTheory.GrothendieckTopology.Cover.Relation.map_f₁ {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {T : J.Cover X} (I : S.Relation) (f : S T) :
                          (I.map f).f₁ = I.f₁
                          @[simp]
                          theorem CategoryTheory.GrothendieckTopology.Cover.Relation.map_Y₂ {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {T : J.Cover X} (I : S.Relation) (f : S T) :
                          (I.map f).Y₂ = I.Y₂
                          @[simp]
                          theorem CategoryTheory.GrothendieckTopology.Cover.Relation.map_f₂ {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {T : J.Cover X} (I : S.Relation) (f : S T) :
                          (I.map f).f₂ = I.f₂
                          @[simp]
                          theorem CategoryTheory.GrothendieckTopology.Cover.Relation.map_g₁ {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {T : J.Cover X} (I : S.Relation) (f : S T) :
                          (I.map f).g₁ = I.g₁
                          @[simp]
                          theorem CategoryTheory.GrothendieckTopology.Cover.Relation.map_Y₁ {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {T : J.Cover X} (I : S.Relation) (f : S T) :
                          (I.map f).Y₁ = I.Y₁
                          def CategoryTheory.GrothendieckTopology.Cover.Relation.map {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {T : J.Cover X} (I : S.Relation) (f : S T) :
                          T.Relation

                          Map a Relation along a refinement S ⟶ T.

                          Equations
                          • I.map f = { Y₁ := I.Y₁, Y₂ := I.Y₂, Z := I.Z, g₁ := I.g₁, g₂ := I.g₂, f₁ := I.f₁, f₂ := I.f₂, h₁ := , h₂ := , w := }
                          Instances For
                            @[simp]
                            theorem CategoryTheory.GrothendieckTopology.Cover.Relation.fst_Y {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (I : S.Relation) :
                            I.fst.Y = I.Y₁
                            @[simp]
                            theorem CategoryTheory.GrothendieckTopology.Cover.Relation.fst_f {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (I : S.Relation) :
                            I.fst.f = I.f₁

                            The first Arrow associated to a Relation. Used in defining index.

                            Equations
                            • I.fst = { Y := I.Y₁, f := I.f₁, hf := }
                            Instances For
                              @[simp]
                              theorem CategoryTheory.GrothendieckTopology.Cover.Relation.snd_Y {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (I : S.Relation) :
                              I.snd.Y = I.Y₂
                              @[simp]
                              theorem CategoryTheory.GrothendieckTopology.Cover.Relation.snd_f {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (I : S.Relation) :
                              I.snd.f = I.f₂

                              The second Arrow associated to a Relation. Used in defining index.

                              Equations
                              • I.snd = { Y := I.Y₂, f := I.f₂, hf := }
                              Instances For
                                @[simp]
                                theorem CategoryTheory.GrothendieckTopology.Cover.Relation.map_fst {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {T : J.Cover X} (I : S.Relation) (f : S T) :
                                I.fst.map f = (I.map f).fst
                                @[simp]
                                theorem CategoryTheory.GrothendieckTopology.Cover.Relation.map_snd {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {T : J.Cover X} (I : S.Relation) (f : S T) :
                                I.snd.map f = (I.map f).snd

                                Pull back a cover along a morphism.

                                Equations
                                Instances For
                                  @[simp]
                                  theorem CategoryTheory.GrothendieckTopology.Cover.Arrow.base_Y {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {J : CategoryTheory.GrothendieckTopology C} {f : Y X} {S : J.Cover X} (I : (S.pullback f).Arrow) :
                                  I.base.Y = I.Y
                                  @[simp]
                                  theorem CategoryTheory.GrothendieckTopology.Cover.Arrow.base_f {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {J : CategoryTheory.GrothendieckTopology C} {f : Y X} {S : J.Cover X} (I : (S.pullback f).Arrow) :
                                  def CategoryTheory.GrothendieckTopology.Cover.Arrow.base {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {J : CategoryTheory.GrothendieckTopology C} {f : Y X} {S : J.Cover X} (I : (S.pullback f).Arrow) :
                                  S.Arrow

                                  An arrow of S.pullback f gives rise to an arrow of S.

                                  Equations
                                  Instances For
                                    @[simp]
                                    theorem CategoryTheory.GrothendieckTopology.Cover.Relation.base_g₂ {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {J : CategoryTheory.GrothendieckTopology C} {f : Y X} {S : J.Cover X} (I : (S.pullback f).Relation) :
                                    I.base.g₂ = I.g₂
                                    @[simp]
                                    theorem CategoryTheory.GrothendieckTopology.Cover.Relation.base_g₁ {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {J : CategoryTheory.GrothendieckTopology C} {f : Y X} {S : J.Cover X} (I : (S.pullback f).Relation) :
                                    I.base.g₁ = I.g₁
                                    @[simp]
                                    theorem CategoryTheory.GrothendieckTopology.Cover.Relation.base_Y₂ {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {J : CategoryTheory.GrothendieckTopology C} {f : Y X} {S : J.Cover X} (I : (S.pullback f).Relation) :
                                    I.base.Y₂ = I.Y₂
                                    @[simp]
                                    theorem CategoryTheory.GrothendieckTopology.Cover.Relation.base_f₁ {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {J : CategoryTheory.GrothendieckTopology C} {f : Y X} {S : J.Cover X} (I : (S.pullback f).Relation) :
                                    @[simp]
                                    theorem CategoryTheory.GrothendieckTopology.Cover.Relation.base_Y₁ {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {J : CategoryTheory.GrothendieckTopology C} {f : Y X} {S : J.Cover X} (I : (S.pullback f).Relation) :
                                    I.base.Y₁ = I.Y₁
                                    @[simp]
                                    theorem CategoryTheory.GrothendieckTopology.Cover.Relation.base_Z {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {J : CategoryTheory.GrothendieckTopology C} {f : Y X} {S : J.Cover X} (I : (S.pullback f).Relation) :
                                    I.base.Z = I.Z
                                    @[simp]
                                    theorem CategoryTheory.GrothendieckTopology.Cover.Relation.base_f₂ {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {J : CategoryTheory.GrothendieckTopology C} {f : Y X} {S : J.Cover X} (I : (S.pullback f).Relation) :
                                    def CategoryTheory.GrothendieckTopology.Cover.Relation.base {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {J : CategoryTheory.GrothendieckTopology C} {f : Y X} {S : J.Cover X} (I : (S.pullback f).Relation) :
                                    S.Relation

                                    A relation of S.pullback f gives rise to a relation of S.

                                    Equations
                                    Instances For
                                      @[simp]
                                      theorem CategoryTheory.GrothendieckTopology.Cover.Relation.base_fst {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {J : CategoryTheory.GrothendieckTopology C} {f : Y X} {S : J.Cover X} (I : (S.pullback f).Relation) :
                                      I.fst.base = I.base.fst
                                      @[simp]
                                      theorem CategoryTheory.GrothendieckTopology.Cover.Relation.base_snd {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {J : CategoryTheory.GrothendieckTopology C} {f : Y X} {S : J.Cover X} (I : (S.pullback f).Relation) :
                                      I.snd.base = I.base.snd
                                      @[simp]
                                      theorem CategoryTheory.GrothendieckTopology.Cover.coe_pullback {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {J : CategoryTheory.GrothendieckTopology C} {Z : C} (f : Y X) (g : Z Y) (S : J.Cover X) :
                                      (S.pullback f).sieve.arrows g S.sieve.arrows (CategoryTheory.CategoryStruct.comp g f)

                                      The isomorphism between S and the pullback of S w.r.t. the identity.

                                      Equations
                                      Instances For
                                        def CategoryTheory.GrothendieckTopology.Cover.pullbackComp {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} {Y : C} {Z : C} (S : J.Cover X) (f : Z Y) (g : Y X) :
                                        S.pullback (CategoryTheory.CategoryStruct.comp f g) (S.pullback g).pullback f

                                        Pulling back with respect to a composition is the composition of the pullbacks.

                                        Equations
                                        Instances For
                                          def CategoryTheory.GrothendieckTopology.Cover.bind {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} (S : J.Cover X) (T : (I : S.Arrow) → J.Cover I.Y) :
                                          J.Cover X

                                          Combine a family of covers over a cover.

                                          Equations
                                          • S.bind T = CategoryTheory.Sieve.bind S.sieve.arrows fun (Y : C) (f : Y X) (hf : S.sieve.arrows f) => (T { Y := Y, f := f, hf := hf }).sieve,
                                          Instances For
                                            def CategoryTheory.GrothendieckTopology.Cover.bindToBase {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} (S : J.Cover X) (T : (I : S.Arrow) → J.Cover I.Y) :
                                            S.bind T S

                                            The canonical morphism from S.bind T to T.

                                            Equations
                                            Instances For
                                              noncomputable def CategoryTheory.GrothendieckTopology.Cover.Arrow.middle {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} {S : J.Cover X} {T : (I : S.Arrow) → J.Cover I.Y} (I : (S.bind T).Arrow) :
                                              C

                                              An arrow in bind has the form A ⟶ B ⟶ X where A ⟶ B is an arrow in T I for some I. and B ⟶ X is an arrow of S. This is the object B.

                                              Equations
                                              Instances For
                                                noncomputable def CategoryTheory.GrothendieckTopology.Cover.Arrow.toMiddleHom {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} {S : J.Cover X} {T : (I : S.Arrow) → J.Cover I.Y} (I : (S.bind T).Arrow) :
                                                I.Y I.middle

                                                An arrow in bind has the form A ⟶ B ⟶ X where A ⟶ B is an arrow in T I for some I. and B ⟶ X is an arrow of S. This is the hom A ⟶ B.

                                                Equations
                                                • I.toMiddleHom = .choose
                                                Instances For
                                                  noncomputable def CategoryTheory.GrothendieckTopology.Cover.Arrow.fromMiddleHom {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} {S : J.Cover X} {T : (I : S.Arrow) → J.Cover I.Y} (I : (S.bind T).Arrow) :
                                                  I.middle X

                                                  An arrow in bind has the form A ⟶ B ⟶ X where A ⟶ B is an arrow in T I for some I. and B ⟶ X is an arrow of S. This is the hom B ⟶ X.

                                                  Equations
                                                  • I.fromMiddleHom = .choose
                                                  Instances For
                                                    theorem CategoryTheory.GrothendieckTopology.Cover.Arrow.from_middle_condition {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} {S : J.Cover X} {T : (I : S.Arrow) → J.Cover I.Y} (I : (S.bind T).Arrow) :
                                                    S.sieve.arrows I.fromMiddleHom
                                                    noncomputable def CategoryTheory.GrothendieckTopology.Cover.Arrow.fromMiddle {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} {S : J.Cover X} {T : (I : S.Arrow) → J.Cover I.Y} (I : (S.bind T).Arrow) :
                                                    S.Arrow

                                                    An arrow in bind has the form A ⟶ B ⟶ X where A ⟶ B is an arrow in T I for some I. and B ⟶ X is an arrow of S. This is the hom B ⟶ X, as an arrow.

                                                    Equations
                                                    • I.fromMiddle = { Y := I.middle, f := I.fromMiddleHom, hf := }
                                                    Instances For
                                                      theorem CategoryTheory.GrothendieckTopology.Cover.Arrow.to_middle_condition {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} {S : J.Cover X} {T : (I : S.Arrow) → J.Cover I.Y} (I : (S.bind T).Arrow) :
                                                      (T I.fromMiddle).sieve.arrows I.toMiddleHom
                                                      noncomputable def CategoryTheory.GrothendieckTopology.Cover.Arrow.toMiddle {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} {S : J.Cover X} {T : (I : S.Arrow) → J.Cover I.Y} (I : (S.bind T).Arrow) :
                                                      (T I.fromMiddle).Arrow

                                                      An arrow in bind has the form A ⟶ B ⟶ X where A ⟶ B is an arrow in T I for some I. and B ⟶ X is an arrow of S. This is the hom A ⟶ B, as an arrow.

                                                      Equations
                                                      • I.toMiddle = { Y := I.Y, f := I.toMiddleHom, hf := }
                                                      Instances For
                                                        theorem CategoryTheory.GrothendieckTopology.Cover.Arrow.middle_spec {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} {S : J.Cover X} {T : (I : S.Arrow) → J.Cover I.Y} (I : (S.bind T).Arrow) :
                                                        CategoryTheory.CategoryStruct.comp I.toMiddleHom I.fromMiddleHom = I.f

                                                        To every S : J.Cover X and presheaf P, associate a MulticospanIndex.

                                                        Equations
                                                        • One or more equations did not get rendered due to their size.
                                                        Instances For
                                                          @[reducible, inline]

                                                          The natural multifork associated to S : J.Cover X for a presheaf P. Saying that this multifork is a limit is essentially equivalent to the sheaf condition at the given object for the given covering sieve. See Sheaf.lean for an equivalent sheaf condition using this.

                                                          Equations
                                                          Instances For
                                                            @[reducible, inline]

                                                            The canonical map from P.obj (op X) to the multiequalizer associated to a covering sieve, assuming such a multiequalizer exists. This will be used in Sheaf.lean to provide an equivalent sheaf condition in terms of multiequalizers.

                                                            Equations
                                                            Instances For
                                                              @[simp]
                                                              theorem CategoryTheory.GrothendieckTopology.pullback_obj {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} (J : CategoryTheory.GrothendieckTopology C) (f : Y X) (S : J.Cover X) :
                                                              (J.pullback f).obj S = S.pullback f

                                                              Pull back a cover along a morphism.

                                                              Equations
                                                              • J.pullback f = { obj := fun (S : J.Cover X) => S.pullback f, map := fun {X_1 Y_1 : J.Cover X} (f_1 : X_1 Y_1) => .hom, map_id := , map_comp := }
                                                              Instances For

                                                                Pulling back along the identity is naturally isomorphic to the identity functor.

                                                                Equations
                                                                Instances For
                                                                  def CategoryTheory.GrothendieckTopology.pullbackComp {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {X : C} {Y : C} {Z : C} (f : X Y) (g : Y Z) :
                                                                  J.pullback (CategoryTheory.CategoryStruct.comp f g) (J.pullback g).comp (J.pullback f)

                                                                  Pulling back along a composition is naturally isomorphic to the composition of the pullbacks.

                                                                  Equations
                                                                  Instances For