File: Mathlib/CategoryTheory/Sites/Grothendieck.lean

full_name: CategoryTheory.GrothendieckTopology.sieves
code: /-- 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.
-/
structure GrothendieckTopology where
  /-- A Grothendieck topology on `C` consists of a set of sieves for each object `X`,
    which satisfy some axioms. -/
  sieves : ∀ X : C, Set (Sieve X)
  /-- The sieves associated to each object must contain the top sieve.
    Use `GrothendieckTopology.top_mem`. -/
  top_mem' : ∀ X, ⊤ ∈ sieves X
  /-- Stability under pullback. Use `GrothendieckTopology.pullback_stable`. -/
  pullback_stable' : ∀ ⦃X Y : C⦄ ⦃S : Sieve X⦄ (f : Y ⟶ X), S ∈ sieves X → S.pullback f ∈ sieves Y
  /-- Transitivity of sieves in a Grothendieck topology.
    Use `GrothendieckTopology.transitive`. -/
  transitive' :
    ∀ ⦃X⦄ ⦃S : Sieve X⦄ (_ : S ∈ sieves X) (R : Sieve X),
      (∀ ⦃Y⦄ ⦃f : Y ⟶ X⦄, S f → R.pullback f ∈ sieves Y) → R ∈ sieves X
goal: Set (CategoryTheory.Sieve X)

full_name: CategoryTheory.GrothendieckTopology.pullback_stable'
code: /-- 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.
-/
structure GrothendieckTopology where
  /-- A Grothendieck topology on `C` consists of a set of sieves for each object `X`,
    which satisfy some axioms. -/
  sieves : ∀ X : C, Set (Sieve X)
  /-- The sieves associated to each object must contain the top sieve.
    Use `GrothendieckTopology.top_mem`. -/
  top_mem' : ∀ X, ⊤ ∈ sieves X
  /-- Stability under pullback. Use `GrothendieckTopology.pullback_stable`. -/
  pullback_stable' : ∀ ⦃X Y : C⦄ ⦃S : Sieve X⦄ (f : Y ⟶ X), S ∈ sieves X → S.pullback f ∈ sieves Y
  /-- Transitivity of sieves in a Grothendieck topology.
    Use `GrothendieckTopology.transitive`. -/
  transitive' :
    ∀ ⦃X⦄ ⦃S : Sieve X⦄ (_ : S ∈ sieves X) (R : Sieve X),
      (∀ ⦃Y⦄ ⦃f : Y ⟶ X⦄, S f → R.pullback f ∈ sieves Y) → R ∈ sieves X
goal: S ∈ self.sieves X → CategoryTheory.Sieve.pullback f S ∈ self.sieves Y

full_name: CategoryTheory.GrothendieckTopology
code: /-- 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.
-/
structure GrothendieckTopology where
  /-- A Grothendieck topology on `C` consists of a set of sieves for each object `X`,
    which satisfy some axioms. -/
  sieves : ∀ X : C, Set (Sieve X)
  /-- The sieves associated to each object must contain the top sieve.
    Use `GrothendieckTopology.top_mem`. -/
  top_mem' : ∀ X, ⊤ ∈ sieves X
  /-- Stability under pullback. Use `GrothendieckTopology.pullback_stable`. -/
  pullback_stable' : ∀ ⦃X Y : C⦄ ⦃S : Sieve X⦄ (f : Y ⟶ X), S ∈ sieves X → S.pullback f ∈ sieves Y
  /-- Transitivity of sieves in a Grothendieck topology.
    Use `GrothendieckTopology.transitive`. -/
  transitive' :
    ∀ ⦃X⦄ ⦃S : Sieve X⦄ (_ : S ∈ sieves X) (R : Sieve X),
      (∀ ⦃Y⦄ ⦃f : Y ⟶ X⦄, S f → R.pullback f ∈ sieves Y) → R ∈ sieves X
goal: Type (max u v)

full_name: CategoryTheory.GrothendieckTopology.transitive'
code: /-- 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.
-/
structure GrothendieckTopology where
  /-- A Grothendieck topology on `C` consists of a set of sieves for each object `X`,
    which satisfy some axioms. -/
  sieves : ∀ X : C, Set (Sieve X)
  /-- The sieves associated to each object must contain the top sieve.
    Use `GrothendieckTopology.top_mem`. -/
  top_mem' : ∀ X, ⊤ ∈ sieves X
  /-- Stability under pullback. Use `GrothendieckTopology.pullback_stable`. -/
  pullback_stable' : ∀ ⦃X Y : C⦄ ⦃S : Sieve X⦄ (f : Y ⟶ X), S ∈ sieves X → S.pullback f ∈ sieves Y
  /-- Transitivity of sieves in a Grothendieck topology.
    Use `GrothendieckTopology.transitive`. -/
  transitive' :
    ∀ ⦃X⦄ ⦃S : Sieve X⦄ (_ : S ∈ sieves X) (R : Sieve X),
      (∀ ⦃Y⦄ ⦃f : Y ⟶ X⦄, S f → R.pullback f ∈ sieves Y) → R ∈ sieves X
goal: S ∈ self.sieves X →
  ∀ (R : CategoryTheory.Sieve X),
    (∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, S.arrows f → CategoryTheory.Sieve.pullback f R ∈ self.sieves Y) → R ∈ self.sieves X

