Covers of schemes

This file provides the basic API for covers of schemes. A cover of a scheme X with respect to a morphism property P is a jointly surjective indexed family of scheme morphisms with target X all satisfying P.

Implementation details

The definition on the pullback of a cover along a morphism depends on results that are developed later in the import tree. Hence in this file, they have additional assumptions that will be automatically satisfied in later files. The motivation here is that we already know that these assumptions are satisfied for open immersions and hence the cover API for open immersions can be used to deduce these assumptions in the general case.

class AlgebraicGeometry.Scheme.JointlySurjective (K : CategoryTheory.Precoverage Scheme) : Prop

A coverage K on Scheme is called jointly surjective if every covering family in K is jointly surjective.

• exists_eq {X : Scheme} (S : CategoryTheory.Presieve X) (hS : S ∈ K.coverings X) (x : ↥X) : ∃ (Y : Scheme) (g : Y ⟶ X), S g ∧ x ∈ Set.range ⇑g

@[reducible, inline]

abbrev AlgebraicGeometry.Scheme.Cover (K : CategoryTheory.Precoverage Scheme) (S : Scheme) : Type (max (u + 1) (v + 1))

A cover of X in the coverage K is a 0-hypercover for K.

theorem AlgebraicGeometry.Scheme.Cover.exists_eq {K : CategoryTheory.Precoverage Scheme} {X : Scheme} [JointlySurjective K] (𝒰 : Cover K X) (x : ↥X) : ∃ (i : 𝒰.I₀) (y : ↥(𝒰.X i)), (𝒰.f i) y = x

def AlgebraicGeometry.Scheme.Cover.idx {K : CategoryTheory.Precoverage Scheme} {X : Scheme} [JointlySurjective K] (𝒰 : Cover K X) (x : ↥X) : 𝒰.I₀

A choice of an index i such that x is in the range of 𝒰.f i.

theorem AlgebraicGeometry.Scheme.Cover.covers {K : CategoryTheory.Precoverage Scheme} {X : Scheme} [JointlySurjective K] (𝒰 : Cover K X) (x : ↥X) : x ∈ Set.range ⇑(𝒰.f (𝒰.idx x))

theorem AlgebraicGeometry.Scheme.Cover.iUnion_range {K : CategoryTheory.Precoverage Scheme} [JointlySurjective K] {X : Scheme} (𝒰 : Cover K X) : ⋃ (i : 𝒰.I₀), Set.range ⇑(𝒰.f i) = Set.univ

instance AlgebraicGeometry.Scheme.Cover.nonempty_of_nonempty {K : CategoryTheory.Precoverage Scheme} {X : Scheme} [JointlySurjective K] [Nonempty ↥X] (𝒰 : Cover K X) : Nonempty 𝒰.I₀

theorem AlgebraicGeometry.Scheme.presieve₀_mem_precoverage_iff {X : Scheme} {P : CategoryTheory.MorphismProperty Scheme} (E : CategoryTheory.PreZeroHypercover X) : E.presieve₀ ∈ (precoverage P).coverings X ↔ (∀ (x : ↥X), ∃ (i : E.I₀), x ∈ Set.range ⇑(E.f i)) ∧ ∀ (i : E.I₀), P (E.f i)

theorem AlgebraicGeometry.Scheme.Cover.map_prop {X : Scheme} {P : CategoryTheory.MorphismProperty Scheme} (𝒰 : Cover (precoverage P) X) (i : 𝒰.I₀) : P (𝒰.f i)

def AlgebraicGeometry.Scheme.Cover.mkOfCovers {X : Scheme} {P : CategoryTheory.MorphismProperty Scheme} (J : Type u_1) (obj : J → Scheme) (map : (j : J) → obj j ⟶ X) (covers : ∀ (x : ↥X), ∃ (j : J) (y : ↥(obj j)), (map j) y = x) (map_prop : ∀ (j : J), P (map j) := by infer_instance) : Cover (precoverage P) X

Given a family of schemes with morphisms to X satisfying P that jointly cover X, Cover.mkOfCovers is an associated P-cover of X.

@[simp]

theorem AlgebraicGeometry.Scheme.Cover.mkOfCovers_f {X : Scheme} {P : CategoryTheory.MorphismProperty Scheme} (J : Type u_1) (obj : J → Scheme) (map : (j : J) → obj j ⟶ X) (covers : ∀ (x : ↥X), ∃ (j : J) (y : ↥(obj j)), (map j) y = x) (map_prop : ∀ (j : J), P (map j) := by infer_instance) (j : J) : (mkOfCovers J obj map covers map_prop).f j = map j

