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_le_iff (R : CommRingCat) (p q : Spec R) : p ≤ q ↔ q.asIdeal ≤ p.asIdeal := by
aesop (add simp PrimeSpectrum.le_iff_specializes)
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.Algebra.MvPolynomial.Monad",
"Mathlib.AlgebraicGeometry.Morphisms.Finite",
"Mathlib.AlgebraicGeometry.Morphisms.FinitePresentation",
"Mathlib.RingTheory.Spectrum.Prime.Polynomial",
"Mathlib.AlgebraicGeometry.PullbackCarrier"
] |
Mathlib/AlgebraicGeometry/AffineSpace.lean
|
spec_le_iff
| null |
@[stacks 01Z2]
Scheme.nonempty_of_isLimit [IsCofilteredOrEmpty I]
[∀ {i j} (f : i ⟶ j), IsAffineHom (D.map f)] [∀ i, Nonempty (D.obj i)]
[∀ i, CompactSpace (D.obj i)] :
Nonempty c.pt := by
classical
cases isEmpty_or_nonempty I
· have e := (isLimitEquivIsTerminalOfIsEmpty _ _ hc).uniqueUpToIso specULiftZIsTerminal
exact Nonempty.map e.inv.base inferInstance
· have i := Nonempty.some ‹Nonempty I›
have : IsCofiltered I := ⟨⟩
let 𝒰 := (D.obj i).affineCover.finiteSubcover
have (i' : _) : IsAffine (𝒰.X i') := inferInstanceAs (IsAffine (Spec _))
obtain ⟨j, H⟩ :
∃ j : 𝒰.I₀, ∀ {i'} (f : i' ⟶ i), Nonempty ((𝒰.pullback₁ (D.map f)).X j) := by
by_contra! H
choose i' f hf using H
let g (j) := IsCofiltered.infTo (insert i (Finset.univ.image i'))
(Finset.univ.image fun j : 𝒰.I₀ ↦ ⟨_, _, by simp, by simp, f j⟩) (X := j)
have (j : 𝒰.I₀) : IsEmpty ((𝒰.pullback₁ (D.map (g i (by simp)))).X j) := by
let F : (𝒰.pullback₁ (D.map (g i (by simp)))).X j ⟶
(𝒰.pullback₁ (D.map (f j))).X j :=
pullback.map _ _ _ _ (D.map (g _ (by simp))) (𝟙 _) (𝟙 _) (by
rw [← D.map_comp, IsCofiltered.infTo_commutes]
· simp [g]
· simp
· exact Finset.mem_image_of_mem _ (Finset.mem_univ _)) (by simp)
exact Function.isEmpty F.base
obtain ⟨x, -⟩ :=
Cover.covers (𝒰.pullback₁ (D.map (g i (by simp)))) (Nonempty.some inferInstance)
exact (this _).elim x
let F := Over.post D ⋙ Over.pullback (𝒰.f j) ⋙ Over.forget _
have (i' : _) : IsAffine (F.obj i') :=
have : IsAffineHom (pullback.snd (D.map i'.hom) (𝒰.f j)) :=
MorphismProperty.pullback_snd _ _ inferInstance
isAffine_of_isAffineHom (pullback.snd (D.map i'.hom) (𝒰.f j))
have (i' : _) : Nonempty (F.obj i') := H i'.hom
let e : F ⟶ (F ⋙ Scheme.Γ.rightOp) ⋙ Scheme.Spec := Functor.whiskerLeft F ΓSpec.adjunction.unit
have (i : _) : IsIso (e.app i) := IsAffine.affine
have : IsIso e := NatIso.isIso_of_isIso_app e
let c' : LimitCone F := ⟨_, (IsLimit.postcomposeInvEquiv (asIso e) _).symm
(isLimitOfPreserves Scheme.Spec (limit.isLimit (F ⋙ Scheme.Γ.rightOp)))⟩
have : Nonempty c'.1.pt := by
apply (config := { allowSynthFailures := true }) PrimeSpectrum.instNonemptyOfNontrivial
have (i' : _) : Nontrivial ((F ⋙ Scheme.Γ.rightOp).leftOp.obj i') := by
apply (config := { allowSynthFailures := true }) Scheme.component_nontrivial
simp
exact CommRingCat.FilteredColimits.nontrivial
(isColimitCoconeLeftOpOfCone _ (limit.isLimit (F ⋙ Scheme.Γ.rightOp)))
let α : F ⟶ Over.forget _ ⋙ D := Functor.whiskerRight
(Functor.whiskerLeft (Over.post D) (Over.mapPullbackAdj (𝒰.f j)).counit) (Over.forget _)
...
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.Algebra.Category.Ring.FinitePresentation",
"Mathlib.AlgebraicGeometry.IdealSheaf.Functorial",
"Mathlib.AlgebraicGeometry.Morphisms.Separated",
"Mathlib.CategoryTheory.Filtered.Final",
"Mathlib.CategoryTheory.Monad.Limits"
] |
Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
|
Scheme.nonempty_of_isLimit
|
Suppose we have a cofiltered diagram of nonempty quasi-compact schemes,
whose transition maps are affine. Then the limit is also nonempty.
|
exists_mem_of_isClosed_of_nonempty
[IsCofilteredOrEmpty I]
[∀ {i j} (f : i ⟶ j), IsAffineHom (D.map f)]
(Z : ∀ (i : I), Set (D.obj i))
(hZc : ∀ (i : I), IsClosed (Z i))
(hZne : ∀ i, (Z i).Nonempty)
(hZcpt : ∀ i, IsCompact (Z i))
(hmapsTo : ∀ {i i' : I} (f : i ⟶ i'), Set.MapsTo (D.map f).base (Z i) (Z i')) :
∃ (s : c.pt), ∀ i, (c.π.app i).base s ∈ Z i := by
let D' : I ⥤ Scheme :=
{ obj i := (vanishingIdeal ⟨Z i, hZc i⟩).subscheme
map {X Y} f := subschemeMap _ _ (D.map f) (by
rw [map_vanishingIdeal, ← le_support_iff_le_vanishingIdeal]
simpa [(hZc _).closure_subset_iff] using (hmapsTo f).subset_preimage)
map_id _ := by simp [← cancel_mono (subschemeι _)]
map_comp _ _ := by simp [← cancel_mono (subschemeι _)] }
let ι : D' ⟶ D := { app i := subschemeι _, naturality _ _ _ := by simp [D'] }
haveI {i j} (f : i ⟶ j) : IsAffineHom (D'.map f) := by
suffices IsAffineHom (D'.map f ≫ ι.app j) from .of_comp _ (ι.app j)
simp only [subschemeMap_subschemeι, D', ι]
infer_instance
haveI _ (i) : Nonempty (D'.obj i) := Set.nonempty_coe_sort.mpr (hZne i)
haveI _ (i) : CompactSpace (D'.obj i) := isCompact_iff_compactSpace.mp (hZcpt i)
let c' : Cone D' :=
{ pt := (⨆ i, (vanishingIdeal ⟨Z i, hZc i⟩).comap (c.π.app i)).subscheme
π :=
{ app i := subschemeMap _ _ (c.π.app i) (by simp [le_map_iff_comap_le, le_iSup_of_le i])
naturality {i j} f := by simp [D', ← cancel_mono (subschemeι _)] } }
let hc' : IsLimit c' :=
{ lift s := IsClosedImmersion.lift (subschemeι _) (hc.lift ((Cones.postcompose ι).obj s)) (by
suffices ∀ i, vanishingIdeal ⟨Z i, hZc i⟩ ≤ (s.π.app i ≫ ι.app i).ker by
simpa [← le_map_iff_comap_le, ← Scheme.Hom.ker_comp]
refine fun i ↦ .trans ?_ (Scheme.Hom.le_ker_comp _ _)
simp [ι])
fac s i := by simp [← cancel_mono (subschemeι _), c', ι]
uniq s m hm := by
rw [← cancel_mono (subschemeι _)]
refine hc.hom_ext fun i ↦ ?_
simp [ι, c', ← hm] }
have : Nonempty (⨆ i, (vanishingIdeal ⟨Z i, hZc i⟩).comap (c.π.app i)).support :=
Scheme.nonempty_of_isLimit D' c' hc'
simpa using this
include hc in
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.Algebra.Category.Ring.FinitePresentation",
"Mathlib.AlgebraicGeometry.IdealSheaf.Functorial",
"Mathlib.AlgebraicGeometry.Morphisms.Separated",
"Mathlib.CategoryTheory.Filtered.Final",
"Mathlib.CategoryTheory.Monad.Limits"
] |
Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
|
exists_mem_of_isClosed_of_nonempty
|
Suppose we have a cofiltered diagram of schemes whose transition maps are affine. The limit of
a family of compatible nonempty quasicompact closed sets in the diagram is also nonempty.
|
@[stacks 01Z3]
exists_mem_of_isClosed_of_nonempty'
[IsCofilteredOrEmpty I]
[∀ {i j} (f : i ⟶ j), IsAffineHom (D.map f)]
{j : I}
(Z : ∀ (i : I), (i ⟶ j) → Set (D.obj i))
(hZc : ∀ i hij, IsClosed (Z i hij))
(hZne : ∀ i hij, (Z i hij).Nonempty)
(hZcpt : ∀ i hij, IsCompact (Z i hij))
(hstab : ∀ (i i' : I) (hi'i : i' ⟶ i) (hij : i ⟶ j),
Set.MapsTo (D.map hi'i).base (Z i' (hi'i ≫ hij)) (Z i hij)) :
∃ (s : c.pt), ∀ i hij, (c.π.app i).base s ∈ Z i hij := by
have {i₁ i₂ : Over j} (f : i₁ ⟶ i₂) : IsAffineHom ((Over.forget j ⋙ D).map f) := by
dsimp; infer_instance
simpa [Over.forall_iff] using exists_mem_of_isClosed_of_nonempty (Over.forget j ⋙ D) _
((Functor.Initial.isLimitWhiskerEquiv (Over.forget j) c).symm hc)
(fun i ↦ Z i.left i.hom) (fun _ ↦ hZc _ _) (fun _ ↦ hZne _ _) (fun _ ↦ hZcpt _ _)
(fun {i₁ i₂} f ↦ by dsimp; rw [← Over.w f]; exact hstab ..)
/-!
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.Algebra.Category.Ring.FinitePresentation",
"Mathlib.AlgebraicGeometry.IdealSheaf.Functorial",
"Mathlib.AlgebraicGeometry.Morphisms.Separated",
"Mathlib.CategoryTheory.Filtered.Final",
"Mathlib.CategoryTheory.Monad.Limits"
] |
Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
|
exists_mem_of_isClosed_of_nonempty'
|
A variant of `exists_mem_of_isClosed_of_nonempty` where the closed sets are only defined
for the objects over a given `j : I`.
|
ExistsHomHomCompEqCompAux where
/-- (Implementation) The limit cone. See the section docstring. -/
c : Cone D
/-- (Implementation) The limit cone is a limit. See the section docstring. -/
hc : IsLimit c
/-- (Implementation) The index on which `a` and `b` lives. See the section docstring. -/
i : I
/-- (Implementation) `a`. See the section docstring. -/
a : D.obj i ⟶ X
ha : t.app i = a ≫ f
/-- (Implementation) `b`. See the section docstring. -/
b : D.obj i ⟶ X
hb : t.app i = b ≫ f
hab : c.π.app i ≫ a = c.π.app i ≫ b
/-- (Implementation) An open cover on `S`. See the section docstring. -/
𝒰S : Scheme.OpenCover.{u} S
[h𝒰S : ∀ i, IsAffine (𝒰S.X i)]
/-- (Implementation) A family of open covers refining `𝒰S`. See the section docstring. -/
𝒰X (i : (𝒰S.pullback₁ f).I₀) : Scheme.OpenCover.{u} ((𝒰S.pullback₁ f).X i)
[h𝒰X : ∀ i j, IsAffine ((𝒰X i).X j)]
attribute [instance] ExistsHomHomCompEqCompAux.h𝒰S ExistsHomHomCompEqCompAux.h𝒰X
|
structure
|
AlgebraicGeometry
|
[
"Mathlib.Algebra.Category.Ring.FinitePresentation",
"Mathlib.AlgebraicGeometry.IdealSheaf.Functorial",
"Mathlib.AlgebraicGeometry.Morphisms.Separated",
"Mathlib.CategoryTheory.Filtered.Final",
"Mathlib.CategoryTheory.Monad.Limits"
] |
Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
|
ExistsHomHomCompEqCompAux
|
Subsumed by `Scheme.exists_hom_hom_comp_eq_comp_of_locallyOfFiniteType`. -/
private nonrec lemma Scheme.exists_hom_hom_comp_eq_comp_of_isAffine_of_locallyOfFiniteType
[IsAffine S] [IsAffine X] [∀ i, IsAffine (D.obj i)] [IsAffine c.pt]
{i : I} (a : D.obj i ⟶ X) (ha : t.app i = a ≫ f)
{j : I} (b : D.obj j ⟶ X) (hb : t.app j = b ≫ f)
(hab : c.π.app i ≫ a = c.π.app j ≫ b) :
∃ (k : I) (hik : k ⟶ i) (hjk : k ⟶ j),
D.map hik ≫ a = D.map hjk ≫ b := by
wlog hS : ∃ R, S = Spec R generalizing S
· exact this (t ≫ ((Functor.const I).mapIso S.isoSpec).hom)
(f ≫ S.isoSpec.hom) (by simp [ha]) (by simp [hb]) ⟨_, rfl⟩
obtain ⟨R, rfl⟩ := hS
wlog hX : ∃ S, X = Spec S generalizing X
· simpa using this (a ≫ X.isoSpec.hom) (b ≫ X.isoSpec.hom) (by simp [hab]) (X.isoSpec.inv ≫ f)
(by simp [ha]) (by simp [hb]) ⟨_, rfl⟩
obtain ⟨S, rfl⟩ := hX
obtain ⟨φ, rfl⟩ := Spec.map_surjective f
wlog hD : ∃ D' : I ⥤ CommRingCatᵒᵖ, D = D' ⋙ Scheme.Spec generalizing D
· let e : D ⟶ D ⋙ Scheme.Γ.rightOp ⋙ Scheme.Spec := D.whiskerLeft ΓSpec.adjunction.unit
have inst (i) : IsIso (e.app i) := by dsimp [e]; infer_instance
have inst : IsIso e := NatIso.isIso_of_isIso_app e
have inst (i) : IsAffine ((D ⋙ Scheme.Γ.rightOp ⋙ Scheme.Spec).obj i) := by
dsimp; infer_instance
have inst : IsAffine ((Cones.postcompose (asIso e).hom).obj c).pt := by
dsimp; infer_instance
have := this (D ⋙ Scheme.Γ.rightOp ⋙ Scheme.Spec) ((Cones.postcompose (asIso e).hom).obj c)
((IsLimit.postcomposeHomEquiv (asIso e) c).symm hc) (inv e ≫ t)
((inv e).app _ ≫ a) ((inv e).app _ ≫ b) (by simp [hab]) (by simp [ha]) (by simp [hb])
⟨D ⋙ Scheme.Γ.rightOp, rfl⟩
simp_rw [(inv e).naturality_assoc] at this
simpa using this
obtain ⟨D, rfl⟩ := hD
obtain ⟨a, rfl⟩ := Spec.map_surjective a
obtain ⟨b, rfl⟩ := Spec.map_surjective b
let e : ((Functor.const Iᵒᵖ).obj R).rightOp ⋙ Scheme.Spec ≅ (Functor.const I).obj (Spec R) :=
NatIso.ofComponents (fun _ ↦ Iso.refl _) (by simp)
obtain ⟨t, rfl⟩ : ∃ t' : (Functor.const Iᵒᵖ).obj R ⟶ D.leftOp,
t = Functor.whiskerRight (NatTrans.rightOp t') Scheme.Spec ≫ e.hom :=
⟨⟨fun i ↦ Spec.preimage (t.app i.unop), fun _ _ f ↦ Spec.map_injective
(by simpa using (t.naturality f.unop).symm)⟩, by ext : 2; simp [e]⟩
have := monadicCreatesLimits Scheme.Spec
obtain ⟨k, hik, hjk, H⟩ := (HasRingHomProperty.Spec_iff.mp ‹LocallyOfFiniteType (Spec.map φ)›)
|>.essFiniteType.exists_comp_map_eq_of_isColimit _ D.leftOp t _
(coconeLeftOpOfCone (liftLimit hc))
(isColimitCoconeLeftOpOfCone _ (liftedLimitIsLimit _))
a (Spec.map_injective (by simpa using ha.symm))
b (Spec.map_injective (by simpa using hb.symm))
(Spec.map_injective (by
simp only [coconeLeftOpOfCone_pt, Functor.const_obj_obj,
Functor.leftOp_obj, coconeLeftOpOfCone_ι_app, Spec.map_comp]
simp only [← Scheme.Spec_map, ← liftedLimitMapsToOriginal_hom_π, Category.assoc, hab]))
exact ⟨k.unop, hik.unop, hjk.unop, by simpa [← Spec.map_comp, Spec.map_inj] using H⟩
/-- (Implementation)
An auxiliary structure used to prove `Scheme.exists_hom_hom_comp_eq_comp_of_locallyOfFiniteType`.
See the section docstring.
|
exists_index : ∃ (i' : I) (hii' : i' ⟶ A.i),
((D.map hii' ≫ pullback.lift A.a A.b (A.ha.symm.trans A.hb)).base ⁻¹'
((Scheme.Pullback.diagonalCoverDiagonalRange f A.𝒰S A.𝒰X : Set <|
↑(pullback f f))ᶜ)) = ∅ := by
let W := Scheme.Pullback.diagonalCoverDiagonalRange f A.𝒰S A.𝒰X
by_contra! h
let Z (i' : I) (hii' : i' ⟶ A.i) :=
(D.map hii' ≫ pullback.lift A.a A.b (A.ha.symm.trans A.hb)).base ⁻¹' Wᶜ
have hZ (i') (hii' : i' ⟶ A.i) : IsClosed (Z i' hii') :=
(W.isOpen.isClosed_compl).preimage <| Scheme.Hom.continuous _
obtain ⟨s, hs⟩ := exists_mem_of_isClosed_of_nonempty' D A.c A.hc Z hZ h
(fun _ _ ↦ (hZ _ _).isCompact) (fun i i' hii' hij ↦ by simp [Z, Set.MapsTo])
refine hs A.i (𝟙 A.i) (Scheme.Pullback.range_diagonal_subset_diagonalCoverDiagonalRange _ _ _ ?_)
use (A.c.π.app A.i ≫ A.a).base s
have H : A.c.π.app A.i ≫ A.a ≫ pullback.diagonal f =
A.c.π.app A.i ≫ pullback.lift A.a A.b (A.ha.symm.trans A.hb) := by ext <;> simp [hab]
simp [← Scheme.comp_base_apply, - Scheme.comp_coeBase, H]
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.Algebra.Category.Ring.FinitePresentation",
"Mathlib.AlgebraicGeometry.IdealSheaf.Functorial",
"Mathlib.AlgebraicGeometry.Morphisms.Separated",
"Mathlib.CategoryTheory.Filtered.Final",
"Mathlib.CategoryTheory.Monad.Limits"
] |
Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
|
exists_index
| null |
i' : I := A.exists_index.choose
|
def
|
AlgebraicGeometry
|
[
"Mathlib.Algebra.Category.Ring.FinitePresentation",
"Mathlib.AlgebraicGeometry.IdealSheaf.Functorial",
"Mathlib.AlgebraicGeometry.Morphisms.Separated",
"Mathlib.CategoryTheory.Filtered.Final",
"Mathlib.CategoryTheory.Monad.Limits"
] |
Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
|
i'
|
(Implementation)
The index `i'` such that `a` and `b` restricted onto `i'` maps into the diagonal components.
See the section docstring.
|
hii' : A.i' ⟶ A.i := A.exists_index.choose_spec.choose
|
def
|
AlgebraicGeometry
|
[
"Mathlib.Algebra.Category.Ring.FinitePresentation",
"Mathlib.AlgebraicGeometry.IdealSheaf.Functorial",
"Mathlib.AlgebraicGeometry.Morphisms.Separated",
"Mathlib.CategoryTheory.Filtered.Final",
"Mathlib.CategoryTheory.Monad.Limits"
] |
Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
|
hii'
|
(Implementation) The map from `i'` to `i`. See the section docstring.
|
g : D.obj A.i' ⟶ pullback f f :=
(D.map A.hii' ≫ pullback.lift A.a A.b (A.ha.symm.trans A.hb))
omit [LocallyOfFiniteType f] in
|
def
|
AlgebraicGeometry
|
[
"Mathlib.Algebra.Category.Ring.FinitePresentation",
"Mathlib.AlgebraicGeometry.IdealSheaf.Functorial",
"Mathlib.AlgebraicGeometry.Morphisms.Separated",
"Mathlib.CategoryTheory.Filtered.Final",
"Mathlib.CategoryTheory.Monad.Limits"
] |
Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
|
g
|
(Implementation)
The map sending `x` to `(a x, b x)`, which should fall in the diagonal component.
See the section docstring.
|
range_g_subset :
Set.range A.g.base ⊆ Scheme.Pullback.diagonalCoverDiagonalRange f A.𝒰S A.𝒰X := by
simpa [ExistsHomHomCompEqCompAux.hii', g] using A.exists_index.choose_spec.choose_spec
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.Algebra.Category.Ring.FinitePresentation",
"Mathlib.AlgebraicGeometry.IdealSheaf.Functorial",
"Mathlib.AlgebraicGeometry.Morphisms.Separated",
"Mathlib.CategoryTheory.Filtered.Final",
"Mathlib.CategoryTheory.Monad.Limits"
] |
Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
|
range_g_subset
| null |
noncomputable 𝒰D₀ : Scheme.OpenCover.{u} (D.obj A.i') :=
Scheme.Cover.mkOfCovers (Σ i : A.𝒰S.I₀, (A.𝒰X i).I₀) _
(fun i ↦ ((Scheme.Pullback.diagonalCover f A.𝒰S A.𝒰X).pullback₁ A.g).f ⟨i.1, i.2, i.2⟩)
(fun x ↦ by simpa [← Set.mem_range, Scheme.Pullback.range_fst,
Scheme.Pullback.diagonalCoverDiagonalRange] using A.range_g_subset ⟨x, rfl⟩)
|
def
|
AlgebraicGeometry
|
[
"Mathlib.Algebra.Category.Ring.FinitePresentation",
"Mathlib.AlgebraicGeometry.IdealSheaf.Functorial",
"Mathlib.AlgebraicGeometry.Morphisms.Separated",
"Mathlib.CategoryTheory.Filtered.Final",
"Mathlib.CategoryTheory.Monad.Limits"
] |
Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
|
𝒰D₀
|
(Implementation)
The covering of `D(i')` by the pullback of the diagonal components of `X ×ₛ X`.
See the section docstring.
|
noncomputable 𝒰D : Scheme.OpenCover.{u} (D.obj A.i') :=
A.𝒰D₀.bind fun _ ↦ Scheme.affineCover _
attribute [-simp] cast_eq eq_mpr_eq_cast
|
def
|
AlgebraicGeometry
|
[
"Mathlib.Algebra.Category.Ring.FinitePresentation",
"Mathlib.AlgebraicGeometry.IdealSheaf.Functorial",
"Mathlib.AlgebraicGeometry.Morphisms.Separated",
"Mathlib.CategoryTheory.Filtered.Final",
"Mathlib.CategoryTheory.Monad.Limits"
] |
Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
|
𝒰D
|
(Implementation) An affine open cover refining `𝒰D₀`. See the section docstring.
|
D' (j : A.𝒰D.I₀) : Over A.i' ⥤ Scheme :=
Over.post D ⋙ Over.pullback (A.𝒰D.f j) ⋙ Over.forget _
|
def
|
AlgebraicGeometry
|
[
"Mathlib.Algebra.Category.Ring.FinitePresentation",
"Mathlib.AlgebraicGeometry.IdealSheaf.Functorial",
"Mathlib.AlgebraicGeometry.Morphisms.Separated",
"Mathlib.CategoryTheory.Filtered.Final",
"Mathlib.CategoryTheory.Monad.Limits"
] |
Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
|
D'
|
(Implementation) The diagram restricted to `Over i'`. See the section docstring.
|
c' (j : A.𝒰D.I₀) : Cone (A.D' j) :=
(Over.pullback (A.𝒰D.f j) ⋙ Over.forget _).mapCone ((Over.conePost _ _).obj A.c)
attribute [local instance] IsCofiltered.isConnected
|
def
|
AlgebraicGeometry
|
[
"Mathlib.Algebra.Category.Ring.FinitePresentation",
"Mathlib.AlgebraicGeometry.IdealSheaf.Functorial",
"Mathlib.AlgebraicGeometry.Morphisms.Separated",
"Mathlib.CategoryTheory.Filtered.Final",
"Mathlib.CategoryTheory.Monad.Limits"
] |
Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
|
c'
|
(Implementation) The limit cone restricted to `Over i'`. See the section docstring.
|
hc' (j : A.𝒰D.I₀) : IsLimit (A.c' j) :=
isLimitOfPreserves (Over.pullback (A.𝒰D.f j) ⋙ Over.forget _) (Over.isLimitConePost _ A.hc)
variable [∀ i, IsAffineHom (A.c.π.app i)]
|
def
|
AlgebraicGeometry
|
[
"Mathlib.Algebra.Category.Ring.FinitePresentation",
"Mathlib.AlgebraicGeometry.IdealSheaf.Functorial",
"Mathlib.AlgebraicGeometry.Morphisms.Separated",
"Mathlib.CategoryTheory.Filtered.Final",
"Mathlib.CategoryTheory.Monad.Limits"
] |
Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
|
hc'
|
(Implementation)
The limit cone restricted to `Over i'` is still a limit because the diagram is cofiltered.
See the section docstring.
|
exists_eq (j : A.𝒰D.I₀) : ∃ (k : I) (hki' : k ⟶ A.i'),
(A.𝒰D.pullback₁ (D.map hki')).f j ≫ D.map (hki' ≫ A.hii') ≫ A.a =
(A.𝒰D.pullback₁ (D.map hki')).f j ≫ D.map (hki' ≫ A.hii') ≫ A.b := by
have : IsAffine (A.𝒰D.X j) := by dsimp [𝒰D]; infer_instance
have (i : _) : IsAffine ((Over.post D ⋙ Over.pullback (A.𝒰D.f j) ⋙ Over.forget _).obj i) := by
dsimp; infer_instance
have : IsAffine ((Over.pullback (A.𝒰D.f j) ⋙ Over.forget (A.𝒰D.X j)).mapCone
((Over.conePost D A.i').obj A.c)).pt := by
dsimp; infer_instance
have : LocallyOfFiniteType ((A.𝒰X j.fst.fst).f j.fst.snd ≫ A.𝒰S.pullbackHom f j.fst.fst) := by
dsimp [Scheme.Cover.pullbackHom]; infer_instance
have H₁ := congr($(pullback.condition (f := A.g) (g := (Scheme.Pullback.diagonalCover f
A.𝒰S A.𝒰X).f ⟨j.1.1, (j.1.2, j.1.2)⟩)) ≫ pullback.fst _ _)
have H₂ := congr($(pullback.condition (f := A.g) (g := (Scheme.Pullback.diagonalCover f
A.𝒰S A.𝒰X).f ⟨j.1.1, (j.1.2, j.1.2)⟩)) ≫ pullback.snd _ _)
simp only [Scheme.Pullback.openCoverOfBase_I₀, Scheme.Pullback.openCoverOfBase_X,
Scheme.Cover.pullbackHom, Scheme.Pullback.openCoverOfLeftRight_I₀,
g, Category.assoc, limit.lift_π, PullbackCone.mk_pt, PullbackCone.mk_π_app,
Scheme.Pullback.diagonalCover_map] at H₁ H₂
obtain ⟨k, hik, hjk, H⟩ := Scheme.exists_hom_hom_comp_eq_comp_of_isAffine_of_locallyOfFiniteType
(Over.post D ⋙ Over.pullback (A.𝒰D.f j) ⋙ Over.forget _)
((Over.post D ⋙ Over.pullback (A.𝒰D.f j)).whiskerLeft (Comma.natTrans _ _) ≫
(Functor.const _).map ((A.𝒰D₀.X j.1).affineCover.f j.2 ≫
(Scheme.Pullback.diagonalCover f A.𝒰S A.𝒰X).pullbackHom _ _ ≫
pullback.fst _ _ ≫
(A.𝒰X j.fst.fst).f j.fst.snd ≫ Scheme.Cover.pullbackHom A.𝒰S f j.fst.fst))
(((A.𝒰X j.1.1).f j.1.2 ≫ A.𝒰S.pullbackHom f j.1.1))
((Over.pullback (A.𝒰D.f j) ⋙ Over.forget _).mapCone ((Over.conePost _ _).obj A.c))
(by
refine isLimitOfPreserves (Over.pullback (A.𝒰D.f j) ⋙ Over.forget _) ?_
apply isLimitOfReflects (Over.forget (D.obj A.i'))
exact (Functor.Initial.isLimitWhiskerEquiv (Over.forget A.i') A.c).symm A.hc)
(i := Over.mk (𝟙 _))
(pullback.snd _ _ ≫ (A.𝒰D₀.X j.1).affineCover.f j.2 ≫
(Scheme.Pullback.diagonalCover f A.𝒰S A.𝒰X).pullbackHom _ _ ≫
pullback.fst _ _)
(by simp)
(j := Over.mk (𝟙 _))
(pullback.snd _ _ ≫ (A.𝒰D₀.X j.1).affineCover.f j.2 ≫
(Scheme.Pullback.diagonalCover f A.𝒰S A.𝒰X).pullbackHom _ _ ≫
pullback.snd _ _)
(by simp [pullback.condition])
(by
rw [← cancel_mono ((A.𝒰X j.1.1).f j.1.2), ← cancel_mono (pullback.fst f (A.𝒰S.f j.1.1))]
have H₃ := congr(pullback.fst (A.c.π.app A.i') (A.𝒰D.f j) ≫ $(A.hab))
simp only [pullback.condition_assoc, 𝒰D, ← A.c.w A.hii', Category.assoc] at H₃
simpa [Scheme.Cover.pullbackHom, g, ← H₁, ← H₂, -Cone.w, -Cone.w_assoc] using H₃)
refine ⟨k.left, k.hom, ?_⟩
simpa [← cancel_mono ((A.𝒰X j.1.1).f j.1.2), ← cancel_mono (pullback.fst f (A.𝒰S.f j.1.1)),
Scheme.Cover.pullbackHom, g, ← H₁, ← H₂, pullback.condition_assoc] using H
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.Algebra.Category.Ring.FinitePresentation",
"Mathlib.AlgebraicGeometry.IdealSheaf.Functorial",
"Mathlib.AlgebraicGeometry.Morphisms.Separated",
"Mathlib.CategoryTheory.Filtered.Final",
"Mathlib.CategoryTheory.Monad.Limits"
] |
Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
|
exists_eq
| null |
@[stacks 01ZC "Injective part of (1) => (3)"]
Scheme.exists_hom_hom_comp_eq_comp_of_locallyOfFiniteType
{i : I} (a : D.obj i ⟶ X) (ha : t.app i = a ≫ f)
{j : I} (b : D.obj j ⟶ X) (hb : t.app j = b ≫ f)
(hab : c.π.app i ≫ a = c.π.app j ≫ b) :
∃ (k : I) (hik : k ⟶ i) (hjk : k ⟶ j),
D.map hik ≫ a = D.map hjk ≫ b := by
classical
wlog h : i = j
· let o := IsCofiltered.min i j
have := this D t f c hc (D.map (IsCofiltered.minToLeft i j) ≫ a)
(by simp [← ha]) (D.map (IsCofiltered.minToRight i j) ≫ b)
(by simp [← hb]) (by simpa) rfl
obtain ⟨k, hik, hjk, heq⟩ := this
use k, hik ≫ IsCofiltered.minToLeft i j, hjk ≫ IsCofiltered.minToRight i j
simpa using heq
subst h
let A : ExistsHomHomCompEqCompAux D t f :=
{ c := c, hc := hc, i := i, a := a, ha := ha, b := b, hb := hb, hab := hab
𝒰S := S.affineCover, 𝒰X i := Scheme.affineCover _ }
let 𝒰 := Scheme.Pullback.diagonalCover f A.𝒰S A.𝒰X
let W := Scheme.Pullback.diagonalCoverDiagonalRange f A.𝒰S A.𝒰X
choose k hki' heq using A.exists_eq
let 𝒰Df := A.𝒰D.finiteSubcover
rcases isEmpty_or_nonempty (D.obj A.i') with h | h
· exact ⟨A.i', A.hii', A.hii', isInitialOfIsEmpty.hom_ext _ _⟩
let O : Finset I := {A.i'} ∪ Finset.univ.image (fun i : 𝒰Df.I₀ ↦ k <| A.𝒰D.idx i.1)
let o := Nonempty.some (inferInstanceAs <| Nonempty 𝒰Df.I₀)
have ho : k (A.𝒰D.idx o.1) ∈ O := by
simp [O]
obtain ⟨l, hl1, hl2⟩ := IsCofiltered.inf_exists O
(Finset.univ.image (fun i : 𝒰Df.I₀ ↦
⟨k <| A.𝒰D.idx i.1, A.i', by simp [O], by simp [O], hki' <| A.𝒰D.idx i.1⟩))
have (w v : 𝒰Df.I₀) :
hl1 (by simp [O]) ≫ hki' (A.𝒰D.idx w.1) = hl1 (by simp [O]) ≫ hki' (A.𝒰D.idx v.1) := by
trans hl1 (show A.i' ∈ O by simp [O])
· exact hl2 _ _ (Finset.mem_image_of_mem _ (Finset.mem_univ _))
· exact .symm <| hl2 _ _ (Finset.mem_image_of_mem _ (by simp))
refine ⟨l, hl1 ho ≫ hki' _ ≫ A.hii', hl1 ho ≫ hki' _ ≫ A.hii', ?_⟩
apply Cover.hom_ext (𝒰Df.pullback₁ (D.map <| hl1 ho ≫ hki' _))
intro u
let F : pullback (D.map (hl1 ho ≫ hki' (A.𝒰D.idx o.1))) (𝒰Df.f u) ⟶
pullback (D.map (hki' <| A.𝒰D.idx u.1)) (A.𝒰D.f <| A.𝒰D.idx u.1) :=
pullback.map _ _ _ _ (D.map <| hl1 (by simp [O]))
(𝟙 _) (𝟙 _) (by rw [Category.comp_id, ← D.map_comp, this]) rfl
have hF : F ≫ pullback.fst (D.map (hki' _)) (A.𝒰D.f _) =
pullback.fst _ _ ≫ D.map (hl1 (by simp [O])) := by simp [F]
simp only [Precoverage.ZeroHypercover.pullback₁_toPreZeroHypercover,
PreZeroHypercover.pullback₁_X, PreZeroHypercover.pullback₁_f, Functor.map_comp, Category.assoc]
at heq ⊢
simp_rw [← D.map_comp_assoc, reassoc_of% this o u, D.map_comp_assoc]
...
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.Algebra.Category.Ring.FinitePresentation",
"Mathlib.AlgebraicGeometry.IdealSheaf.Functorial",
"Mathlib.AlgebraicGeometry.Morphisms.Separated",
"Mathlib.CategoryTheory.Filtered.Final",
"Mathlib.CategoryTheory.Monad.Limits"
] |
Mathlib/AlgebraicGeometry/AffineTransitionLimit.lean
|
Scheme.exists_hom_hom_comp_eq_comp_of_locallyOfFiniteType
|
Given a cofiltered diagram `D` of quasi-compact `S`-schemes with affine transition maps,
and another scheme `X` of finite type over `S`.
Then the canonical map `colim Homₛ(Dᵢ, X) ⟶ Homₛ(lim Dᵢ, X)` is injective.
In other words, for each pair of `a : Homₛ(Dᵢ, X)` and `b : Homₛ(Dⱼ, X)` that give rise to the
same map `Homₛ(lim Dᵢ, X)`, there exists a `k` with `fᵢ : k ⟶ i` and `fⱼ : k ⟶ j` such that
`D(fᵢ) ≫ a = D(fⱼ) ≫ b`.
|
Scheme.Hom.fiber (f : X.Hom Y) (y : Y) : Scheme := pullback f (Y.fromSpecResidueField y)
|
def
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.PullbackCarrier",
"Mathlib.AlgebraicGeometry.Morphisms.Finite",
"Mathlib.RingTheory.Spectrum.Prime.Jacobson"
] |
Mathlib/AlgebraicGeometry/Fiber.lean
|
Scheme.Hom.fiber
|
`f.fiber y` is the scheme-theoretic fiber of `f` at `y`.
|
Scheme.Hom.fiberι (f : X.Hom Y) (y : Y) : f.fiber y ⟶ X := pullback.fst _ _
|
def
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.PullbackCarrier",
"Mathlib.AlgebraicGeometry.Morphisms.Finite",
"Mathlib.RingTheory.Spectrum.Prime.Jacobson"
] |
Mathlib/AlgebraicGeometry/Fiber.lean
|
Scheme.Hom.fiberι
|
`f.fiberι y : f.fiber y ⟶ X` is the embedding of the scheme-theoretic fiber into `X`.
|
Scheme.Hom.fiberToSpecResidueField (f : X.Hom Y) (y : Y) :
f.fiber y ⟶ Spec (Y.residueField y) :=
pullback.snd _ _
|
def
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.PullbackCarrier",
"Mathlib.AlgebraicGeometry.Morphisms.Finite",
"Mathlib.RingTheory.Spectrum.Prime.Jacobson"
] |
Mathlib/AlgebraicGeometry/Fiber.lean
|
Scheme.Hom.fiberToSpecResidueField
|
The canonical map from the scheme-theoretic fiber to the residue field.
|
@[reducible] Scheme.Hom.fiberOverSpecResidueField
(f : X.Hom Y) (y : Y) : (f.fiber y).Over (Spec (Y.residueField y)) where
hom := f.fiberToSpecResidueField y
|
def
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.PullbackCarrier",
"Mathlib.AlgebraicGeometry.Morphisms.Finite",
"Mathlib.RingTheory.Spectrum.Prime.Jacobson"
] |
Mathlib/AlgebraicGeometry/Fiber.lean
|
Scheme.Hom.fiberOverSpecResidueField
|
The fiber of `f` at `y` is naturally a `κ(y)`-scheme.
|
Scheme.Hom.fiberToSpecResidueField_apply (f : X.Hom Y) (y : Y) (x : f.fiber y) :
(f.fiberToSpecResidueField y).base x = IsLocalRing.closedPoint (Y.residueField y) :=
Subsingleton.elim (α := PrimeSpectrum _) _ _
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.PullbackCarrier",
"Mathlib.AlgebraicGeometry.Morphisms.Finite",
"Mathlib.RingTheory.Spectrum.Prime.Jacobson"
] |
Mathlib/AlgebraicGeometry/Fiber.lean
|
Scheme.Hom.fiberToSpecResidueField_apply
| null |
Scheme.Hom.range_fiberι (f : X.Hom Y) (y : Y) :
Set.range (f.fiberι y).base = f.base ⁻¹' {y} := by
simp [fiber, fiberι, Scheme.Pullback.range_fst, Scheme.range_fromSpecResidueField]
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.PullbackCarrier",
"Mathlib.AlgebraicGeometry.Morphisms.Finite",
"Mathlib.RingTheory.Spectrum.Prime.Jacobson"
] |
Mathlib/AlgebraicGeometry/Fiber.lean
|
Scheme.Hom.range_fiberι
| null |
Scheme.Hom.fiberHomeo (f : X.Hom Y) (y : Y) : f.fiber y ≃ₜ f.base ⁻¹' {y} :=
.trans (f.fiberι y).isEmbedding.toHomeomorph (.setCongr (f.range_fiberι y))
@[simp]
|
def
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.PullbackCarrier",
"Mathlib.AlgebraicGeometry.Morphisms.Finite",
"Mathlib.RingTheory.Spectrum.Prime.Jacobson"
] |
Mathlib/AlgebraicGeometry/Fiber.lean
|
Scheme.Hom.fiberHomeo
|
The scheme-theoretic fiber of `f` at `y` is homeomorphic to `f ⁻¹' {y}`.
|
Scheme.Hom.fiberHomeo_apply (f : X.Hom Y) (y : Y) (x : f.fiber y) :
(f.fiberHomeo y x).1 = (f.fiberι y).base x := rfl
@[simp]
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.PullbackCarrier",
"Mathlib.AlgebraicGeometry.Morphisms.Finite",
"Mathlib.RingTheory.Spectrum.Prime.Jacobson"
] |
Mathlib/AlgebraicGeometry/Fiber.lean
|
Scheme.Hom.fiberHomeo_apply
| null |
Scheme.Hom.fiberι_fiberHomeo_symm (f : X.Hom Y) (y : Y) (x : f.base ⁻¹' {y}) :
(f.fiberι y).base ((f.fiberHomeo y).symm x) = x :=
congr($((f.fiberHomeo y).apply_symm_apply x).1)
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.PullbackCarrier",
"Mathlib.AlgebraicGeometry.Morphisms.Finite",
"Mathlib.RingTheory.Spectrum.Prime.Jacobson"
] |
Mathlib/AlgebraicGeometry/Fiber.lean
|
Scheme.Hom.fiberι_fiberHomeo_symm
| null |
Scheme.Hom.asFiber (f : X.Hom Y) (x : X) : f.fiber (f.base x) :=
(f.fiberHomeo (f.base x)).symm ⟨x, rfl⟩
@[simp]
|
def
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.PullbackCarrier",
"Mathlib.AlgebraicGeometry.Morphisms.Finite",
"Mathlib.RingTheory.Spectrum.Prime.Jacobson"
] |
Mathlib/AlgebraicGeometry/Fiber.lean
|
Scheme.Hom.asFiber
|
A point `x` as a point in the fiber of `f` at `f x`.
|
Scheme.Hom.fiberι_asFiber (f : X.Hom Y) (x : X) : (f.fiberι _).base (f.asFiber x) = x :=
f.fiberι_fiberHomeo_symm _ _
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.PullbackCarrier",
"Mathlib.AlgebraicGeometry.Morphisms.Finite",
"Mathlib.RingTheory.Spectrum.Prime.Jacobson"
] |
Mathlib/AlgebraicGeometry/Fiber.lean
|
Scheme.Hom.fiberι_asFiber
| null |
QuasiCompact.isCompact_preimage_singleton (f : X ⟶ Y) [QuasiCompact f] (y : Y) :
IsCompact (f.base ⁻¹' {y}) :=
f.range_fiberι y ▸ isCompact_range (f.fiberι y).continuous
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.PullbackCarrier",
"Mathlib.AlgebraicGeometry.Morphisms.Finite",
"Mathlib.RingTheory.Spectrum.Prime.Jacobson"
] |
Mathlib/AlgebraicGeometry/Fiber.lean
|
QuasiCompact.isCompact_preimage_singleton
| null |
IsFinite.finite_preimage_singleton (f : X ⟶ Y) [IsFinite f] (y : Y) :
(f.base ⁻¹' {y}).Finite :=
f.range_fiberι y ▸ Set.finite_range (f.fiberι y).base
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.PullbackCarrier",
"Mathlib.AlgebraicGeometry.Morphisms.Finite",
"Mathlib.RingTheory.Spectrum.Prime.Jacobson"
] |
Mathlib/AlgebraicGeometry/Fiber.lean
|
IsFinite.finite_preimage_singleton
| null |
Scheme.Hom.finite_preimage (f : X.Hom Y) [IsFinite f] {s : Set Y} (hs : s.Finite) :
(f.base ⁻¹' s).Finite := by
rw [← Set.biUnion_of_singleton s, Set.preimage_iUnion₂]
exact hs.biUnion fun _ _ ↦ IsFinite.finite_preimage_singleton f _
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.PullbackCarrier",
"Mathlib.AlgebraicGeometry.Morphisms.Finite",
"Mathlib.RingTheory.Spectrum.Prime.Jacobson"
] |
Mathlib/AlgebraicGeometry/Fiber.lean
|
Scheme.Hom.finite_preimage
| null |
Scheme.Hom.discrete_fiber (f : X ⟶ Y) (y : Y) [IsFinite f] :
DiscreteTopology (f.fiber y) := inferInstance
|
instance
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.PullbackCarrier",
"Mathlib.AlgebraicGeometry.Morphisms.Finite",
"Mathlib.RingTheory.Spectrum.Prime.Jacobson"
] |
Mathlib/AlgebraicGeometry/Fiber.lean
|
Scheme.Hom.discrete_fiber
| null |
noncomputable Scheme.functionField [IrreducibleSpace X] : CommRingCat :=
X.presheaf.stalk (genericPoint X)
|
abbrev
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Properties"
] |
Mathlib/AlgebraicGeometry/FunctionField.lean
|
Scheme.functionField
|
The function field of an irreducible scheme is the local ring at its generic point.
Despite the name, this is a field only when the scheme is integral.
|
noncomputable Scheme.germToFunctionField [IrreducibleSpace X] (U : X.Opens)
[h : Nonempty U] : Γ(X, U) ⟶ X.functionField :=
X.presheaf.germ U
(genericPoint X)
(((genericPoint_spec X).mem_open_set_iff U.isOpen).mpr (by simpa using h))
|
abbrev
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Properties"
] |
Mathlib/AlgebraicGeometry/FunctionField.lean
|
Scheme.germToFunctionField
|
The restriction map from a component to the function field.
|
germ_injective_of_isIntegral [IsIntegral X] {U : X.Opens} (x : X) (hx : x ∈ U) :
Function.Injective (X.presheaf.germ U x hx) := by
rw [injective_iff_map_eq_zero]
intro y hy
rw [← (X.presheaf.germ U x hx).hom.map_zero] at hy
obtain ⟨W, hW, iU, iV, e⟩ := X.presheaf.germ_eq _ hx hx _ _ hy
cases Subsingleton.elim iU iV
haveI : Nonempty W := ⟨⟨_, hW⟩⟩
exact map_injective_of_isIntegral X iU e
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Properties"
] |
Mathlib/AlgebraicGeometry/FunctionField.lean
|
germ_injective_of_isIntegral
| null |
Scheme.germToFunctionField_injective [IsIntegral X] (U : X.Opens) [Nonempty U] :
Function.Injective (X.germToFunctionField U) :=
germ_injective_of_isIntegral _ _ _
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Properties"
] |
Mathlib/AlgebraicGeometry/FunctionField.lean
|
Scheme.germToFunctionField_injective
| null |
genericPoint_eq_of_isOpenImmersion {X Y : Scheme} (f : X ⟶ Y) [H : IsOpenImmersion f]
[hX : IrreducibleSpace X] [IrreducibleSpace Y] :
f.base (genericPoint X) = genericPoint Y := by
apply ((genericPoint_spec Y).eq _).symm
convert (genericPoint_spec X).image (show Continuous f.base by fun_prop)
symm
rw [← Set.univ_subset_iff]
convert subset_closure_inter_of_isPreirreducible_of_isOpen _ H.base_open.isOpen_range _
· rw [Set.univ_inter, Set.image_univ]
· apply PreirreducibleSpace.isPreirreducible_univ (X := Y)
· exact ⟨_, trivial, Set.mem_range_self hX.2.some⟩
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Properties"
] |
Mathlib/AlgebraicGeometry/FunctionField.lean
|
genericPoint_eq_of_isOpenImmersion
| null |
noncomputable stalkFunctionFieldAlgebra [IrreducibleSpace X] (x : X) :
Algebra (X.presheaf.stalk x) X.functionField := by
apply RingHom.toAlgebra
exact (X.presheaf.stalkSpecializes ((genericPoint_spec X).specializes trivial)).hom
|
instance
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Properties"
] |
Mathlib/AlgebraicGeometry/FunctionField.lean
|
stalkFunctionFieldAlgebra
| null |
functionField_isScalarTower [IrreducibleSpace X] (U : X.Opens) (x : U)
[Nonempty U] : IsScalarTower Γ(X, U) (X.presheaf.stalk x) X.functionField := by
apply IsScalarTower.of_algebraMap_eq'
simp_rw [RingHom.algebraMap_toAlgebra]
change _ = (X.presheaf.germ U x x.2 ≫ _).hom
rw [X.presheaf.germ_stalkSpecializes]
|
instance
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Properties"
] |
Mathlib/AlgebraicGeometry/FunctionField.lean
|
functionField_isScalarTower
| null |
@[simp]
genericPoint_eq_bot_of_affine (R : CommRingCat) [IsDomain R] :
genericPoint (Spec R) = (⊥ : PrimeSpectrum R) := by
apply (genericPoint_spec (Spec R)).eq
rw [isGenericPoint_def]
rw [← PrimeSpectrum.zeroLocus_vanishingIdeal_eq_closure, PrimeSpectrum.vanishingIdeal_singleton]
rw [← PrimeSpectrum.zeroLocus_singleton_zero]
rfl
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Properties"
] |
Mathlib/AlgebraicGeometry/FunctionField.lean
|
genericPoint_eq_bot_of_affine
| null |
functionField_isFractionRing_of_affine (R : CommRingCat.{u}) [IsDomain R] :
IsFractionRing R (Spec R).functionField := by
convert StructureSheaf.IsLocalization.to_stalk R (genericPoint (Spec R))
delta IsFractionRing IsLocalization.AtPrime
apply Eq.to_iff
congr 1
rw [genericPoint_eq_bot_of_affine]
ext
exact mem_nonZeroDivisors_iff_ne_zero
|
instance
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Properties"
] |
Mathlib/AlgebraicGeometry/FunctionField.lean
|
functionField_isFractionRing_of_affine
| null |
IsAffineOpen.primeIdealOf_genericPoint {X : Scheme} [IsIntegral X] {U : X.Opens}
(hU : IsAffineOpen U) [h : Nonempty U] :
hU.primeIdealOf
⟨genericPoint X,
((genericPoint_spec X).mem_open_set_iff U.isOpen).mpr (by simpa using h)⟩ =
genericPoint (Spec Γ(X, U)) := by
haveI : IsAffine _ := hU
delta IsAffineOpen.primeIdealOf
convert
genericPoint_eq_of_isOpenImmersion
(U.toScheme.isoSpec.hom ≫ Spec.map (X.presheaf.map (eqToHom U.isOpenEmbedding_obj_top).op))
apply Subtype.ext
exact (genericPoint_eq_of_isOpenImmersion U.ι).symm
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Properties"
] |
Mathlib/AlgebraicGeometry/FunctionField.lean
|
IsAffineOpen.primeIdealOf_genericPoint
| null |
functionField_isFractionRing_of_isAffineOpen [IsIntegral X] (U : X.Opens)
(hU : IsAffineOpen U) [Nonempty U] :
IsFractionRing Γ(X, U) X.functionField := by
haveI : IsAffine _ := hU
haveI : IsIntegral U :=
@isIntegral_of_isAffine_of_isDomain _ _ _
(by rw [Scheme.Opens.toScheme_presheaf_obj, Opens.isOpenEmbedding_obj_top]; infer_instance)
delta IsFractionRing Scheme.functionField
convert hU.isLocalization_stalk ⟨genericPoint X,
(((genericPoint_spec X).mem_open_set_iff U.isOpen).mpr (by simpa using ‹Nonempty U›))⟩ using 1
rw [hU.primeIdealOf_genericPoint, genericPoint_eq_bot_of_affine]
ext; exact mem_nonZeroDivisors_iff_ne_zero
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Properties"
] |
Mathlib/AlgebraicGeometry/FunctionField.lean
|
functionField_isFractionRing_of_isAffineOpen
| null |
toΓSpecFun : X → PrimeSpectrum (Γ.obj (op X)) := fun x =>
comap (X.presheaf.Γgerm x).hom (IsLocalRing.closedPoint (X.presheaf.stalk x))
|
def
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
toΓSpecFun
|
The canonical map from the underlying set to the prime spectrum of `Γ(X)`.
|
notMem_prime_iff_unit_in_stalk (r : Γ.obj (op X)) (x : X) :
r ∉ (X.toΓSpecFun x).asIdeal ↔ IsUnit (X.presheaf.Γgerm x r) := by
simp [toΓSpecFun, IsLocalRing.closedPoint]
@[deprecated (since := "2025-05-23")]
alias not_mem_prime_iff_unit_in_stalk := notMem_prime_iff_unit_in_stalk
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
notMem_prime_iff_unit_in_stalk
| null |
toΓSpec_preimage_basicOpen_eq (r : Γ.obj (op X)) :
X.toΓSpecFun ⁻¹' basicOpen r = SetLike.coe (X.toRingedSpace.basicOpen r) := by
ext
dsimp
simp only [Set.mem_preimage, SetLike.mem_coe]
rw [X.toRingedSpace.mem_top_basicOpen]
exact notMem_prime_iff_unit_in_stalk ..
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
toΓSpec_preimage_basicOpen_eq
|
The preimage of a basic open in `Spec Γ(X)` under the unit is the basic
open in `X` defined by the same element (they are equal as sets).
|
toΓSpec_continuous : Continuous X.toΓSpecFun := by
rw [isTopologicalBasis_basic_opens.continuous_iff]
rintro _ ⟨r, rfl⟩
rw [X.toΓSpec_preimage_basicOpen_eq r]
exact (X.toRingedSpace.basicOpen r).2
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
toΓSpec_continuous
|
`toΓSpecFun` is continuous.
|
toΓSpecBase : X.toTopCat ⟶ Spec.topObj (Γ.obj (op X)) :=
TopCat.ofHom
{ toFun := X.toΓSpecFun
continuous_toFun := X.toΓSpec_continuous }
variable (r : Γ.obj (op X))
|
def
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
toΓSpecBase
|
The canonical (bundled) continuous map from the underlying topological
space of `X` to the prime spectrum of its global sections.
|
toΓSpecMapBasicOpen : Opens X :=
(Opens.map X.toΓSpecBase).obj (basicOpen r)
|
abbrev
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
toΓSpecMapBasicOpen
|
The preimage in `X` of a basic open in `Spec Γ(X)` (as an open set).
|
toΓSpecMapBasicOpen_eq : X.toΓSpecMapBasicOpen r = X.toRingedSpace.basicOpen r :=
Opens.ext (X.toΓSpec_preimage_basicOpen_eq r)
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
toΓSpecMapBasicOpen_eq
|
The preimage is the basic open in `X` defined by the same element `r`.
|
toToΓSpecMapBasicOpen :
X.presheaf.obj (op ⊤) ⟶ X.presheaf.obj (op <| X.toΓSpecMapBasicOpen r) :=
X.presheaf.map (X.toΓSpecMapBasicOpen r).leTop.op
|
abbrev
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
toToΓSpecMapBasicOpen
|
The map from the global sections `Γ(X)` to the sections on the (preimage of) a basic open.
|
isUnit_res_toΓSpecMapBasicOpen : IsUnit (X.toToΓSpecMapBasicOpen r r) := by
convert
(X.presheaf.map <| (eqToHom <| X.toΓSpecMapBasicOpen_eq r).op).hom.isUnit_map
(X.toRingedSpace.isUnit_res_basicOpen r)
rw [← CommRingCat.comp_apply, ← Functor.map_comp]
congr
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
isUnit_res_toΓSpecMapBasicOpen
|
`r` is a unit as a section on the basic open defined by `r`.
|
toΓSpecCApp :
(structureSheaf <| Γ.obj <| op X).val.obj (op <| basicOpen r) ⟶
X.presheaf.obj (op <| X.toΓSpecMapBasicOpen r) :=
CommRingCat.ofHom <|
IsLocalization.Away.lift
(R := Γ.obj (op X))
(S := (structureSheaf ↑(Γ.obj (op X))).val.obj (op (basicOpen r)))
r
(isUnit_res_toΓSpecMapBasicOpen _ r)
|
def
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
toΓSpecCApp
|
Define the sheaf hom on individual basic opens for the unit.
|
toΓSpecCApp_iff
(f :
(structureSheaf <| Γ.obj <| op X).val.obj (op <| basicOpen r) ⟶
X.presheaf.obj (op <| X.toΓSpecMapBasicOpen r)) :
toOpen _ (basicOpen r) ≫ f = X.toToΓSpecMapBasicOpen r ↔ f = X.toΓSpecCApp r := by
have loc_inst := IsLocalization.to_basicOpen (Γ.obj (op X)) r
refine ConcreteCategory.ext_iff.trans ?_
rw [← @IsLocalization.Away.lift_comp _ _ _ _ _ _ _ r loc_inst _
(X.isUnit_res_toΓSpecMapBasicOpen r)]
constructor
· intro h
ext : 1
exact IsLocalization.ringHom_ext (Submonoid.powers r) h
apply congr_arg
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
toΓSpecCApp_iff
|
Characterization of the sheaf hom on basic opens,
direction ← (next lemma) is used at various places, but → is not used in this file.
|
toΓSpecCApp_spec : toOpen _ (basicOpen r) ≫ X.toΓSpecCApp r = X.toToΓSpecMapBasicOpen r :=
(X.toΓSpecCApp_iff r _).2 rfl
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
toΓSpecCApp_spec
| null |
@[simps app]
toΓSpecCBasicOpens :
(inducedFunctor basicOpen).op ⋙ (structureSheaf (Γ.obj (op X))).1 ⟶
(inducedFunctor basicOpen).op ⋙ ((TopCat.Sheaf.pushforward _ X.toΓSpecBase).obj X.𝒪).1 where
app r := X.toΓSpecCApp r.unop
naturality r s f := by
apply (StructureSheaf.to_basicOpen_epi (Γ.obj (op X)) r.unop).1
simp only [← Category.assoc]
rw [X.toΓSpecCApp_spec r.unop]
convert X.toΓSpecCApp_spec s.unop
symm
apply X.presheaf.map_comp
|
def
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
toΓSpecCBasicOpens
|
The sheaf hom on all basic opens, commuting with restrictions.
|
@[simps]
toΓSpecSheafedSpace : X.toSheafedSpace ⟶ Spec.toSheafedSpace.obj (op (Γ.obj (op X))) where
base := X.toΓSpecBase
c :=
TopCat.Sheaf.restrictHomEquivHom (structureSheaf (Γ.obj (op X))).1 _ isBasis_basic_opens
X.toΓSpecCBasicOpens
|
def
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
toΓSpecSheafedSpace
|
The canonical morphism of sheafed spaces from `X` to the spectrum of its global sections.
|
toΓSpecSheafedSpace_app_eq :
X.toΓSpecSheafedSpace.c.app (op (basicOpen r)) = X.toΓSpecCApp r := by
apply TopCat.Sheaf.extend_hom_app _ _ _
@[reassoc] theorem toΓSpecSheafedSpace_app_spec (r : Γ.obj (op X)) :
toOpen (Γ.obj (op X)) (basicOpen r) ≫ X.toΓSpecSheafedSpace.c.app (op (basicOpen r)) =
X.toToΓSpecMapBasicOpen r :=
(X.toΓSpecSheafedSpace_app_eq r).symm ▸ X.toΓSpecCApp_spec r
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
toΓSpecSheafedSpace_app_eq
| null |
toStalk_stalkMap_toΓSpec (x : X) :
toStalk _ _ ≫ X.toΓSpecSheafedSpace.stalkMap x = X.presheaf.Γgerm x := by
rw [PresheafedSpace.Hom.stalkMap,
← toOpen_germ _ (basicOpen (1 : Γ.obj (op X))) _ (by rw [basicOpen_one]; trivial),
← Category.assoc, Category.assoc (toOpen _ _), stalkFunctor_map_germ, ← Category.assoc,
X.toΓSpecSheafedSpace_app_eq, X.toΓSpecCApp_spec, Γgerm]
erw [← stalkPushforward_germ _ _ X.presheaf ⊤]
congr 1
exact (X.toΓSpecBase _* X.presheaf).germ_res le_top.hom _ _
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
toStalk_stalkMap_toΓSpec
|
The map on stalks induced by the unit commutes with maps from `Γ(X)` to
stalks (in `Spec Γ(X)` and in `X`).
|
@[simps! base]
toΓSpec : X ⟶ Spec.locallyRingedSpaceObj (Γ.obj (op X)) where
__ := X.toΓSpecSheafedSpace
prop := by
intro x
let p : PrimeSpectrum (Γ.obj (op X)) := X.toΓSpecFun x
constructor
let S := (structureSheaf _).presheaf.stalk p
rintro (t : S) ht
obtain ⟨⟨r, s⟩, he⟩ := IsLocalization.surj p.asIdeal.primeCompl t
dsimp at he
set t' := _
change t * t' = _ at he
apply isUnit_of_mul_isUnit_left (y := t')
rw [he]
refine IsLocalization.map_units S (⟨r, ?_⟩ : p.asIdeal.primeCompl)
apply (notMem_prime_iff_unit_in_stalk _ _ _).mpr
rw [← toStalk_stalkMap_toΓSpec, CommRingCat.comp_apply]
erw [← he]
rw [RingHom.map_mul]
exact ht.mul <| (IsLocalization.map_units (R := Γ.obj (op X)) S s).map _
|
def
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
toΓSpec
|
The canonical morphism from `X` to the spectrum of its global sections.
|
toΓSpec_preimage_zeroLocus_eq {X : LocallyRingedSpace.{u}}
(s : Set (X.presheaf.obj (op ⊤))) :
X.toΓSpec.base ⁻¹' PrimeSpectrum.zeroLocus s = X.toRingedSpace.zeroLocus s := by
simp only [RingedSpace.zeroLocus]
have (i : LocallyRingedSpace.Γ.obj (op X)) (_ : i ∈ s) :
(SetLike.coe (X.toRingedSpace.basicOpen i))ᶜ =
X.toΓSpec.base ⁻¹' ((PrimeSpectrum.basicOpen i).carrier)ᶜ := by
symm
rw [Set.preimage_compl, Opens.carrier_eq_coe]
erw [X.toΓSpec_preimage_basicOpen_eq i]
erw [Set.iInter₂_congr this]
simp_rw [← Set.preimage_iInter₂, Opens.carrier_eq_coe, PrimeSpectrum.basicOpen_eq_zeroLocus_compl,
compl_compl]
rw [← PrimeSpectrum.zeroLocus_iUnion₂]
simp
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
toΓSpec_preimage_zeroLocus_eq
|
On a locally ringed space `X`, the preimage of the zero locus of the prime spectrum
of `Γ(X, ⊤)` under `toΓSpec` agrees with the associated zero locus on `X`.
|
comp_ring_hom_ext {X : LocallyRingedSpace.{u}} {R : CommRingCat.{u}} {f : R ⟶ Γ.obj (op X)}
{β : X ⟶ Spec.locallyRingedSpaceObj R}
(w : X.toΓSpec.base ≫ (Spec.locallyRingedSpaceMap f).base = β.base)
(h :
∀ r : R,
f ≫ X.presheaf.map (homOfLE le_top : (Opens.map β.base).obj (basicOpen r) ⟶ _).op =
toOpen R (basicOpen r) ≫ β.c.app (op (basicOpen r))) :
X.toΓSpec ≫ Spec.locallyRingedSpaceMap f = β := by
ext1
refine Spec.basicOpen_hom_ext w ?_
intro r U
rw [LocallyRingedSpace.comp_c_app]
erw [toOpen_comp_comap_assoc]
rw [Category.assoc]
erw [toΓSpecSheafedSpace_app_spec, ← X.presheaf.map_comp]
exact h r
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
comp_ring_hom_ext
| null |
Γ_Spec_left_triangle : toSpecΓ (Γ.obj (op X)) ≫ X.toΓSpec.c.app (op ⊤) = 𝟙 _ := by
unfold toSpecΓ
rw [← toOpen_res _ (basicOpen (1 : Γ.obj (op X))) ⊤ (eqToHom basicOpen_one.symm),
Category.assoc, NatTrans.naturality, ← Category.assoc]
erw [X.toΓSpecSheafedSpace_app_spec 1, ← Functor.map_comp]
convert eqToHom_map X.presheaf _; rfl
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
Γ_Spec_left_triangle
|
`toSpecΓ _` is an isomorphism so these are mutually two-sided inverses.
|
identityToΓSpec : 𝟭 LocallyRingedSpace.{u} ⟶ Γ.rightOp ⋙ Spec.toLocallyRingedSpace where
app := LocallyRingedSpace.toΓSpec
naturality X Y f := by
symm
apply LocallyRingedSpace.comp_ring_hom_ext
· ext1 x
dsimp
change PrimeSpectrum.comap (f.c.app (op ⊤)).hom (X.toΓSpecFun x) = Y.toΓSpecFun (f.base x)
dsimp [toΓSpecFun]
rw [← IsLocalRing.comap_closedPoint (f.stalkMap x).hom, ←
PrimeSpectrum.comap_comp_apply, ← PrimeSpectrum.comap_comp_apply,
← CommRingCat.hom_comp, ← CommRingCat.hom_comp]
congr 3
exact (PresheafedSpace.stalkMap_germ f.1 ⊤ x trivial).symm
· intro r
rw [LocallyRingedSpace.comp_c_app, ← Category.assoc]
erw [Y.toΓSpecSheafedSpace_app_spec, f.c.naturality]
rfl
|
def
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
identityToΓSpec
|
The unit as a natural transformation.
|
left_triangle (X : LocallyRingedSpace) :
SpecΓIdentity.inv.app (Γ.obj (op X)) ≫ (identityToΓSpec.app X).c.app (op ⊤) = 𝟙 _ :=
X.Γ_Spec_left_triangle
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
left_triangle
| null |
right_triangle (R : CommRingCat) :
identityToΓSpec.app (Spec.toLocallyRingedSpace.obj <| op R) ≫
Spec.toLocallyRingedSpace.map (SpecΓIdentity.inv.app R).op =
𝟙 _ := by
apply LocallyRingedSpace.comp_ring_hom_ext
· ext (p : PrimeSpectrum R)
dsimp
refine PrimeSpectrum.ext (Ideal.ext fun x => ?_)
rw [← IsLocalization.AtPrime.to_map_mem_maximal_iff ((structureSheaf R).presheaf.stalk p)
p.asIdeal x]
rfl
· intro r; apply toOpen_res
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
right_triangle
|
`SpecΓIdentity` is iso so these are mutually two-sided inverses.
|
@[simps]
locallyRingedSpaceAdjunction : Γ.rightOp ⊣ Spec.toLocallyRingedSpace.{u} where
unit := identityToΓSpec
counit := (NatIso.op SpecΓIdentity).inv
left_triangle_components X := by
simp only [Functor.id_obj, Functor.rightOp_obj, Γ_obj, Functor.comp_obj,
Spec.toLocallyRingedSpace_obj, Spec.locallyRingedSpaceObj_toSheafedSpace,
Spec.sheafedSpaceObj_carrier, Spec.sheafedSpaceObj_presheaf, Functor.rightOp_map, Γ_map,
Quiver.Hom.unop_op, NatIso.op_inv, NatTrans.op_app, SpecΓIdentity_inv_app]
exact congr_arg Quiver.Hom.op (left_triangle X)
right_triangle_components R := by
simp only [Spec.toLocallyRingedSpace_obj, Functor.id_obj, Functor.comp_obj, Functor.rightOp_obj,
Γ_obj, Spec.locallyRingedSpaceObj_toSheafedSpace, Spec.sheafedSpaceObj_carrier,
Spec.sheafedSpaceObj_presheaf, NatIso.op_inv, NatTrans.op_app, op_unop, SpecΓIdentity_inv_app,
Spec.toLocallyRingedSpace_map, Quiver.Hom.unop_op]
exact right_triangle R.unop
|
def
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
locallyRingedSpaceAdjunction
|
The adjunction `Γ ⊣ Spec` from `CommRingᵒᵖ` to `LocallyRingedSpace`.
|
@[simp]
toSpecΓ_unop (R : CommRingCatᵒᵖ) :
AlgebraicGeometry.toSpecΓ (Opposite.unop R) = toOpen R.unop ⊤ := rfl
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
toSpecΓ_unop
|
`@[simp]`-normal form of `locallyRingedSpaceAdjunction_counit_app`.
|
@[simp]
toSpecΓ_of (R : Type u) [CommRing R] :
AlgebraicGeometry.toSpecΓ (CommRingCat.of R) = toOpen R ⊤ := rfl
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
toSpecΓ_of
|
`@[simp]`-normal form of `locallyRingedSpaceAdjunction_counit_app'`.
|
locallyRingedSpaceAdjunction_counit_app (R : CommRingCatᵒᵖ) :
locallyRingedSpaceAdjunction.counit.app R =
(toOpen R.unop ⊤).op := rfl
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
locallyRingedSpaceAdjunction_counit_app
| null |
locallyRingedSpaceAdjunction_counit_app' (R : Type u) [CommRing R] :
locallyRingedSpaceAdjunction.counit.app (op <| CommRingCat.of R) =
(toOpen R ⊤).op := rfl
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
locallyRingedSpaceAdjunction_counit_app'
| null |
locallyRingedSpaceAdjunction_homEquiv_apply
{X : LocallyRingedSpace} {R : CommRingCatᵒᵖ}
(f : Γ.rightOp.obj X ⟶ R) :
locallyRingedSpaceAdjunction.homEquiv X R f =
identityToΓSpec.app X ≫ Spec.locallyRingedSpaceMap f.unop := rfl
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
locallyRingedSpaceAdjunction_homEquiv_apply
| null |
locallyRingedSpaceAdjunction_homEquiv_apply'
{X : LocallyRingedSpace} {R : Type u} [CommRing R]
(f : CommRingCat.of R ⟶ Γ.obj <| op X) :
locallyRingedSpaceAdjunction.homEquiv X (op <| CommRingCat.of R) (op f) =
identityToΓSpec.app X ≫ Spec.locallyRingedSpaceMap f := rfl
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
locallyRingedSpaceAdjunction_homEquiv_apply'
| null |
toOpen_comp_locallyRingedSpaceAdjunction_homEquiv_app
{X : LocallyRingedSpace} {R : Type u} [CommRing R]
(f : Γ.rightOp.obj X ⟶ op (CommRingCat.of R)) (U) :
StructureSheaf.toOpen R U.unop ≫
(locallyRingedSpaceAdjunction.homEquiv X (op <| CommRingCat.of R) f).c.app U =
f.unop ≫ X.presheaf.map (homOfLE le_top).op := by
rw [← StructureSheaf.toOpen_res _ _ _ (homOfLE le_top), Category.assoc,
NatTrans.naturality _ (homOfLE (le_top (a := U.unop))).op,
show (toOpen R ⊤) = (toOpen R ⊤).op.unop from rfl,
← locallyRingedSpaceAdjunction_counit_app']
simp_rw [← Γ_map_op]
rw [← Γ.rightOp_map_unop, ← Category.assoc, ← unop_comp, ← Adjunction.homEquiv_counit,
Equiv.symm_apply_apply]
rfl
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
toOpen_comp_locallyRingedSpaceAdjunction_homEquiv_app
| null |
adjunction : Scheme.Γ.rightOp ⊣ Scheme.Spec.{u} where
unit :=
{ app := fun X ↦ ⟨locallyRingedSpaceAdjunction.{u}.unit.app X.toLocallyRingedSpace⟩
naturality := fun _ _ f ↦
Scheme.Hom.ext' (locallyRingedSpaceAdjunction.{u}.unit.naturality f.toLRSHom) }
counit := (NatIso.op Scheme.SpecΓIdentity.{u}).inv
left_triangle_components Y :=
locallyRingedSpaceAdjunction.left_triangle_components Y.toLocallyRingedSpace
right_triangle_components R :=
Scheme.Hom.ext' <| locallyRingedSpaceAdjunction.right_triangle_components R
|
def
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
adjunction
|
The adjunction `Γ ⊣ Spec` from `CommRingᵒᵖ` to `Scheme`.
|
adjunction_homEquiv_apply {X : Scheme} {R : CommRingCatᵒᵖ}
(f : (op <| Scheme.Γ.obj <| op X) ⟶ R) :
ΓSpec.adjunction.homEquiv X R f = ⟨locallyRingedSpaceAdjunction.homEquiv X.1 R f⟩ := rfl
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
adjunction_homEquiv_apply
| null |
adjunction_homEquiv_symm_apply {X : Scheme} {R : CommRingCatᵒᵖ}
(f : X ⟶ Scheme.Spec.obj R) :
(ΓSpec.adjunction.homEquiv X R).symm f =
(locallyRingedSpaceAdjunction.homEquiv X.1 R).symm f.toLRSHom := rfl
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
adjunction_homEquiv_symm_apply
| null |
adjunction_counit_app' {R : CommRingCatᵒᵖ} :
ΓSpec.adjunction.counit.app R = locallyRingedSpaceAdjunction.counit.app R := rfl
@[simp]
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
adjunction_counit_app'
| null |
adjunction_counit_app {R : CommRingCatᵒᵖ} :
ΓSpec.adjunction.counit.app R = (Scheme.ΓSpecIso (unop R)).inv.op := rfl
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
adjunction_counit_app
| null |
_root_.AlgebraicGeometry.Scheme.toSpecΓ (X : Scheme.{u}) : X ⟶ Spec Γ(X, ⊤) :=
ΓSpec.adjunction.unit.app X
@[simp]
|
def
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
_root_.AlgebraicGeometry.Scheme.toSpecΓ
|
The canonical map `X ⟶ Spec Γ(X, ⊤)`. This is the unit of the `Γ-Spec` adjunction.
|
adjunction_unit_app {X : Scheme} :
ΓSpec.adjunction.unit.app X = X.toSpecΓ := rfl
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
adjunction_unit_app
| null |
isIso_locallyRingedSpaceAdjunction_counit :
IsIso.{u + 1, u + 1} locallyRingedSpaceAdjunction.counit :=
(NatIso.op SpecΓIdentity).isIso_inv
|
instance
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
isIso_locallyRingedSpaceAdjunction_counit
| null |
isIso_adjunction_counit : IsIso ΓSpec.adjunction.counit := by
apply (config := { allowSynthFailures := true }) NatIso.isIso_of_isIso_app
intro R
rw [adjunction_counit_app]
infer_instance
|
instance
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
isIso_adjunction_counit
| null |
Scheme.toSpecΓ_base (X : Scheme.{u}) (x) :
(Scheme.toSpecΓ X).base x =
(Spec.map (X.presheaf.germ ⊤ x trivial)).base (IsLocalRing.closedPoint _) := rfl
@[reassoc]
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
Scheme.toSpecΓ_base
| null |
Scheme.toSpecΓ_naturality {X Y : Scheme.{u}} (f : X ⟶ Y) :
f ≫ Y.toSpecΓ = X.toSpecΓ ≫ Spec.map (f.appTop) :=
ΓSpec.adjunction.unit.naturality f
@[simp]
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
Scheme.toSpecΓ_naturality
| null |
Scheme.toSpecΓ_appTop (X : Scheme.{u}) :
X.toSpecΓ.appTop = (Scheme.ΓSpecIso Γ(X, ⊤)).hom := by
have := ΓSpec.adjunction.left_triangle_components X
dsimp at this
rw [← IsIso.eq_comp_inv] at this
simp only [Category.id_comp] at this
rw [← Quiver.Hom.op_inj.eq_iff, this, ← op_inv, IsIso.Iso.inv_inv]
@[simp]
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
Scheme.toSpecΓ_appTop
| null |
SpecMap_ΓSpecIso_hom (R : CommRingCat.{u}) :
Spec.map ((Scheme.ΓSpecIso R).hom) = (Spec R).toSpecΓ := by
have := ΓSpec.adjunction.right_triangle_components (op R)
dsimp at this
rwa [← IsIso.eq_comp_inv, Category.id_comp, ← Spec.map_inv, IsIso.Iso.inv_inv, eq_comm] at this
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
SpecMap_ΓSpecIso_hom
| null |
Scheme.toSpecΓ_preimage_basicOpen (X : Scheme.{u}) (r : Γ(X, ⊤)) :
X.toSpecΓ ⁻¹ᵁ (PrimeSpectrum.basicOpen r) = X.basicOpen r := by
rw [← basicOpen_eq_of_affine, Scheme.preimage_basicOpen, ← Scheme.Hom.appTop]
congr
rw [Scheme.toSpecΓ_appTop]
exact Iso.inv_hom_id_apply (C := CommRingCat) _ _
@[reassoc (attr := simp)]
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
Scheme.toSpecΓ_preimage_basicOpen
| null |
toOpen_toSpecΓ_app {X : Scheme.{u}} (U) :
StructureSheaf.toOpen _ _ ≫ X.toSpecΓ.app U =
X.presheaf.map (homOfLE (by exact le_top)).op := by
rw [← StructureSheaf.toOpen_res _ _ _ (homOfLE le_top), Category.assoc,
NatTrans.naturality _ (homOfLE (le_top (a := U))).op]
change (ΓSpec.adjunction.counit.app (Scheme.Γ.rightOp.obj X)).unop ≫
(Scheme.Γ.rightOp.map (ΓSpec.adjunction.unit.app X)).unop ≫ _ = _
rw [← Category.assoc, ← unop_comp, ΓSpec.adjunction.left_triangle_components]
dsimp
exact Category.id_comp _
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
toOpen_toSpecΓ_app
| null |
ΓSpecIso_inv_ΓSpec_adjunction_homEquiv {X : Scheme.{u}} {B : CommRingCat} (φ : B ⟶ Γ(X, ⊤)) :
(Scheme.ΓSpecIso B).inv ≫ ((ΓSpec.adjunction.homEquiv X (op B)) φ.op).appTop = φ := by
simp only [Adjunction.homEquiv_apply, Scheme.Spec_map, Opens.map_top, Scheme.comp_app]
simp
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
ΓSpecIso_inv_ΓSpec_adjunction_homEquiv
| null |
ΓSpec_adjunction_homEquiv_eq {X : Scheme.{u}} {B : CommRingCat} (φ : B ⟶ Γ(X, ⊤)) :
((ΓSpec.adjunction.homEquiv X (op B)) φ.op).appTop = (Scheme.ΓSpecIso B).hom ≫ φ := by
rw [← Iso.inv_comp_eq, ΓSpecIso_inv_ΓSpec_adjunction_homEquiv]
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
ΓSpec_adjunction_homEquiv_eq
| null |
ΓSpecIso_obj_hom {X : Scheme.{u}} (U : X.Opens) :
(Scheme.ΓSpecIso Γ(X, U)).hom = (Spec.map U.topIso.inv).appTop ≫
U.toScheme.toSpecΓ.appTop ≫ U.topIso.hom := by simp
/-! Immediate consequences of the adjunction. -/
|
theorem
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
ΓSpecIso_obj_hom
| null |
Spec.fullyFaithfulToLocallyRingedSpace : Spec.toLocallyRingedSpace.FullyFaithful :=
ΓSpec.locallyRingedSpaceAdjunction.fullyFaithfulROfIsIsoCounit
|
def
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
Spec.fullyFaithfulToLocallyRingedSpace
|
The functor `Spec.toLocallyRingedSpace : CommRingCatᵒᵖ ⥤ LocallyRingedSpace`
is fully faithful.
|
Spec.fullyFaithful : Scheme.Spec.FullyFaithful :=
ΓSpec.adjunction.fullyFaithfulROfIsIsoCounit
|
def
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
Spec.fullyFaithful
|
Spec is a full functor. -/
instance : Spec.toLocallyRingedSpace.Full :=
Spec.fullyFaithfulToLocallyRingedSpace.full
/-- Spec is a faithful functor. -/
instance : Spec.toLocallyRingedSpace.Faithful :=
Spec.fullyFaithfulToLocallyRingedSpace.faithful
/-- The functor `Spec : CommRingCatᵒᵖ ⥤ Scheme` is fully faithful.
|
Spec.full : Scheme.Spec.Full :=
Spec.fullyFaithful.full
|
instance
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
Spec.full
|
Spec is a full functor.
|
Spec.faithful : Scheme.Spec.Faithful :=
Spec.fullyFaithful.faithful
|
instance
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
Spec.faithful
|
Spec is a faithful functor.
|
Spec.map_inj : Spec.map φ = Spec.map ψ ↔ φ = ψ := by
rw [iff_comm, ← Quiver.Hom.op_inj.eq_iff, ← Scheme.Spec.map_injective.eq_iff]
rfl
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
Spec.map_inj
| null |
Spec.map_injective {R S : CommRingCat} : Function.Injective (Spec.map : (R ⟶ S) → _) :=
fun _ _ ↦ Spec.map_inj.mp
@[simp]
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
Spec.map_injective
| null |
Spec.map_eq_id {R : CommRingCat} {ϕ : R ⟶ R} : Spec.map ϕ = 𝟙 (Spec R) ↔ ϕ = 𝟙 R := by
simp [← map_inj]
|
lemma
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
Spec.map_eq_id
| null |
Spec.preimage : R ⟶ S := (Scheme.Spec.preimage f).unop
@[simp] lemma Spec.map_preimage : Spec.map (Spec.preimage f) = f := Scheme.Spec.map_preimage f
@[simp] lemma Spec.map_preimage_unop (f : Spec R ⟶ Spec S) :
Spec.map (Spec.fullyFaithful.preimage f).unop = f := Spec.fullyFaithful.map_preimage _
variable (φ) in
@[simp] lemma Spec.preimage_map : Spec.preimage (Spec.map φ) = φ :=
Spec.map_injective (Spec.map_preimage (Spec.map φ))
|
def
|
AlgebraicGeometry
|
[
"Mathlib.AlgebraicGeometry.Restrict",
"Mathlib.CategoryTheory.Adjunction.Limits",
"Mathlib.CategoryTheory.Adjunction.Opposites",
"Mathlib.CategoryTheory.Adjunction.Reflective"
] |
Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean
|
Spec.preimage
|
The preimage under Spec.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.