full_name: CategoryTheory.GrothendieckTopology.top_mem'
code: /-- 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.
-/
structure GrothendieckTopology where
  /-- A Grothendieck topology on `C` consists of a set of sieves for each object `X`,
    which satisfy some axioms. -/
  sieves : ∀ X : C, Set (Sieve X)
  /-- The sieves associated to each object must contain the top sieve.
    Use `GrothendieckTopology.top_mem`. -/
  top_mem' : ∀ X, ⊤ ∈ sieves X
  /-- Stability under pullback. Use `GrothendieckTopology.pullback_stable`. -/
  pullback_stable' : ∀ ⦃X Y : C⦄ ⦃S : Sieve X⦄ (f : Y ⟶ X), S ∈ sieves X → S.pullback f ∈ sieves Y
  /-- Transitivity of sieves in a Grothendieck topology.
    Use `GrothendieckTopology.transitive`. -/
  transitive' :
    ∀ ⦃X⦄ ⦃S : Sieve X⦄ (_ : S ∈ sieves X) (R : Sieve X),
      (∀ ⦃Y⦄ ⦃f : Y ⟶ X⦄, S f → R.pullback f ∈ sieves Y) → R ∈ sieves X
goal: ⊤ ∈ self.sieves X

full_name: CategoryTheory.GrothendieckTopology.instCoeFunForallSetSieve
code: instance : CoeFun (GrothendieckTopology C) fun _ => ∀ X : C, Set (Sieve X) 
goal: CoeFun (CategoryTheory.GrothendieckTopology C) fun x => (X : C) → Set (CategoryTheory.Sieve X)