@[simp]

theorem AlgebraicGeometry.Scheme.Cover.mkOfCovers_I₀ {X : Scheme} {P : CategoryTheory.MorphismProperty Scheme} (J : Type u_1) (obj : J → Scheme) (map : (j : J) → obj j ⟶ X) (covers : ∀ (x : ↥X), ∃ (j : J) (y : ↥(obj j)), (map j) y = x) (map_prop : ∀ (j : J), P (map j) := by infer_instance) : (mkOfCovers J obj map covers map_prop).I₀ = J

@[simp]

theorem AlgebraicGeometry.Scheme.Cover.mkOfCovers_X {X : Scheme} {P : CategoryTheory.MorphismProperty Scheme} (J : Type u_1) (obj : J → Scheme) (map : (j : J) → obj j ⟶ X) (covers : ∀ (x : ↥X), ∃ (j : J) (y : ↥(obj j)), (map j) y = x) (map_prop : ∀ (j : J), P (map j) := by infer_instance) (a✝ : J) : (mkOfCovers J obj map covers map_prop).X a✝ = obj a✝

def AlgebraicGeometry.Scheme.coverOfIsIso {P : CategoryTheory.MorphismProperty Scheme} [P.ContainsIdentities] [P.RespectsIso] {X Y : Scheme} (f : X ⟶ Y) [CategoryTheory.IsIso f] : Cover (precoverage P) Y

An isomorphism X ⟶ Y is a P-cover of Y.

@[simp]

theorem AlgebraicGeometry.Scheme.coverOfIsIso_I₀ {P : CategoryTheory.MorphismProperty Scheme} [P.ContainsIdentities] [P.RespectsIso] {X Y : Scheme} (f : X ⟶ Y) [CategoryTheory.IsIso f] : (coverOfIsIso f).I₀ = PUnit.{v + 1}

@[simp]

theorem AlgebraicGeometry.Scheme.coverOfIsIso_f {P : CategoryTheory.MorphismProperty Scheme} [P.ContainsIdentities] [P.RespectsIso] {X Y : Scheme} (f : X ⟶ Y) [CategoryTheory.IsIso f] (x✝ : PUnit.{v + 1}) : (coverOfIsIso f).f x✝ = f

@[simp]

theorem AlgebraicGeometry.Scheme.coverOfIsIso_X {P : CategoryTheory.MorphismProperty Scheme} [P.ContainsIdentities] [P.RespectsIso] {X Y : Scheme} (f : X ⟶ Y) [CategoryTheory.IsIso f] (x✝ : PUnit.{v + 1}) : (coverOfIsIso f).X x✝ = X

instance AlgebraicGeometry.Scheme.instJointlySurjectivePrecoverage {P : CategoryTheory.MorphismProperty Scheme} : JointlySurjective (precoverage P)

def AlgebraicGeometry.Scheme.Cover.changeProp {K : CategoryTheory.Precoverage Scheme} {X : Scheme} {Q : CategoryTheory.MorphismProperty Scheme} [JointlySurjective K] (𝒰 : Cover K X) (h : ∀ (j : 𝒰.I₀), Q (𝒰.f j)) : Cover (precoverage Q) X

Turn a K-cover into a Q-cover by showing that the components satisfy Q.

def AlgebraicGeometry.Scheme.Cover.copy {P : CategoryTheory.MorphismProperty Scheme} [P.RespectsIso] {X : Scheme} (𝒰 : Cover (precoverage P) X) (J : Type u_1) (obj : J → Scheme) (map : (i : J) → obj i ⟶ X) (e₁ : J ≃ 𝒰.I₀) (e₂ : (i : J) → obj i ≅ 𝒰.X (e₁ i)) (h : ∀ (i : J), map i = CategoryTheory.CategoryStruct.comp (e₂ i).hom (𝒰.f (e₁ i))) : Cover (precoverage P) X

We construct a cover from another, by providing the needed fields and showing that the provided fields are isomorphic with the original cover.

@[simp]

