fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
Scheme.isoOfEq_inv (X : Scheme.{u}) {U V : X.Opens} (e : U = V) :
(X.isoOfEq e).inv = X.homOfLE e.ge := rfl
@[simp] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | Scheme.isoOfEq_inv | null |
Scheme.isoOfEq_rfl (X : Scheme.{u}) (U : X.Opens) : X.isoOfEq (refl U) = Iso.refl _ := by
ext1
rw [← cancel_mono U.ι, Scheme.isoOfEq_hom_ι, Iso.refl_hom, Category.id_comp] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | Scheme.isoOfEq_rfl | null |
noncomputable Scheme.Hom.preimageIso {X Y : Scheme.{u}} (f : X.Hom Y) [IsIso (C := Scheme) f]
(U : Y.Opens) : (f ⁻¹ᵁ U).toScheme ≅ U := by
apply IsOpenImmersion.isoOfRangeEq (f := (f ⁻¹ᵁ U).ι ≫ f) U.ι _
dsimp
rw [Set.range_comp, Opens.range_ι, Opens.range_ι]
refine @Set.image_preimage_eq _ _ f.base U.1 f.homeomorph.surjective
@[reassoc (attr := simp)] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | Scheme.Hom.preimageIso | The restriction of an isomorphism onto an open set. |
Scheme.Hom.preimageIso_hom_ι {X Y : Scheme.{u}} (f : X.Hom Y) [IsIso (C := Scheme) f]
(U : Y.Opens) : (f.preimageIso U).hom ≫ U.ι = (f ⁻¹ᵁ U).ι ≫ f :=
IsOpenImmersion.isoOfRangeEq_hom_fac _ _ _
@[reassoc (attr := simp)] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | Scheme.Hom.preimageIso_hom_ι | null |
Scheme.Hom.preimageIso_inv_ι {X Y : Scheme.{u}} (f : X.Hom Y) [IsIso (C := Scheme) f]
(U : Y.Opens) : (f.preimageIso U).inv ≫ (f ⁻¹ᵁ U).ι ≫ f = U.ι :=
IsOpenImmersion.isoOfRangeEq_inv_fac _ _ _ | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | Scheme.Hom.preimageIso_inv_ι | null |
noncomputable Scheme.Opens.isoOfLE {X : Scheme.{u}} {U V : X.Opens}
(hUV : U ≤ V) : (V.ι ⁻¹ᵁ U).toScheme ≅ U :=
IsOpenImmersion.isoOfRangeEq ((V.ι ⁻¹ᵁ U).ι ≫ V.ι) U.ι <| by
have : V.ι ''ᵁ (V.ι ⁻¹ᵁ U) = U := by simpa [Scheme.Hom.image_preimage_eq_opensRange_inter]
rw [Scheme.comp_coeBase, TopCat.coe_comp, Scheme.Opens.range_ι, Set.range_comp, ← this]
simp
@[reassoc (attr := simp)] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | Scheme.Opens.isoOfLE | If `U ≤ V` are opens of `X`, the restriction of `U` to `V` is isomorphic to `U`. |
Scheme.Opens.isoOfLE_hom_ι {X : Scheme.{u}} {U V : X.Opens}
(hUV : U ≤ V) :
(Scheme.Opens.isoOfLE hUV).hom ≫ U.ι = (V.ι ⁻¹ᵁ U).ι ≫ V.ι := by
simp [isoOfLE]
@[reassoc (attr := simp)] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | Scheme.Opens.isoOfLE_hom_ι | null |
Scheme.Opens.isoOfLE_inv_ι {X : Scheme.{u}} {U V : X.Opens}
(hUV : U ≤ V) :
(Scheme.Opens.isoOfLE hUV).inv ≫ (V.ι ⁻¹ᵁ U).ι ≫ V.ι = U.ι := by
simp [isoOfLE] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | Scheme.Opens.isoOfLE_inv_ι | null |
basicOpenIsoSpecAway {R : CommRingCat.{u}} (f : R) :
Scheme.Opens.toScheme (X := Spec R) (PrimeSpectrum.basicOpen f) ≅ Spec(Localization.Away f) :=
IsOpenImmersion.isoOfRangeEq (Scheme.Opens.ι _) (Spec.map (CommRingCat.ofHom (algebraMap _ _)))
(by
simp only [Scheme.Opens.range_ι]
exact (PrimeSpectrum.localization_away_comap_range _ _).symm)
@[reassoc] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | basicOpenIsoSpecAway | For `f : R`, `D(f)` as an open subscheme of `Spec R` is isomorphic to `Spec R[1/f]`. |
basicOpenIsoSpecAway_inv_homOfLE {R : CommRingCat.{u}} (f g x : R) (hx : x = f * g) :
haveI : IsLocalization.Away (f * g) (Localization.Away x) := by rw [hx]; infer_instance
(basicOpenIsoSpecAway x).inv ≫ (Spec R).homOfLE (by simp [hx, PrimeSpectrum.basicOpen_mul]) =
Spec.map (CommRingCat.ofHom (IsLocalization.Away.awayToAwayRight f g)) ≫
(basicOpenIsoSpecAway f).inv := by
subst hx
rw [← cancel_mono (Scheme.Opens.ι _)]
simp only [basicOpenIsoSpecAway, Category.assoc, Scheme.homOfLE_ι,
IsOpenImmersion.isoOfRangeEq_inv_fac]
simp only [← Spec.map_comp, ← CommRingCat.ofHom_comp]
congr
ext x
exact (IsLocalization.Away.awayToAwayRight_eq f g x).symm | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | basicOpenIsoSpecAway_inv_homOfLE | null |
pullbackRestrictIsoRestrict {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) :
pullback f (U.ι) ≅ f ⁻¹ᵁ U := by
refine IsOpenImmersion.isoOfRangeEq (pullback.fst f _) (Scheme.Opens.ι _) ?_
simp [IsOpenImmersion.range_pullback_fst_of_right]
@[simp, reassoc] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | pullbackRestrictIsoRestrict | Given a morphism `f : X ⟶ Y` and an open set `U ⊆ Y`, we have `X ×[Y] U ≅ X |_{f ⁻¹ U}` |
pullbackRestrictIsoRestrict_inv_fst {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) :
(pullbackRestrictIsoRestrict f U).inv ≫ pullback.fst f _ = (f ⁻¹ᵁ U).ι := by
delta pullbackRestrictIsoRestrict; simp
@[reassoc (attr := simp)] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | pullbackRestrictIsoRestrict_inv_fst | null |
pullbackRestrictIsoRestrict_hom_ι {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) :
(pullbackRestrictIsoRestrict f U).hom ≫ (f ⁻¹ᵁ U).ι = pullback.fst f _ := by
delta pullbackRestrictIsoRestrict; simp | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | pullbackRestrictIsoRestrict_hom_ι | null |
morphismRestrict {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) : (f ⁻¹ᵁ U).toScheme ⟶ U :=
(pullbackRestrictIsoRestrict f U).inv ≫ pullback.snd _ _ | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | morphismRestrict | The restriction of a morphism `X ⟶ Y` onto `X |_{f ⁻¹ U} ⟶ Y |_ U`. |
morphismRestrictOpensRange
{X Y U : Scheme.{u}} (f : X ⟶ Y) (g : U ⟶ Y) [hg : IsOpenImmersion g] :
Arrow.mk (f ∣_ g.opensRange) ≅ Arrow.mk (pullback.snd f g) := by
let V : Y.Opens := g.opensRange
let e :=
IsOpenImmersion.isoOfRangeEq g V.ι Subtype.range_coe.symm
let t : pullback f g ⟶ pullback f V.ι :=
pullback.map _ _ _ _ (𝟙 _) e.hom (𝟙 _) (by rw [Category.comp_id, Category.id_comp])
(by rw [Category.comp_id, IsOpenImmersion.isoOfRangeEq_hom_fac])
symm
refine Arrow.isoMk (asIso t ≪≫ pullbackRestrictIsoRestrict f V) e ?_
rw [Iso.trans_hom, asIso_hom, ← Iso.comp_inv_eq, ← cancel_mono g, Arrow.mk_hom, Arrow.mk_hom,
Category.assoc, Category.assoc, Category.assoc, IsOpenImmersion.isoOfRangeEq_inv_fac,
← pullback.condition, morphismRestrict_ι,
pullbackRestrictIsoRestrict_hom_ι_assoc, pullback.lift_fst_assoc, Category.comp_id] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | morphismRestrictOpensRange | the notation for restricting a morphism of scheme to an open subset of the target scheme -/
infixl:85 " ∣_ " => morphismRestrict
@[reassoc (attr := simp)]
theorem pullbackRestrictIsoRestrict_hom_morphismRestrict {X Y : Scheme.{u}} (f : X ⟶ Y)
(U : Y.Opens) : (pullbackRestrictIsoRestrict f U).hom ≫ f ∣_ U = pullback.snd _ _ :=
Iso.hom_inv_id_assoc _ _
@[reassoc (attr := simp)]
theorem morphismRestrict_ι {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) :
(f ∣_ U) ≫ U.ι = (f ⁻¹ᵁ U).ι ≫ f := by
delta morphismRestrict
rw [Category.assoc, pullback.condition.symm, pullbackRestrictIsoRestrict_inv_fst_assoc]
theorem isPullback_morphismRestrict {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) :
IsPullback (f ∣_ U) (f ⁻¹ᵁ U).ι U.ι f := by
delta morphismRestrict
rw [← Category.id_comp f]
refine
(IsPullback.of_horiz_isIso ⟨?_⟩).paste_horiz
(IsPullback.of_hasPullback f (Y.ofRestrict U.isOpenEmbedding)).flip
erw [pullbackRestrictIsoRestrict_inv_fst]
rw [Category.comp_id]
lemma isPullback_opens_inf_le {X : Scheme} {U V W : X.Opens} (hU : U ≤ W) (hV : V ≤ W) :
IsPullback (X.homOfLE inf_le_left) (X.homOfLE inf_le_right) (X.homOfLE hU) (X.homOfLE hV) := by
refine (isPullback_morphismRestrict (X.homOfLE hV) (W.ι ⁻¹ᵁ U)).of_iso (V.ι.isoImage _ ≪≫
X.isoOfEq ?_) (W.ι.isoImage _ ≪≫ X.isoOfEq ?_) (Iso.refl _) (Iso.refl _) ?_ ?_ ?_ ?_
· rw [← TopologicalSpace.Opens.map_comp_obj, ← Scheme.comp_base, Scheme.homOfLE_ι]
exact V.functor_map_eq_inf U
· exact (W.functor_map_eq_inf U).trans (by simpa)
all_goals { simp [← cancel_mono (Scheme.Opens.ι _)] }
lemma isPullback_opens_inf {X : Scheme} (U V : X.Opens) :
IsPullback (X.homOfLE inf_le_left) (X.homOfLE inf_le_right) U.ι V.ι :=
(isPullback_morphismRestrict V.ι U).of_iso (V.ι.isoImage _ ≪≫ X.isoOfEq
(V.functor_map_eq_inf U)) (Iso.refl _) (Iso.refl _) (Iso.refl _) (by simp [← cancel_mono U.ι])
(by simp [← cancel_mono V.ι]) (by simp) (by simp)
@[simp]
lemma morphismRestrict_id {X : Scheme.{u}} (U : X.Opens) : 𝟙 X ∣_ U = 𝟙 _ := by
rw [← cancel_mono U.ι, morphismRestrict_ι, Category.comp_id, Category.id_comp]
rfl
theorem morphismRestrict_comp {X Y Z : Scheme.{u}} (f : X ⟶ Y) (g : Y ⟶ Z) (U : Opens Z) :
(f ≫ g) ∣_ U = f ∣_ g ⁻¹ᵁ U ≫ g ∣_ U := by
delta morphismRestrict
rw [← pullbackRightPullbackFstIso_inv_snd_snd]
simp_rw [← Category.assoc]
congr 1
rw [← cancel_mono (pullback.fst _ _)]
simp_rw [Category.assoc]
rw [pullbackRestrictIsoRestrict_inv_fst, pullbackRightPullbackFstIso_inv_snd_fst, ←
pullback.condition, pullbackRestrictIsoRestrict_inv_fst_assoc,
pullbackRestrictIsoRestrict_inv_fst_assoc]
rfl
instance {X Y : Scheme.{u}} (f : X ⟶ Y) [IsIso f] (U : Y.Opens) : IsIso (f ∣_ U) := by
delta morphismRestrict; infer_instance
theorem morphismRestrict_base_coe {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) (x) :
@Coe.coe U Y (⟨fun x => x.1⟩) ((f ∣_ U).base x) = f.base x.1 :=
congr_arg (fun f => (Scheme.Hom.toLRSHom f).base x)
(morphismRestrict_ι f U)
theorem morphismRestrict_base {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) :
⇑(f ∣_ U).base = U.1.restrictPreimage f.base :=
funext fun x => Subtype.ext (morphismRestrict_base_coe f U x)
theorem image_morphismRestrict_preimage {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) (V : Opens U) :
(f ⁻¹ᵁ U).ι ''ᵁ ((f ∣_ U) ⁻¹ᵁ V) = f ⁻¹ᵁ (U.ι ''ᵁ V) := by
ext1
ext x
constructor
· rintro ⟨⟨x, hx⟩, hx' : (f ∣_ U).base _ ∈ V, rfl⟩
refine ⟨⟨_, hx⟩, ?_, rfl⟩
convert hx'
-- Porting note (https://github.com/leanprover-community/mathlib4/issues/11041): `ext1` is not compiling
refine Subtype.ext ?_
exact (morphismRestrict_base_coe f U ⟨x, hx⟩).symm
· rintro ⟨⟨x, hx⟩, hx' : _ ∈ V.1, rfl : x = _⟩
refine ⟨⟨_, hx⟩, (?_ : (f ∣_ U).base ⟨x, hx⟩ ∈ V.1), rfl⟩
convert hx'
-- Porting note (https://github.com/leanprover-community/mathlib4/issues/11041): `ext1` is not compiling
refine Subtype.ext ?_
exact morphismRestrict_base_coe f U ⟨x, hx⟩
lemma eqToHom_eq_homOfLE {C} [Preorder C] {X Y : C} (e : X = Y) : eqToHom e = homOfLE e.le := rfl
open Scheme in
theorem morphismRestrict_app {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) (V : U.toScheme.Opens) :
(f ∣_ U).app V = f.app (U.ι ''ᵁ V) ≫
X.presheaf.map (eqToHom (image_morphismRestrict_preimage f U V)).op := by
have := Scheme.congr_app (morphismRestrict_ι f U) (U.ι ''ᵁ V)
simp only [Scheme.preimage_comp, Opens.toScheme_presheaf_obj, Hom.app_eq_appLE, comp_appLE,
Opens.ι_appLE, eqToHom_op, Opens.toScheme_presheaf_map, eqToHom_unop] at this
have e : U.ι ⁻¹ᵁ (U.ι ''ᵁ V) = V :=
Opens.ext (Set.preimage_image_eq _ Subtype.coe_injective)
have e' : (f ∣_ U) ⁻¹ᵁ V = (f ∣_ U) ⁻¹ᵁ U.ι ⁻¹ᵁ U.ι ''ᵁ V := by rw [e]
simp only [Opens.toScheme_presheaf_obj, Hom.app_eq_appLE, eqToHom_op, Hom.appLE_map]
rw [← (f ∣_ U).appLE_map' _ e', ← (f ∣_ U).map_appLE' _ e]
simp only [Opens.toScheme_presheaf_obj, eqToHom_eq_homOfLE, Opens.toScheme_presheaf_map,
Quiver.Hom.unop_op, Hom.opensFunctor_map_homOfLE]
rw [this, Hom.appLE_map, Hom.appLE_map, Hom.appLE_map]
theorem morphismRestrict_appTop {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) :
(f ∣_ U).appTop = f.app (U.ι ''ᵁ ⊤) ≫
X.presheaf.map (eqToHom (image_morphismRestrict_preimage f U ⊤)).op :=
morphismRestrict_app ..
@[simp]
theorem morphismRestrict_app' {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) (V : Opens U) :
(f ∣_ U).app V = f.appLE _ _ (image_morphismRestrict_preimage f U V).le :=
morphismRestrict_app f U V
@[simp]
theorem morphismRestrict_appLE {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) (V W e) :
(f ∣_ U).appLE V W e = f.appLE (U.ι ''ᵁ V) ((f ⁻¹ᵁ U).ι ''ᵁ W)
((Set.image_mono e).trans (image_morphismRestrict_preimage f U V).le) := by
rw [Scheme.Hom.appLE, morphismRestrict_app', Scheme.Opens.toScheme_presheaf_map,
Scheme.Hom.appLE_map]
theorem Γ_map_morphismRestrict {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) :
Scheme.Γ.map (f ∣_ U).op =
Y.presheaf.map (eqToHom U.isOpenEmbedding_obj_top.symm).op ≫
f.app U ≫ X.presheaf.map (eqToHom (f ⁻¹ᵁ U).isOpenEmbedding_obj_top).op := by
rw [Scheme.Γ_map_op, morphismRestrict_appTop f U, f.naturality_assoc, ← X.presheaf.map_comp]
rfl
/-- Restricting a morphism onto the image of an open immersion is isomorphic to the base change
along the immersion. |
morphismRestrictEq {X Y : Scheme.{u}} (f : X ⟶ Y) {U V : Y.Opens} (e : U = V) :
Arrow.mk (f ∣_ U) ≅ Arrow.mk (f ∣_ V) :=
eqToIso (by subst e; rfl) | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | morphismRestrictEq | The restrictions onto two equal open sets are isomorphic. This currently has bad defeqs when
unfolded, but it should not matter for now. Replace this definition if better defeqs are needed. |
morphismRestrictRestrict {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) (V : U.toScheme.Opens) :
Arrow.mk (f ∣_ U ∣_ V) ≅ Arrow.mk (f ∣_ U.ι ''ᵁ V) := by
refine Arrow.isoMk' _ _ ((Scheme.Opens.ι _).isoImage _ ≪≫ Scheme.isoOfEq _ ?_)
((Scheme.Opens.ι _).isoImage _) ?_
· exact image_morphismRestrict_preimage f U V
· rw [← cancel_mono (Scheme.Opens.ι _), Iso.trans_hom, Category.assoc, Category.assoc,
Category.assoc, morphismRestrict_ι, Scheme.isoOfEq_hom_ι_assoc,
Scheme.Hom.isoImage_hom_ι_assoc,
Scheme.Hom.isoImage_hom_ι,
morphismRestrict_ι_assoc, morphismRestrict_ι] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | morphismRestrictRestrict | Restricting a morphism twice is isomorphic to one restriction. |
morphismRestrictRestrictBasicOpen {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) (r : Γ(Y, U)) :
Arrow.mk (f ∣_ U ∣_
U.toScheme.basicOpen (Y.presheaf.map (eqToHom U.isOpenEmbedding_obj_top).op r)) ≅
Arrow.mk (f ∣_ Y.basicOpen r) := by
refine morphismRestrictRestrict _ _ _ ≪≫ morphismRestrictEq _ ?_
have e := Scheme.preimage_basicOpen U.ι r
rw [Scheme.Opens.ι_app] at e
rw [← U.toScheme.basicOpen_res_eq _ (eqToHom U.inclusion'_map_eq_top).op]
erw [← elementwise_of% Y.presheaf.map_comp]
rw [eqToHom_op, eqToHom_op, eqToHom_map, eqToHom_trans]
erw [← e]
ext1
dsimp [Opens.map_coe]
rw [Set.image_preimage_eq_inter_range, Set.inter_eq_left, Scheme.Opens.range_ι]
exact Y.basicOpen_le r | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | morphismRestrictRestrictBasicOpen | Restricting a morphism twice onto a basic open set is isomorphic to one restriction. |
morphismRestrictStalkMap {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) (x) :
Arrow.mk ((f ∣_ U).stalkMap x) ≅ Arrow.mk (f.stalkMap x.1) := Arrow.isoMk' _ _
(U.stalkIso ((f ∣_ U).base x) ≪≫
(TopCat.Presheaf.stalkCongr _ <| Inseparable.of_eq <| morphismRestrict_base_coe f U x))
((f ⁻¹ᵁ U).stalkIso x) <| by
apply TopCat.Presheaf.stalk_hom_ext
intro V hxV
change ↑(f ⁻¹ᵁ U) at x
simp [Scheme.stalkMap_germ_assoc, Scheme.Hom.appLE] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | morphismRestrictStalkMap | The stalk map of a restriction of a morphism is isomorphic to the stalk map of the original map. |
resLE (f : Hom X Y) (U : Y.Opens) (V : X.Opens) (e : V ≤ f ⁻¹ᵁ U) : V.toScheme ⟶ U.toScheme :=
X.homOfLE e ≫ f ∣_ U
variable (f : X ⟶ Y) {U U' : Y.Opens} {V V' : X.Opens} (e : V ≤ f ⁻¹ᵁ U) | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | resLE | The restriction of a morphism `f : X ⟶ Y` to open sets on the source and target. |
resLE_eq_morphismRestrict : f.resLE U (f ⁻¹ᵁ U) le_rfl = f ∣_ U := by
simp [resLE] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | resLE_eq_morphismRestrict | null |
resLE_id (i : V ≤ V') : resLE (𝟙 X) V' V i = X.homOfLE i := by
simp only [resLE, morphismRestrict_id]
rfl
@[reassoc (attr := simp)] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | resLE_id | null |
resLE_comp_ι : f.resLE U V e ≫ U.ι = V.ι ≫ f := by
simp [resLE]
@[reassoc] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | resLE_comp_ι | null |
resLE_comp_resLE {Z : Scheme.{u}} (g : Y ⟶ Z) {W : Z.Opens} (e') :
f.resLE U V e ≫ g.resLE W U e' = (f ≫ g).resLE W V
(e.trans ((Opens.map f.base).map (homOfLE e')).le) := by
simp [← cancel_mono W.ι]
@[reassoc (attr := simp)] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | resLE_comp_resLE | null |
map_resLE (i : V' ≤ V) :
X.homOfLE i ≫ f.resLE U V e = f.resLE U V' (i.trans e) := by
simp_rw [← resLE_id, resLE_comp_resLE, Category.id_comp]
@[reassoc (attr := simp)] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | map_resLE | null |
resLE_map (i : U ≤ U') :
f.resLE U V e ≫ Y.homOfLE i =
f.resLE U' V (e.trans ((Opens.map f.base).map i.hom).le) := by
simp_rw [← resLE_id, resLE_comp_resLE, Category.comp_id] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | resLE_map | null |
resLE_congr (e₁ : U = U') (e₂ : V = V') (P : MorphismProperty Scheme.{u}) :
P (f.resLE U V e) ↔ P (f.resLE U' V' (e₁ ▸ e₂ ▸ e)) := by
subst e₁; subst e₂; rfl | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | resLE_congr | null |
resLE_preimage (f : X ⟶ Y) {U : Y.Opens} {V : X.Opens} (e : V ≤ f ⁻¹ᵁ U)
(O : U.toScheme.Opens) :
f.resLE U V e ⁻¹ᵁ O = V.ι ⁻¹ᵁ (f ⁻¹ᵁ U.ι ''ᵁ O) := by
rw [← preimage_comp, ← resLE_comp_ι f e, preimage_comp, preimage_image_eq] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | resLE_preimage | null |
le_preimage_resLE_iff {U : Y.Opens} {V : X.Opens} (e : V ≤ f ⁻¹ᵁ U)
(O : U.toScheme.Opens) (W : V.toScheme.Opens) :
W ≤ (f.resLE U V e) ⁻¹ᵁ O ↔ V.ι ''ᵁ W ≤ f ⁻¹ᵁ U.ι ''ᵁ O := by
simp [resLE_preimage, ← image_le_image_iff V.ι, image_preimage_eq_opensRange_inter, V.ι_image_le] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | le_preimage_resLE_iff | null |
resLE_appLE {U : Y.Opens} {V : X.Opens} (e : V ≤ f ⁻¹ᵁ U)
(O : U.toScheme.Opens) (W : V.toScheme.Opens) (e' : W ≤ resLE f U V e ⁻¹ᵁ O) :
(f.resLE U V e).appLE O W e' =
f.appLE (U.ι ''ᵁ O) (V.ι ''ᵁ W) ((le_preimage_resLE_iff f e O W).mp e') := by
simp only [appLE, resLE, comp_coeBase, Opens.map_comp_obj, comp_app, morphismRestrict_app',
homOfLE_leOfHom, homOfLE_app, Category.assoc, Opens.toScheme_presheaf_map, Quiver.Hom.unop_op,
opensFunctor_map_homOfLE]
rw [← X.presheaf.map_comp, ← X.presheaf.map_comp]
rfl
@[simp] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | resLE_appLE | null |
coe_resLE_base (x : V) : ((f.resLE U V e).base x).val = f.base x := by
simp [resLE, morphismRestrict_base] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | coe_resLE_base | null |
resLEStalkMap (x : V) :
Arrow.mk ((f.resLE U V e).stalkMap x) ≅ Arrow.mk (f.stalkMap x) :=
Arrow.isoMk (U.stalkIso _ ≪≫
(Y.presheaf.stalkCongr <| Inseparable.of_eq <| by simp)) (V.stalkIso x) <| by
dsimp
rw [Category.assoc, ← Iso.eq_inv_comp, ← Category.assoc, ← Iso.comp_inv_eq,
Opens.stalkIso_inv, Opens.stalkIso_inv, ← stalkMap_comp,
stalkMap_congr_hom _ _ (resLE_comp_ι f e), stalkMap_comp]
simp | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | resLEStalkMap | The stalk map of `f.resLE U V` at `x : V` is is the stalk map of `f` at `x`. |
noncomputable arrowResLEAppIso (f : X ⟶ Y) (U : Y.Opens) (V : X.Opens) (e : V ≤ f ⁻¹ᵁ U) :
Arrow.mk ((f.resLE U V e).appTop) ≅ Arrow.mk (f.appLE U V e) :=
Arrow.isoMk U.topIso V.topIso <| by
simp only [Arrow.mk_left, Arrow.mk_right, Functor.id_obj, Scheme.Opens.topIso_hom,
eqToHom_op, Arrow.mk_hom, Scheme.Hom.map_appLE]
rw [Scheme.Hom.appTop, ← Scheme.Hom.appLE_eq_app, Scheme.Hom.resLE_appLE, Scheme.Hom.appLE_map] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | arrowResLEAppIso | `f.resLE U V` induces `f.appLE U V` on global sections. |
@[simps! I₀ X f]
noncomputable
Scheme.OpenCover.restrict {X : Scheme.{u}} (𝒰 : X.OpenCover) (U : Opens X) :
U.toScheme.OpenCover := by
refine Cover.copy (𝒰.pullback₁ U.ι) 𝒰.I₀ _ (𝒰.f · ∣_ U) (Equiv.refl _)
(fun i ↦ IsOpenImmersion.isoOfRangeEq (Opens.ι _) (pullback.snd _ _) ?_) ?_
· dsimp only [Precoverage.ZeroHypercover.pullback₁_toPreZeroHypercover,
PreZeroHypercover.pullback₁_I₀, Equiv.refl_apply, PreZeroHypercover.pullback₁_X]
rw [IsOpenImmersion.range_pullback_snd_of_left U.ι (𝒰.f i), Opens.opensRange_ι]
exact Subtype.range_val
· intro i
rw [← cancel_mono U.ι]
simp [morphismRestrict_ι, Equiv.refl_apply, Category.assoc, pullback.condition] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Cover.Open",
"Mathlib.AlgebraicGeometry.Over"
] | Mathlib/AlgebraicGeometry/Restrict.lean | Scheme.OpenCover.restrict | The restriction of an open cover to an open subset. |
Scheme extends LocallyRingedSpace where
local_affine :
∀ x : toLocallyRingedSpace,
∃ (U : OpenNhds x) (R : CommRingCat),
Nonempty
(toLocallyRingedSpace.restrict U.isOpenEmbedding ≅ Spec.toLocallyRingedSpace.obj (op R)) | structure | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Scheme | We define `Scheme` as an `X : LocallyRingedSpace`,
along with a proof that every point has an open neighbourhood `U`
so that the restriction of `X` to `U` is isomorphic,
as a locally ringed space, to `Spec.toLocallyRingedSpace.obj (op R)`
for some `R : CommRingCat`. |
@[app_delab TopCat.carrier]
partial delabAdjoinNotation : Delab := whenPPOption getPPNotation do
guard <| (← getExpr).isAppOfArity ``TopCat.carrier 1
withNaryArg 0 do
guard <| (← getExpr).isAppOfArity ``PresheafedSpace.carrier 3
withNaryArg 2 do
guard <| (← getExpr).isAppOfArity ``SheafedSpace.toPresheafedSpace 3
withNaryArg 2 do
guard <| (← getExpr).isAppOfArity ``LocallyRingedSpace.toSheafedSpace 1
withNaryArg 0 do
guard <| (← getExpr).isAppOfArity ``Scheme.toLocallyRingedSpace 1
withNaryArg 0 do
`(↥$(← delab)) | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | delabAdjoinNotation | Pretty printer for coercing schemes to types. |
Opens (X : Scheme) : Type* := TopologicalSpace.Opens X | abbrev | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Opens | The type of open sets of a scheme. |
Hom (X Y : Scheme)
extends toLRSHom' : X.toLocallyRingedSpace.Hom Y.toLocallyRingedSpace where | structure | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Hom | A morphism between schemes is a morphism between the underlying locally ringed spaces. |
Hom.toLRSHom {X Y : Scheme.{u}} (f : X.Hom Y) :
X.toLocallyRingedSpace ⟶ Y.toLocallyRingedSpace :=
f.toLRSHom' | abbrev | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Hom.toLRSHom | Cast a morphism of schemes into morphisms of local ringed spaces. |
Hom.Simps.toLRSHom {X Y : Scheme.{u}} (f : X.Hom Y) :
X.toLocallyRingedSpace ⟶ Y.toLocallyRingedSpace :=
f.toLRSHom
initialize_simps_projections Hom (toLRSHom' → toLRSHom) | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Hom.Simps.toLRSHom | See Note [custom simps projection] |
protected sheaf (X : Scheme) :=
X.toSheafedSpace.sheaf | abbrev | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | sheaf | Schemes are a full subcategory of locally ringed spaces.
-/
instance : Category Scheme where
Hom := Hom
id X := Hom.mk (𝟙 X.toLocallyRingedSpace)
comp f g := Hom.mk (f.toLRSHom ≫ g.toLRSHom)
/-- `f ⁻¹ᵁ U` is notation for `(Opens.map f.base).obj U`,
the preimage of an open set `U` under `f`. -/
scoped[AlgebraicGeometry] notation3:90 f:91 " ⁻¹ᵁ " U:90 =>
@Functor.obj (Scheme.Opens _) _ (Scheme.Opens _) _
(Opens.map (f : Scheme.Hom _ _).base) U
/-- `Γ(X, U)` is notation for `X.presheaf.obj (op U)`. -/
scoped[AlgebraicGeometry] notation3 "Γ(" X ", " U ")" =>
(PresheafedSpace.presheaf (SheafedSpace.toPresheafedSpace
(LocallyRingedSpace.toSheafedSpace (Scheme.toLocallyRingedSpace X)))).obj
(op (α := Scheme.Opens _) U)
instance {X : Scheme.{u}} : Subsingleton Γ(X, ⊥) :=
CommRingCat.subsingleton_of_isTerminal X.sheaf.isTerminalOfEmpty
@[continuity, fun_prop]
lemma Hom.continuous {X Y : Scheme} (f : X.Hom Y) : Continuous f.base := f.base.hom.2
/-- The structure sheaf of a scheme. |
app (U : Y.Opens) : Γ(Y, U) ⟶ Γ(X, f ⁻¹ᵁ U) :=
f.c.app (op U) | abbrev | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | app | We give schemes the specialization preorder by default.
-/
instance {X : Scheme.{u}} : Preorder X := specializationPreorder X
lemma le_iff_specializes {X : Scheme.{u}} {a b : X} : a ≤ b ↔ b ⤳ a := by rfl
open Order in
lemma height_of_isClosed {X : Scheme} {x : X} (hx : IsClosed {x}) : height x = 0 := by
simp only [height_eq_zero]
intro b _
obtain rfl | h := eq_or_ne b x
· assumption
· have := IsClosed.not_specializes hx rfl h
contradiction
namespace Hom
variable {X Y : Scheme.{u}} (f : Hom X Y) {U U' : Y.Opens} {V V' : X.Opens}
/-- Given a morphism of schemes `f : X ⟶ Y`, and open `U ⊆ Y`,
this is the induced map `Γ(Y, U) ⟶ Γ(X, f ⁻¹ᵁ U)`. |
appTop : Γ(Y, ⊤) ⟶ Γ(X, ⊤) :=
f.app ⊤
@[reassoc] | abbrev | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | appTop | Given a morphism of schemes `f : X ⟶ Y`,
this is the induced map `Γ(Y, ⊤) ⟶ Γ(X, ⊤)`. |
naturality (i : op U' ⟶ op U) :
Y.presheaf.map i ≫ f.app U = f.app U' ≫ X.presheaf.map ((Opens.map f.base).map i.unop).op :=
f.c.naturality i | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | naturality | null |
appLE (U : Y.Opens) (V : X.Opens) (e : V ≤ f ⁻¹ᵁ U) : Γ(Y, U) ⟶ Γ(X, V) :=
f.app U ≫ X.presheaf.map (homOfLE e).op
@[reassoc (attr := simp)] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | appLE | Given a morphism of schemes `f : X ⟶ Y`, and open sets `U ⊆ Y`, `V ⊆ f ⁻¹' U`,
this is the induced map `Γ(Y, U) ⟶ Γ(X, V)`. |
appLE_map (e : V ≤ f ⁻¹ᵁ U) (i : op V ⟶ op V') :
f.appLE U V e ≫ X.presheaf.map i = f.appLE U V' (i.unop.le.trans e) := by
rw [Hom.appLE, Category.assoc, ← Functor.map_comp]
rfl
@[reassoc] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | appLE_map | null |
appLE_map' (e : V ≤ f ⁻¹ᵁ U) (i : V = V') :
f.appLE U V' (i ▸ e) ≫ X.presheaf.map (eqToHom i).op = f.appLE U V e :=
appLE_map _ _ _
@[reassoc (attr := simp)] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | appLE_map' | null |
map_appLE (e : V ≤ f ⁻¹ᵁ U) (i : op U' ⟶ op U) :
Y.presheaf.map i ≫ f.appLE U V e =
f.appLE U' V (e.trans ((Opens.map f.base).map i.unop).le) := by
rw [Hom.appLE, f.naturality_assoc, ← Functor.map_comp]
rfl
@[reassoc] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | map_appLE | null |
map_appLE' (e : V ≤ f ⁻¹ᵁ U) (i : U' = U) :
Y.presheaf.map (eqToHom i).op ≫ f.appLE U' V (i ▸ e) = f.appLE U V e :=
map_appLE _ _ _ | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | map_appLE' | null |
app_eq_appLE {U : Y.Opens} :
f.app U = f.appLE U _ le_rfl := by
simp [Hom.appLE] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | app_eq_appLE | null |
appLE_eq_app {U : Y.Opens} :
f.appLE U (f ⁻¹ᵁ U) le_rfl = f.app U :=
(app_eq_appLE f).symm | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | appLE_eq_app | null |
appLE_congr (e : V ≤ f ⁻¹ᵁ U) (e₁ : U = U') (e₂ : V = V')
(P : ∀ {R S : CommRingCat.{u}} (_ : R ⟶ S), Prop) :
P (f.appLE U V e) ↔ P (f.appLE U' V' (e₁ ▸ e₂ ▸ e)) := by
subst e₁; subst e₂; rfl | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | appLE_congr | null |
stalkMap (x : X) : Y.presheaf.stalk (f.base x) ⟶ X.presheaf.stalk x :=
f.toLRSHom.stalkMap x | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | stalkMap | A morphism of schemes `f : X ⟶ Y` induces a local ring homomorphism from
`Y.presheaf.stalk (f x)` to `X.presheaf.stalk x` for any `x : X`. |
protected ext {f g : X ⟶ Y} (h_base : f.base = g.base)
(h_app : ∀ U, f.app U ≫ X.presheaf.map
(eqToHom congr((Opens.map $h_base.symm).obj U)).op = g.app U) : f = g := by
cases f; cases g; congr 1
exact LocallyRingedSpace.Hom.ext' <| SheafedSpace.ext _ _ h_base
(TopCat.Presheaf.ext fun U ↦ by simpa using h_app U) | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | ext | null |
protected ext' {f g : X ⟶ Y} (h : f.toLRSHom = g.toLRSHom) : f = g := by
cases f; cases g; congr 1 | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | ext' | An alternative ext lemma for scheme morphisms. |
preimage_iSup {ι} (U : ι → Opens Y) : f ⁻¹ᵁ iSup U = ⨆ i, f ⁻¹ᵁ U i :=
Opens.ext (by simp) | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | preimage_iSup | null |
preimage_iSup_eq_top {ι} {U : ι → Opens Y} (hU : iSup U = ⊤) :
⨆ i, f ⁻¹ᵁ U i = ⊤ := f.preimage_iSup U ▸ hU ▸ rfl | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | preimage_iSup_eq_top | null |
preimage_le_preimage_of_le {U U' : Y.Opens} (hUU' : U ≤ U') :
f ⁻¹ᵁ U ≤ f ⁻¹ᵁ U' :=
fun _ ha ↦ hUU' ha | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | preimage_le_preimage_of_le | null |
@[simp]
preimage_comp {X Y Z : Scheme.{u}} (f : X ⟶ Y) (g : Y ⟶ Z) (U) :
(f ≫ g) ⁻¹ᵁ U = f ⁻¹ᵁ g ⁻¹ᵁ U := rfl | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | preimage_comp | null |
@[simps!]
forgetToLocallyRingedSpace : Scheme ⥤ LocallyRingedSpace where
obj := toLocallyRingedSpace
map := Hom.toLRSHom | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | forgetToLocallyRingedSpace | The forgetful functor from `Scheme` to `LocallyRingedSpace`. |
@[simps preimage_toLRSHom]
fullyFaithfulForgetToLocallyRingedSpace :
forgetToLocallyRingedSpace.FullyFaithful where
preimage := Hom.mk | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | fullyFaithfulForgetToLocallyRingedSpace | The forget functor `Scheme ⥤ LocallyRingedSpace` is fully faithful. |
@[simps!]
forgetToTop : Scheme ⥤ TopCat :=
Scheme.forgetToLocallyRingedSpace ⋙ LocallyRingedSpace.forgetToTop | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | forgetToTop | The forgetful functor from `Scheme` to `TopCat`. |
noncomputable homeoOfIso {X Y : Scheme.{u}} (e : X ≅ Y) : X ≃ₜ Y :=
TopCat.homeoOfIso (forgetToTop.mapIso e)
@[simp] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | homeoOfIso | An isomorphism of schemes induces a homeomorphism of the underlying topological spaces. |
coe_homeoOfIso {X Y : Scheme.{u}} (e : X ≅ Y) :
⇑(homeoOfIso e) = e.hom.base := rfl
@[simp] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | coe_homeoOfIso | null |
coe_homeoOfIso_symm {X Y : Scheme.{u}} (e : X ≅ Y) :
⇑(homeoOfIso e.symm) = e.inv.base := rfl
@[simp] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | coe_homeoOfIso_symm | null |
homeoOfIso_symm {X Y : Scheme} (e : X ≅ Y) :
(homeoOfIso e).symm = homeoOfIso e.symm := rfl | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | homeoOfIso_symm | null |
homeoOfIso_apply {X Y : Scheme} (e : X ≅ Y) (x : X) :
homeoOfIso e x = e.hom.base x := rfl
alias _root_.CategoryTheory.Iso.schemeIsoToHomeo := homeoOfIso | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | homeoOfIso_apply | null |
noncomputable Hom.homeomorph {X Y : Scheme.{u}} (f : X.Hom Y) [IsIso (C := Scheme) f] :
X ≃ₜ Y :=
(asIso f).schemeIsoToHomeo
@[simp] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Hom.homeomorph | An isomorphism of schemes induces a homeomorphism of the underlying topological spaces. |
Hom.homeomorph_apply {X Y : Scheme.{u}} (f : X.Hom Y) [IsIso (C := Scheme) f] (x) :
f.homeomorph x = f.base x := rfl | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Hom.homeomorph_apply | null |
hasCoeToTopCat : CoeOut Scheme TopCat where
coe X := X.carrier | instance | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | hasCoeToTopCat | null |
Hom.copyBase {X Y : Scheme} (f : X.Hom Y) (g : X → Y) (h : f.base = g) : X ⟶ Y where
base := TopCat.ofHom ⟨g, h ▸ f.base.1.2⟩
c := f.c ≫ (TopCat.Presheaf.pushforwardEq (by subst h; rfl) _).hom
prop x := by
subst h
convert f.prop x using 4
cat_disch | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Hom.copyBase | forgetful functor to `TopCat` is the same as coercion -/
unif_hint forgetToTop_obj_eq_coe (X : Scheme) where ⊢
forgetToTop.obj X ≟ (X : TopCat)
/-- The forgetful functor from `Scheme` to `Type`. -/
nonrec def forget : Scheme.{u} ⥤ Type u := Scheme.forgetToTop ⋙ forget TopCat
/-- forgetful functor to `Scheme` is the same as coercion -/
-- Schemes are often coerced as types, and it would be useful to have definitionally equal types
-- to be reducibly equal. The alternative is to make `forget` reducible but that option has
-- poor performance consequences.
unif_hint forget_obj_eq_coe (X : Scheme) where ⊢
forget.obj X ≟ (X : Type*)
@[simp] lemma forget_obj (X) : Scheme.forget.obj X = X := rfl
@[simp] lemma forget_map {X Y} (f : X ⟶ Y) : forget.map f = (f.base : X → Y) := rfl
@[simp]
theorem id.base (X : Scheme) : (𝟙 X :).base = 𝟙 _ :=
rfl
@[simp]
theorem id_app {X : Scheme} (U : X.Opens) :
(𝟙 X :).app U = 𝟙 _ := rfl
@[simp]
theorem id_appTop {X : Scheme} :
(𝟙 X :).appTop = 𝟙 _ :=
rfl
@[reassoc]
theorem comp_toLRSHom {X Y Z : Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) :
(f ≫ g).toLRSHom = f.toLRSHom ≫ g.toLRSHom :=
rfl
@[simp, reassoc] -- reassoc lemma does not need `simp`
theorem comp_coeBase {X Y Z : Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) :
(f ≫ g).base = f.base ≫ g.base :=
rfl
@[reassoc]
theorem comp_base {X Y Z : Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) :
(f ≫ g).base = f.base ≫ g.base :=
rfl
theorem comp_base_apply {X Y Z : Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) (x : X) :
(f ≫ g).base x = g.base (f.base x) := by
simp
@[simp, reassoc] -- reassoc lemma does not need `simp`
theorem comp_app {X Y Z : Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) (U) :
(f ≫ g).app U = g.app U ≫ f.app _ :=
rfl
@[simp, reassoc] -- reassoc lemma does not need `simp`
theorem comp_appTop {X Y Z : Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) :
(f ≫ g).appTop = g.appTop ≫ f.appTop :=
rfl
theorem appLE_comp_appLE {X Y Z : Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) (U V W e₁ e₂) :
g.appLE U V e₁ ≫ f.appLE V W e₂ =
(f ≫ g).appLE U W (e₂.trans ((Opens.map f.base).map (homOfLE e₁)).le) := by
dsimp [Hom.appLE]
rw [Category.assoc, f.naturality_assoc, ← Functor.map_comp]
rfl
@[simp, reassoc] -- reassoc lemma does not need `simp`
theorem comp_appLE {X Y Z : Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) (U V e) :
(f ≫ g).appLE U V e = g.app U ≫ f.appLE _ V e := by
rw [g.app_eq_appLE, appLE_comp_appLE]
theorem congr_app {X Y : Scheme} {f g : X ⟶ Y} (e : f = g) (U) :
f.app U = g.app U ≫ X.presheaf.map (eqToHom (by subst e; rfl)).op := by
subst e; simp
theorem app_eq {X Y : Scheme} (f : X ⟶ Y) {U V : Y.Opens} (e : U = V) :
f.app U =
Y.presheaf.map (eqToHom e.symm).op ≫
f.app V ≫
X.presheaf.map (eqToHom (congr_arg (Opens.map f.base).obj e)).op := by
rw [← IsIso.inv_comp_eq, ← Functor.map_inv, f.naturality]
cases e
rfl
theorem eqToHom_c_app {X Y : Scheme} (e : X = Y) (U) :
(eqToHom e).app U = eqToHom (by subst e; rfl) := by subst e; rfl
lemma presheaf_map_eqToHom_op (X : Scheme) (U V : X.Opens) (i : U = V) :
X.presheaf.map (eqToHom i).op = eqToHom (i ▸ rfl) := by
rw [eqToHom_op, eqToHom_map]
instance isIso_toLRSHom {X Y : Scheme} (f : X ⟶ Y) [IsIso f] : IsIso f.toLRSHom :=
forgetToLocallyRingedSpace.map_isIso f
instance isIso_base {X Y : Scheme.{u}} (f : X ⟶ Y) [IsIso f] : IsIso f.base :=
Scheme.forgetToTop.map_isIso f
instance {X Y : Scheme} (f : X ⟶ Y) [IsIso f] (U) : IsIso (f.app U) :=
haveI := PresheafedSpace.c_isIso_of_iso f.toPshHom
NatIso.isIso_app_of_isIso f.c _
@[simp]
theorem inv_app {X Y : Scheme} (f : X ⟶ Y) [IsIso f] (U : X.Opens) :
(inv f).app U =
X.presheaf.map (eqToHom (show (f ≫ inv f) ⁻¹ᵁ U = U by rw [IsIso.hom_inv_id]; rfl)).op ≫
inv (f.app ((inv f) ⁻¹ᵁ U)) := by
rw [IsIso.eq_comp_inv, ← Scheme.comp_app, Scheme.congr_app (IsIso.hom_inv_id f),
Scheme.id_app, Category.id_comp]
theorem inv_appTop {X Y : Scheme} (f : X ⟶ Y) [IsIso f] :
(inv f).appTop = inv (f.appTop) := by simp
/-- Copies a morphism with a different underlying map |
Hom.copyBase_eq {X Y : Scheme} (f : X.Hom Y) (g : X → Y) (h : f.base = g) :
f.copyBase g h = f := by
subst h
obtain ⟨⟨⟨f₁, f₂⟩, f₃⟩, f₄⟩ := f
simp only [Hom.copyBase, LocallyRingedSpace.Hom.toShHom_mk]
congr
cat_disch | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Hom.copyBase_eq | null |
Spec (R : CommRingCat) : Scheme where
local_affine _ := ⟨⟨⊤, trivial⟩, R, ⟨(Spec.toLocallyRingedSpace.obj (op R)).restrictTopIso⟩⟩
toLocallyRingedSpace := Spec.locallyRingedSpaceObj R | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Spec | The spectrum of a commutative ring, as a scheme. |
Spec.map {R S : CommRingCat} (f : R ⟶ S) : Spec S ⟶ Spec R :=
⟨Spec.locallyRingedSpaceMap f⟩
@[simp] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Spec.map | The spectrum of an unbundled ring as a scheme.
WARNING: If `R` is already an element of `CommRingCat`, you should use `Spec R` instead of
`Spec(R)`, which is secretly `Spec(↑R)`. -/
scoped notation3 "Spec("R")" => Spec <| .of R
theorem Spec_toLocallyRingedSpace (R : CommRingCat) :
(Spec R).toLocallyRingedSpace = Spec.locallyRingedSpaceObj R :=
rfl
/-- The induced map of a ring homomorphism on the ring spectra, as a morphism of schemes. |
Spec.map_id (R : CommRingCat) : Spec.map (𝟙 R) = 𝟙 (Spec R) :=
Scheme.Hom.ext' <| Spec.locallyRingedSpaceMap_id R
@[reassoc, simp] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Spec.map_id | null |
Spec.map_comp {R S T : CommRingCat} (f : R ⟶ S) (g : S ⟶ T) :
Spec.map (f ≫ g) = Spec.map g ≫ Spec.map f :=
Scheme.Hom.ext' <| Spec.locallyRingedSpaceMap_comp f g | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Spec.map_comp | null |
@[simps]
protected Scheme.Spec : CommRingCatᵒᵖ ⥤ Scheme where
obj R := Spec (unop R)
map f := Spec.map f.unop
map_id R := by simp
map_comp f g := by simp | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Scheme.Spec | The spectrum, as a contravariant functor from commutative rings to schemes. |
Spec.map_eqToHom {R S : CommRingCat} (e : R = S) :
Spec.map (eqToHom e) = eqToHom (e ▸ rfl) := by
subst e; exact Spec.map_id _ | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Spec.map_eqToHom | null |
@[simp]
Spec.map_inv {R S : CommRingCat} (f : R ⟶ S) [IsIso f] :
Spec.map (inv f) = inv (Spec.map f) := by
change Scheme.Spec.map (inv f).op = inv (Scheme.Spec.map f.op)
rw [op_inv, ← Scheme.Spec.map_inv] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Spec.map_inv | null |
Spec_carrier (R : CommRingCat.{u}) : (Spec R).carrier = PrimeSpectrum R := rfl | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Spec_carrier | null |
Spec_sheaf (R : CommRingCat.{u}) : (Spec R).sheaf = Spec.structureSheaf R := rfl | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Spec_sheaf | null |
Spec_presheaf (R : CommRingCat.{u}) : (Spec R).presheaf = (Spec.structureSheaf R).1 := rfl | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Spec_presheaf | null |
Spec.map_base : (Spec.map f).base = ofHom (PrimeSpectrum.comap f.hom) := rfl | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Spec.map_base | null |
Spec.map_base_apply (x : Spec S) : (Spec.map f).base x = PrimeSpectrum.comap f.hom x := rfl | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Spec.map_base_apply | null |
Spec.map_app (U) :
(Spec.map f).app U =
CommRingCat.ofHom (StructureSheaf.comap f.hom U (Spec.map f ⁻¹ᵁ U) le_rfl) := rfl | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Spec.map_app | null |
Spec.map_appLE {U V} (e : U ≤ Spec.map f ⁻¹ᵁ V) :
(Spec.map f).appLE V U e = CommRingCat.ofHom (StructureSheaf.comap f.hom V U e) := rfl | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Spec.map_appLE | null |
isEmpty_of_commSq {W X Y S : Scheme.{u}} {f : X ⟶ S} {g : Y ⟶ S}
{i : W ⟶ X} {j : W ⟶ Y} (h : CommSq i j f g)
(H : Disjoint (Set.range f.base) (Set.range g.base)) : IsEmpty W :=
⟨fun x ↦ (Set.disjoint_iff_inter_eq_empty.mp H).le
⟨⟨i.base x, congr($(h.w).base x)⟩, ⟨j.base x, rfl⟩⟩⟩ | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | isEmpty_of_commSq | null |
@[simps]
empty : Scheme where
carrier := TopCat.of PEmpty
presheaf := (CategoryTheory.Functor.const _).obj (CommRingCat.of PUnit)
IsSheaf := Presheaf.isSheaf_of_isTerminal _ CommRingCat.punitIsTerminal
isLocalRing x := PEmpty.elim x
local_affine x := PEmpty.elim x | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | empty | The empty scheme. |
Γ : Schemeᵒᵖ ⥤ CommRingCat :=
Scheme.forgetToLocallyRingedSpace.op ⋙ LocallyRingedSpace.Γ | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Γ | The global sections, notated Gamma. |
Γ_def : Γ = Scheme.forgetToLocallyRingedSpace.op ⋙ LocallyRingedSpace.Γ :=
rfl
@[simp] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Γ_def | null |
Γ_obj (X : Schemeᵒᵖ) : Γ.obj X = Γ(unop X, ⊤) :=
rfl | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Γ_obj | null |
Γ_obj_op (X : Scheme) : Γ.obj (op X) = Γ(X, ⊤) :=
rfl
@[simp] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Γ_obj_op | null |
Γ_map {X Y : Schemeᵒᵖ} (f : X ⟶ Y) : Γ.map f = f.unop.appTop :=
rfl | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Γ_map | null |
Γ_map_op {X Y : Scheme} (f : X ⟶ Y) : Γ.map f.op = f.appTop :=
rfl | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | Γ_map_op | null |
SpecΓIdentity : Scheme.Spec.rightOp ⋙ Scheme.Γ ≅ 𝟭 _ :=
Iso.symm <| NatIso.ofComponents.{u,u,u+1,u+1}
(fun R => asIso (StructureSheaf.toOpen R ⊤))
(fun {X Y} f => by convert Spec_Γ_naturality (R := X) (S := Y) f)
variable (R : CommRingCat.{u}) | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | SpecΓIdentity | The counit (`SpecΓIdentity.inv.op`) of the adjunction `Γ ⊣ Spec` as an isomorphism.
This is almost never needed in practical use cases. Use `ΓSpecIso` instead. |
ΓSpecIso : Γ(Spec R, ⊤) ≅ R := SpecΓIdentity.app R
@[simp] lemma SpecΓIdentity_app : SpecΓIdentity.app R = ΓSpecIso R := rfl
@[simp] lemma SpecΓIdentity_hom_app : SpecΓIdentity.hom.app R = (ΓSpecIso R).hom := rfl
@[simp] lemma SpecΓIdentity_inv_app : SpecΓIdentity.inv.app R = (ΓSpecIso R).inv := rfl
@[reassoc (attr := simp)] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | ΓSpecIso | The global sections of `Spec R` is isomorphic to `R`. |
ΓSpecIso_naturality {R S : CommRingCat.{u}} (f : R ⟶ S) :
(Spec.map f).appTop ≫ (ΓSpecIso S).hom = (ΓSpecIso R).hom ≫ f := SpecΓIdentity.hom.naturality f
@[reassoc (attr := simp)] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | ΓSpecIso_naturality | null |
ΓSpecIso_inv_naturality {R S : CommRingCat.{u}} (f : R ⟶ S) :
f ≫ (ΓSpecIso S).inv = (ΓSpecIso R).inv ≫ (Spec.map f).appTop := SpecΓIdentity.inv.naturality f | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | ΓSpecIso_inv_naturality | null |
ΓSpecIso_inv : (ΓSpecIso R).inv = StructureSheaf.toOpen R ⊤ := rfl | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | ΓSpecIso_inv | null |
toOpen_eq (U) :
(by exact StructureSheaf.toOpen R U) =
(ΓSpecIso R).inv ≫ (Spec R).presheaf.map (homOfLE le_top).op := rfl | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Spec",
"Mathlib.Algebra.Category.Ring.Constructions",
"Mathlib.CategoryTheory.Elementwise"
] | Mathlib/AlgebraicGeometry/Scheme.lean | toOpen_eq | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.