full_name: CategoryTheory.GrothendieckTopology.ext
code: /-- 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`.
-/
@[ext]
theorem ext {J₁ J₂ : GrothendieckTopology C} (h : (J₁ : ∀ X : C, Set (Sieve X)) = J₂) :
    J₁ = J₂ 
goal: J₁ = J₂

full_name: CategoryTheory.GrothendieckTopology.top_mem
code: /-- Also known as the maximality axiom. -/
@[simp]
theorem top_mem (X : C) : ⊤ ∈ J X 
goal: ⊤ ∈ J.sieves X

full_name: CategoryTheory.GrothendieckTopology.pullback_stable
code: /-- Also known as the stability axiom. -/
@[simp]
theorem pullback_stable (f : Y ⟶ X) (hS : S ∈ J X) : S.pullback f ∈ J Y 
goal: CategoryTheory.Sieve.pullback f S ∈ J.sieves Y

full_name: CategoryTheory.GrothendieckTopology.pullback_mem_iff_of_isIso
code: @[simp]
lemma pullback_mem_iff_of_isIso {i : X ⟶ Y} [IsIso i] {S : Sieve Y} :
    S.pullback i ∈ J _ ↔ S ∈ J _ 
goal: CategoryTheory.Sieve.pullback i S ∈ J.sieves X ↔ S ∈ J.sieves Y

full_name: CategoryTheory.GrothendieckTopology.transitive
code: theorem transitive (hS : S ∈ J X) (R : Sieve X) (h : ∀ ⦃Y⦄ ⦃f : Y ⟶ X⦄, S f → R.pullback f ∈ J Y) :
    R ∈ J X 
goal: R ∈ J.sieves X

full_name: CategoryTheory.GrothendieckTopology.covering_of_eq_top
code: theorem covering_of_eq_top : S = ⊤ → S ∈ J X 
goal: S = ⊤ → S ∈ J.sieves X

full_name: CategoryTheory.GrothendieckTopology.superset_covering
code: /-- 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.
-/
theorem superset_covering (Hss : S ≤ R) (sjx : S ∈ J X) : R ∈ J X 
goal: R ∈ J.sieves X

full_name: CategoryTheory.GrothendieckTopology.intersection_covering
code: /-- 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 intersection_covering (rj : R ∈ J X) (sj : S ∈ J X) : R ⊓ S ∈ J X 
goal: R ⊓ S ∈ J.sieves X

full_name: CategoryTheory.GrothendieckTopology.intersection_covering_iff
code: @[simp]
theorem intersection_covering_iff : R ⊓ S ∈ J X ↔ R ∈ J X ∧ S ∈ J X 
goal: R ⊓ S ∈ J.sieves X ↔ R ∈ J.sieves X ∧ S ∈ J.sieves X

full_name: CategoryTheory.GrothendieckTopology.bind_covering
code: theorem bind_covering {S : Sieve X} {R : ∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, S f → Sieve Y} (hS : S ∈ J X)
    (hR : ∀ ⦃Y⦄ ⦃f : Y ⟶ X⦄ (H : S f), R H ∈ J Y) : Sieve.bind S R ∈ J X 
goal: CategoryTheory.Sieve.bind S.arrows R ∈ J.sieves X

full_name: CategoryTheory.GrothendieckTopology.Covers
code: /-- 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.
-/
def Covers (S : Sieve X) (f : Y ⟶ X) : Prop 
goal: Prop

full_name: CategoryTheory.GrothendieckTopology.covers_iff
code: theorem covers_iff (S : Sieve X) (f : Y ⟶ X) : J.Covers S f ↔ S.pullback f ∈ J Y 
goal: J.Covers S f ↔ CategoryTheory.Sieve.pullback f S ∈ J.sieves Y

full_name: CategoryTheory.GrothendieckTopology.covering_iff_covers_id
code: theorem covering_iff_covers_id (S : Sieve X) : S ∈ J X ↔ J.Covers S (𝟙 X) 
goal: S ∈ J.sieves X ↔ J.Covers S (CategoryTheory.CategoryStruct.id X)

full_name: CategoryTheory.GrothendieckTopology.arrow_max
code: /-- The maximality axiom in 'arrow' form: Any arrow `f` in `S` is covered by `S`. -/
theorem arrow_max (f : Y ⟶ X) (S : Sieve X) (hf : S f) : J.Covers S f 
goal: J.Covers S f

full_name: CategoryTheory.GrothendieckTopology.arrow_stable
code: /-- The stability axiom in 'arrow' form: If `S` covers `f` then `S` covers `g ≫ f` for any `g`. -/
theorem arrow_stable (f : Y ⟶ X) (S : Sieve X) (h : J.Covers S f) {Z : C} (g : Z ⟶ Y) :
    J.Covers S (g ≫ f) 
goal: J.Covers S (CategoryTheory.CategoryStruct.comp g f)

full_name: CategoryTheory.GrothendieckTopology.arrow_trans
code: /-- The transitivity axiom in 'arrow' form: If `S` covers `f` and every arrow in `S` is covered by
`R`, then `R` covers `f`.
-/
theorem arrow_trans (f : Y ⟶ X) (S R : Sieve X) (h : J.Covers S f) :
    (∀ {Z : C} (g : Z ⟶ X), S g → J.Covers R g) → J.Covers R f 
goal: (∀ {Z : C} (g : Z ⟶ X), S.arrows g → J.Covers R g) → J.Covers R f

full_name: CategoryTheory.GrothendieckTopology.arrow_intersect
code: theorem arrow_intersect (f : Y ⟶ X) (S R : Sieve X) (hS : J.Covers S f) (hR : J.Covers R f) :
    J.Covers (S ⊓ R) f 
goal: J.Covers (S ⊓ R) f

full_name: CategoryTheory.GrothendieckTopology.trivial
code: /-- 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
-/
def trivial : GrothendieckTopology C 
goal: CategoryTheory.GrothendieckTopology C

full_name: CategoryTheory.GrothendieckTopology.discrete
code: /-- The discrete Grothendieck topology, in which every sieve is covering.

See https://en.wikipedia.org/wiki/Grothendieck_topology#The_discrete_and_indiscrete_topologies.
-/
def discrete : GrothendieckTopology C 
goal: CategoryTheory.GrothendieckTopology C

full_name: CategoryTheory.GrothendieckTopology.trivial_covering
code: theorem trivial_covering : S ∈ trivial C X ↔ S = ⊤ 
goal: S ∈ (CategoryTheory.GrothendieckTopology.trivial C).sieves X ↔ S = ⊤

full_name: CategoryTheory.GrothendieckTopology.instLEGrothendieckTopology
code: /-- See <https://stacks.math.columbia.edu/tag/00Z6> -/
instance instLEGrothendieckTopology : LE (GrothendieckTopology C) 
goal: LE (CategoryTheory.GrothendieckTopology C)

full_name: CategoryTheory.GrothendieckTopology.le_def
code: theorem le_def {J₁ J₂ : GrothendieckTopology C} : J₁ ≤ J₂ ↔ (J₁ : ∀ X : C, Set (Sieve X)) ≤ J₂ 
goal: J₁ ≤ J₂ ↔ J₁.sieves ≤ J₂.sieves

full_name: CategoryTheory.GrothendieckTopology.instPartialOrder
code: /-- See <https://stacks.math.columbia.edu/tag/00Z6> -/
instance : PartialOrder (GrothendieckTopology C) 
goal: PartialOrder (CategoryTheory.GrothendieckTopology C)

full_name: CategoryTheory.GrothendieckTopology.instInfSet
code: /-- See <https://stacks.math.columbia.edu/tag/00Z7> -/
instance : InfSet (GrothendieckTopology C) 
goal: InfSet (CategoryTheory.GrothendieckTopology C)

full_name: CategoryTheory.GrothendieckTopology.isGLB_sInf
code: /-- See <https://stacks.math.columbia.edu/tag/00Z7> -/
theorem isGLB_sInf (s : Set (GrothendieckTopology C)) : IsGLB s (sInf s) 
goal: IsGLB s (sInf s)

full_name: CategoryTheory.GrothendieckTopology.instCompleteLattice
code: /-- Construct a complete lattice from the `Inf`, but make the trivial and discrete topologies
definitionally equal to the bottom and top respectively.
-/
instance : CompleteLattice (GrothendieckTopology C) 
goal: CompleteLattice (CategoryTheory.GrothendieckTopology C)

full_name: CategoryTheory.GrothendieckTopology.instInhabited
code: instance : Inhabited (GrothendieckTopology C) 
goal: Inhabited (CategoryTheory.GrothendieckTopology C)

full_name: CategoryTheory.GrothendieckTopology.trivial_eq_bot
code: @[simp]
theorem trivial_eq_bot : trivial C = ⊥ 
goal: CategoryTheory.GrothendieckTopology.trivial C = ⊥

full_name: CategoryTheory.GrothendieckTopology.discrete_eq_top
code: @[simp]
theorem discrete_eq_top : discrete C = ⊤ 
goal: CategoryTheory.GrothendieckTopology.discrete C = ⊤

full_name: CategoryTheory.GrothendieckTopology.bot_covering
code: @[simp]
theorem bot_covering : S ∈ (⊥ : GrothendieckTopology C) X ↔ S = ⊤ 
goal: S ∈ ⊥.sieves X ↔ S = ⊤

full_name: CategoryTheory.GrothendieckTopology.top_covering
code: @[simp]
theorem top_covering : S ∈ (⊤ : GrothendieckTopology C) X 
goal: S ∈ ⊤.sieves X

full_name: CategoryTheory.GrothendieckTopology.bot_covers
code: theorem bot_covers (S : Sieve X) (f : Y ⟶ X) : (⊥ : GrothendieckTopology C).Covers S f ↔ S f 
goal: ⊥.Covers S f ↔ S.arrows f

full_name: CategoryTheory.GrothendieckTopology.top_covers
code: @[simp]
theorem top_covers (S : Sieve X) (f : Y ⟶ X) : (⊤ : GrothendieckTopology C).Covers S f 
goal: ⊤.Covers S f

full_name: CategoryTheory.GrothendieckTopology.dense
code: /-- The dense Grothendieck topology.

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

full_name: CategoryTheory.GrothendieckTopology.dense_covering
code: theorem dense_covering : S ∈ dense X ↔ ∀ {Y} (f : Y ⟶ X), ∃ (Z : _) (g : Z ⟶ Y), S (g ≫ f) 
goal: S ∈ CategoryTheory.GrothendieckTopology.dense.sieves X ↔
  ∀ {Y : C} (f : Y ⟶ X), ∃ Z g, S.arrows (CategoryTheory.CategoryStruct.comp g f)

full_name: CategoryTheory.GrothendieckTopology.RightOreCondition
code: /--
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`.
-/
def RightOreCondition (C : Type u) [Category.{v} C] : Prop 
goal: Prop