theorem AlgebraicGeometry.Scheme.Cover.copy_f {P : CategoryTheory.MorphismProperty Scheme} [P.RespectsIso] {X : Scheme} (𝒰 : Cover (precoverage P) X) (J : Type u_1) (obj : J → Scheme) (map : (i : J) → obj i ⟶ X) (e₁ : J ≃ 𝒰.I₀) (e₂ : (i : J) → obj i ≅ 𝒰.X (e₁ i)) (h : ∀ (i : J), map i = CategoryTheory.CategoryStruct.comp (e₂ i).hom (𝒰.f (e₁ i))) (i : J) : (𝒰.copy J obj map e₁ e₂ h).f i = map i

@[simp]

theorem AlgebraicGeometry.Scheme.Cover.copy_I₀ {P : CategoryTheory.MorphismProperty Scheme} [P.RespectsIso] {X : Scheme} (𝒰 : Cover (precoverage P) X) (J : Type u_1) (obj : J → Scheme) (map : (i : J) → obj i ⟶ X) (e₁ : J ≃ 𝒰.I₀) (e₂ : (i : J) → obj i ≅ 𝒰.X (e₁ i)) (h : ∀ (i : J), map i = CategoryTheory.CategoryStruct.comp (e₂ i).hom (𝒰.f (e₁ i))) : (𝒰.copy J obj map e₁ e₂ h).I₀ = J

@[simp]

theorem AlgebraicGeometry.Scheme.Cover.copy_X {P : CategoryTheory.MorphismProperty Scheme} [P.RespectsIso] {X : Scheme} (𝒰 : Cover (precoverage P) X) (J : Type u_1) (obj : J → Scheme) (map : (i : J) → obj i ⟶ X) (e₁ : J ≃ 𝒰.I₀) (e₂ : (i : J) → obj i ≅ 𝒰.X (e₁ i)) (h : ∀ (i : J), map i = CategoryTheory.CategoryStruct.comp (e₂ i).hom (𝒰.f (e₁ i))) (a✝ : J) : (𝒰.copy J obj map e₁ e₂ h).X a✝ = obj a✝

def AlgebraicGeometry.Scheme.Cover.pushforwardIso {P : CategoryTheory.MorphismProperty Scheme} [P.RespectsIso] [P.ContainsIdentities] [P.IsStableUnderComposition] {X Y : Scheme} (𝒰 : Cover (precoverage P) X) (f : X ⟶ Y) [CategoryTheory.IsIso f] : Cover (precoverage P) Y

The pushforward of a cover along an isomorphism.

@[simp]

theorem AlgebraicGeometry.Scheme.Cover.pushforwardIso_I₀ {P : CategoryTheory.MorphismProperty Scheme} [P.RespectsIso] [P.ContainsIdentities] [P.IsStableUnderComposition] {X Y : Scheme} (𝒰 : Cover (precoverage P) X) (f : X ⟶ Y) [CategoryTheory.IsIso f] : (𝒰.pushforwardIso f).I₀ = 𝒰.I₀

@[simp]

theorem AlgebraicGeometry.Scheme.Cover.pushforwardIso_f {P : CategoryTheory.MorphismProperty Scheme} [P.RespectsIso] [P.ContainsIdentities] [P.IsStableUnderComposition] {X Y : Scheme} (𝒰 : Cover (precoverage P) X) (f : X ⟶ Y) [CategoryTheory.IsIso f] (x✝ : 𝒰.I₀) : (𝒰.pushforwardIso f).f x✝ = CategoryTheory.CategoryStruct.comp (𝒰.f x✝) f

@[simp]

theorem AlgebraicGeometry.Scheme.Cover.pushforwardIso_X {P : CategoryTheory.MorphismProperty Scheme} [P.RespectsIso] [P.ContainsIdentities] [P.IsStableUnderComposition] {X Y : Scheme} (𝒰 : Cover (precoverage P) X) (f : X ⟶ Y) [CategoryTheory.IsIso f] (x✝ : 𝒰.I₀) : (𝒰.pushforwardIso f).X x✝ = 𝒰.X x✝

def AlgebraicGeometry.Scheme.Cover.add {P : CategoryTheory.MorphismProperty Scheme} {X Y : Scheme} (𝒰 : Cover (precoverage P) X) (f : Y ⟶ X) (hf : P f := by infer_instance) : Cover (precoverage P) X

Adding map satisfying P into a cover gives another cover.

@[simp]

theorem AlgebraicGeometry.Scheme.Cover.add_toPreZeroHypercover {P : CategoryTheory.MorphismProperty Scheme} {X Y : Scheme} (𝒰 : Cover (precoverage P) X) (f : Y ⟶ X) (hf : P f := by infer_instance) : (𝒰.add f hf).toPreZeroHypercover = 𝒰.add f

