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.ho... | 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, ... | 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 (PrimeSpect... | 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 (IsLocaliz... | 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.ι :... | 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 = pullbac... |
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 ... | 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 _ ?_
... | 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
... | 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,... | 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... | 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.H... | 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 [Precover... | 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.toPresheafedSpa... | 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[Algebrai... |
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 [... |
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 usi... | 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... |
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.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 := ... | 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.