full_name: CategoryTheory.GrothendieckTopology.right_ore_of_pullbacks
code: theorem right_ore_of_pullbacks [Limits.HasPullbacks C] : RightOreCondition C 
goal: CategoryTheory.GrothendieckTopology.RightOreCondition C

full_name: CategoryTheory.GrothendieckTopology.atomic
code: /-- 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).
-/
def atomic (hro : RightOreCondition C) : GrothendieckTopology C 
goal: CategoryTheory.GrothendieckTopology C

full_name: CategoryTheory.GrothendieckTopology.Cover
code: /-- `J.Cover X` denotes the poset of covers of `X` with respect to the
Grothendieck topology `J`. -/
-- Porting note: Lean 3 inferred `Type max u v`, Lean 4 by default gives `Type (max 0 u v)`
def Cover (X : C) : Type max u v 
goal: Type (max u v)

full_name: CategoryTheory.GrothendieckTopology.instPreorderCover
code: instance (X : C) : Preorder (J.Cover X) 
goal: Preorder (J.Cover X)

full_name: CategoryTheory.GrothendieckTopology.Cover.sieve
code: /-- The sieve associated to a term of `J.Cover X`. -/
def sieve (S : J.Cover X) : Sieve X 
goal: CategoryTheory.Sieve X

full_name: CategoryTheory.GrothendieckTopology.Cover.instCoeFunForallForallHomProp
code: instance : CoeFun (J.Cover X) fun _ => ∀ ⦃Y⦄ (_ : Y ⟶ X), Prop 
goal: CoeFun (J.Cover X) fun x => ⦃Y : C⦄ → (Y ⟶ X) → Prop

full_name: CategoryTheory.GrothendieckTopology.Cover.condition
code: theorem condition (S : J.Cover X) : S.sieve ∈ J X 
goal: S.sieve ∈ J.sieves X

full_name: CategoryTheory.GrothendieckTopology.Cover.ext
code: @[ext]
theorem ext (S T : J.Cover X) (h : ∀ ⦃Y⦄ (f : Y ⟶ X), S f ↔ T f) : S = T 
goal: S = T

full_name: CategoryTheory.GrothendieckTopology.Cover.instOrderTop
code: instance : OrderTop (J.Cover X) 
goal: OrderTop (J.Cover X)

full_name: CategoryTheory.GrothendieckTopology.Cover.instSemilatticeInf
code: instance : SemilatticeInf (J.Cover X) 
goal: SemilatticeInf (J.Cover X)

full_name: CategoryTheory.GrothendieckTopology.Cover.instInhabited
code: instance : Inhabited (J.Cover X) 
goal: Inhabited (J.Cover X)

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.hf
code: /-- An auxiliary structure, used to define `S.index`. -/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
@[ext]
structure Arrow (S : J.Cover X) where
  /-- The source of the arrow. -/
  Y : C
  /-- The arrow itself. -/
  f : Y ⟶ X
  /-- The given arrow is contained in the given sieve. -/
  hf : S f
goal: S.sieve.arrows self.f

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow
code: /-- An auxiliary structure, used to define `S.index`. -/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
@[ext]
structure Arrow (S : J.Cover X) where
  /-- The source of the arrow. -/
  Y : C
  /-- The arrow itself. -/
  f : Y ⟶ X
  /-- The given arrow is contained in the given sieve. -/
  hf : S f
goal: Type (max u v)

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.Y
code: /-- An auxiliary structure, used to define `S.index`. -/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
@[ext]
structure Arrow (S : J.Cover X) where
  /-- The source of the arrow. -/
  Y : C
  /-- The arrow itself. -/
  f : Y ⟶ X
  /-- The given arrow is contained in the given sieve. -/
  hf : S f
goal: C

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.f
code: /-- An auxiliary structure, used to define `S.index`. -/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
@[ext]
structure Arrow (S : J.Cover X) where
  /-- The source of the arrow. -/
  Y : C
  /-- The arrow itself. -/
  f : Y ⟶ X
  /-- The given arrow is contained in the given sieve. -/
  hf : S f
goal: self.Y ⟶ X

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation.w
code: /-- Relation between two elements in `S.arrow`, the data of which
involves a commutative square. -/
@[ext]
structure Arrow.Relation {S : J.Cover X} (I₁ I₂ : S.Arrow) where
  /-- The source of the arrows defining the relation. -/
  Z : C
  /-- The first arrow defining the relation. -/
  g₁ : Z ⟶ I₁.Y
  /-- The second arrow defining the relation. -/
  g₂ : Z ⟶ I₂.Y
  /-- The relation itself. -/
  w : g₁ ≫ I₁.f = g₂ ≫ I₂.f := by aesop_cat
goal: CategoryTheory.CategoryStruct.comp self.g₁ I₁.f = CategoryTheory.CategoryStruct.comp self.g₂ I₂.f

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation.g₂
code: /-- Relation between two elements in `S.arrow`, the data of which
involves a commutative square. -/
@[ext]
structure Arrow.Relation {S : J.Cover X} (I₁ I₂ : S.Arrow) where
  /-- The source of the arrows defining the relation. -/
  Z : C
  /-- The first arrow defining the relation. -/
  g₁ : Z ⟶ I₁.Y
  /-- The second arrow defining the relation. -/
  g₂ : Z ⟶ I₂.Y
  /-- The relation itself. -/
  w : g₁ ≫ I₁.f = g₂ ≫ I₂.f := by aesop_cat