@[deprecated CategoryTheory.Precoverage.ZeroHypercover.pullback₁ (since := "2025-10-02")]

def AlgebraicGeometry.Scheme.Cover.pullbackCover {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Precoverage C} {S T : C} [J.IsStableUnderBaseChange] (f : S ⟶ T) (E : J.ZeroHypercover T) [∀ (i : E.I₀), CategoryTheory.Limits.HasPullback f (E.f i)] : J.ZeroHypercover S

Alias of CategoryTheory.Precoverage.ZeroHypercover.pullback₁.

def AlgebraicGeometry.Scheme.Cover.pullbackHom {P : CategoryTheory.MorphismProperty Scheme} [P.IsStableUnderBaseChange] [IsJointlySurjectivePreserving P] {X W : Scheme} (𝒰 : Cover (precoverage P) X) (f : W ⟶ X) (i : 𝒰.toPreZeroHypercover.1) [∀ (x : 𝒰.I₀), CategoryTheory.Limits.HasPullback f (𝒰.f x)] : (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰).X i ⟶ 𝒰.X i

The family of morphisms from the pullback cover to the original cover.

@[simp]

theorem AlgebraicGeometry.Scheme.Cover.pullbackHom_map {P : CategoryTheory.MorphismProperty Scheme} [P.IsStableUnderBaseChange] [IsJointlySurjectivePreserving P] {X W : Scheme} (𝒰 : Cover (precoverage P) X) (f : W ⟶ X) [∀ (x : 𝒰.I₀), CategoryTheory.Limits.HasPullback f (𝒰.f x)] (i : 𝒰.toPreZeroHypercover.1) : CategoryTheory.CategoryStruct.comp (𝒰.pullbackHom f i) (𝒰.f i) = CategoryTheory.CategoryStruct.comp ((CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰).f i) f

@[simp]

theorem AlgebraicGeometry.Scheme.Cover.pullbackHom_map_assoc {P : CategoryTheory.MorphismProperty Scheme} [P.IsStableUnderBaseChange] [IsJointlySurjectivePreserving P] {X W : Scheme} (𝒰 : Cover (precoverage P) X) (f : W ⟶ X) [∀ (x : 𝒰.I₀), CategoryTheory.Limits.HasPullback f (𝒰.f x)] (i : 𝒰.toPreZeroHypercover.1) {Z : Scheme} (h : X ⟶ Z) : CategoryTheory.CategoryStruct.comp (𝒰.pullbackHom f i) (CategoryTheory.CategoryStruct.comp (𝒰.f i) h) = CategoryTheory.CategoryStruct.comp ((CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰).f i) (CategoryTheory.CategoryStruct.comp f h)

@[deprecated CategoryTheory.Precoverage.ZeroHypercover.pullback₂ (since := "2025-10-02")]

def AlgebraicGeometry.Scheme.Cover.pullbackCover' {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Precoverage C} {S T : C} [J.IsStableUnderBaseChange] (f : S ⟶ T) (E : J.ZeroHypercover T) [∀ (i : E.I₀), CategoryTheory.Limits.HasPullback (E.f i) f] : J.ZeroHypercover S

Alias of CategoryTheory.Precoverage.ZeroHypercover.pullback₂.

structure AlgebraicGeometry.Scheme.AffineCover (P : CategoryTheory.MorphismProperty Scheme) (S : Scheme) : Type (max (u + 1) (v + 1))

An affine cover of X consists of a jointly surjective family of maps into X from spectra of rings.

Note: The map_prop field is equipped with a default argument by infer_instance. In general this causes worse error messages, but in practice P is mostly defined via class.

• I₀ : Type v

  index set of an affine cover of a scheme S

• X (j : self.I₀) : CommRingCat

  the ring associated to a component of an affine cover

• f (j : self.I₀) : Spec (self.X j) ⟶ S

  the components map to S

• idx (x : ↥S) : self.I₀

  given a point of x : S, idx x is the index of the component which contains x

• covers (x : ↥S) : x ∈ Set.range ⇑(self.f (self.idx x))

  the components cover S

• map_prop (j : self.I₀) : P (self.f j)

  the component maps satisfy P

@[deprecated AlgebraicGeometry.Scheme.AffineCover.I₀ (since := "2025-09-19")]

