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:

• The dense topology
• The atomic topology as well as the complete lattice structure on Grothendieck topologies (which gives two additional explicit topologies: the discrete and trivial topologies.)

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

• nLab, Grothendieck topology
• S. MacLane, I. Moerdijk, Sheaves in Geometry and Logic

Implementation notes

We use the definition of [nlab] and [MLM92] (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.

structure CategoryTheory.GrothendieckTopology (C : Type u) [CategoryTheory.Category.{v, u} C] : Type (max u v)

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 [MLM92] Chapter III, Section 2, Definition 1.

• sieves : (X : C) → Set (CategoryTheory.Sieve X)

  A Grothendieck topology on C consists of a set of sieves for each object X, which satisfy some axioms.

• top_mem' : ∀ (X : C), ⊤ ∈ self.sieves X

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

• pullback_stable' : ∀ ⦃X Y : C⦄ ⦃S : CategoryTheory.Sieve X⦄ (f : Y ⟶ X), S ∈ self.sieves X → CategoryTheory.Sieve.pullback f S ∈ self.sieves Y

  Stability under pullback. Use GrothendieckTopology.pullback_stable.

• transitive' : ∀ ⦃X : C⦄ ⦃S : CategoryTheory.Sieve X⦄, 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

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

instance CategoryTheory.GrothendieckTopology.instDFunLikeSetSieve (C : Type u) [CategoryTheory.Category.{v, u} C] : DFunLike (CategoryTheory.GrothendieckTopology C) C fun (X : C) => Set (CategoryTheory.Sieve X)

Equations

• CategoryTheory.GrothendieckTopology.instDFunLikeSetSieve C = { coe := fun (J : CategoryTheory.GrothendieckTopology C) (X : C) => J.sieves X, coe_injective' := ⋯ }

theorem CategoryTheory.GrothendieckTopology.ext {C : Type u} [CategoryTheory.Category.{v, u} C] {J₁ J₂ : CategoryTheory.GrothendieckTopology C} (h : ⇑J₁ = ⇑J₂) : J₁ = J₂

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]

theorem CategoryTheory.GrothendieckTopology.mem_sieves_iff_coe {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {S : CategoryTheory.Sieve X} (J : CategoryTheory.GrothendieckTopology C) : S ∈ J.sieves X ↔ S ∈ J X

@[simp]

theorem CategoryTheory.GrothendieckTopology.top_mem {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) (X : C) : ⊤ ∈ J X

Also known as the maximality axiom.

@[simp]

theorem CategoryTheory.GrothendieckTopology.pullback_stable {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {S : CategoryTheory.Sieve X} (J : CategoryTheory.GrothendieckTopology C) (f : Y ⟶ X) (hS : S ∈ J X) : CategoryTheory.Sieve.pullback f S ∈ J Y

Also known as the stability axiom.

@[simp]

theorem CategoryTheory.GrothendieckTopology.pullback_mem_iff_of_isIso {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {J : CategoryTheory.GrothendieckTopology C} {i : X ⟶ Y} [CategoryTheory.IsIso i] {S : CategoryTheory.Sieve Y} : CategoryTheory.Sieve.pullback i S ∈ J X ↔ S ∈ J Y

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 X) (R : CategoryTheory.Sieve X) (h : ∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, S.arrows f → CategoryTheory.Sieve.pullback f R ∈ J Y) : R ∈ J X

theorem CategoryTheory.GrothendieckTopology.covering_of_eq_top {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {S : CategoryTheory.Sieve X} (J : CategoryTheory.GrothendieckTopology C) : S = ⊤ → S ∈ J X

theorem CategoryTheory.GrothendieckTopology.superset_covering {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {S R : CategoryTheory.Sieve X} (J : CategoryTheory.GrothendieckTopology C) (Hss : S ≤ R) (sjx : S ∈ J X) : R ∈ J 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 [MLM92] Chapter III, Section 2, Definition 1.

theorem CategoryTheory.GrothendieckTopology.intersection_covering {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {S R : CategoryTheory.Sieve X} (J : CategoryTheory.GrothendieckTopology C) (rj : R ∈ J X) (sj : S ∈ J X) : R ⊓ S ∈ J X

The intersection of two covering sieves is covering.

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

@[simp]

theorem CategoryTheory.GrothendieckTopology.intersection_covering_iff {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {S R : CategoryTheory.Sieve X} (J : CategoryTheory.GrothendieckTopology C) : R ⊓ S ∈ J X ↔ R ∈ J X ∧ S ∈ J X

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 f → CategoryTheory.Sieve Y} (hS : S ∈ J X) (hR : ∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄ (H : S.arrows f), R H ∈ J Y) : CategoryTheory.Sieve.bind S.arrows R ∈ J X

def CategoryTheory.GrothendieckTopology.Covers {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (J : CategoryTheory.GrothendieckTopology C) (S : CategoryTheory.Sieve X) (f : Y ⟶ X) : Prop

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

• J.Covers S f = (CategoryTheory.Sieve.pullback f S ∈ J Y)

theorem CategoryTheory.GrothendieckTopology.covers_iff {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (J : CategoryTheory.GrothendieckTopology C) (S : CategoryTheory.Sieve X) (f : Y ⟶ X) : J.Covers S f ↔ CategoryTheory.Sieve.pullback f S ∈ J Y

theorem CategoryTheory.GrothendieckTopology.covering_iff_covers_id {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} (J : CategoryTheory.GrothendieckTopology C) (S : CategoryTheory.Sieve X) : S ∈ J X ↔ J.Covers S (CategoryTheory.CategoryStruct.id X)

theorem CategoryTheory.GrothendieckTopology.arrow_max {C : Type u} [CategoryTheory.Category.{v, u} C] {X 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 Y : C} (J : CategoryTheory.GrothendieckTopology C) (f : Y ⟶ X) (S : CategoryTheory.Sieve X) (h : J.Covers S f) {Z : C} (g : Z ⟶ Y) : J.Covers S (CategoryTheory.CategoryStruct.comp g f)

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 Y : C} (J : CategoryTheory.GrothendieckTopology C) (f : Y ⟶ X) (S R : CategoryTheory.Sieve X) (h : J.Covers S f) : (∀ {Z : C} (g : Z ⟶ X), S.arrows g → J.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 Y : C} (J : CategoryTheory.GrothendieckTopology C) (f : Y ⟶ X) (S R : CategoryTheory.Sieve X) (hS : J.Covers S f) (hR : J.Covers R f) : J.Covers (S ⊓ R) f

def CategoryTheory.GrothendieckTopology.trivial (C : Type u) [CategoryTheory.Category.{v, u} C] : CategoryTheory.GrothendieckTopology C

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 [MLM92] Chapter III, Section 2, example (a), or https://en.wikipedia.org/wiki/Grothendieck_topology#The_discrete_and_indiscrete_topologies

Equations

• CategoryTheory.GrothendieckTopology.trivial C = { sieves := fun (x : C) => {⊤}, top_mem' := ⋯, pullback_stable' := ⋯, transitive' := ⋯ }

def CategoryTheory.GrothendieckTopology.discrete (C : Type u) [CategoryTheory.Category.{v, u} C] : CategoryTheory.GrothendieckTopology C

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

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

Equations

• CategoryTheory.GrothendieckTopology.discrete C = { sieves := fun (x : C) => Set.univ, top_mem' := ⋯, pullback_stable' := ⋯, transitive' := ⋯ }

theorem CategoryTheory.GrothendieckTopology.trivial_covering {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {S : CategoryTheory.Sieve X} : S ∈ (CategoryTheory.GrothendieckTopology.trivial C) X ↔ S = ⊤

instance CategoryTheory.GrothendieckTopology.instLEGrothendieckTopology {C : Type u} [CategoryTheory.Category.{v, u} C] : LE (CategoryTheory.GrothendieckTopology C)

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

Equations

• CategoryTheory.GrothendieckTopology.instLEGrothendieckTopology = { le := fun (J₁ J₂ : CategoryTheory.GrothendieckTopology C) => ⇑J₁ ≤ ⇑J₂ }

theorem CategoryTheory.GrothendieckTopology.le_def {C : Type u} [CategoryTheory.Category.{v, u} C] {J₁ J₂ : CategoryTheory.GrothendieckTopology C} : J₁ ≤ J₂ ↔ ⇑J₁ ≤ ⇑J₂

instance CategoryTheory.GrothendieckTopology.instPartialOrder {C : Type u} [CategoryTheory.Category.{v, u} C] : PartialOrder (CategoryTheory.GrothendieckTopology C)

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

Equations

• CategoryTheory.GrothendieckTopology.instPartialOrder = PartialOrder.mk ⋯

instance CategoryTheory.GrothendieckTopology.instInfSet {C : Type u} [CategoryTheory.Category.{v, u} C] : InfSet (CategoryTheory.GrothendieckTopology C)

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

Equations

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

theorem CategoryTheory.GrothendieckTopology.mem_sInf {C : Type u} [CategoryTheory.Category.{v, u} C] (s : Set (CategoryTheory.GrothendieckTopology C)) {X : C} (S : CategoryTheory.Sieve X) : S ∈ (sInf s) X ↔ ∀ t ∈ s, S ∈ t X

theorem CategoryTheory.GrothendieckTopology.isGLB_sInf {C : Type u} [CategoryTheory.Category.{v, u} C] (s : Set (CategoryTheory.GrothendieckTopology C)) : IsGLB s (sInf s)

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

instance CategoryTheory.GrothendieckTopology.instCompleteLattice {C : Type u} [CategoryTheory.Category.{v, u} C] : CompleteLattice (CategoryTheory.GrothendieckTopology C)

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.

instance CategoryTheory.GrothendieckTopology.instInhabited {C : Type u} [CategoryTheory.Category.{v, u} C] : Inhabited (CategoryTheory.GrothendieckTopology C)

Equations

• CategoryTheory.GrothendieckTopology.instInhabited = { default := ⊤ }

@[simp]

theorem CategoryTheory.GrothendieckTopology.trivial_eq_bot {C : Type u} [CategoryTheory.Category.{v, u} C] : CategoryTheory.GrothendieckTopology.trivial C = ⊥

@[simp]

theorem CategoryTheory.GrothendieckTopology.discrete_eq_top {C : Type u} [CategoryTheory.Category.{v, u} C] : CategoryTheory.GrothendieckTopology.discrete C = ⊤

@[simp]

theorem CategoryTheory.GrothendieckTopology.bot_covering {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {S : CategoryTheory.Sieve X} : S ∈ ⊥ X ↔ S = ⊤

@[simp]

theorem CategoryTheory.GrothendieckTopology.top_covering {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {S : CategoryTheory.Sieve X} : S ∈ ⊤ X

theorem CategoryTheory.GrothendieckTopology.bot_covers {C : Type u} [CategoryTheory.Category.{v, u} C] {X 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 Y : C} (S : CategoryTheory.Sieve X) (f : Y ⟶ X) : ⊤.Covers S f

def CategoryTheory.GrothendieckTopology.dense {C : Type u} [CategoryTheory.Category.{v, u} C] : CategoryTheory.GrothendieckTopology C

The dense Grothendieck topology.

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

Equations

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

theorem CategoryTheory.GrothendieckTopology.dense_covering {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {S : CategoryTheory.Sieve X} : S ∈ CategoryTheory.GrothendieckTopology.dense X ↔ ∀ {Y : C} (f : Y ⟶ X), ∃ (Z : C) (g : Z ⟶ Y), S.arrows (CategoryTheory.CategoryStruct.comp g f)

def CategoryTheory.GrothendieckTopology.RightOreCondition (C : Type u) [CategoryTheory.Category.{v, u} C] : Prop

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.

theorem CategoryTheory.GrothendieckTopology.right_ore_of_pullbacks {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasPullbacks C] : CategoryTheory.GrothendieckTopology.RightOreCondition C

def CategoryTheory.GrothendieckTopology.atomic {C : Type u} [CategoryTheory.Category.{v, u} C] (hro : CategoryTheory.GrothendieckTopology.RightOreCondition C) : CategoryTheory.GrothendieckTopology C

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 [MLM92] Chapter III, Section 2, example (f).

Equations

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

def CategoryTheory.GrothendieckTopology.Cover {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) (X : C) : Type (max u v)

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

Equations

• J.Cover X = { S : CategoryTheory.Sieve X // S ∈ J X }

instance CategoryTheory.GrothendieckTopology.instPreorderCover {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) (X : C) : Preorder (J.Cover X)

Equations

• J.instPreorderCover X = inferInstance

instance CategoryTheory.GrothendieckTopology.Cover.instCoeOutSieve {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} : CoeOut (J.Cover X) (CategoryTheory.Sieve X)

Equations

• CategoryTheory.GrothendieckTopology.Cover.instCoeOutSieve = { coe := fun (S : J.Cover X) => ↑S }

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).arrows }

theorem CategoryTheory.GrothendieckTopology.Cover.condition {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} (S : J.Cover X) : ↑S ∈ J X

theorem CategoryTheory.GrothendieckTopology.Cover.ext {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} (S T : J.Cover X) (h : ∀ ⦃Y : C⦄ (f : Y ⟶ X), (↑S).arrows f ↔ (↑T).arrows f) : S = T

instance CategoryTheory.GrothendieckTopology.Cover.instOrderTop {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} : OrderTop (J.Cover X)

Equations

• CategoryTheory.GrothendieckTopology.Cover.instOrderTop = OrderTop.mk ⋯

instance CategoryTheory.GrothendieckTopology.Cover.instSemilatticeInf {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} : SemilatticeInf (J.Cover X)

Equations

• CategoryTheory.GrothendieckTopology.Cover.instSemilatticeInf = SemilatticeInf.mk (fun (S T : J.Cover X) => ⟨↑S ⊓ ↑T, ⋯⟩) ⋯ ⋯ ⋯

instance CategoryTheory.GrothendieckTopology.Cover.instInhabited {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} : Inhabited (J.Cover X)

Equations

• CategoryTheory.GrothendieckTopology.Cover.instInhabited = { default := ⊤ }

structure CategoryTheory.GrothendieckTopology.Cover.Arrow {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} (S : J.Cover X) : Type (max u v)

An auxiliary structure, used to define S.index.

• Y : C

  The source of the arrow.

• f : self.Y ⟶ X

  The arrow itself.

• hf : (↑S).arrows self.f

  The given arrow is contained in the given sieve.

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} (Y : x.Y = y.Y) (f : HEq x.f y.f) : x = y

structure CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (I₁ I₂ : S.Arrow) : Type (max u v)

Relation between two elements in S.arrow, the data of which involves a commutative square.

• Z : C

  The source of the arrows defining the relation.

• g₁ : self.Z ⟶ I₁.Y

  The first arrow defining the relation.

• g₂ : self.Z ⟶ I₂.Y

  The second arrow defining the relation.

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

  The relation itself.

theorem CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation.ext {C : Type u} {inst✝ : CategoryTheory.Category.{v, u} C} {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {I₁ I₂ : S.Arrow} {x y : I₁.Relation I₂} (Z : x.Z = y.Z) (g₁ : HEq x.g₁ y.g₁) (g₂ : HEq x.g₂ y.g₂) : x = y

theorem CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation.w_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {I₁ I₂ : S.Arrow} (self : I₁.Relation I₂) {Z : C} (h : X ⟶ Z) : CategoryTheory.CategoryStruct.comp self.g₁ (CategoryTheory.CategoryStruct.comp I₁.f h) = CategoryTheory.CategoryStruct.comp self.g₂ (CategoryTheory.CategoryStruct.comp I₂.f h)

def CategoryTheory.GrothendieckTopology.Cover.Arrow.precomp {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y) : S.Arrow

Given I : S.Arrow and a morphism g : Z ⟶ I.Y, this is the arrow in S.Arrow corresponding to g ≫ I.f.

Equations

• I.precomp g = { Y := Z, f := CategoryTheory.CategoryStruct.comp g I.f, hf := ⋯ }

@[simp]

theorem CategoryTheory.GrothendieckTopology.Cover.Arrow.precomp_Y {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y) : (I.precomp g).Y = Z

@[simp]

theorem CategoryTheory.GrothendieckTopology.Cover.Arrow.precomp_f {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y) : (I.precomp g).f = CategoryTheory.CategoryStruct.comp g I.f

def CategoryTheory.GrothendieckTopology.Cover.Arrow.precompRelation {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y) : (I.precomp g).Relation I

Given I : S.Arrow and a morphism g : Z ⟶ I.Y, this is the obvious relation from I.precomp g to I.

Equations

• I.precompRelation g = { Z := (I.precomp g).Y, g₁ := CategoryTheory.CategoryStruct.id (I.precomp g).Y, g₂ := g, w := ⋯ }

@[simp]

theorem CategoryTheory.GrothendieckTopology.Cover.Arrow.precompRelation_Z {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y) : (I.precompRelation g).Z = (I.precomp g).Y

@[simp]

theorem CategoryTheory.GrothendieckTopology.Cover.Arrow.precompRelation_g₂ {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y) : (I.precompRelation g).g₂ = g

@[simp]

theorem CategoryTheory.GrothendieckTopology.Cover.Arrow.precompRelation_g₁ {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y) : (I.precompRelation g).g₁ = CategoryTheory.CategoryStruct.id (I.precomp g).Y

def CategoryTheory.GrothendieckTopology.Cover.Arrow.map {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S 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 := ⋯ }

@[simp]

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

@[simp]

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

def CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation.map {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S T : J.Cover X} {I₁ I₂ : S.Arrow} (r : I₁.Relation I₂) (f : S ⟶ T) : (I₁.map f).Relation (I₂.map f)

Map an Arrow.Relation along a refinement S ⟶ T.

Equations

• r.map f = { Z := r.Z, g₁ := r.g₁, g₂ := r.g₂, w := ⋯ }

@[simp]

theorem CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation.map_Z {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S T : J.Cover X} {I₁ I₂ : S.Arrow} (r : I₁.Relation I₂) (f : S ⟶ T) : (r.map f).Z = r.Z

@[simp]

theorem CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation.map_g₁ {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S T : J.Cover X} {I₁ I₂ : S.Arrow} (r : I₁.Relation I₂) (f : S ⟶ T) : (r.map f).g₁ = r.g₁

@[simp]

theorem CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation.map_g₂ {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S T : J.Cover X} {I₁ I₂ : S.Arrow} (r : I₁.Relation I₂) (f : S ⟶ T) : (r.map f).g₂ = r.g₂

def CategoryTheory.GrothendieckTopology.Cover.pullback {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {J : CategoryTheory.GrothendieckTopology C} (S : J.Cover X) (f : Y ⟶ X) : J.Cover Y

Pull back a cover along a morphism.

Equations

• S.pullback f = ⟨CategoryTheory.Sieve.pullback f ↑S, ⋯⟩

def CategoryTheory.GrothendieckTopology.Cover.Arrow.base {C : Type u} [CategoryTheory.Category.{v, u} C] {X 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

• I.base = { Y := I.Y, f := CategoryTheory.CategoryStruct.comp I.f f, hf := ⋯ }

@[simp]

theorem CategoryTheory.GrothendieckTopology.Cover.Arrow.base_Y {C : Type u} [CategoryTheory.Category.{v, u} C] {X 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 Y : C} {J : CategoryTheory.GrothendieckTopology C} {f : Y ⟶ X} {S : J.Cover X} (I : (S.pullback f).Arrow) : I.base.f = CategoryTheory.CategoryStruct.comp I.f f

def CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation.base {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {J : CategoryTheory.GrothendieckTopology C} {f : Y ⟶ X} {S : J.Cover X} {I₁ I₂ : (S.pullback f).Arrow} (r : I₁.Relation I₂) : I₁.base.Relation I₂.base

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

Equations

• r.base = { Z := r.Z, g₁ := r.g₁, g₂ := r.g₂, w := ⋯ }

@[simp]

theorem CategoryTheory.GrothendieckTopology.Cover.coe_pullback {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {J : CategoryTheory.GrothendieckTopology C} {Z : C} (f : Y ⟶ X) (g : Z ⟶ Y) (S : J.Cover X) : (↑(S.pullback f)).arrows g ↔ (↑S).arrows (CategoryTheory.CategoryStruct.comp g f)

def CategoryTheory.GrothendieckTopology.Cover.pullbackId {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} (S : J.Cover X) : S.pullback (CategoryTheory.CategoryStruct.id X) ≅ S

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

Equations

• S.pullbackId = CategoryTheory.eqToIso ⋯

def CategoryTheory.GrothendieckTopology.Cover.pullbackComp {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X Y 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

• S.pullbackComp f g = CategoryTheory.eqToIso ⋯

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).arrows fun (Y : C) (f : Y ⟶ X) (hf : (↑S).arrows f) => ↑(T { Y := Y, f := f, hf := hf }), ⋯⟩

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

• S.bindToBase T = CategoryTheory.homOfLE ⋯

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

• I.middle = Exists.choose ⋯

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

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

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).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 := ⋯ }

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)).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 := ⋯ }

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

structure CategoryTheory.GrothendieckTopology.Cover.Relation {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} (S : J.Cover X) : Type (max u v)

An auxiliary structure, used to define S.index.

• fst : S.Arrow

  The first arrow.

• snd : S.Arrow

  The second arrow.

• r : self.fst.Relation self.snd

  The relation between the two arrows.

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} (fst : x.fst = y.fst) (snd : x.snd = y.snd) (r : HEq x.r y.r) : x = y

def CategoryTheory.GrothendieckTopology.Cover.Relation.mk' {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {fst snd : S.Arrow} (r : fst.Relation snd) : S.Relation

Constructor for Cover.Relation which takes as an input r : I₁.Relation I₂ with I₁ I₂ : S.Arrow.

Equations

• CategoryTheory.GrothendieckTopology.Cover.Relation.mk' r = { fst := fst, snd := snd, r := r }

@[simp]

theorem CategoryTheory.GrothendieckTopology.Cover.Relation.mk'_snd {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {fst snd : S.Arrow} (r : fst.Relation snd) : (CategoryTheory.GrothendieckTopology.Cover.Relation.mk' r).snd = snd

@[simp]

theorem CategoryTheory.GrothendieckTopology.Cover.Relation.mk'_r {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {fst snd : S.Arrow} (r : fst.Relation snd) : (CategoryTheory.GrothendieckTopology.Cover.Relation.mk' r).r = r

@[simp]

theorem CategoryTheory.GrothendieckTopology.Cover.Relation.mk'_fst {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {S : J.Cover X} {fst snd : S.Arrow} (r : fst.Relation snd) : (CategoryTheory.GrothendieckTopology.Cover.Relation.mk' r).fst = fst

def CategoryTheory.GrothendieckTopology.Cover.index {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D) : CategoryTheory.Limits.MulticospanIndex D

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.

@[simp]

theorem CategoryTheory.GrothendieckTopology.Cover.index_snd {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D) (I : S.Relation) : (S.index P).snd I = P.map I.r.g₂.op

@[simp]

theorem CategoryTheory.GrothendieckTopology.Cover.index_left {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D) (I : S.Arrow) : (S.index P).left I = P.obj (Opposite.op I.Y)

@[simp]

theorem CategoryTheory.GrothendieckTopology.Cover.index_fst {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D) (I : S.Relation) : (S.index P).fst I = P.map I.r.g₁.op

@[simp]

theorem CategoryTheory.GrothendieckTopology.Cover.index_R {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D) : (S.index P).R = S.Relation

@[simp]

theorem CategoryTheory.GrothendieckTopology.Cover.index_right {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D) (I : S.Relation) : (S.index P).right I = P.obj (Opposite.op I.r.Z)

@[simp]

theorem CategoryTheory.GrothendieckTopology.Cover.index_L {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D) : (S.index P).L = S.Arrow

@[simp]

theorem CategoryTheory.GrothendieckTopology.Cover.index_fstTo {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D) (I : S.Relation) : (S.index P).fstTo I = I.fst

@[simp]

theorem CategoryTheory.GrothendieckTopology.Cover.index_sndTo {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D) (I : S.Relation) : (S.index P).sndTo I = I.snd

@[reducible, inline]

abbrev CategoryTheory.GrothendieckTopology.Cover.multifork {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D) : CategoryTheory.Limits.Multifork (S.index P)

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

• S.multifork P = CategoryTheory.Limits.Multifork.ofι (S.index P) (P.obj (Opposite.op X)) (fun (I : (S.index P).L) => P.map I.f.op) ⋯

@[reducible, inline]

noncomputable abbrev CategoryTheory.GrothendieckTopology.Cover.toMultiequalizer {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D) [CategoryTheory.Limits.HasMultiequalizer (S.index P)] : P.obj (Opposite.op X) ⟶ CategoryTheory.Limits.multiequalizer (S.index P)

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

• S.toMultiequalizer P = CategoryTheory.Limits.Multiequalizer.lift (S.index P) (P.obj (Opposite.op X)) (fun (I : (S.index P).L) => P.map I.f.op) ⋯

def CategoryTheory.GrothendieckTopology.pullback {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (J : CategoryTheory.GrothendieckTopology C) (f : Y ⟶ X) : CategoryTheory.Functor (J.Cover X) (J.Cover Y)

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 := ⋯ }

@[simp]

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

def CategoryTheory.GrothendieckTopology.pullbackId {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) (X : C) : J.pullback (CategoryTheory.CategoryStruct.id X) ≅ CategoryTheory.Functor.id (J.Cover X)

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

Equations

• J.pullbackId X = CategoryTheory.NatIso.ofComponents (fun (S : J.Cover X) => S.pullbackId) ⋯

def CategoryTheory.GrothendieckTopology.pullbackComp {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {X Y 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

• J.pullbackComp f g = CategoryTheory.NatIso.ofComponents (fun (S : J.Cover Z) => S.pullbackComp f g) ⋯