goal: self.Z ⟶ I₂.Y

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation.Z
code: /-- Relation between two elements in `S.arrow`, the data of which
involves a commutative square. -/
@[ext]
structure Arrow.Relation {S : J.Cover X} (I₁ I₂ : S.Arrow) where
  /-- The source of the arrows defining the relation. -/
  Z : C
  /-- The first arrow defining the relation. -/
  g₁ : Z ⟶ I₁.Y
  /-- The second arrow defining the relation. -/
  g₂ : Z ⟶ I₂.Y
  /-- The relation itself. -/
  w : g₁ ≫ I₁.f = g₂ ≫ I₂.f := by aesop_cat
goal: C

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation
code: /-- Relation between two elements in `S.arrow`, the data of which
involves a commutative square. -/
@[ext]
structure Arrow.Relation {S : J.Cover X} (I₁ I₂ : S.Arrow) where
  /-- The source of the arrows defining the relation. -/
  Z : C
  /-- The first arrow defining the relation. -/
  g₁ : Z ⟶ I₁.Y
  /-- The second arrow defining the relation. -/
  g₂ : Z ⟶ I₂.Y
  /-- The relation itself. -/
  w : g₁ ≫ I₁.f = g₂ ≫ I₂.f := by aesop_cat
goal: Type (max u v)

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation.g₁
code: /-- Relation between two elements in `S.arrow`, the data of which
involves a commutative square. -/
@[ext]
structure Arrow.Relation {S : J.Cover X} (I₁ I₂ : S.Arrow) where
  /-- The source of the arrows defining the relation. -/
  Z : C
  /-- The first arrow defining the relation. -/
  g₁ : Z ⟶ I₁.Y
  /-- The second arrow defining the relation. -/
  g₂ : Z ⟶ I₂.Y
  /-- The relation itself. -/
  w : g₁ ≫ I₁.f = g₂ ≫ I₂.f := by aesop_cat
goal: self.Z ⟶ I₁.Y

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.precomp_f
code: /-- Given `I : S.Arrow` and a morphism `g : Z ⟶ I.Y`, this is the arrow in `S.Arrow`
corresponding to `g ≫ I.f`. -/
@[simps]
def Arrow.precomp {S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y) : S.Arrow 
goal: (I.precomp g).f = CategoryTheory.CategoryStruct.comp g I.f

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.precomp_Y
code: /-- Given `I : S.Arrow` and a morphism `g : Z ⟶ I.Y`, this is the arrow in `S.Arrow`
corresponding to `g ≫ I.f`. -/
@[simps]
def Arrow.precomp {S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y) : S.Arrow 
goal: (I.precomp g).Y = Z

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.precomp
code: /-- Given `I : S.Arrow` and a morphism `g : Z ⟶ I.Y`, this is the arrow in `S.Arrow`
corresponding to `g ≫ I.f`. -/
@[simps]
def Arrow.precomp {S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y) : S.Arrow 
goal: S.Arrow

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.precompRelation_g₁
code: /-- Given `I : S.Arrow` and a morphism `g : Z ⟶ I.Y`, this is the obvious relation
from `I.precomp g` to `I`. -/
@[simps]
def Arrow.precompRelation {S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y) :
    (I.precomp g).Relation I 
goal: (I.precompRelation g).g₁ = CategoryTheory.CategoryStruct.id (I.precomp g).Y

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.precompRelation
code: /-- Given `I : S.Arrow` and a morphism `g : Z ⟶ I.Y`, this is the obvious relation
from `I.precomp g` to `I`. -/
@[simps]
def Arrow.precompRelation {S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y) :
    (I.precomp g).Relation I 
goal: (I.precomp g).Relation I

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.precompRelation_g₂
code: /-- Given `I : S.Arrow` and a morphism `g : Z ⟶ I.Y`, this is the obvious relation
from `I.precomp g` to `I`. -/
@[simps]
def Arrow.precompRelation {S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y) :
    (I.precomp g).Relation I 
goal: (I.precompRelation g).g₂ = g

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.precompRelation_Z
code: /-- Given `I : S.Arrow` and a morphism `g : Z ⟶ I.Y`, this is the obvious relation
from `I.precomp g` to `I`. -/
@[simps]
def Arrow.precompRelation {S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y) :
    (I.precomp g).Relation I 
goal: (I.precompRelation g).Z = (I.precomp g).Y

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.map_Y
code: /-- Map an `Arrow` along a refinement `S ⟶ T`. -/
@[simps]
def Arrow.map {S T : J.Cover X} (I : S.Arrow) (f : S ⟶ T) : T.Arrow 
goal: (I.map f).Y = I.Y

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.map_f
code: /-- Map an `Arrow` along a refinement `S ⟶ T`. -/
@[simps]
def Arrow.map {S T : J.Cover X} (I : S.Arrow) (f : S ⟶ T) : T.Arrow 
goal: (I.map f).f = I.f

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.map
code: /-- Map an `Arrow` along a refinement `S ⟶ T`. -/
@[simps]
def Arrow.map {S T : J.Cover X} (I : S.Arrow) (f : S ⟶ T) : T.Arrow 
goal: T.Arrow

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation.map
code: /-- Map an `Arrow.Relation` along a refinement `S ⟶ T`. -/
@[simps]
def Arrow.Relation.map {S T : J.Cover X} {I₁ I₂ : S.Arrow}
    (r : I₁.Relation I₂) (f : S ⟶ T) : (I₁.map f).Relation (I₂.map f) 