def AlgebraicGeometry.Scheme.AffineCover.J {P : CategoryTheory.MorphismProperty Scheme} {S : Scheme} (self : AffineCover P S) : Type v

Alias of AlgebraicGeometry.Scheme.AffineCover.I₀.

---

index set of an affine cover of a scheme S

@[deprecated AlgebraicGeometry.Scheme.AffineCover.X (since := "2025-09-19")]

def AlgebraicGeometry.Scheme.AffineCover.obj {P : CategoryTheory.MorphismProperty Scheme} {S : Scheme} (self : AffineCover P S) (j : self.I₀) : CommRingCat

Alias of AlgebraicGeometry.Scheme.AffineCover.X.

---

the ring associated to a component of an affine cover

@[deprecated AlgebraicGeometry.Scheme.AffineCover.f (since := "2025-09-19")]

def AlgebraicGeometry.Scheme.AffineCover.map {P : CategoryTheory.MorphismProperty Scheme} {S : Scheme} (self : AffineCover P S) (j : self.I₀) : Spec (self.X j) ⟶ S

Alias of AlgebraicGeometry.Scheme.AffineCover.f.

---

the components map to S

def AlgebraicGeometry.Scheme.AffineCover.cover {P : CategoryTheory.MorphismProperty Scheme} {X : Scheme} (𝒰 : AffineCover P X) : Cover (precoverage P) X

The cover associated to an affine cover.

@[simp]

theorem AlgebraicGeometry.Scheme.AffineCover.cover_X {P : CategoryTheory.MorphismProperty Scheme} {X : Scheme} (𝒰 : AffineCover P X) (j : 𝒰.I₀) : 𝒰.cover.X j = Spec (𝒰.X j)

@[simp]

theorem AlgebraicGeometry.Scheme.AffineCover.cover_I₀ {P : CategoryTheory.MorphismProperty Scheme} {X : Scheme} (𝒰 : AffineCover P X) : 𝒰.cover.I₀ = 𝒰.I₀

@[simp]

theorem AlgebraicGeometry.Scheme.AffineCover.cover_f {P : CategoryTheory.MorphismProperty Scheme} {X : Scheme} (𝒰 : AffineCover P X) (j : 𝒰.I₀) : 𝒰.cover.f j = 𝒰.f j

def AlgebraicGeometry.Scheme.Cover.ulift {X : Scheme} {P : CategoryTheory.MorphismProperty Scheme} (𝒰 : Cover (precoverage P) X) : Cover (precoverage P) X

Any v-cover 𝒰 induces a u-cover indexed by the points of X.

@[simp]

theorem AlgebraicGeometry.Scheme.Cover.ulift_I₀ {X : Scheme} {P : CategoryTheory.MorphismProperty Scheme} (𝒰 : Cover (precoverage P) X) : 𝒰.ulift.I₀ = ↥X

@[simp]

theorem AlgebraicGeometry.Scheme.Cover.ulift_f {X : Scheme} {P : CategoryTheory.MorphismProperty Scheme} (𝒰 : Cover (precoverage P) X) (x : ↥X) : 𝒰.ulift.f x = 𝒰.f (𝒰.idx x)

@[simp]

theorem AlgebraicGeometry.Scheme.Cover.ulift_X {X : Scheme} {P : CategoryTheory.MorphismProperty Scheme} (𝒰 : Cover (precoverage P) X) (x : ↥X) : 𝒰.ulift.X x = 𝒰.X (𝒰.idx x)

instance AlgebraicGeometry.Scheme.instSmallPrecoverage {P : CategoryTheory.MorphismProperty Scheme} : (precoverage P).Small

@[reducible, inline]

abbrev AlgebraicGeometry.Scheme.Cover.Hom {K : CategoryTheory.Precoverage Scheme} {X : Scheme} (𝒰 𝒱 : Cover K X) : Type (max u v)

A morphism between covers 𝒰 ⟶ 𝒱 indicates that 𝒰 is a refinement of 𝒱. Since covers of schemes are indexed, the definition also involves a map on the indexing types. This is implemented as an abbrev for CategoryTheory.Precoverage.ZeroHypercover.Hom.

@[deprecated CategoryTheory.PreZeroHypercover.Hom.s₀ (since := "2026-01-13")]

def AlgebraicGeometry.Scheme.Cover.Hom.idx {C : Type u} [CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreZeroHypercover S} {F : CategoryTheory.PreZeroHypercover S} (self : E.Hom F) (i : E.I₀) : F.I₀

