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 ⌀ |
|---|---|---|---|---|---|---|
Spec.map_surjective {R S : CommRingCat} :
Function.Surjective (Spec.map : (R ⟶ S) → _) := by
intro f
use Spec.preimage f
simp | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] | Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean | Spec.map_surjective | Useful for replacing `f` by `Spec.map φ` everywhere in proofs. |
@[simps]
Spec.homEquiv {R S : CommRingCat} : (Spec S ⟶ Spec R) ≃ (R ⟶ S) where
toFun := Spec.preimage
invFun := Spec.map
left_inv := Spec.map_preimage
right_inv := Spec.preimage_map
@[simp] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] | Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean | Spec.homEquiv | Spec is fully faithful |
Spec.preimage_id {R : CommRingCat} : Spec.preimage (𝟙 (Spec R)) = 𝟙 R :=
Spec.map_injective (by simp)
@[simp, reassoc] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] | Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean | Spec.preimage_id | null |
Spec.preimage_comp {R S T : CommRingCat} (f : Spec R ⟶ Spec S) (g : Spec S ⟶ Spec T) :
Spec.preimage (f ≫ g) = Spec.preimage g ≫ Spec.preimage f :=
Spec.map_injective (by simp) | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] | Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean | Spec.preimage_comp | null |
Spec.reflective : Reflective Scheme.Spec where
L := Scheme.Γ.rightOp
adj := ΓSpec.adjunction | instance | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] | Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean | Spec.reflective | null |
GlueData extends CategoryTheory.GlueData Scheme where
f_open : ∀ i j, IsOpenImmersion (f i j)
attribute [instance] GlueData.f_open | structure | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | GlueData | A family of gluing data consists of
1. An index type `J`
2. A scheme `U i` for each `i : J`.
3. A scheme `V i j` for each `i j : J`.
(Note that this is `J × J → Scheme` rather than `J → J → Scheme` to connect to the
limits library easier.)
4. An open immersion `f i j : V i j ⟶ U i` for each `i j : ι`.
5. A transition map `t i j : V i j ⟶ V j i` for each `i j : ι`.
such that
6. `f i i` is an isomorphism.
7. `t i i` is the identity.
8. `V i j ×[U i] V i k ⟶ V i j ⟶ V j i` factors through `V j k ×[U j] V j i ⟶ V j i` via some
`t' : V i j ×[U i] V i k ⟶ V j k ×[U j] V j i`.
9. `t' i j k ≫ t' j k i ≫ t' k i j = 𝟙 _`.
We can then glue the schemes `U i` together by identifying `V i j` with `V j i`, such
that the `U i`'s are open subschemes of the glued space. |
toLocallyRingedSpaceGlueData : LocallyRingedSpace.GlueData :=
{ f_open := D.f_open
toGlueData := 𝖣.mapGlueData forgetToLocallyRingedSpace } | abbrev | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | toLocallyRingedSpaceGlueData | The glue data of locally ringed spaces associated to a family of glue data of schemes. |
gluedScheme : Scheme := by
apply LocallyRingedSpace.IsOpenImmersion.scheme
D.toLocallyRingedSpaceGlueData.toGlueData.glued
intro x
obtain ⟨i, y, rfl⟩ := D.toLocallyRingedSpaceGlueData.ι_jointly_surjective x
obtain ⟨j, z, hz⟩ := (D.U i).affineCover.exists_eq y
refine ⟨_, ((D.U i).affineCover.f j).toLRSHom ≫
D.toLocallyRingedSpaceGlueData.toGlueData.ι i, ?_⟩
constructor
· simp only [LocallyRingedSpace.comp_toShHom, SheafedSpace.comp_base, TopCat.hom_comp,
ContinuousMap.coe_comp, Set.range_comp]
exact Set.mem_image_of_mem _ ⟨z, hz⟩
· infer_instance | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | gluedScheme | (Implementation). The glued scheme of a glue data.
This should not be used outside this file. Use `AlgebraicGeometry.Scheme.GlueData.glued` instead. |
glued : Scheme :=
𝖣.glued | abbrev | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | glued | The glued scheme of a glued space. |
ι (i : D.J) : D.U i ⟶ D.glued :=
𝖣.ι i | abbrev | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | ι | The immersion from `D.U i` into the glued space. |
isoLocallyRingedSpace :
D.glued.toLocallyRingedSpace ≅ D.toLocallyRingedSpaceGlueData.toGlueData.glued :=
𝖣.gluedIso forgetToLocallyRingedSpace | abbrev | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | isoLocallyRingedSpace | The gluing as sheafed spaces is isomorphic to the gluing as presheafed spaces. |
ι_isoLocallyRingedSpace_inv (i : D.J) :
D.toLocallyRingedSpaceGlueData.toGlueData.ι i ≫
D.isoLocallyRingedSpace.inv = (𝖣.ι i).toLRSHom :=
𝖣.ι_gluedIso_inv forgetToLocallyRingedSpace i | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | ι_isoLocallyRingedSpace_inv | null |
ι_isOpenImmersion (i : D.J) : IsOpenImmersion (𝖣.ι i) := by
rw [IsOpenImmersion, ← D.ι_isoLocallyRingedSpace_inv]; infer_instance | instance | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | ι_isOpenImmersion | null |
ι_jointly_surjective (x : 𝖣.glued.carrier) :
∃ (i : D.J) (y : (D.U i).carrier), (D.ι i).base y = x :=
𝖣.ι_jointly_surjective forget x | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | ι_jointly_surjective | null |
@[simp (high), reassoc]
glue_condition (i j : D.J) : D.t i j ≫ D.f j i ≫ D.ι j = D.f i j ≫ D.ι i :=
𝖣.glue_condition i j | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | glue_condition | Promoted to higher priority to short circuit simplifier. |
vPullbackCone (i j : D.J) : PullbackCone (D.ι i) (D.ι j) :=
PullbackCone.mk (D.f i j) (D.t i j ≫ D.f j i) (by simp) | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | vPullbackCone | The pullback cone spanned by `V i j ⟶ U i` and `V i j ⟶ U j`.
This is a pullback diagram (`vPullbackConeIsLimit`). |
vPullbackConeIsLimit (i j : D.J) : IsLimit (D.vPullbackCone i j) :=
𝖣.vPullbackConeIsLimitOfMap forgetToLocallyRingedSpace i j
(D.toLocallyRingedSpaceGlueData.vPullbackConeIsLimit _ _)
local notation "D_" => TopCat.GlueData.toGlueData <|
D.toLocallyRingedSpaceGlueData.toSheafedSpaceGlueData.toPresheafedSpaceGlueData.toTopGlueData | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | vPullbackConeIsLimit | The following diagram is a pullback, i.e. `Vᵢⱼ` is the intersection of `Uᵢ` and `Uⱼ` in `X`.
```
Vᵢⱼ ⟶ Uᵢ
| |
↓ ↓
Uⱼ ⟶ X
``` |
isoCarrier :
D.glued.carrier ≅ (D_).glued := by
refine (PresheafedSpace.forget _).mapIso ?_ ≪≫
GlueData.gluedIso _ (PresheafedSpace.forget.{_, _, u} _)
refine SheafedSpace.forgetToPresheafedSpace.mapIso ?_ ≪≫
SheafedSpace.GlueData.isoPresheafedSpace _
refine LocallyRingedSpace.forgetToSheafedSpace.mapIso ?_ ≪≫
LocallyRingedSpace.GlueData.isoSheafedSpace _
exact Scheme.GlueData.isoLocallyRingedSpace _
@[simp] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | isoCarrier | The underlying topological space of the glued scheme is isomorphic to the gluing of the
underlying spaces |
ι_isoCarrier_inv (i : D.J) :
(D_).ι i ≫ D.isoCarrier.inv = (D.ι i).base := by
delta isoCarrier
rw [Iso.trans_inv, GlueData.ι_gluedIso_inv_assoc, Functor.mapIso_inv, Iso.trans_inv,
Functor.mapIso_inv, Iso.trans_inv, SheafedSpace.forgetToPresheafedSpace_map,
PresheafedSpace.forget_map,
PresheafedSpace.forget_map, ← PresheafedSpace.comp_base, ← Category.assoc,
D.toLocallyRingedSpaceGlueData.toSheafedSpaceGlueData.ι_isoPresheafedSpace_inv i]
erw [← Category.assoc, D.toLocallyRingedSpaceGlueData.ι_isoSheafedSpace_inv i]
change (_ ≫ D.isoLocallyRingedSpace.inv).base = _
rw [D.ι_isoLocallyRingedSpace_inv i] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | ι_isoCarrier_inv | null |
Rel (a b : Σ i, ((D.U i).carrier : Type _)) : Prop :=
∃ x : (D.V (a.1, b.1)).carrier, (D.f _ _).base x = a.2 ∧ (D.t _ _ ≫ D.f _ _).base x = b.2 | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | Rel | An equivalence relation on `Σ i, D.U i` that holds iff `𝖣.ι i x = 𝖣.ι j y`.
See `AlgebraicGeometry.Scheme.GlueData.ι_eq_iff`. |
ι_eq_iff (i j : D.J) (x : (D.U i).carrier) (y : (D.U j).carrier) :
(𝖣.ι i).base x = (𝖣.ι j).base y ↔ D.Rel ⟨i, x⟩ ⟨j, y⟩ := by
refine Iff.trans ?_
(TopCat.GlueData.ι_eq_iff_rel
D.toLocallyRingedSpaceGlueData.toSheafedSpaceGlueData.toPresheafedSpaceGlueData.toTopGlueData
i j x y)
rw [← ((TopCat.mono_iff_injective D.isoCarrier.inv).mp _).eq_iff, ← ConcreteCategory.comp_apply]
· simp_rw [← D.ι_isoCarrier_inv]
rfl -- `rfl` was not needed before https://github.com/leanprover-community/mathlib4/pull/13170
· infer_instance | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | ι_eq_iff | null |
isOpen_iff (U : Set D.glued.carrier) : IsOpen U ↔ ∀ i, IsOpen ((D.ι i).base ⁻¹' U) := by
rw [← (TopCat.homeoOfIso D.isoCarrier.symm).isOpen_preimage, TopCat.GlueData.isOpen_iff]
apply forall_congr'
intro i
rw [← Set.preimage_comp, ← ι_isoCarrier_inv]
rfl | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | isOpen_iff | null |
@[simps -isSimp]
openCover (D : Scheme.GlueData) : OpenCover D.glued where
I₀ := D.J
X := D.U
f := D.ι
mem₀ := by
rw [presieve₀_mem_precoverage_iff]
exact ⟨D.ι_jointly_surjective, inferInstance⟩ | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | openCover | The open cover of the glued space given by the glue data. |
gluedCoverT' (x y z : 𝒰.I₀) :
pullback (pullback.fst (𝒰.f x) (𝒰.f y)) (pullback.fst (𝒰.f x) (𝒰.f z)) ⟶
pullback (pullback.fst (𝒰.f y) (𝒰.f z)) (pullback.fst (𝒰.f y) (𝒰.f x)) := by
refine (pullbackRightPullbackFstIso _ _ _).hom ≫ ?_
refine ?_ ≫ (pullbackSymmetry _ _).hom
refine ?_ ≫ (pullbackRightPullbackFstIso _ _ _).inv
refine pullback.map _ _ _ _ (pullbackSymmetry _ _).hom (𝟙 _) (𝟙 _) ?_ ?_
· simp [pullback.condition]
· simp
@[simp, reassoc] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | gluedCoverT' | (Implementation) the transition maps in the glue data associated with an open cover. |
gluedCoverT'_fst_fst (x y z : 𝒰.I₀) :
𝒰.gluedCoverT' x y z ≫ pullback.fst _ _ ≫ pullback.fst _ _ =
pullback.fst _ _ ≫ pullback.snd _ _ := by
delta gluedCoverT'; simp
@[simp, reassoc] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | gluedCoverT'_fst_fst | null |
gluedCoverT'_fst_snd (x y z : 𝒰.I₀) :
gluedCoverT' 𝒰 x y z ≫ pullback.fst _ _ ≫ pullback.snd _ _ =
pullback.snd _ _ ≫ pullback.snd _ _ := by
delta gluedCoverT'; simp
@[simp, reassoc] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | gluedCoverT'_fst_snd | null |
gluedCoverT'_snd_fst (x y z : 𝒰.I₀) :
gluedCoverT' 𝒰 x y z ≫ pullback.snd _ _ ≫ pullback.fst _ _ =
pullback.fst _ _ ≫ pullback.snd _ _ := by
delta gluedCoverT'; simp
@[simp, reassoc] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | gluedCoverT'_snd_fst | null |
gluedCoverT'_snd_snd (x y z : 𝒰.I₀) :
gluedCoverT' 𝒰 x y z ≫ pullback.snd _ _ ≫ pullback.snd _ _ =
pullback.fst _ _ ≫ pullback.fst _ _ := by
delta gluedCoverT'; simp | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | gluedCoverT'_snd_snd | null |
glued_cover_cocycle_fst (x y z : 𝒰.I₀) :
gluedCoverT' 𝒰 x y z ≫ gluedCoverT' 𝒰 y z x ≫ gluedCoverT' 𝒰 z x y ≫ pullback.fst _ _ =
pullback.fst _ _ := by
apply pullback.hom_ext <;> simp | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | glued_cover_cocycle_fst | null |
glued_cover_cocycle_snd (x y z : 𝒰.I₀) :
gluedCoverT' 𝒰 x y z ≫ gluedCoverT' 𝒰 y z x ≫ gluedCoverT' 𝒰 z x y ≫ pullback.snd _ _ =
pullback.snd _ _ := by
apply pullback.hom_ext <;> simp [pullback.condition] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | glued_cover_cocycle_snd | null |
glued_cover_cocycle (x y z : 𝒰.I₀) :
gluedCoverT' 𝒰 x y z ≫ gluedCoverT' 𝒰 y z x ≫ gluedCoverT' 𝒰 z x y = 𝟙 _ := by
apply pullback.hom_ext <;> simp_rw [Category.id_comp, Category.assoc]
· apply glued_cover_cocycle_fst
· apply glued_cover_cocycle_snd | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | glued_cover_cocycle | null |
@[simps]
gluedCover : Scheme.GlueData.{u} where
J := 𝒰.I₀
U := 𝒰.X
V := fun ⟨x, y⟩ => pullback (𝒰.f x) (𝒰.f y)
f _ _ := pullback.fst _ _
f_id _ := inferInstance
t _ _ := (pullbackSymmetry _ _).hom
t_id x := by simp
t' x y z := gluedCoverT' 𝒰 x y z
t_fac x y z := by apply pullback.hom_ext <;> simp
cocycle x y z := glued_cover_cocycle 𝒰 x y z
f_open _ := inferInstance | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | gluedCover | The glue data associated with an open cover.
The canonical isomorphism `𝒰.gluedCover.glued ⟶ X` is provided by `𝒰.fromGlued`. |
fromGlued : 𝒰.gluedCover.glued ⟶ X := by
fapply Multicoequalizer.desc
· exact fun x => 𝒰.f x
rintro ⟨x, y⟩
change pullback.fst _ _ ≫ _ = ((pullbackSymmetry _ _).hom ≫ pullback.fst _ _) ≫ _
simpa using pullback.condition
@[simp, reassoc] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | fromGlued | The canonical morphism from the gluing of an open cover of `X` into `X`.
This is an isomorphism, as witnessed by an `IsIso` instance. |
ι_fromGlued (x : 𝒰.I₀) : 𝒰.gluedCover.ι x ≫ 𝒰.fromGlued = 𝒰.f x :=
Multicoequalizer.π_desc _ _ _ _ _ | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | ι_fromGlued | null |
fromGlued_injective : Function.Injective 𝒰.fromGlued.base := by
intro x y h
obtain ⟨i, x, rfl⟩ := 𝒰.gluedCover.ι_jointly_surjective x
obtain ⟨j, y, rfl⟩ := 𝒰.gluedCover.ι_jointly_surjective y
rw [← ConcreteCategory.comp_apply, ← ConcreteCategory.comp_apply] at h
simp_rw [← Scheme.comp_base] at h
rw [ι_fromGlued, ι_fromGlued] at h
let e :=
(TopCat.pullbackConeIsLimit _ _).conePointUniqueUpToIso
(isLimitOfHasPullbackOfPreservesLimit Scheme.forgetToTop (𝒰.f i) (𝒰.f j))
rw [𝒰.gluedCover.ι_eq_iff]
use e.hom ⟨⟨x, y⟩, h⟩
constructor
· erw [← ConcreteCategory.comp_apply e.hom,
IsLimit.conePointUniqueUpToIso_hom_comp _ _ WalkingCospan.left]
rfl
· erw [← ConcreteCategory.comp_apply e.hom, pullbackSymmetry_hom_comp_fst,
IsLimit.conePointUniqueUpToIso_hom_comp _ _ WalkingCospan.right]
rfl | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | fromGlued_injective | null |
fromGlued_stalk_iso (x : 𝒰.gluedCover.glued.carrier) :
IsIso (𝒰.fromGlued.stalkMap x) := by
obtain ⟨i, x, rfl⟩ := 𝒰.gluedCover.ι_jointly_surjective x
have := stalkMap_congr_hom _ _ (𝒰.ι_fromGlued i) x
rw [stalkMap_comp, ← IsIso.eq_comp_inv] at this
rw [this]
infer_instance | instance | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | fromGlued_stalk_iso | null |
fromGlued_open_map : IsOpenMap 𝒰.fromGlued.base := by
intro U hU
rw [isOpen_iff_forall_mem_open]
intro x hx
rw [𝒰.gluedCover.isOpen_iff] at hU
use 𝒰.fromGlued.base '' U ∩ Set.range (𝒰.f (𝒰.idx x)).base
use Set.inter_subset_left
constructor
· rw [← Set.image_preimage_eq_inter_range]
apply (show IsOpenImmersion (𝒰.f (𝒰.idx x)) from inferInstance).base_open.isOpenMap
convert hU (𝒰.idx x) using 1
simp only [← ι_fromGlued, gluedCover_U, comp_coeBase, TopCat.hom_comp, ContinuousMap.coe_comp,
Set.preimage_comp]
congr! 1
exact Set.preimage_image_eq _ 𝒰.fromGlued_injective
· exact ⟨hx, 𝒰.covers x⟩ | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | fromGlued_open_map | null |
fromGlued_isOpenEmbedding : IsOpenEmbedding 𝒰.fromGlued.base :=
.of_continuous_injective_isOpenMap (by fun_prop) 𝒰.fromGlued_injective 𝒰.fromGlued_open_map | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | fromGlued_isOpenEmbedding | null |
fromGlued_open_immersion : IsOpenImmersion 𝒰.fromGlued :=
IsOpenImmersion.of_stalk_iso _ 𝒰.fromGlued_isOpenEmbedding | instance | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | fromGlued_open_immersion | null |
glueMorphisms (𝒰 : OpenCover.{v} X) {Y : Scheme.{u}} (f : ∀ x, 𝒰.X x ⟶ Y)
(hf : ∀ x y, pullback.fst (𝒰.f x) (𝒰.f y) ≫ f x = pullback.snd _ _ ≫ f y) :
X ⟶ Y := by
refine inv 𝒰.ulift.fromGlued ≫ ?_
fapply Multicoequalizer.desc
· exact fun i ↦ f _
rintro ⟨i, j⟩
dsimp
change pullback.fst _ _ ≫ f _ = (_ ≫ _) ≫ f _
simpa [pullbackSymmetry_hom_comp_fst] using hf _ _ | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | glueMorphisms | Given an open cover of `X`, and a morphism `𝒰.X x ⟶ Y` for each open subscheme in the cover,
such that these morphisms are compatible in the intersection (pullback), we may glue the morphisms
together into a morphism `X ⟶ Y`.
Note:
If `X` is exactly (defeq to) the gluing of `U i`, then using `Multicoequalizer.desc` suffices. |
hom_ext (𝒰 : OpenCover.{v} X) {Y : Scheme} (f₁ f₂ : X ⟶ Y)
(h : ∀ x, 𝒰.f x ≫ f₁ = 𝒰.f x ≫ f₂) : f₁ = f₂ := by
rw [← cancel_epi 𝒰.ulift.fromGlued]
apply Multicoequalizer.hom_ext
intro x
rw [fromGlued, Multicoequalizer.π_desc_assoc, Multicoequalizer.π_desc_assoc]
exact h _
@[simp, reassoc] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | hom_ext | null |
ι_glueMorphisms (𝒰 : OpenCover.{v} X) {Y : Scheme} (f : ∀ x, 𝒰.X x ⟶ Y)
(hf : ∀ x y, pullback.fst (𝒰.f x) (𝒰.f y) ≫ f x = pullback.snd _ _ ≫ f y)
(x : 𝒰.I₀) : 𝒰.f x ≫ 𝒰.glueMorphisms f hf = f x := by
refine Cover.hom_ext (𝒰.ulift.pullback₁ (𝒰.f x)) _ _ fun i ↦ ?_
dsimp only [Precoverage.ZeroHypercover.pullback₁_toPreZeroHypercover,
PreZeroHypercover.pullback₁_X, ulift_X, ulift_f, PreZeroHypercover.pullback₁_f]
simp_rw [pullback.condition_assoc, ← ulift_f, ← ι_fromGlued, Category.assoc, glueMorphisms,
IsIso.hom_inv_id_assoc, ulift_f, hf]
erw [Multicoequalizer.π_desc] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | ι_glueMorphisms | null |
hom_ext_of_forall {X Y : Scheme} (f g : X ⟶ Y)
(H : ∀ x : X, ∃ U : X.Opens, x ∈ U ∧ U.ι ≫ f = U.ι ≫ g) : f = g := by
choose U hxU hU using H
let 𝒰 : X.OpenCover := {
I₀ := X, X i := (U i), f i := (U i).ι,
mem₀ := by
rw [presieve₀_mem_precoverage_iff]
refine ⟨fun x ↦ ⟨x, by simpa using hxU x⟩, inferInstance⟩ }
exact 𝒰.hom_ext _ _ hU
/-! | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | hom_ext_of_forall | null |
noncomputable
V (i j : J) : (F.obj i).Opens := ⨆ (k : Σ k, (k ⟶ i) × (k ⟶ j)), (F.map k.2.1).opensRange | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | V | (Implementation detail)
The intersection `V` in the glue data associated to a locally directed diagram. |
V_self (i) : V F i i = ⊤ :=
top_le_iff.mp (le_iSup_of_le ⟨i, 𝟙 _, 𝟙 _⟩ (by simp [Scheme.Hom.opensRange_of_isIso]))
variable [(F ⋙ forget).IsLocallyDirected] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | V_self | null |
exists_of_pullback_V_V {i j k : J} (x : pullback (C := Scheme) (V F i j).ι (V F i k).ι) :
∃ (l : J) (fi : l ⟶ i) (fj : l ⟶ j) (fk : l ⟶ k)
(α : F.obj l ⟶ pullback (V F i j).ι (V F i k).ι) (z : F.obj l),
IsOpenImmersion α ∧
α ≫ pullback.fst _ _ = (F.map fi).isoOpensRange.hom ≫
(F.obj i).homOfLE (le_iSup_of_le ⟨l, _, fj⟩ le_rfl) ∧
α ≫ pullback.snd _ _ = (F.map fi).isoOpensRange.hom ≫
(F.obj i).homOfLE (le_iSup_of_le ⟨l, _, fk⟩ le_rfl) ∧
α.base z = x := by
obtain ⟨k₁, y₁, hy₁⟩ := mem_iSup.mp ((pullback.fst (C := Scheme) _ _).base x).2
obtain ⟨k₂, y₂, hy₂⟩ := mem_iSup.mp ((pullback.snd (C := Scheme) _ _).base x).2
obtain ⟨l, hli, hlk, z, rfl, rfl⟩ :=
(F ⋙ forget).exists_map_eq_of_isLocallyDirected k₁.2.1 k₂.2.1 y₁ y₂
(by simpa [hy₁, hy₂] using congr($(pullback.condition (f := (V F i j).ι)).base x))
let α : F.obj l ⟶ pullback (V F i j).ι (V F i k).ι :=
pullback.lift
((F.map (hli ≫ k₁.2.1)).isoOpensRange.hom ≫ Scheme.homOfLE _
(le_iSup_of_le ⟨l, hli ≫ k₁.2.1, hli ≫ k₁.2.2⟩ le_rfl))
((F.map (hli ≫ k₁.2.1)).isoOpensRange.hom ≫ Scheme.homOfLE _
(le_iSup_of_le ⟨l, hli ≫ k₁.2.1, hlk ≫ k₂.2.2⟩ le_rfl))
(by simp)
have : IsOpenImmersion α := by
apply (config := { allowSynthFailures := true }) IsOpenImmersion.of_comp
· exact inferInstanceAs (IsOpenImmersion (pullback.fst _ _))
· simp only [limit.lift_π, PullbackCone.mk_pt, PullbackCone.mk_π_app, α]
infer_instance
have : α.base z = x := by
apply (pullback.fst (C := Scheme) _ _).isOpenEmbedding.injective
apply (V F i j).ι.isOpenEmbedding.injective
rw [← Scheme.comp_base_apply, ← Scheme.comp_base_apply, pullback.lift_fst_assoc]
simpa using hy₁
exact ⟨l, hli ≫ k₁.2.1, hli ≫ k₁.2.2, hlk ≫ k₂.2.2, α, z, ‹_›, by simp [α], by simp [α], ‹_›⟩
variable [Quiver.IsThin J] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | exists_of_pullback_V_V | null |
fst_inv_eq_snd_inv
{i j : J} (k₁ k₂ : (k : J) × (k ⟶ i) × (k ⟶ j)) {U : (F.obj i).Opens}
(h₁ : (F.map k₁.2.1).opensRange ≤ U) (h₂ : (F.map k₂.2.1).opensRange ≤ U) :
pullback.fst ((F.obj i).homOfLE h₁) ((F.obj i).homOfLE h₂) ≫
(F.map k₁.2.1).isoOpensRange.inv ≫ F.map k₁.2.2 =
pullback.snd ((F.obj i).homOfLE h₁) ((F.obj i).homOfLE h₂) ≫
(F.map k₂.2.1).isoOpensRange.inv ≫ F.map k₂.2.2 := by
apply Scheme.hom_ext_of_forall
intro x
obtain ⟨l, hli, hlj, y, hy₁, hy₂⟩ := (F ⋙ forget).exists_map_eq_of_isLocallyDirected k₁.2.1 k₂.2.1
((pullback.fst _ _ ≫ (F.map k₁.2.1).isoOpensRange.inv).base x)
((pullback.snd _ _ ≫ (F.map k₂.2.1).isoOpensRange.inv).base x) (by
simp only [Functor.comp_obj, forget_obj, Functor.comp_map, forget_map, ← comp_base_apply,
Category.assoc, Hom.isoOpensRange_inv_comp]
congr 5
simpa using congr($(pullback.condition (f := (F.obj i).homOfLE h₁)
(g := (F.obj i).homOfLE h₂)) ≫ Scheme.Opens.ι _))
let α : F.obj l ⟶ pullback ((F.obj i).homOfLE h₁) ((F.obj i).homOfLE h₂) :=
pullback.lift
(F.map hli ≫ (F.map k₁.2.1).isoOpensRange.hom)
(F.map hlj ≫ (F.map k₂.2.1).isoOpensRange.hom)
(by simp [← cancel_mono (Scheme.Opens.ι _), ← Functor.map_comp,
Subsingleton.elim (hli ≫ k₁.2.1) (hlj ≫ k₂.2.1)])
have : IsOpenImmersion α := by
have : IsOpenImmersion (α ≫ pullback.fst _ _) := by
simp only [pullback.lift_fst, α]; infer_instance
exact .of_comp _ (pullback.fst _ _)
have : α.base y = x := by
simp only [Functor.comp_obj, forget_obj, Functor.comp_map, forget_map, comp_coeBase,
TopCat.hom_comp, ContinuousMap.comp_apply] at hy₁
apply (pullback.fst ((F.obj i).homOfLE h₁) _).isOpenEmbedding.injective
simp only [← Scheme.comp_base_apply, α, pullback.lift_fst]
simp [hy₁]
refine ⟨α.opensRange, ⟨y, this⟩, ?_⟩
rw [← cancel_epi α.isoOpensRange.hom]
simp [α, ← Functor.map_comp, Subsingleton.elim (hli ≫ k₁.2.2) (hlj ≫ k₂.2.2)] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | fst_inv_eq_snd_inv | null |
tAux (i j : J) : (V F i j).toScheme ⟶ F.obj j :=
(Scheme.Opens.iSupOpenCover _).glueMorphisms
(fun k ↦ (F.map k.2.1).isoOpensRange.inv ≫ F.map k.2.2) fun k₁ k₂ ↦ by
dsimp [Scheme.Opens.iSupOpenCover]
apply fst_inv_eq_snd_inv F
@[reassoc] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | tAux | (Implementation detail)
The inclusion map `V i j ⟶ F j` in the glue data associated to a locally directed diagram. |
homOfLE_tAux (i j : J) {k : J} (fi : k ⟶ i) (fj : k ⟶ j) :
(F.obj i).homOfLE (le_iSup_of_le ⟨k, fi, fj⟩ le_rfl) ≫
tAux F i j = (F.map fi).isoOpensRange.inv ≫ F.map fj :=
(Scheme.Opens.iSupOpenCover (J := Σ k, (k ⟶ i) × (k ⟶ j)) _).ι_glueMorphisms _ _ ⟨k, fi, fj⟩ | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | homOfLE_tAux | null |
t (i j : J) : (V F i j).toScheme ⟶ (V F j i).toScheme :=
IsOpenImmersion.lift (V F j i).ι (tAux F i j) (by
rintro _ ⟨x, rfl⟩
obtain ⟨l, x, rfl⟩ := (Scheme.Opens.iSupOpenCover _).exists_eq x
simp only [V, tAux, ← Scheme.comp_base_apply, Cover.ι_glueMorphisms]
simp only [Opens.range_ι, iSup_mk, carrier_eq_coe, Hom.coe_opensRange, coe_mk, comp_coeBase,
TopCat.hom_comp, ContinuousMap.comp_apply]
exact Set.mem_iUnion.mpr ⟨⟨l.1, l.2.2, l.2.1⟩, ⟨_, rfl⟩⟩) | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | t | (Implementation detail)
The transition map `V i j ⟶ V j i` in the glue data associated to a locally directed diagram. |
t_id (i : J) : t F i i = 𝟙 _ := by
refine (Scheme.Opens.iSupOpenCover _).hom_ext _ _ fun k ↦ ?_
simp only [Category.comp_id, ← cancel_mono (Scheme.Opens.ι _), Category.assoc,
IsOpenImmersion.lift_fac, Scheme.Cover.ι_glueMorphisms, t, tAux, V]
simp [Scheme.Opens.iSupOpenCover, Iso.inv_comp_eq, Subsingleton.elim k.2.1 k.2.2]
variable [Small.{u} J]
local notation3:max "↓"j:arg => Equiv.symm (equivShrink _) j | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | t_id | null |
glueData : Scheme.GlueData where
J := Shrink.{u} J
U j := F.obj ↓j
V ij := V F ↓ij.1 ↓ij.2
f i j := Scheme.Opens.ι _
f_id i := V_self F ↓i ▸ (Scheme.topIso _).isIso_hom
f_hasPullback := inferInstance
f_open := inferInstance
t i j := t F ↓i ↓j
t_id i := t_id F ↓i
t' i j k := pullback.lift
(IsOpenImmersion.lift (V F ↓j ↓k).ι (pullback.fst _ _ ≫ tAux F ↓i ↓j) (by
rintro _ ⟨x, rfl⟩
obtain ⟨l, fi, fj, fk, α, z, hα, hα₁, hα₂, rfl⟩ := exists_of_pullback_V_V F x
rw [← Scheme.comp_base_apply, reassoc_of% hα₁, homOfLE_tAux F ↓i ↓j fi fj,
Iso.hom_inv_id_assoc, Scheme.Opens.range_ι, SetLike.mem_coe]
exact TopologicalSpace.Opens.mem_iSup.mpr ⟨⟨l, fj, fk⟩, ⟨z, rfl⟩⟩))
(pullback.fst _ _ ≫ t F _ _) (by simp [t])
t_fac i j k := pullback.lift_snd _ _ _
cocycle i j k := by
refine Scheme.hom_ext_of_forall _ _ fun x ↦ ?_
have := exists_of_pullback_V_V F x
obtain ⟨l, fi, fj, fk, α, z, hα, hα₁, hα₂, e⟩ := this -- doing them in the same step times out.
refine ⟨α.opensRange, ⟨_, e⟩, ?_⟩
rw [← cancel_mono (pullback.snd _ _), ← cancel_mono (Scheme.Opens.ι _)]
simp only [t, Category.assoc, limit.lift_π, PullbackCone.mk_pt, PullbackCone.mk_π_app,
limit.lift_π_assoc, cospan_left, IsOpenImmersion.lift_fac, Category.id_comp]
rw [IsOpenImmersion.comp_lift_assoc]
simp only [limit.lift_π_assoc, PullbackCone.mk_pt, cospan_left, PullbackCone.mk_π_app]
rw [← cancel_epi α.isoOpensRange.hom]
simp_rw [Scheme.Hom.isoOpensRange_hom_ι_assoc, IsOpenImmersion.comp_lift_assoc]
simp only [reassoc_of% hα₁, homOfLE_tAux F _ _ fi fj, Iso.hom_inv_id_assoc, reassoc_of% hα₂]
generalize_proofs _ h₁
have : IsOpenImmersion.lift (V F ↓j ↓k).ι (F.map fj) h₁ = (F.map fj).isoOpensRange.hom ≫
(F.obj ↓j).homOfLE (le_iSup_of_le ⟨l, fj, fk⟩ le_rfl) := by
rw [← cancel_mono (Scheme.Opens.ι _), Category.assoc, IsOpenImmersion.lift_fac,
← Iso.inv_comp_eq, Scheme.Hom.isoOpensRange_inv_comp]
exact (Scheme.homOfLE_ι _ _).symm
simp_rw [this, Category.assoc, homOfLE_tAux F _ _ fj fk, Iso.hom_inv_id_assoc]
generalize_proofs h₂
have : IsOpenImmersion.lift (V F ↓k ↓i).ι (F.map fk) h₂ = (F.map fk).isoOpensRange.hom ≫
(F.obj ↓k).homOfLE (le_iSup_of_le ⟨l, fk, fi⟩ le_rfl) := by
rw [← cancel_mono (Scheme.Opens.ι _), Category.assoc, IsOpenImmersion.lift_fac,
← Iso.inv_comp_eq, Scheme.Hom.isoOpensRange_inv_comp]
exact (Scheme.homOfLE_ι _ _).symm
simp_rw [this, Category.assoc, homOfLE_tAux F _ _ fk fi, Iso.hom_inv_id_assoc,
← Iso.inv_comp_eq, Scheme.Hom.isoOpensRange_inv_comp]
exact (Scheme.homOfLE_ι _ _).symm | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | glueData | (Implementation detail)
The glue data associated to a locally directed diagram.
One usually does not want to use this directly, and instead use the generic `colimit` API. |
glueDataι_naturality {i j : Shrink.{u} J} (f : ↓i ⟶ ↓j) :
F.map f ≫ (glueData F).ι j = (glueData F).ι i := by
have : IsIso (V F ↓i ↓j).ι := by
have : V F ↓i ↓j = ⊤ :=
top_le_iff.mp (le_iSup_of_le ⟨_, 𝟙 i, f⟩ (by simp [Scheme.Hom.opensRange_of_isIso]))
exact this ▸ (topIso _).isIso_hom
have : t F ↓i ↓j ≫ (V F ↓j ↓i).ι ≫ _ = (V F ↓i ↓j).ι ≫ _ :=
(glueData F).glue_condition i j
simp only [t, IsOpenImmersion.lift_fac_assoc] at this
rw [← cancel_epi (V F ↓i ↓j).ι, ← this, ← Category.assoc,
← (Iso.eq_inv_comp _).mp (homOfLE_tAux F ↓i ↓j (𝟙 i) f),
← Category.assoc, ← Category.assoc, Category.assoc]
convert Category.id_comp _
rw [← cancel_mono (Opens.ι _)]
simp [V, InducedCategory.category, Shrink.instCategoryShrink] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | glueDataι_naturality | null |
cocone : Cocone F where
pt := (glueData F).glued
ι.app j := F.map (eqToHom (by simp)) ≫ (glueData F).ι (equivShrink _ j)
ι.naturality {i j} f := by
simp only [← IsIso.inv_comp_eq, ← Functor.map_inv, ← Functor.map_comp_assoc,
glueDataι_naturality, Functor.const_obj_obj, Functor.const_obj_map, Category.comp_id] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | cocone | (Implementation detail)
The cocone associated to a locally directed diagram.
One usually does not want to use this directly, and instead use the generic `colimit` API. |
noncomputable
isColimit : IsColimit (cocone F) where
desc s := Multicoequalizer.desc _ _ (fun i ↦ s.ι.app ↓i) (by
rintro ⟨i, j⟩
dsimp [glueData, GlueData.diagram]
simp only [t, IsOpenImmersion.lift_fac]
apply (Scheme.Opens.iSupOpenCover _).hom_ext _ _ fun k ↦ ?_
simp only [Opens.iSupOpenCover, V, Scheme.homOfLE_ι_assoc]
rw [homOfLE_tAux_assoc F ↓i ↓j k.2.1 k.2.2, Iso.eq_inv_comp]
simp)
fac s j := by
refine (Category.assoc _ _ _).trans ?_
conv_lhs => enter [2]; tactic => exact Multicoequalizer.π_desc _ _ _ _ _
simp
uniq s m hm := Multicoequalizer.hom_ext _ _ _ fun i ↦ by
simp [← hm ↓i, cocone, reassoc_of% glueDataι_naturality]
rfl | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | isColimit | (Implementation detail)
The cocone associated to a locally directed diagram is a colimit.
One usually does not want to use this directly, and instead use the generic `colimit` API. |
noncomputable
isColimitForgetToLocallyRingedSpace :
IsColimit (Scheme.forgetToLocallyRingedSpace.mapCocone (cocone F)) where
desc s := (glueData F).isoLocallyRingedSpace.hom ≫
Multicoequalizer.desc _ _ (fun i ↦ s.ι.app ↓i) (by
rintro ⟨i, j⟩
dsimp [glueData, GlueData.diagram]
simp only [t, IsOpenImmersion.lift_fac, ← Scheme.comp_toLRSHom]
rw [← cancel_epi (Scheme.Opens.iSupOpenCover _).ulift.fromGlued.toLRSHom,
← cancel_epi (Scheme.Opens.iSupOpenCover _).ulift.gluedCover.isoLocallyRingedSpace.inv]
refine Multicoequalizer.hom_ext _ _ _ fun ⟨k, hk⟩ ↦ ?_
rw [← CategoryTheory.GlueData.ι, reassoc_of% GlueData.ι_isoLocallyRingedSpace_inv,
reassoc_of% GlueData.ι_isoLocallyRingedSpace_inv,
← cancel_epi (Hom.isoOpensRange (F.map _)).hom.toLRSHom]
simp only [Opens.iSupOpenCover, Cover.ulift, V, ← comp_toLRSHom_assoc,
Cover.ι_fromGlued_assoc, homOfLE_ι, Hom.isoOpensRange_hom_ι]
generalize_proofs _ _ h
rw [homOfLE_tAux F ↓i ↓j h.choose.2.1 h.choose.2.2, Iso.hom_inv_id_assoc]
exact (s.w h.choose.2.1).trans (s.w h.choose.2.2).symm)
fac s j := by
simp only [cocone, Functor.mapCocone_ι_app, Scheme.comp_toLRSHom,
forgetToLocallyRingedSpace_map, ← GlueData.ι_isoLocallyRingedSpace_inv]
simpa [CategoryTheory.GlueData.ι] using s.w _
uniq s m hm := by
rw [← Iso.inv_comp_eq]
refine Multicoequalizer.hom_ext _ _ _ fun i ↦ ?_
conv_lhs => rw [← ι.eq_def]
dsimp
simp [cocone, ← hm, glueDataι_naturality,
← GlueData.ι_isoLocallyRingedSpace_inv, -ι_gluedIso_inv_assoc, -ι_gluedIso_inv] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | isColimitForgetToLocallyRingedSpace | (Implementation detail)
The cocone associated to a locally directed diagram is a colimit as locally ringed spaces.
One usually does not want to use this directly, and instead use the generic `colimit` API. |
@[simps! I₀ X f]
openCover : (colimit F).OpenCover :=
Cover.copy ((coverOfIsIso ((isColimit F).coconePointUniqueUpToIso (colimit.isColimit F)).hom).bind
fun i ↦ (glueData F).openCover) J F.obj (colimit.ι F)
((equivShrink J).trans <| (Equiv.uniqueSigma fun (_ : Unit) ↦ Shrink J).symm)
(fun _ ↦ F.mapIso (eqToIso (by simp [GlueData.openCover, glueData]))) fun i ↦ by
change colimit.ι F i = _ ≫ (glueData F).ι (equivShrink J i) ≫ _
simp [← Category.assoc, ← Iso.comp_inv_eq, cocone] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | openCover | The open cover of the colimit of a locally directed diagram by the components. |
ι_eq_ι_iff {i j : J} {xi : F.obj i} {xj : F.obj j} :
(colimit.ι F i).base xi = (colimit.ι F j).base xj ↔
∃ k fi fj, ∃ (x : F.obj k), (F.map fi).base x = xi ∧ (F.map fj).base x = xj := by
constructor; swap
· rintro ⟨k, fi, fj, x, rfl, rfl⟩; simp only [← Scheme.comp_base_apply, colimit.w]
obtain ⟨i, rfl⟩ := (equivShrink J).symm.surjective i
obtain ⟨j, rfl⟩ := (equivShrink J).symm.surjective j
rw [← ((isColimit F).coconePointUniqueUpToIso
(colimit.isColimit F)).inv.isOpenEmbedding.injective.eq_iff]
simp only [Limits.colimit, ← Scheme.comp_base_apply,
colimit.comp_coconePointUniqueUpToIso_inv, cocone, glueDataι_naturality]
refine ?_ ∘ ((glueData F).ι_eq_iff _ _ _ _).mp
dsimp only [GlueData.Rel]
rintro ⟨x, rfl, rfl⟩
obtain ⟨⟨k, ki, kj⟩, y, hy : (F.map ki).base y = ((glueData F).f i j).base x⟩ := mem_iSup.mp x.2
refine ⟨k, ki, kj, y, hy, ?_⟩
obtain ⟨k, rfl⟩ := (equivShrink J).symm.surjective k
apply ((glueData F).ι _).isOpenEmbedding.injective
simp only [← Scheme.comp_base_apply, Category.assoc, GlueData.glue_condition]
trans ((glueData F).ι k).base y
· simp [← glueDataι_naturality F kj]; rfl
· simp [← glueDataι_naturality F ki, ← hy]; rfl | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.LocallyDirected",
"Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing"
] | Mathlib/AlgebraicGeometry/Gluing.lean | ι_eq_ι_iff | null |
@[simps]
noncomputable oneHypercover : Scheme.zariskiTopology.OneHypercover D.glued where
I₀ := D.J
X := D.U
f := D.ι
I₁ _ _ := PUnit
Y i₁ i₂ _ := D.V (i₁, i₂)
p₁ i₁ i₂ _ := D.f i₁ i₂
p₂ i₁ i₂ _ := D.t i₁ i₂ ≫ D.f i₂ i₁
w i₁ i₂ _ := by simp only [Category.assoc, Scheme.GlueData.glue_condition]
mem₀ := by
refine zariskiTopology.superset_covering ?_ D.openCover.mem_grothendieckTopology
rw [Sieve.generate_le_iff]
rintro W _ ⟨i⟩
exact ⟨_, 𝟙 _, _, ⟨i⟩, by simp; rfl⟩
mem₁ i₁ i₂ W p₁ p₂ fac := by
refine zariskiTopology.superset_covering (fun T g _ ↦ ?_) (zariskiTopology.top_mem _)
have ⟨φ, h₁, h₂⟩ := PullbackCone.IsLimit.lift' (D.vPullbackConeIsLimit i₁ i₂)
(g ≫ p₁) (g ≫ p₂) (by simpa using g ≫= fac)
exact ⟨⟨⟩, φ, h₁.symm, h₂.symm⟩ | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.AlgebraicGeometry.Sites.BigZariski",
"Mathlib.CategoryTheory.Sites.Hypercover.One"
] | Mathlib/AlgebraicGeometry/GluingOneHypercover.lean | oneHypercover | The 1-hypercover of `D.glued` in the big Zariski site that is given by the
open cover `D.U` from the glue data `D`.
The "covering of the intersection of two such open subsets" is the trivial
covering given by `D.V`. |
noncomputable sheafValGluedMk : F.val.obj (op D.glued) :=
Multifork.IsLimit.sectionsEquiv (D.oneHypercover.isLimitMultifork F)
{ val := s
property := fun _ ↦ h _ _ }
@[simp] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.AlgebraicGeometry.Sites.BigZariski",
"Mathlib.CategoryTheory.Sites.Hypercover.One"
] | Mathlib/AlgebraicGeometry/GluingOneHypercover.lean | sheafValGluedMk | Constructor for sections over `D.glued` of a sheaf of types on the big Zariski site. |
sheafValGluedMk_val (j : D.J) : F.val.map (D.ι j).op (D.sheafValGluedMk s h) = s j :=
Multifork.IsLimit.sectionsEquiv_apply_val (D.oneHypercover.isLimitMultifork F) _ _ | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.AlgebraicGeometry.Sites.BigZariski",
"Mathlib.CategoryTheory.Sites.Hypercover.One"
] | Mathlib/AlgebraicGeometry/GluingOneHypercover.lean | sheafValGluedMk_val | null |
noncomputable specZIsTerminal : IsTerminal Spec(ℤ) :=
@IsTerminal.isTerminalObj _ _ _ _ Scheme.Spec _ inferInstance
(terminalOpOfInitial CommRingCat.zIsInitial) | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | specZIsTerminal | `Spec ℤ` is the terminal object in the category of schemes. |
noncomputable specULiftZIsTerminal : IsTerminal Spec(ULift.{u} ℤ) :=
@IsTerminal.isTerminalObj _ _ _ _ Scheme.Spec _ inferInstance
(terminalOpOfInitial CommRingCat.isInitial) | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | specULiftZIsTerminal | `Spec ℤ` is the terminal object in the category of schemes. |
@[simps]
Scheme.emptyTo (X : Scheme.{u}) : ∅ ⟶ X :=
⟨{ base := TopCat.ofHom ⟨fun x => PEmpty.elim x, by fun_prop⟩
c := { app := fun _ => CommRingCat.punitIsTerminal.from _ } }, fun x => PEmpty.elim x⟩
@[ext] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | Scheme.emptyTo | The map from the empty scheme. |
Scheme.empty_ext {X : Scheme.{u}} (f g : ∅ ⟶ X) : f = g :=
Scheme.Hom.ext' (Subsingleton.elim (α := ∅ ⟶ _) _ _) | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | Scheme.empty_ext | null |
Scheme.eq_emptyTo {X : Scheme.{u}} (f : ∅ ⟶ X) : f = Scheme.emptyTo X :=
Scheme.empty_ext f (Scheme.emptyTo X) | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | Scheme.eq_emptyTo | null |
Scheme.hom_unique_of_empty_source (X : Scheme.{u}) : Unique (∅ ⟶ X) :=
⟨⟨Scheme.emptyTo _⟩, fun _ => Scheme.empty_ext _ _⟩ | instance | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | Scheme.hom_unique_of_empty_source | null |
emptyIsInitial : IsInitial (∅ : Scheme.{u}) :=
IsInitial.ofUnique _
@[simp] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | emptyIsInitial | The empty scheme is the initial object in the category of schemes. |
emptyIsInitial_to : emptyIsInitial.to = Scheme.emptyTo :=
rfl | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | emptyIsInitial_to | null |
spec_punit_isEmpty : IsEmpty Spec(PUnit.{u+1}) :=
inferInstanceAs <| IsEmpty (PrimeSpectrum PUnit) | instance | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | spec_punit_isEmpty | null |
noncomputable isInitialOfIsEmpty {X : Scheme} [IsEmpty X] : IsInitial X :=
emptyIsInitial.ofIso (asIso <| emptyIsInitial.to _) | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | isInitialOfIsEmpty | A scheme is initial if its underlying space is empty . |
noncomputable specPunitIsInitial : IsInitial Spec(PUnit.{u+1}) :=
emptyIsInitial.ofIso (asIso <| emptyIsInitial.to _) | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | specPunitIsInitial | `Spec 0` is the initial object in the category of schemes. |
initial_isEmpty : IsEmpty (⊥_ Scheme) :=
⟨fun x => ((initial.to Scheme.empty :).base x).elim⟩ | instance | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | initial_isEmpty | null |
isAffineOpen_bot (X : Scheme) : IsAffineOpen (⊥ : X.Opens) :=
@isAffine_of_isEmpty _ (inferInstanceAs (IsEmpty (∅ : Set X))) | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | isAffineOpen_bot | null |
sigmaι_eq_iff (i j : ι) (x y) :
(Sigma.ι f i).base x = (Sigma.ι f j).base y ↔
(Sigma.mk i x : Σ i, f i) = Sigma.mk j y := by
refine (Scheme.IsLocallyDirected.ι_eq_ι_iff _).trans ⟨?_, ?_⟩
· rintro ⟨k, ⟨⟨⟨⟩⟩⟩, ⟨⟨⟨⟩⟩⟩, x, rfl, rfl⟩; simp
· simp only [Discrete.functor_obj_eq_as, Sigma.mk.injEq]
rintro ⟨rfl, e⟩
obtain rfl := (heq_eq_eq x y).mp e
exact ⟨⟨i⟩, 𝟙 _, 𝟙 _, x, by simp⟩ | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | sigmaι_eq_iff | null |
disjoint_opensRange_sigmaι (i j : ι) (h : i ≠ j) :
Disjoint (Sigma.ι f i).opensRange (Sigma.ι f j).opensRange := by
intro U hU hU' x hx
obtain ⟨x, rfl⟩ := hU hx
obtain ⟨y, hy⟩ := hU' hx
obtain ⟨rfl⟩ := (sigmaι_eq_iff _ _ _ _ _).mp hy
cases h rfl | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | disjoint_opensRange_sigmaι | The images of each component in the coproduct is disjoint. |
@[simps!]
noncomputable sigmaOpenCover [Small.{u} σ] : (∐ g).OpenCover :=
(Scheme.IsLocallyDirected.openCover (Discrete.functor g)).copy σ g (Sigma.ι _)
(discreteEquiv.symm) (fun _ ↦ Iso.refl _) (fun _ ↦ rfl) | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | sigmaOpenCover | The cover of `∐ X` by the `Xᵢ`. |
noncomputable
sigmaMk : (Σ i, f i) ≃ₜ (∐ f :) :=
TopCat.homeoOfIso ((colimit.isoColimitCocone ⟨_, TopCat.sigmaCofanIsColimit _⟩).symm ≪≫
(PreservesCoproduct.iso Scheme.forgetToTop f).symm)
@[simp] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | sigmaMk | The underlying topological space of the coproduct is homeomorphic to the disjoint union. |
sigmaMk_mk (i) (x : f i) :
sigmaMk f (.mk i x) = (Sigma.ι f i).base x := by
change ((TopCat.sigmaCofan (fun x ↦ (f x).toTopCat)).inj i ≫
(colimit.isoColimitCocone ⟨_, TopCat.sigmaCofanIsColimit _⟩).inv ≫ _) x =
Scheme.forgetToTop.map (Sigma.ι f i) x
congr 2
refine (colimit.isoColimitCocone_ι_inv_assoc ⟨_, TopCat.sigmaCofanIsColimit _⟩ _ _).trans ?_
exact ι_comp_sigmaComparison Scheme.forgetToTop _ _
open scoped Function in | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | sigmaMk_mk | null |
private isOpenImmersion_sigmaDesc_aux
{X : Scheme.{u}} (α : ∀ i, f i ⟶ X) [∀ i, IsOpenImmersion (α i)]
(hα : Pairwise (Disjoint on (Set.range <| α · |>.base))) :
IsOpenImmersion (Sigma.desc α) := by
rw [IsOpenImmersion.iff_stalk_iso]
constructor
· suffices Topology.IsOpenEmbedding ((Sigma.desc α).base ∘ sigmaMk f) by
convert this.comp (sigmaMk f).symm.isOpenEmbedding; ext; simp
refine .of_continuous_injective_isOpenMap ?_ ?_ ?_
· fun_prop
· rintro ⟨ix, x⟩ ⟨iy, y⟩ e
have : (α ix).base x = (α iy).base y := by
simpa [← Scheme.comp_base_apply] using e
obtain rfl : ix = iy := by
by_contra h
exact Set.disjoint_iff_forall_ne.mp (hα h) ⟨x, rfl⟩ ⟨y, this.symm⟩ rfl
rw [(α ix).isOpenEmbedding.injective this]
· rw [isOpenMap_sigma]
intro i
simpa [← Scheme.comp_base_apply] using (α i).isOpenEmbedding.isOpenMap
· intro x
have ⟨y, hy⟩ := (Scheme.IsLocallyDirected.openCover (Discrete.functor f)).covers x
rw [← hy]
refine IsIso.of_isIso_fac_right
(g := ((Scheme.IsLocallyDirected.openCover (Discrete.functor f)).f _).stalkMap y)
(h := (X.presheaf.stalkCongr (.of_eq ?_)).hom ≫ (α _).stalkMap _) ?_
· simp [← Scheme.comp_base_apply]
· simp [← Scheme.stalkMap_comp, Scheme.stalkMap_congr_hom _ _ (colimit.ι_desc _ _)]
open scoped Function in | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | isOpenImmersion_sigmaDesc_aux | null |
isOpenImmersion_sigmaDesc [Small.{u} σ]
{X : Scheme.{u}} (α : ∀ i, g i ⟶ X) [∀ i, IsOpenImmersion (α i)]
(hα : Pairwise (Disjoint on (Set.range <| α · |>.base))) :
IsOpenImmersion (Sigma.desc α) := by
obtain ⟨ι, ⟨e⟩⟩ := Small.equiv_small (α := σ)
convert IsOpenImmersion.comp ((Sigma.reindex e.symm g).inv) (Sigma.desc fun i ↦ α _)
· refine Sigma.hom_ext _ _ fun i ↦ ?_
obtain ⟨i, rfl⟩ := e.symm.surjective i
simp
· apply isOpenImmersion_sigmaDesc_aux
intro i j hij
exact hα (fun h ↦ hij (e.symm.injective h))
open scoped Function in | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | isOpenImmersion_sigmaDesc | null |
nonempty_isColimit_cofanMk_of [Small.{u} σ]
{X : σ → Scheme.{u}} {S : Scheme.{u}} (f : ∀ i, X i ⟶ S) [∀ i, IsOpenImmersion (f i)]
(hcov : ⨆ i, (f i).opensRange = ⊤) (hdisj : Pairwise (Disjoint on (f · |>.opensRange))) :
Nonempty (IsColimit <| Cofan.mk S f) := by
have : IsOpenImmersion (Sigma.desc f) := by
refine isOpenImmersion_sigmaDesc _ _ (fun i j hij ↦ ?_)
simpa [Function.onFun_apply, disjoint_iff, Opens.ext_iff] using hdisj hij
simp only [← Cofan.isColimit_iff_isIso_sigmaDesc (Cofan.mk S f), cofan_mk_inj, Cofan.mk_pt]
apply isIso_of_isOpenImmersion_of_opensRange_eq_top
rw [eq_top_iff]
intro x hx
have : x ∈ ⨆ i, (f i).opensRange := by rwa [hcov]
obtain ⟨i, y, rfl⟩ := by simpa only [Opens.iSup_mk, Opens.mem_mk, Set.mem_iUnion] using this
use Sigma.ι X i |>.base y
simp [← Scheme.comp_base_apply]
variable (X Y : Scheme.{u}) | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | nonempty_isColimit_cofanMk_of | `S` is the disjoint union of `Xᵢ` if the `Xᵢ` are covering, pairwise disjoint open subschemes
of `S`. |
noncomputable
coprodIsoSigma : X ⨿ Y ≅ ∐ fun i : ULift.{u} WalkingPair ↦ i.1.casesOn X Y :=
Sigma.whiskerEquiv Equiv.ulift.symm (fun _ ↦ by exact Iso.refl _) | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | coprodIsoSigma | (Implementation Detail)
The coproduct of the two schemes is given by indexed coproducts over `WalkingPair`. |
ι_left_coprodIsoSigma_inv : Sigma.ι _ ⟨.left⟩ ≫ (coprodIsoSigma X Y).inv = coprod.inl :=
Sigma.ι_comp_map' _ _ _ | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | ι_left_coprodIsoSigma_inv | null |
ι_right_coprodIsoSigma_inv : Sigma.ι _ ⟨.right⟩ ≫ (coprodIsoSigma X Y).inv = coprod.inr :=
Sigma.ι_comp_map' _ _ _ | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | ι_right_coprodIsoSigma_inv | null |
isCompl_range_inl_inr :
IsCompl (Set.range (coprod.inl : X ⟶ X ⨿ Y).base)
(Set.range (coprod.inr : Y ⟶ X ⨿ Y).base) :=
((TopCat.binaryCofan_isColimit_iff _).mp
⟨mapIsColimitOfPreservesOfIsColimit Scheme.forgetToTop.{u} _ _ (coprodIsCoprod X Y)⟩).2.2 | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | isCompl_range_inl_inr | null |
isCompl_opensRange_inl_inr :
IsCompl (coprod.inl : X ⟶ X ⨿ Y).opensRange (coprod.inr : Y ⟶ X ⨿ Y).opensRange := by
convert isCompl_range_inl_inr X Y
simp only [isCompl_iff, disjoint_iff, codisjoint_iff, ← TopologicalSpace.Opens.coe_inj]
rfl | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | isCompl_opensRange_inl_inr | null |
noncomputable
coprodMk : X ⊕ Y ≃ₜ (X ⨿ Y : Scheme.{u}) :=
TopCat.homeoOfIso ((colimit.isoColimitCocone ⟨_, TopCat.binaryCofanIsColimit _ _⟩).symm ≪≫
PreservesColimitPair.iso Scheme.forgetToTop X Y)
@[simp] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | coprodMk | The underlying topological space of the coproduct is homeomorphic to the disjoint union |
coprodMk_inl (x : X) :
coprodMk X Y (.inl x) = (coprod.inl : X ⟶ X ⨿ Y).base x := by
change ((TopCat.binaryCofan X Y).inl ≫
(colimit.isoColimitCocone ⟨_, TopCat.binaryCofanIsColimit _ _⟩).inv ≫ _) x =
Scheme.forgetToTop.map coprod.inl x
congr 2
refine (colimit.isoColimitCocone_ι_inv_assoc ⟨_, TopCat.binaryCofanIsColimit _ _⟩ _ _).trans ?_
exact coprodComparison_inl Scheme.forgetToTop
@[simp] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | coprodMk_inl | null |
coprodMk_inr (x : Y) :
coprodMk X Y (.inr x) = (coprod.inr : Y ⟶ X ⨿ Y).base x := by
change ((TopCat.binaryCofan X Y).inr ≫
(colimit.isoColimitCocone ⟨_, TopCat.binaryCofanIsColimit _ _⟩).inv ≫ _) x =
Scheme.forgetToTop.map coprod.inr x
congr 2
refine (colimit.isoColimitCocone_ι_inv_assoc ⟨_, TopCat.binaryCofanIsColimit _ _⟩ _ _).trans ?_
exact coprodComparison_inr Scheme.forgetToTop | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | coprodMk_inr | null |
noncomputable
coprodOpenCover.{w} : (X ⨿ Y).OpenCover where
I₀ := PUnit.{w + 1} ⊕ PUnit.{w + 1}
X x := x.elim (fun _ ↦ X) (fun _ ↦ Y)
f x := x.rec (fun _ ↦ coprod.inl) (fun _ ↦ coprod.inr)
mem₀ := by
rw [Scheme.presieve₀_mem_precoverage_iff]
refine ⟨fun x ↦ ?_, fun x ↦ x.rec (fun _ ↦ inferInstance) (fun _ ↦ inferInstance)⟩
use ((coprodMk X Y).symm x).elim (fun _ ↦ Sum.inl .unit) (fun _ ↦ Sum.inr .unit)
obtain ⟨x, rfl⟩ := (coprodMk X Y).surjective x
simp only [Sum.elim_inl, Sum.elim_inr, Set.mem_range]
rw [Homeomorph.symm_apply_apply]
obtain (x | x) := x
· simp only [Sum.elim_inl, coprodMk_inl, exists_apply_eq_apply]
· simp only [Sum.elim_inr, coprodMk_inr, exists_apply_eq_apply] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | coprodOpenCover. | The open cover of the coproduct of two schemes. |
nonempty_isColimit_binaryCofanMk_of_isCompl {X Y S : Scheme.{u}}
(f : X ⟶ S) (g : Y ⟶ S) [IsOpenImmersion f] [IsOpenImmersion g]
(hf : IsCompl f.opensRange g.opensRange) :
Nonempty (IsColimit <| BinaryCofan.mk f g) := by
let c' : Cofan fun j ↦ (WalkingPair.casesOn j X Y : Scheme.{u}) :=
.mk S fun j ↦ WalkingPair.casesOn j f g
let i : BinaryCofan.mk f g ≅ c' := Cofan.ext (Iso.refl _) (by rintro (b|b) <;> rfl)
refine ⟨IsColimit.ofIsoColimit (Nonempty.some ?_) i.symm⟩
let fi (j : WalkingPair) : WalkingPair.casesOn j X Y ⟶ S := WalkingPair.casesOn j f g
convert nonempty_isColimit_cofanMk_of fi _ _
· intro i
cases i <;> (simp [fi]; infer_instance)
· simpa [← WalkingPair.equivBool.symm.iSup_comp, iSup_bool_eq, ← codisjoint_iff] using hf.2
· intro i j hij
match i, j with
| .left, .right => simpa [fi] using hf.1
| .right, .left => simpa [fi] using hf.1.symm
variable (R S : Type u) [CommRing R] [CommRing S] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | nonempty_isColimit_binaryCofanMk_of_isCompl | If `X` and `Y` are open disjoint and covering open subschemes of `S`,
`S` is the disjoint union of `X` and `Y`. |
noncomputable
coprodSpec : Spec(R) ⨿ Spec(S) ⟶ Spec(R × S) :=
coprod.desc (Spec.map (CommRingCat.ofHom <| RingHom.fst _ _))
(Spec.map (CommRingCat.ofHom <| RingHom.snd _ _))
@[simp, reassoc] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | coprodSpec | The map `Spec R ⨿ Spec S ⟶ Spec (R × S)`.
This is an isomorphism as witnessed by an `IsIso` instance provided below. |
coprodSpec_inl : coprod.inl ≫ coprodSpec R S =
Spec.map (CommRingCat.ofHom <| RingHom.fst R S) :=
coprod.inl_desc _ _
@[simp, reassoc] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | coprodSpec_inl | null |
coprodSpec_inr : coprod.inr ≫ coprodSpec R S =
Spec.map (CommRingCat.ofHom <| RingHom.snd R S) :=
coprod.inr_desc _ _ | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | coprodSpec_inr | null |
coprodSpec_coprodMk (x) :
(coprodSpec R S).base (coprodMk _ _ x) = (PrimeSpectrum.primeSpectrumProd R S).symm x := by
apply PrimeSpectrum.ext
obtain (x | x) := x <;>
simp only [coprodMk_inl, coprodMk_inr, ← Scheme.comp_base_apply,
coprodSpec, coprod.inl_desc, coprod.inr_desc]
· change Ideal.comap _ _ = x.asIdeal.prod ⊤
ext; simp [Ideal.prod, CommRingCat.ofHom]
· change Ideal.comap _ _ = Ideal.prod ⊤ x.asIdeal
ext; simp [Ideal.prod, CommRingCat.ofHom] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | coprodSpec_coprodMk | null |
coprodSpec_apply (x) :
(coprodSpec R S).base x =
(PrimeSpectrum.primeSpectrumProd R S).symm ((coprodMk Spec(R) Spec(S)).symm x) := by
rw [← coprodSpec_coprodMk, Homeomorph.apply_symm_apply] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | coprodSpec_apply | null |
isIso_stalkMap_coprodSpec (x) :
IsIso ((coprodSpec R S).stalkMap x) := by
obtain ⟨x | x, rfl⟩ := (coprodMk _ _).surjective x
· have := Scheme.stalkMap_comp coprod.inl (coprodSpec R S) x
rw [← IsIso.comp_inv_eq, Scheme.stalkMap_congr_hom _ (Spec.map _) (coprodSpec_inl R S)] at this
rw [coprodMk_inl, ← this]
letI := (RingHom.fst R S).toAlgebra
have : IsOpenImmersion (Spec.map (CommRingCat.ofHom (RingHom.fst R S))) :=
IsOpenImmersion.of_isLocalization (1, 0)
infer_instance
· have := Scheme.stalkMap_comp coprod.inr (coprodSpec R S) x
rw [← IsIso.comp_inv_eq, Scheme.stalkMap_congr_hom _ (Spec.map _) (coprodSpec_inr R S)] at this
rw [coprodMk_inr, ← this]
letI := (RingHom.snd R S).toAlgebra
have : IsOpenImmersion (Spec.map (CommRingCat.ofHom (RingHom.snd R S))) :=
IsOpenImmersion.of_isLocalization (0, 1)
infer_instance | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | isIso_stalkMap_coprodSpec | null |
noncomputable
sigmaSpec (R : ι → CommRingCat) : (∐ fun i ↦ Spec (R i)) ⟶ Spec(Π i, R i) :=
Sigma.desc (fun i ↦ Spec.map (CommRingCat.ofHom (Pi.evalRingHom _ i)))
@[reassoc (attr := simp)] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | sigmaSpec | The canonical map `∐ Spec Rᵢ ⟶ Spec (Π Rᵢ)`.
This is an isomorphism when the product is finite. |
ι_sigmaSpec (R : ι → CommRingCat) (i) :
Sigma.ι _ i ≫ sigmaSpec R = Spec.map (CommRingCat.ofHom (Pi.evalRingHom _ i)) :=
Sigma.ι_desc _ _ | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Pullbacks",
"Mathlib.AlgebraicGeometry.AffineScheme"
] | Mathlib/AlgebraicGeometry/Limits.lean | ι_sigmaSpec | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.