goal: (I₁.map f).Relation (I₂.map f)

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation.map_g₂
code: /-- Map an `Arrow.Relation` along a refinement `S ⟶ T`. -/
@[simps]
def Arrow.Relation.map {S T : J.Cover X} {I₁ I₂ : S.Arrow}
    (r : I₁.Relation I₂) (f : S ⟶ T) : (I₁.map f).Relation (I₂.map f) 
goal: (r.map f).g₂ = r.g₂

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation.map_g₁
code: /-- Map an `Arrow.Relation` along a refinement `S ⟶ T`. -/
@[simps]
def Arrow.Relation.map {S T : J.Cover X} {I₁ I₂ : S.Arrow}
    (r : I₁.Relation I₂) (f : S ⟶ T) : (I₁.map f).Relation (I₂.map f) 
goal: (r.map f).g₁ = r.g₁

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation.map_Z
code: /-- Map an `Arrow.Relation` along a refinement `S ⟶ T`. -/
@[simps]
def Arrow.Relation.map {S T : J.Cover X} {I₁ I₂ : S.Arrow}
    (r : I₁.Relation I₂) (f : S ⟶ T) : (I₁.map f).Relation (I₂.map f) 
goal: (r.map f).Z = r.Z

full_name: CategoryTheory.GrothendieckTopology.Cover.pullback
code: /-- Pull back a cover along a morphism. -/
def pullback (S : J.Cover X) (f : Y ⟶ X) : J.Cover Y 
goal: J.Cover Y

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.base_Y
code: /-- An arrow of `S.pullback f` gives rise to an arrow of `S`. -/
@[simps]
def Arrow.base {f : Y ⟶ X} {S : J.Cover X} (I : (S.pullback f).Arrow) : S.Arrow 
goal: I.base.Y = I.Y

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.base
code: /-- An arrow of `S.pullback f` gives rise to an arrow of `S`. -/
@[simps]
def Arrow.base {f : Y ⟶ X} {S : J.Cover X} (I : (S.pullback f).Arrow) : S.Arrow 
goal: S.Arrow

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.base_f
code: /-- An arrow of `S.pullback f` gives rise to an arrow of `S`. -/
@[simps]
def Arrow.base {f : Y ⟶ X} {S : J.Cover X} (I : (S.pullback f).Arrow) : S.Arrow 
goal: I.base.f = CategoryTheory.CategoryStruct.comp I.f f

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation.base
code: /-- A relation of `S.pullback f` gives rise to a relation of `S`. -/
def Arrow.Relation.base
    {f : Y ⟶ X} {S : J.Cover X} {I₁ I₂ : (S.pullback f).Arrow}
    (r : I₁.Relation I₂) : I₁.base.Relation I₂.base 
goal: I₁.base.Relation I₂.base

full_name: CategoryTheory.GrothendieckTopology.Cover.coe_pullback
code: @[simp]
theorem coe_pullback {Z : C} (f : Y ⟶ X) (g : Z ⟶ Y) (S : J.Cover X) :
    (S.pullback f) g ↔ S (g ≫ f) 
goal: (S.pullback f).sieve.arrows g ↔ S.sieve.arrows (CategoryTheory.CategoryStruct.comp g f)

full_name: CategoryTheory.GrothendieckTopology.Cover.pullbackId
code: /-- The isomorphism between `S` and the pullback of `S` w.r.t. the identity. -/
def pullbackId (S : J.Cover X) : S.pullback (𝟙 X) ≅ S 
goal: S.pullback (CategoryTheory.CategoryStruct.id X) ≅ S

full_name: CategoryTheory.GrothendieckTopology.Cover.pullbackComp
code: /-- Pulling back with respect to a composition is the composition of the pullbacks. -/
def pullbackComp {X Y Z : C} (S : J.Cover X) (f : Z ⟶ Y) (g : Y ⟶ X) :
    S.pullback (f ≫ g) ≅ (S.pullback g).pullback f 
goal: S.pullback (CategoryTheory.CategoryStruct.comp f g) ≅ (S.pullback g).pullback f

full_name: CategoryTheory.GrothendieckTopology.Cover.bind
code: /-- Combine a family of covers over a cover. -/
def bind {X : C} (S : J.Cover X) (T : ∀ I : S.Arrow, J.Cover I.Y) : J.Cover X 
goal: J.Cover X

full_name: CategoryTheory.GrothendieckTopology.Cover.bindToBase
code: /-- The canonical morphism from `S.bind T` to `T`. -/
def bindToBase {X : C} (S : J.Cover X) (T : ∀ I : S.Arrow, J.Cover I.Y) : S.bind T ⟶ S 
goal: S.bind T ⟶ S

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.middle
code: /-- 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`. -/
noncomputable def Arrow.middle {X : C} {S : J.Cover X} {T : ∀ I : S.Arrow, J.Cover I.Y}
    (I : (S.bind T).Arrow) : C 
goal: C

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.toMiddleHom
code: /-- 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`. -/
noncomputable def Arrow.toMiddleHom {X : C} {S : J.Cover X} {T : ∀ I : S.Arrow, J.Cover I.Y}
    (I : (S.bind T).Arrow) : I.Y ⟶ I.middle 