Alias of CategoryTheory.PreZeroHypercover.Hom.s₀.

@[deprecated CategoryTheory.PreZeroHypercover.Hom.h₀ (since := "2026-01-13")]

def AlgebraicGeometry.Scheme.Cover.Hom.app {C : Type u} [CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreZeroHypercover S} {F : CategoryTheory.PreZeroHypercover S} (self : E.Hom F) (i : E.I₀) : E.X i ⟶ F.X (self.s₀ i)

Alias of CategoryTheory.PreZeroHypercover.Hom.h₀.

@[deprecated CategoryTheory.PreZeroHypercover.Hom.w₀ (since := "2026-01-13")]

theorem AlgebraicGeometry.Scheme.Cover.Hom.w {C : Type u} [CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreZeroHypercover S} {F : CategoryTheory.PreZeroHypercover S} (self : E.Hom F) (i : E.I₀) : CategoryTheory.CategoryStruct.comp (self.h₀ i) (F.f (self.s₀ i)) = E.f i

Alias of CategoryTheory.PreZeroHypercover.Hom.w₀.

@[deprecated CategoryTheory.PreZeroHypercover.Hom.id (since := "2026-01-13")]

def AlgebraicGeometry.Scheme.Cover.Hom.id {C : Type u} [CategoryTheory.Category.{v, u} C] {S : C} (E : CategoryTheory.PreZeroHypercover S) : E.Hom E

Alias of CategoryTheory.PreZeroHypercover.Hom.id.

@[deprecated CategoryTheory.PreZeroHypercover.Hom.comp (since := "2026-01-13")]

def AlgebraicGeometry.Scheme.Cover.Hom.comp {C : Type u} [CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreZeroHypercover S} {F : CategoryTheory.PreZeroHypercover S} {G : CategoryTheory.PreZeroHypercover S} (f : E.Hom F) (g : F.Hom G) : E.Hom G

Alias of CategoryTheory.PreZeroHypercover.Hom.comp.

@[deprecated CategoryTheory.PreZeroHypercover.id_s₀ (since := "2026-01-13")]

theorem AlgebraicGeometry.Scheme.Cover.id_idx_apply {C : Type u} [CategoryTheory.Category.{v, u} C] {S : C} (E : CategoryTheory.PreZeroHypercover S) (a : E.I₀) : (CategoryTheory.CategoryStruct.id E).s₀ a = a

Alias of CategoryTheory.PreZeroHypercover.id_s₀.

@[deprecated CategoryTheory.PreZeroHypercover.id_h₀ (since := "2026-01-13")]

theorem AlgebraicGeometry.Scheme.Cover.id_app {C : Type u} [CategoryTheory.Category.{v, u} C] {S : C} (E : CategoryTheory.PreZeroHypercover S) (x✝ : E.I₀) : (CategoryTheory.CategoryStruct.id E).h₀ x✝ = CategoryTheory.CategoryStruct.id (E.X x✝)

Alias of CategoryTheory.PreZeroHypercover.id_h₀.

@[deprecated CategoryTheory.PreZeroHypercover.comp_s₀ (since := "2026-01-13")]

theorem AlgebraicGeometry.Scheme.Cover.comp_idx_apply {C : Type u} [CategoryTheory.Category.{v, u} C] {S : C} {X✝ Y✝ Z✝ : CategoryTheory.PreZeroHypercover S} (f : X✝.Hom Y✝) (g : Y✝.Hom Z✝) (a✝ : X✝.I₀) : (CategoryTheory.CategoryStruct.comp f g).s₀ a✝ = g.s₀ (f.s₀ a✝)

Alias of CategoryTheory.PreZeroHypercover.comp_s₀.

@[deprecated CategoryTheory.PreZeroHypercover.comp_h₀ (since := "2026-01-13")]

theorem AlgebraicGeometry.Scheme.Cover.comp_app {C : Type u} [CategoryTheory.Category.{v, u} C] {S : C} {X✝ Y✝ Z✝ : CategoryTheory.PreZeroHypercover S} (f : X✝.Hom Y✝) (g : Y✝.Hom Z✝) (i : X✝.I₀) : (CategoryTheory.CategoryStruct.comp f g).h₀ i = CategoryTheory.CategoryStruct.comp (f.h₀ i) (g.h₀ (f.s₀ i))

Alias of CategoryTheory.PreZeroHypercover.comp_h₀.