goal: I.Y ⟶ I.middle

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.fromMiddleHom
code: /-- 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`. -/
noncomputable def Arrow.fromMiddleHom {X : C} {S : J.Cover X} {T : ∀ I : S.Arrow, J.Cover I.Y}
    (I : (S.bind T).Arrow) : I.middle ⟶ X 
goal: I.middle ⟶ X

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.from_middle_condition
code: theorem Arrow.from_middle_condition {X : C} {S : J.Cover X} {T : ∀ I : S.Arrow, J.Cover I.Y}
    (I : (S.bind T).Arrow) : S I.fromMiddleHom 
goal: S.sieve.arrows I.fromMiddleHom

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.fromMiddle
code: /-- 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. -/
noncomputable def Arrow.fromMiddle {X : C} {S : J.Cover X} {T : ∀ I : S.Arrow, J.Cover I.Y}
    (I : (S.bind T).Arrow) : S.Arrow 
goal: S.Arrow

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.to_middle_condition
code: theorem Arrow.to_middle_condition {X : C} {S : J.Cover X} {T : ∀ I : S.Arrow, J.Cover I.Y}
    (I : (S.bind T).Arrow) : (T I.fromMiddle) I.toMiddleHom 
goal: (T I.fromMiddle).sieve.arrows I.toMiddleHom

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.toMiddle
code: /-- 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. -/
noncomputable def Arrow.toMiddle {X : C} {S : J.Cover X} {T : ∀ I : S.Arrow, J.Cover I.Y}
    (I : (S.bind T).Arrow) : (T I.fromMiddle).Arrow 
goal: (T I.fromMiddle).Arrow

full_name: CategoryTheory.GrothendieckTopology.Cover.Arrow.middle_spec
code: theorem Arrow.middle_spec {X : C} {S : J.Cover X} {T : ∀ I : S.Arrow, J.Cover I.Y}
    (I : (S.bind T).Arrow) : I.toMiddleHom ≫ I.fromMiddleHom = I.f 
goal: CategoryTheory.CategoryStruct.comp I.toMiddleHom I.fromMiddleHom = I.f

full_name: CategoryTheory.GrothendieckTopology.Cover.Relation.snd
code: /-- An auxiliary structure, used to define `S.index`. -/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance, ext]
@[ext]
structure Relation (S : J.Cover X) where
  /-- The first arrow. -/
  fst : S.Arrow
  /-- The second arrow. -/
  snd : S.Arrow
  /-- The relation between the two arrows. -/
  r : fst.Relation snd
goal: S.Arrow

full_name: CategoryTheory.GrothendieckTopology.Cover.Relation.r
code: /-- An auxiliary structure, used to define `S.index`. -/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance, ext]
@[ext]
structure Relation (S : J.Cover X) where
  /-- The first arrow. -/
  fst : S.Arrow
  /-- The second arrow. -/
  snd : S.Arrow
  /-- The relation between the two arrows. -/
  r : fst.Relation snd
goal: self.fst.Relation self.snd

full_name: CategoryTheory.GrothendieckTopology.Cover.Relation.fst
code: /-- An auxiliary structure, used to define `S.index`. -/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance, ext]
@[ext]
structure Relation (S : J.Cover X) where
  /-- The first arrow. -/
  fst : S.Arrow
  /-- The second arrow. -/
  snd : S.Arrow
  /-- The relation between the two arrows. -/
  r : fst.Relation snd
goal: S.Arrow

full_name: CategoryTheory.GrothendieckTopology.Cover.Relation
code: /-- An auxiliary structure, used to define `S.index`. -/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance, ext]
@[ext]
structure Relation (S : J.Cover X) where
  /-- The first arrow. -/
  fst : S.Arrow
  /-- The second arrow. -/
  snd : S.Arrow
  /-- The relation between the two arrows. -/
  r : fst.Relation snd
goal: Type (max u v)

full_name: CategoryTheory.GrothendieckTopology.Cover.Relation.mk'_r
code: /-- Constructor for `Cover.Relation` which takes as an input
`r : I₁.Relation I₂` with `I₁ I₂ : S.Arrow`. -/
@[simps]
def Relation.mk' {S : J.Cover X} {fst snd : S.Arrow} (r : fst.Relation snd) :
    S.Relation 
goal: (CategoryTheory.GrothendieckTopology.Cover.Relation.mk' r).r = r

full_name: CategoryTheory.GrothendieckTopology.Cover.Relation.mk'_fst
code: /-- Constructor for `Cover.Relation` which takes as an input
`r : I₁.Relation I₂` with `I₁ I₂ : S.Arrow`. -/
@[simps]
def Relation.mk' {S : J.Cover X} {fst snd : S.Arrow} (r : fst.Relation snd) :
    S.Relation 
goal: (CategoryTheory.GrothendieckTopology.Cover.Relation.mk' r).fst = fst

full_name: CategoryTheory.GrothendieckTopology.Cover.Relation.mk'_snd
code: /-- Constructor for `Cover.Relation` which takes as an input
`r : I₁.Relation I₂` with `I₁ I₂ : S.Arrow`. -/
@[simps]
def Relation.mk' {S : J.Cover X} {fst snd : S.Arrow} (r : fst.Relation snd) :
    S.Relation 
goal: (CategoryTheory.GrothendieckTopology.Cover.Relation.mk' r).snd = snd

full_name: CategoryTheory.GrothendieckTopology.Cover.Relation.mk'
code: /-- Constructor for `Cover.Relation` which takes as an input
`r : I₁.Relation I₂` with `I₁ I₂ : S.Arrow`. -/
@[simps]
def Relation.mk' {S : J.Cover X} {fst snd : S.Arrow} (r : fst.Relation snd) :
    S.Relation 
goal: S.Relation

full_name: CategoryTheory.GrothendieckTopology.Cover.index_sndTo
code: /-- To every `S : J.Cover X` and presheaf `P`, associate a `MulticospanIndex`. -/
@[simps]
def index {D : Type u₁} [Category.{v₁} D] (S : J.Cover X) (P : Cᵒᵖ ⥤ D) :
    Limits.MulticospanIndex D 
goal: (S.index P).sndTo I = I.snd

full_name: CategoryTheory.GrothendieckTopology.Cover.index_snd
code: /-- To every `S : J.Cover X` and presheaf `P`, associate a `MulticospanIndex`. -/
@[simps]
def index {D : Type u₁} [Category.{v₁} D] (S : J.Cover X) (P : Cᵒᵖ ⥤ D) :
    Limits.MulticospanIndex D 
goal: (S.index P).snd I = P.map I.r.g₂.op

full_name: CategoryTheory.GrothendieckTopology.Cover.index_fst
code: /-- To every `S : J.Cover X` and presheaf `P`, associate a `MulticospanIndex`. -/
@[simps]
def index {D : Type u₁} [Category.{v₁} D] (S : J.Cover X) (P : Cᵒᵖ ⥤ D) :
    Limits.MulticospanIndex D 
goal: (S.index P).fst I = P.map I.r.g₁.op

full_name: CategoryTheory.GrothendieckTopology.Cover.index_R
code: /-- To every `S : J.Cover X` and presheaf `P`, associate a `MulticospanIndex`. -/
@[simps]
def index {D : Type u₁} [Category.{v₁} D] (S : J.Cover X) (P : Cᵒᵖ ⥤ D) :
    Limits.MulticospanIndex D 
goal: (S.index P).R = S.Relation

full_name: CategoryTheory.GrothendieckTopology.Cover.index_fstTo
code: /-- To every `S : J.Cover X` and presheaf `P`, associate a `MulticospanIndex`. -/
@[simps]
def index {D : Type u₁} [Category.{v₁} D] (S : J.Cover X) (P : Cᵒᵖ ⥤ D) :
    Limits.MulticospanIndex D 
goal: (S.index P).fstTo I = I.fst

full_name: CategoryTheory.GrothendieckTopology.Cover.index_right
code: /-- To every `S : J.Cover X` and presheaf `P`, associate a `MulticospanIndex`. -/
@[simps]
def index {D : Type u₁} [Category.{v₁} D] (S : J.Cover X) (P : Cᵒᵖ ⥤ D) :
    Limits.MulticospanIndex D 
goal: (S.index P).right I = P.obj (Opposite.op I.r.Z)

full_name: CategoryTheory.GrothendieckTopology.Cover.index_L
code: /-- To every `S : J.Cover X` and presheaf `P`, associate a `MulticospanIndex`. -/
@[simps]
def index {D : Type u₁} [Category.{v₁} D] (S : J.Cover X) (P : Cᵒᵖ ⥤ D) :
    Limits.MulticospanIndex D 
goal: (S.index P).L = S.Arrow

full_name: CategoryTheory.GrothendieckTopology.Cover.index_left
code: /-- To every `S : J.Cover X` and presheaf `P`, associate a `MulticospanIndex`. -/
@[simps]
def index {D : Type u₁} [Category.{v₁} D] (S : J.Cover X) (P : Cᵒᵖ ⥤ D) :
    Limits.MulticospanIndex D 
goal: (S.index P).left I = P.obj (Opposite.op I.Y)

full_name: CategoryTheory.GrothendieckTopology.Cover.index
code: /-- To every `S : J.Cover X` and presheaf `P`, associate a `MulticospanIndex`. -/
@[simps]
def index {D : Type u₁} [Category.{v₁} D] (S : J.Cover X) (P : Cᵒᵖ ⥤ D) :
    Limits.MulticospanIndex D 
goal: CategoryTheory.Limits.MulticospanIndex D

full_name: CategoryTheory.GrothendieckTopology.Cover.multifork
code: /-- 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.
-/
abbrev multifork {D : Type u₁} [Category.{v₁} D] (S : J.Cover X) (P : Cᵒᵖ ⥤ D) :
    Limits.Multifork (S.index P) 
goal: CategoryTheory.Limits.Multifork (S.index P)

full_name: CategoryTheory.GrothendieckTopology.Cover.toMultiequalizer
code: /-- 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. -/
noncomputable abbrev toMultiequalizer {D : Type u₁} [Category.{v₁} D] (S : J.Cover X)
    (P : Cᵒᵖ ⥤ D) [Limits.HasMultiequalizer (S.index P)] :
    P.obj (Opposite.op X) ⟶ Limits.multiequalizer (S.index P) 
goal: P.obj (Opposite.op X) ⟶ CategoryTheory.Limits.multiequalizer (S.index P)

full_name: CategoryTheory.GrothendieckTopology.pullback_obj
code: /-- Pull back a cover along a morphism. -/
@[simps obj]
def pullback (f : Y ⟶ X) : J.Cover X ⥤ J.Cover Y 
goal: (J.pullback f).obj S = S.pullback f

full_name: CategoryTheory.GrothendieckTopology.pullback
code: /-- Pull back a cover along a morphism. -/
@[simps obj]
def pullback (f : Y ⟶ X) : J.Cover X ⥤ J.Cover Y 
goal: CategoryTheory.Functor (J.Cover X) (J.Cover Y)

full_name: CategoryTheory.GrothendieckTopology.pullbackId
code: /-- Pulling back along the identity is naturally isomorphic to the identity functor. -/
def pullbackId (X : C) : J.pullback (𝟙 X) ≅ 𝟭 _ 
goal: J.pullback (CategoryTheory.CategoryStruct.id X) ≅ CategoryTheory.Functor.id (J.Cover X)

full_name: CategoryTheory.GrothendieckTopology.pullbackComp
code: /-- Pulling back along a composition is naturally isomorphic to
the composition of the pullbacks. -/
def pullbackComp {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) :
    J.pullback (f ≫ g) ≅ J.pullback g ⋙ J.pullback f 
goal: J.pullback (CategoryTheory.CategoryStruct.comp f g) ≅ (J.pullback g).comp (J.pullback f)