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 ⌀ |
|---|---|---|---|---|---|---|
toStalk_comp_stalkToFiberRingHom (x : PrimeSpectrum.Top R) :
toStalk R x ≫ stalkToFiberRingHom R x = CommRingCat.ofHom (algebraMap _ _) := by
rw [toStalk, Category.assoc, germ_comp_stalkToFiberRingHom]; rfl
@[simp] | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | toStalk_comp_stalkToFiberRingHom | null |
stalkToFiberRingHom_toStalk (x : PrimeSpectrum.Top R) (f : R) :
stalkToFiberRingHom R x (toStalk R x f) = algebraMap _ _ f :=
RingHom.ext_iff.1 (CommRingCat.hom_ext_iff.mp (toStalk_comp_stalkToFiberRingHom R x)) _ | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | stalkToFiberRingHom_toStalk | null |
@[simps]
stalkIso (x : PrimeSpectrum.Top R) :
(structureSheaf R).presheaf.stalk x ≅ CommRingCat.of (Localization.AtPrime x.asIdeal) where
hom := stalkToFiberRingHom R x
inv := localizationToStalk R x
hom_inv_id := by
apply stalk_hom_ext
intro U hxU
ext s
dsimp only [CommRingCat.hom_comp, RingHom.coe_comp, Function.comp_apply, CommRingCat.hom_id,
RingHom.coe_id, id_eq]
rw [stalkToFiberRingHom_germ]
obtain ⟨V, hxV, iVU, f, g, (hg : V ≤ PrimeSpectrum.basicOpen _), hs⟩ :=
exists_const _ _ s x hxU
have := res_apply R U V iVU s ⟨x, hxV⟩
dsimp only [isLocallyFraction_pred, Opens.apply_mk] at this
rw [← this, ← hs, const_apply, localizationToStalk_mk']
refine (structureSheaf R).presheaf.germ_ext V hxV (homOfLE hg) iVU ?_
rw [← hs, res_const']
inv_hom_id := CommRingCat.hom_ext <|
@IsLocalization.ringHom_ext R _ x.asIdeal.primeCompl (Localization.AtPrime x.asIdeal) _ _
(Localization.AtPrime x.asIdeal) _ _
(RingHom.comp (stalkToFiberRingHom R x).hom (localizationToStalk R x).hom)
(RingHom.id (Localization.AtPrime _)) <| by
ext f
rw [RingHom.comp_apply, RingHom.comp_apply, localizationToStalk_of,
stalkToFiberRingHom_toStalk, RingHom.comp_apply, RingHom.id_apply] | def | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | stalkIso | The ring isomorphism between the stalk of the structure sheaf of `R` at a point `p`
corresponding to a prime ideal in `R` and the localization of `R` at `p`. |
@[simp, reassoc]
stalkToFiberRingHom_localizationToStalk (x : PrimeSpectrum.Top R) :
stalkToFiberRingHom R x ≫ localizationToStalk R x = 𝟙 _ :=
(stalkIso R x).hom_inv_id
@[simp, reassoc] | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | stalkToFiberRingHom_localizationToStalk | null |
localizationToStalk_stalkToFiberRingHom (x : PrimeSpectrum.Top R) :
localizationToStalk R x ≫ stalkToFiberRingHom R x = 𝟙 _ :=
(stalkIso R x).inv_hom_id | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | localizationToStalk_stalkToFiberRingHom | null |
toBasicOpen (f : R) :
Localization.Away f →+* (structureSheaf R).1.obj (op <| PrimeSpectrum.basicOpen f) :=
IsLocalization.Away.lift f (isUnit_to_basicOpen_self R f)
@[simp] | def | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | toBasicOpen | The canonical ring homomorphism interpreting `s ∈ R_f` as a section of the structure sheaf
on the basic open defined by `f ∈ R`. |
toBasicOpen_mk' (s f : R) (g : Submonoid.powers s) :
toBasicOpen R s (IsLocalization.mk' (Localization.Away s) f g) =
const R f g (PrimeSpectrum.basicOpen s) fun _ hx => Submonoid.powers_le.2 hx g.2 :=
(IsLocalization.lift_mk'_spec _ _ _ _).2 <| by
rw [toOpen_eq_const, toOpen_eq_const, const_mul_cancel']
@[simp] | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | toBasicOpen_mk' | null |
localization_toBasicOpen (f : R) :
RingHom.comp (toBasicOpen R f) (algebraMap R (Localization.Away f)) =
(toOpen R (PrimeSpectrum.basicOpen f)).hom :=
RingHom.ext fun g => by
rw [toBasicOpen, IsLocalization.Away.lift, RingHom.comp_apply, IsLocalization.lift_eq]
@[simp] | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | localization_toBasicOpen | null |
toBasicOpen_to_map (s f : R) :
toBasicOpen R s (algebraMap R (Localization.Away s) f) =
const R f 1 (PrimeSpectrum.basicOpen s) fun _ _ => Submonoid.one_mem _ :=
(IsLocalization.lift_eq _ _).trans <| toOpen_eq_const _ _ _ | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | toBasicOpen_to_map | null |
toBasicOpen_injective (f : R) : Function.Injective (toBasicOpen R f) := by
intro s t h_eq
obtain ⟨a, ⟨b, hb⟩, rfl⟩ := IsLocalization.mk'_surjective (Submonoid.powers f) s
obtain ⟨c, ⟨d, hd⟩, rfl⟩ := IsLocalization.mk'_surjective (Submonoid.powers f) t
simp only [toBasicOpen_mk'] at h_eq
rw [IsLocalization.eq]
let I : Ideal R :=
{ carrier := { r : R | r * (d * a) = r * (b * c) }
zero_mem' := by simp only [Set.mem_setOf_eq, zero_mul]
add_mem' := fun {r₁ r₂} hr₁ hr₂ => by dsimp at hr₁ hr₂ ⊢; simp only [add_mul, hr₁, hr₂]
smul_mem' := fun {r₁ r₂} hr₂ => by dsimp at hr₂ ⊢; simp only [mul_assoc, hr₂] }
suffices f ∈ I.radical by
obtain ⟨n, hn⟩ := this
exact ⟨⟨f ^ n, n, rfl⟩, hn⟩
rw [← PrimeSpectrum.vanishingIdeal_zeroLocus_eq_radical, PrimeSpectrum.mem_vanishingIdeal]
intro p hfp
contrapose hfp
rw [PrimeSpectrum.mem_zeroLocus, Set.not_subset]
have := congr_fun (congr_arg Subtype.val h_eq) ⟨p, hfp⟩
dsimp at this
rw [IsLocalization.eq (S := Localization.AtPrime p.asIdeal)] at this
obtain ⟨r, hr⟩ := this
exact ⟨r.1, hr, r.2⟩
/-
Auxiliary lemma for surjectivity of `toBasicOpen`.
Every section can locally be represented on basic opens `basicOpen g` as a fraction `f/g`
-/ | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | toBasicOpen_injective | null |
locally_const_basicOpen (U : Opens (PrimeSpectrum.Top R))
(s : (structureSheaf R).1.obj (op U)) (x : U) :
∃ (f g : R) (i : PrimeSpectrum.basicOpen g ⟶ U), x.1 ∈ PrimeSpectrum.basicOpen g ∧
(const R f g (PrimeSpectrum.basicOpen g) fun _ hy => hy) =
(structureSheaf R).1.map i.op s := by
obtain ⟨V, hxV : x.1 ∈ V.1, iVU, f, g, hVDg : V ≤ PrimeSpectrum.basicOpen g, s_eq⟩ :=
exists_const R U s x.1 x.2
obtain ⟨_, ⟨h, rfl⟩, hxDh, hDhV : PrimeSpectrum.basicOpen h ≤ V⟩ :=
PrimeSpectrum.isTopologicalBasis_basic_opens.exists_subset_of_mem_open hxV V.2
obtain ⟨n, hn⟩ := (PrimeSpectrum.basicOpen_le_basicOpen_iff h g).mp (Set.Subset.trans hDhV hVDg)
replace hn := Ideal.mul_mem_right h (Ideal.span {g}) hn
rw [← pow_succ, Ideal.mem_span_singleton'] at hn
obtain ⟨c, hc⟩ := hn
have basic_opens_eq := PrimeSpectrum.basicOpen_pow h (n + 1) (by cutsat)
have i_basic_open := eqToHom basic_opens_eq ≫ homOfLE hDhV
use f * c, h ^ (n + 1), i_basic_open ≫ iVU, (basic_opens_eq.symm.le :) hxDh
rw [op_comp, Functor.map_comp, ConcreteCategory.comp_apply, ← s_eq, res_const]
swap
· intro y hy
rw [basic_opens_eq] at hy
exact (Set.Subset.trans hDhV hVDg :) hy
apply const_ext
rw [mul_assoc f c g, hc]
/-
Auxiliary lemma for surjectivity of `toBasicOpen`.
A local representation of a section `s` as fractions `a i / h i` on finitely many basic opens
`basicOpen (h i)` can be "normalized" in such a way that `a i * h j = h i * a j` for all `i, j`
-/ | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | locally_const_basicOpen | null |
normalize_finite_fraction_representation (U : Opens (PrimeSpectrum.Top R))
(s : (structureSheaf R).1.obj (op U)) {ι : Type*} (t : Finset ι) (a h : ι → R)
(iDh : ∀ i : ι, PrimeSpectrum.basicOpen (h i) ⟶ U)
(h_cover : U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h i))
(hs :
∀ i : ι,
(const R (a i) (h i) (PrimeSpectrum.basicOpen (h i)) fun _ hy => hy) =
(structureSheaf R).1.map (iDh i).op s) :
∃ (a' h' : ι → R) (iDh' : ∀ i : ι, PrimeSpectrum.basicOpen (h' i) ⟶ U),
(U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h' i)) ∧
(∀ (i) (_ : i ∈ t) (j) (_ : j ∈ t), a' i * h' j = h' i * a' j) ∧
∀ i ∈ t,
(structureSheaf R).1.map (iDh' i).op s =
const R (a' i) (h' i) (PrimeSpectrum.basicOpen (h' i)) fun _ hy => hy := by
have fractions_eq :
∀ i j : ι,
IsLocalization.mk' (Localization.Away (h i * h j))
(a i * h j) ⟨h i * h j, Submonoid.mem_powers _⟩ =
IsLocalization.mk' _ (h i * a j) ⟨h i * h j, Submonoid.mem_powers _⟩ := by
intro i j
let D := PrimeSpectrum.basicOpen (h i * h j)
let iDi : D ⟶ PrimeSpectrum.basicOpen (h i) := homOfLE (PrimeSpectrum.basicOpen_mul_le_left _ _)
let iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
homOfLE (PrimeSpectrum.basicOpen_mul_le_right _ _)
apply toBasicOpen_injective R (h i * h j)
rw [toBasicOpen_mk', toBasicOpen_mk']
simp only []
trans
on_goal 1 =>
convert congr_arg ((structureSheaf R).1.map iDj.op) (hs j).symm using 1
convert congr_arg ((structureSheaf R).1.map iDi.op) (hs i) using 1
all_goals rw [res_const]; apply const_ext; ring
exacts [PrimeSpectrum.basicOpen_mul_le_left _ _, PrimeSpectrum.basicOpen_mul_le_right _ _]
have exists_power :
∀ i j : ι, ∃ n : ℕ, a i * h j * (h i * h j) ^ n = h i * a j * (h i * h j) ^ n := by
intro i j
obtain ⟨⟨c, n, rfl⟩, hc⟩ := IsLocalization.eq.mp (fractions_eq i j)
use n + 1
rw [pow_succ]
dsimp at hc
convert hc using 1 <;> ring
let n := fun p : ι × ι => (exists_power p.1 p.2).choose
have n_spec := fun p : ι × ι => (exists_power p.fst p.snd).choose_spec
let N := (t ×ˢ t).sup n
have basic_opens_eq : ∀ i : ι, PrimeSpectrum.basicOpen (h i ^ (N + 1)) =
PrimeSpectrum.basicOpen (h i) := fun i => PrimeSpectrum.basicOpen_pow _ _ (by cutsat)
refine
⟨fun i => a i * h i ^ N, fun i => h i ^ (N + 1), fun i => eqToHom (basic_opens_eq i) ≫ iDh i,
?_, ?_, ?_⟩
· simpa only [basic_opens_eq] using h_cover
· intro i hi j hj
... | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | normalize_finite_fraction_representation | null |
toBasicOpen_surjective (f : R) : Function.Surjective (toBasicOpen R f) := by
intro s
let ι : Type u := PrimeSpectrum.basicOpen f
choose a' h' iDh' hxDh' s_eq' using locally_const_basicOpen R (PrimeSpectrum.basicOpen f) s
obtain ⟨t, ht_cover'⟩ :=
(PrimeSpectrum.isCompact_basicOpen f).elim_finite_subcover
(fun i : ι => PrimeSpectrum.basicOpen (h' i)) (fun i => PrimeSpectrum.isOpen_basicOpen)
fun x hx => by rw [Set.mem_iUnion]; exact ⟨⟨x, hx⟩, hxDh' ⟨x, hx⟩⟩
simp only [← Opens.coe_iSup, SetLike.coe_subset_coe] at ht_cover'
obtain ⟨a, h, iDh, ht_cover, ah_ha, s_eq⟩ :=
normalize_finite_fraction_representation R (PrimeSpectrum.basicOpen f)
s t a' h' iDh' ht_cover' s_eq'
clear s_eq' iDh' hxDh' ht_cover' a' h'
simp only [← SetLike.coe_subset_coe, Opens.coe_iSup] at ht_cover
replace ht_cover : (PrimeSpectrum.basicOpen f : Set <| PrimeSpectrum R) ⊆
⋃ (i : ι) (x : i ∈ t), (PrimeSpectrum.basicOpen (h i) : Set _) := ht_cover
obtain ⟨n, hn⟩ : f ∈ (Ideal.span (h '' ↑t)).radical := by
rw [← PrimeSpectrum.vanishingIdeal_zeroLocus_eq_radical, PrimeSpectrum.zeroLocus_span]
simp only [PrimeSpectrum.basicOpen_eq_zeroLocus_compl] at ht_cover
replace ht_cover : (PrimeSpectrum.zeroLocus {f})ᶜ ⊆
⋃ (i : ι) (x : i ∈ t), (PrimeSpectrum.zeroLocus {h i})ᶜ := ht_cover
rw [Set.compl_subset_comm] at ht_cover
simp_rw [Set.compl_iUnion, compl_compl, ← PrimeSpectrum.zeroLocus_iUnion,
← Finset.set_biUnion_coe, ← Set.image_eq_iUnion] at ht_cover
apply PrimeSpectrum.vanishingIdeal_anti_mono ht_cover
exact PrimeSpectrum.subset_vanishingIdeal_zeroLocus {f} (Set.mem_singleton f)
replace hn := Ideal.mul_mem_right f _ hn
rw [← pow_succ, Ideal.span, Finsupp.mem_span_image_iff_linearCombination] at hn
rcases hn with ⟨b, b_supp, hb⟩
rw [Finsupp.linearCombination_apply_of_mem_supported R b_supp] at hb
dsimp at hb
use
IsLocalization.mk' (Localization.Away f) (∑ i ∈ t, b i * a i)
(⟨f ^ (n + 1), n + 1, rfl⟩ : Submonoid.powers _)
rw [toBasicOpen_mk']
let tt := ((t : Set (PrimeSpectrum.basicOpen f)) : Type u)
apply
(structureSheaf R).eq_of_locally_eq' (fun i : tt => PrimeSpectrum.basicOpen (h i))
(PrimeSpectrum.basicOpen f) fun i : tt => iDh i
· -- This feels a little redundant, since already have `ht_cover` as a hypothesis
intro x hx
rw [SetLike.mem_coe, TopologicalSpace.Opens.mem_iSup]
have := ht_cover hx
rw [← Finset.set_biUnion_coe, Set.mem_iUnion₂] at this
rcases this with ⟨i, i_mem, x_mem⟩
exact ⟨⟨i, i_mem⟩, x_mem⟩
rintro ⟨i, hi⟩
dsimp
change (structureSheaf R).1.map (iDh i).op _ = (structureSheaf R).1.map (iDh i).op _
rw [s_eq i hi, res_const]
swap
... | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | toBasicOpen_surjective | null |
isIso_toBasicOpen (f : R) :
IsIso (CommRingCat.ofHom (toBasicOpen R f)) :=
haveI : IsIso ((forget CommRingCat).map (CommRingCat.ofHom (toBasicOpen R f))) :=
(isIso_iff_bijective _).mpr ⟨toBasicOpen_injective R f, toBasicOpen_surjective R f⟩
isIso_of_reflects_iso _ (forget CommRingCat) | instance | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | isIso_toBasicOpen | null |
basicOpenIso (f : R) :
(structureSheaf R).1.obj (op (PrimeSpectrum.basicOpen f)) ≅
CommRingCat.of (Localization.Away f) :=
(asIso (CommRingCat.ofHom (toBasicOpen R f))).symm | def | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | basicOpenIso | The ring isomorphism between the structure sheaf on `basicOpen f` and the localization of `R`
at the submonoid of powers of `f`. |
stalkAlgebra (p : PrimeSpectrum R) : Algebra R ((structureSheaf R).presheaf.stalk p) :=
(toStalk R p).hom.toAlgebra
@[simp] | instance | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | stalkAlgebra | null |
stalkAlgebra_map (p : PrimeSpectrum R) (r : R) :
algebraMap R ((structureSheaf R).presheaf.stalk p) r = toStalk R p r :=
rfl | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | stalkAlgebra_map | null |
IsLocalization.to_stalk (p : PrimeSpectrum R) :
IsLocalization.AtPrime ((structureSheaf R).presheaf.stalk p) p.asIdeal := by
convert (IsLocalization.isLocalization_iff_of_ringEquiv (S := Localization.AtPrime p.asIdeal) _
(stalkIso R p).symm.commRingCatIsoToRingEquiv).mp
Localization.isLocalization
apply Algebra.algebra_ext
intro
rw [stalkAlgebra_map]
congr 2
change toStalk R p = _ ≫ (stalkIso R p).inv
rw [Iso.eq_comp_inv]
exact toStalk_comp_stalkToFiberRingHom R p | instance | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | IsLocalization.to_stalk | Stalk of the structure sheaf at a prime p as localization of R |
openAlgebra (U : (Opens (PrimeSpectrum R))ᵒᵖ) : Algebra R ((structureSheaf R).val.obj U) :=
(toOpen R (unop U)).hom.toAlgebra
@[simp] | instance | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | openAlgebra | null |
openAlgebra_map (U : (Opens (PrimeSpectrum R))ᵒᵖ) (r : R) :
algebraMap R ((structureSheaf R).val.obj U) r = toOpen R (unop U) r :=
rfl | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | openAlgebra_map | null |
IsLocalization.to_basicOpen (r : R) :
IsLocalization.Away r ((structureSheaf R).val.obj (op <| PrimeSpectrum.basicOpen r)) := by
convert (IsLocalization.isLocalization_iff_of_ringEquiv (S := Localization.Away r) _
(basicOpenIso R r).symm.commRingCatIsoToRingEquiv).mp
Localization.isLocalization
apply Algebra.algebra_ext
intro x
congr 1
exact (localization_toBasicOpen R r).symm | instance | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | IsLocalization.to_basicOpen | Sections of the structure sheaf of Spec R on a basic open as localization of R |
to_basicOpen_epi (r : R) : Epi (toOpen R (PrimeSpectrum.basicOpen r)) :=
⟨fun _ _ h => CommRingCat.hom_ext (IsLocalization.ringHom_ext (Submonoid.powers r)
(CommRingCat.hom_ext_iff.mp h))⟩
@[elementwise] | instance | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | to_basicOpen_epi | null |
to_global_factors :
toOpen R ⊤ =
CommRingCat.ofHom (algebraMap R (Localization.Away (1 : R))) ≫
CommRingCat.ofHom (toBasicOpen R (1 : R)) ≫
(structureSheaf R).1.map (eqToHom PrimeSpectrum.basicOpen_one.symm).op := by
rw [← Category.assoc]
change toOpen R ⊤ =
(CommRingCat.ofHom <| (toBasicOpen R 1).comp (algebraMap R (Localization.Away 1))) ≫
(structureSheaf R).1.map (eqToHom _).op
rw [localization_toBasicOpen R, CommRingCat.ofHom_hom, toOpen_res] | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | to_global_factors | null |
isIso_to_global : IsIso (toOpen R ⊤) := by
let hom := CommRingCat.ofHom (algebraMap R (Localization.Away (1 : R)))
haveI : IsIso hom :=
(IsLocalization.atOne R (Localization.Away (1 : R))).toRingEquiv.toCommRingCatIso.isIso_hom
rw [to_global_factors R]
infer_instance | instance | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | isIso_to_global | null |
@[simps! inv]
globalSectionsIso : CommRingCat.of R ≅ (structureSheaf R).1.obj (op ⊤) :=
asIso (toOpen R ⊤)
@[simp] | def | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | globalSectionsIso | The ring isomorphism between the ring `R` and the global sections `Γ(X, 𝒪ₓ)`. |
globalSectionsIso_hom (R : CommRingCat) : (globalSectionsIso R).hom = toOpen R ⊤ :=
rfl
@[simp, reassoc, elementwise nosimp] | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | globalSectionsIso_hom | null |
toStalk_stalkSpecializes {R : Type*} [CommRing R] {x y : PrimeSpectrum R} (h : x ⤳ y) :
toStalk R y ≫ (structureSheaf R).presheaf.stalkSpecializes h = toStalk R x := by
dsimp [toStalk]; simp [-toOpen_germ]
@[simp, reassoc, elementwise nosimp] | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | toStalk_stalkSpecializes | null |
localizationToStalk_stalkSpecializes {R : Type*} [CommRing R] {x y : PrimeSpectrum R}
(h : x ⤳ y) :
StructureSheaf.localizationToStalk R y ≫ (structureSheaf R).presheaf.stalkSpecializes h =
CommRingCat.ofHom (PrimeSpectrum.localizationMapOfSpecializes h) ≫
StructureSheaf.localizationToStalk R x := by
ext : 1
apply IsLocalization.ringHom_ext (S := Localization.AtPrime y.asIdeal) y.asIdeal.primeCompl
rw [CommRingCat.hom_comp, RingHom.comp_assoc, CommRingCat.hom_comp, RingHom.comp_assoc]
dsimp [localizationToStalk, PrimeSpectrum.localizationMapOfSpecializes]
rw [IsLocalization.lift_comp, IsLocalization.lift_comp, IsLocalization.lift_comp]
exact CommRingCat.hom_ext_iff.mp (toStalk_stalkSpecializes h)
@[simp, reassoc, elementwise nosimp] | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | localizationToStalk_stalkSpecializes | null |
stalkSpecializes_stalk_to_fiber {R : Type*} [CommRing R] {x y : PrimeSpectrum R}
(h : x ⤳ y) :
(structureSheaf R).presheaf.stalkSpecializes h ≫ StructureSheaf.stalkToFiberRingHom R x =
StructureSheaf.stalkToFiberRingHom R y ≫
(CommRingCat.ofHom (PrimeSpectrum.localizationMapOfSpecializes h)) := by
change _ ≫ (StructureSheaf.stalkIso R x).hom = (StructureSheaf.stalkIso R y).hom ≫ _
rw [← Iso.eq_comp_inv, Category.assoc, ← Iso.inv_comp_eq]
exact localizationToStalk_stalkSpecializes h | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | stalkSpecializes_stalk_to_fiber | null |
comapFun (f : R →+* S) (U : Opens (PrimeSpectrum.Top R)) (V : Opens (PrimeSpectrum.Top S))
(hUV : V.1 ⊆ PrimeSpectrum.comap f ⁻¹' U.1) (s : ∀ x : U, Localizations R x) (y : V) :
Localizations S y :=
Localization.localRingHom (PrimeSpectrum.comap f y.1).asIdeal _ f rfl
(s ⟨PrimeSpectrum.comap f y.1, hUV y.2⟩ :) | def | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | comapFun | Given a ring homomorphism `f : R →+* S`, an open set `U` of the prime spectrum of `R` and an open
set `V` of the prime spectrum of `S`, such that `V ⊆ (comap f) ⁻¹' U`, we can push a section `s`
on `U` to a section on `V`, by composing with `Localization.localRingHom _ _ f` from the left and
`comap f` from the right. Explicitly, if `s` evaluates on `comap f p` to `a / b`, its image on `V`
evaluates on `p` to `f(a) / f(b)`.
At the moment, we work with arbitrary dependent functions `s : Π x : U, Localizations R x`. Below,
we prove the predicate `isLocallyFraction` is preserved by this map, hence it can be extended to
a morphism between the structure sheaves of `R` and `S`. |
comapFunIsLocallyFraction (f : R →+* S) (U : Opens (PrimeSpectrum.Top R))
(V : Opens (PrimeSpectrum.Top S)) (hUV : V.1 ⊆ PrimeSpectrum.comap f ⁻¹' U.1)
(s : ∀ x : U, Localizations R x) (hs : (isLocallyFraction R).toPrelocalPredicate.pred s) :
(isLocallyFraction S).toPrelocalPredicate.pred (comapFun f U V hUV s) := by
rintro ⟨p, hpV⟩
rcases hs ⟨PrimeSpectrum.comap f p, hUV hpV⟩ with ⟨W, m, iWU, a, b, h_frac⟩
refine ⟨Opens.comap (PrimeSpectrum.comap f) W ⊓ V, ⟨m, hpV⟩, Opens.infLERight _ _, f a, f b, ?_⟩
rintro ⟨q, ⟨hqW, hqV⟩⟩
specialize h_frac ⟨PrimeSpectrum.comap f q, hqW⟩
refine ⟨h_frac.1, ?_⟩
dsimp only [comapFun]
erw [← Localization.localRingHom_to_map (PrimeSpectrum.comap f q).asIdeal _ _ rfl,
← RingHom.map_mul, h_frac.2, Localization.localRingHom_to_map]
rfl | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | comapFunIsLocallyFraction | null |
comap (f : R →+* S) (U : Opens (PrimeSpectrum.Top R)) (V : Opens (PrimeSpectrum.Top S))
(hUV : V.1 ⊆ PrimeSpectrum.comap f ⁻¹' U.1) :
(structureSheaf R).1.obj (op U) →+* (structureSheaf S).1.obj (op V) where
toFun s := ⟨comapFun f U V hUV s.1, comapFunIsLocallyFraction f U V hUV s.1 s.2⟩
map_one' :=
Subtype.ext <|
funext fun p => by
dsimp
rw [comapFun, (sectionsSubring R (op U)).coe_one, Pi.one_apply, RingHom.map_one]
rfl
map_zero' :=
Subtype.ext <|
funext fun p => by
dsimp
rw [comapFun, (sectionsSubring R (op U)).coe_zero, Pi.zero_apply, RingHom.map_zero]
rfl
map_add' s t :=
Subtype.ext <|
funext fun p => by
dsimp
rw [comapFun, (sectionsSubring R (op U)).coe_add, Pi.add_apply, RingHom.map_add]
rfl
map_mul' s t :=
Subtype.ext <|
funext fun p => by
dsimp
rw [comapFun, (sectionsSubring R (op U)).coe_mul, Pi.mul_apply, RingHom.map_mul]
rfl
@[simp] | def | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | comap | For a ring homomorphism `f : R →+* S` and open sets `U` and `V` of the prime spectra of `R` and
`S` such that `V ⊆ (comap f) ⁻¹ U`, the induced ring homomorphism from the structure sheaf of `R`
at `U` to the structure sheaf of `S` at `V`.
Explicitly, this map is given as follows: For a point `p : V`, if the section `s` evaluates on `p`
to the fraction `a / b`, its image on `V` evaluates on `p` to the fraction `f(a) / f(b)`. |
comap_apply (f : R →+* S) (U : Opens (PrimeSpectrum.Top R))
(V : Opens (PrimeSpectrum.Top S)) (hUV : V.1 ⊆ PrimeSpectrum.comap f ⁻¹' U.1)
(s : (structureSheaf R).1.obj (op U)) (p : V) :
(comap f U V hUV s).1 p =
Localization.localRingHom (PrimeSpectrum.comap f p.1).asIdeal _ f rfl
(s.1 ⟨PrimeSpectrum.comap f p.1, hUV p.2⟩ :) :=
rfl | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | comap_apply | null |
comap_const (f : R →+* S) (U : Opens (PrimeSpectrum.Top R))
(V : Opens (PrimeSpectrum.Top S)) (hUV : V.1 ⊆ PrimeSpectrum.comap f ⁻¹' U.1) (a b : R)
(hb : ∀ x : PrimeSpectrum R, x ∈ U → b ∈ x.asIdeal.primeCompl) :
comap f U V hUV (const R a b U hb) =
const S (f a) (f b) V fun p hpV => hb (PrimeSpectrum.comap f p) (hUV hpV) :=
Subtype.eq <|
funext fun p => by
rw [comap_apply, const_apply, const_apply, Localization.localRingHom_mk'] | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | comap_const | null |
comap_id_eq_map (U V : Opens (PrimeSpectrum.Top R)) (iVU : V ⟶ U) :
(comap (RingHom.id R) U V fun _ hpV => leOfHom iVU <| hpV) =
((structureSheaf R).1.map iVU.op).hom :=
RingHom.ext fun s => Subtype.eq <| funext fun p => by
rw [comap_apply]
obtain ⟨W, hpW, iWU, h⟩ := s.2 (iVU p)
obtain ⟨a, b, h'⟩ := h.eq_mk'
obtain ⟨hb₁, s_eq₁⟩ := h' ⟨p, hpW⟩
obtain ⟨hb₂, s_eq₂⟩ :=
h' ⟨PrimeSpectrum.comap (RingHom.id _) p.1, hpW⟩
dsimp only at s_eq₁ s_eq₂
erw [s_eq₂, Localization.localRingHom_mk', ← s_eq₁, ← res_apply _ _ _ iVU] | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | comap_id_eq_map | For an inclusion `i : V ⟶ U` between open sets of the prime spectrum of `R`, the comap of the
identity from OO_X(U) to OO_X(V) equals as the restriction map of the structure sheaf.
This is a generalization of the fact that, for fixed `U`, the comap of the identity from OO_X(U)
to OO_X(U) is the identity. |
comap_id {U V : Opens (PrimeSpectrum.Top R)} (hUV : U = V) :
(comap (RingHom.id R) U V fun p hpV => by rwa [hUV, PrimeSpectrum.comap_id]) =
(eqToHom (show (structureSheaf R).1.obj (op U) = _ by rw [hUV])).hom := by
rw [comap_id_eq_map U V (eqToHom hUV.symm), eqToHom_op, eqToHom_map]
@[simp] | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | comap_id | The comap of the identity is the identity. In this variant of the lemma, two open subsets `U` and
`V` are given as arguments, together with a proof that `U = V`. This is useful when `U` and `V`
are not definitionally equal. |
comap_id' (U : Opens (PrimeSpectrum.Top R)) :
(comap (RingHom.id R) U U fun p hpU => by rwa [PrimeSpectrum.comap_id]) = RingHom.id _ := by
rw [comap_id rfl]; rfl | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | comap_id' | null |
comap_comp (f : R →+* S) (g : S →+* P) (U : Opens (PrimeSpectrum.Top R))
(V : Opens (PrimeSpectrum.Top S)) (W : Opens (PrimeSpectrum.Top P))
(hUV : ∀ p ∈ V, PrimeSpectrum.comap f p ∈ U) (hVW : ∀ p ∈ W, PrimeSpectrum.comap g p ∈ V) :
(comap (g.comp f) U W fun p hpW => hUV (PrimeSpectrum.comap g p) (hVW p hpW)) =
(comap g V W hVW).comp (comap f U V hUV) :=
RingHom.ext fun s =>
Subtype.eq <|
funext fun p => by
rw [comap_apply, Localization.localRingHom_comp _ (PrimeSpectrum.comap g p.1).asIdeal] <;>
simp
@[elementwise, reassoc] | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | comap_comp | null |
toOpen_comp_comap (f : R →+* S) (U : Opens (PrimeSpectrum.Top R)) :
(toOpen R U ≫ CommRingCat.ofHom (comap f U (Opens.comap (PrimeSpectrum.comap f) U)
fun _ => id)) =
CommRingCat.ofHom f ≫ toOpen S _ :=
CommRingCat.hom_ext <| RingHom.ext fun _ => Subtype.eq <| funext fun _ =>
Localization.localRingHom_to_map _ _ _ _ _ | theorem | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | toOpen_comp_comap | null |
comap_basicOpen (f : R →+* S) (x : R) :
comap f (PrimeSpectrum.basicOpen x) (PrimeSpectrum.basicOpen (f x))
(PrimeSpectrum.comap_basicOpen f x).le =
IsLocalization.map (M := .powers x) (T := .powers (f x)) _ f
(Submonoid.powers_le.mpr (Submonoid.mem_powers _)) :=
IsLocalization.ringHom_ext (.powers x) <| by
simpa [CommRingCat.hom_ext_iff] using toOpen_comp_comap f _ | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.Colimits",
"Mathlib.Algebra.Category.Ring.Instances",
"Mathlib.Algebra.Category.Ring.Limits",
"Mathlib.Algebra.Ring.Subring.Basic",
"Mathlib.RingTheory.Localization.AtPrime.Basic",
"Mathlib.RingTheory.Spectrum.Prime.Topology",
"Mathlib.Topology.Sheaves.LocalPredicate"
] | Mathlib/AlgebraicGeometry/StructureSheaf.lean | comap_basicOpen | null |
ValuativeCommSq {X Y : Scheme.{u}} (f : X ⟶ Y) where
/-- The valuation ring of a valuative commutative square. -/
R : Type u
[commRing : CommRing R]
[domain : IsDomain R]
[valuationRing : ValuationRing R]
/-- The field of fractions of a valuative commutative square. -/
K : Type u
[field : Field K]
[algebra : Algebra R K]
[isFractionRing : IsFractionRing R K]
/-- The top map in a valuative commutative map. -/
(i₁ : Spec(K) ⟶ X)
/-- The bottom map in a valuative commutative map. -/
(i₂ : Spec(R) ⟶ Y)
(commSq : CommSq i₁ (Spec.map (CommRingCat.ofHom (algebraMap R K))) f i₂) | structure | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion",
"Mathlib.AlgebraicGeometry.Morphisms.Proper",
"Mathlib.RingTheory.RingHom.Injective",
"Mathlib.RingTheory.Valuation.LocalSubring"
] | Mathlib/AlgebraicGeometry/ValuativeCriterion.lean | ValuativeCommSq | A valuative commutative square over a morphism `f : X ⟶ Y` is a square
```
Spec K ⟶ Y
| |
↓ ↓
Spec R ⟶ X
```
where `R` is a valuation ring, and `K` is its ring of fractions.
We are interested in finding lifts `Spec R ⟶ Y` of this diagram. |
ValuativeCriterion.Existence : MorphismProperty Scheme :=
fun _ _ f ↦ ∀ S : ValuativeCommSq f, S.commSq.HasLift | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion",
"Mathlib.AlgebraicGeometry.Morphisms.Proper",
"Mathlib.RingTheory.RingHom.Injective",
"Mathlib.RingTheory.Valuation.LocalSubring"
] | Mathlib/AlgebraicGeometry/ValuativeCriterion.lean | ValuativeCriterion.Existence | A morphism `f : X ⟶ Y` satisfies the existence part of the valuative criterion if
every valuative commutative square over `f` has (at least) a lift. |
ValuativeCriterion.Uniqueness : MorphismProperty Scheme :=
fun _ _ f ↦ ∀ S : ValuativeCommSq f, Subsingleton S.commSq.LiftStruct | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion",
"Mathlib.AlgebraicGeometry.Morphisms.Proper",
"Mathlib.RingTheory.RingHom.Injective",
"Mathlib.RingTheory.Valuation.LocalSubring"
] | Mathlib/AlgebraicGeometry/ValuativeCriterion.lean | ValuativeCriterion.Uniqueness | A morphism `f : X ⟶ Y` satisfies the uniqueness part of the valuative criterion if
every valuative commutative square over `f` has at most one lift. |
ValuativeCriterion : MorphismProperty Scheme :=
fun _ _ f ↦ ∀ S : ValuativeCommSq f, Nonempty (Unique (S.commSq.LiftStruct))
variable {X Y : Scheme.{u}} (f : X ⟶ Y) | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion",
"Mathlib.AlgebraicGeometry.Morphisms.Proper",
"Mathlib.RingTheory.RingHom.Injective",
"Mathlib.RingTheory.Valuation.LocalSubring"
] | Mathlib/AlgebraicGeometry/ValuativeCriterion.lean | ValuativeCriterion | A morphism `f : X ⟶ Y` satisfies the valuative criterion if
every valuative commutative square over `f` has a unique lift. |
ValuativeCriterion.iff {f : X ⟶ Y} :
ValuativeCriterion f ↔ Existence f ∧ Uniqueness f := by
change (∀ _, _) ↔ (∀ _, _) ∧ (∀ _, _)
simp_rw [← forall_and, unique_iff_subsingleton_and_nonempty, and_comm, CommSq.HasLift.iff] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion",
"Mathlib.AlgebraicGeometry.Morphisms.Proper",
"Mathlib.RingTheory.RingHom.Injective",
"Mathlib.RingTheory.Valuation.LocalSubring"
] | Mathlib/AlgebraicGeometry/ValuativeCriterion.lean | ValuativeCriterion.iff | null |
ValuativeCriterion.eq :
ValuativeCriterion = Existence ⊓ Uniqueness := by
ext X Y f
exact iff | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion",
"Mathlib.AlgebraicGeometry.Morphisms.Proper",
"Mathlib.RingTheory.RingHom.Injective",
"Mathlib.RingTheory.Valuation.LocalSubring"
] | Mathlib/AlgebraicGeometry/ValuativeCriterion.lean | ValuativeCriterion.eq | null |
ValuativeCriterion.existence {f : X ⟶ Y} (h : ValuativeCriterion f) :
ValuativeCriterion.Existence f := (iff.mp h).1 | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion",
"Mathlib.AlgebraicGeometry.Morphisms.Proper",
"Mathlib.RingTheory.RingHom.Injective",
"Mathlib.RingTheory.Valuation.LocalSubring"
] | Mathlib/AlgebraicGeometry/ValuativeCriterion.lean | ValuativeCriterion.existence | null |
ValuativeCriterion.uniqueness {f : X ⟶ Y} (h : ValuativeCriterion f) :
ValuativeCriterion.Uniqueness f := (iff.mp h).2 | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion",
"Mathlib.AlgebraicGeometry.Morphisms.Proper",
"Mathlib.RingTheory.RingHom.Injective",
"Mathlib.RingTheory.Valuation.LocalSubring"
] | Mathlib/AlgebraicGeometry/ValuativeCriterion.lean | ValuativeCriterion.uniqueness | null |
@[stacks 01KE]
specializingMap (H : ValuativeCriterion.Existence f) :
SpecializingMap f.base := by
intro x' y h
let stalk_y_to_residue_x' : Y.presheaf.stalk y ⟶ X.residueField x' :=
Y.presheaf.stalkSpecializes h ≫ f.stalkMap x' ≫ X.residue x'
obtain ⟨A, hA, hA_local⟩ := exists_factor_valuationRing stalk_y_to_residue_x'.hom
let stalk_y_to_A : Y.presheaf.stalk y ⟶ .of A :=
CommRingCat.ofHom (stalk_y_to_residue_x'.hom.codRestrict _ hA)
have w : X.fromSpecResidueField x' ≫ f =
Spec.map (CommRingCat.ofHom (algebraMap A (X.residueField x'))) ≫
Spec.map stalk_y_to_A ≫ Y.fromSpecStalk y := by
rw [Scheme.fromSpecResidueField, Category.assoc, ← Scheme.Spec_map_stalkMap_fromSpecStalk,
← Scheme.Spec_map_stalkSpecializes_fromSpecStalk h]
simp_rw [← Spec.map_comp_assoc]
rfl
obtain ⟨l, hl₁, hl₂⟩ := (H { R := A, K := X.residueField x', commSq := ⟨w⟩, .. }).exists_lift
dsimp only at hl₁ hl₂
refine ⟨l.base (closedPoint A), ?_, ?_⟩
· simp_rw [← Scheme.fromSpecResidueField_apply x' (closedPoint (X.residueField x')), ← hl₁]
exact (specializes_closedPoint _).map l.base.hom.2
· rw [← Scheme.comp_base_apply, hl₂]
simp only [Scheme.comp_coeBase, TopCat.coe_comp, Function.comp_apply]
have : (Spec.map stalk_y_to_A).base (closedPoint A) = closedPoint (Y.presheaf.stalk y) :=
comap_closedPoint (S := A) (stalk_y_to_residue_x'.hom.codRestrict A.toSubring hA)
rw [this, Y.fromSpecStalk_closedPoint] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion",
"Mathlib.AlgebraicGeometry.Morphisms.Proper",
"Mathlib.RingTheory.RingHom.Injective",
"Mathlib.RingTheory.Valuation.LocalSubring"
] | Mathlib/AlgebraicGeometry/ValuativeCriterion.lean | specializingMap | null |
of_specializingMap (H : (topologically @SpecializingMap).universally f) :
ValuativeCriterion.Existence f := by
rintro ⟨R, K, i₁, i₂, ⟨w⟩⟩
haveI : IsDomain (CommRingCat.of R) := ‹_›
haveI : ValuationRing (CommRingCat.of R) := ‹_›
letI : Field (CommRingCat.of K) := ‹_›
replace H := H (pullback.snd i₂ f) i₂ (pullback.fst i₂ f) (.of_hasPullback i₂ f)
let lft := pullback.lift (Spec.map (CommRingCat.ofHom (algebraMap R K))) i₁ w.symm
obtain ⟨x, h₁, h₂⟩ := @H (lft.base (closedPoint _)) _ (specializes_closedPoint (R := R) _)
let e : CommRingCat.of R ≅ Spec(R).presheaf.stalk ((pullback.fst i₂ f).base x) :=
(stalkClosedPointIso (.of R)).symm ≪≫
Spec(R).presheaf.stalkCongr (.of_eq h₂.symm)
let α := e.hom ≫ (pullback.fst i₂ f).stalkMap x
have : IsLocalHom e.hom.hom := isLocalHom_of_isIso e.hom
have : IsLocalHom α.hom := inferInstanceAs
(IsLocalHom (((pullback.fst i₂ f).stalkMap x).hom.comp e.hom.hom))
let β := (pullback i₂ f).presheaf.stalkSpecializes h₁ ≫ Scheme.stalkClosedPointTo lft
have hαβ : α ≫ β = CommRingCat.ofHom (algebraMap R K) := by
simp only [CommRingCat.coe_of, Iso.trans_hom, Iso.symm_hom, TopCat.Presheaf.stalkCongr_hom,
Category.assoc, α, e, β, stalkClosedPointIso_inv, StructureSheaf.toStalk]
change (Scheme.ΓSpecIso (.of R)).inv ≫ Spec(R).presheaf.germ _ _ _ ≫ _ = _
simp only [TopCat.Presheaf.germ_stalkSpecializes_assoc, Scheme.stalkMap_germ_assoc]
simp only [TopologicalSpace.Opens.map_top]
rw [Scheme.germ_stalkClosedPointTo lft ⊤ trivial]
erw [← Scheme.comp_app_assoc lft (pullback.fst i₂ f)]
rw [pullback.lift_fst]
simp
have hbij := (bijective_rangeRestrict_comp_of_valuationRing (R := R) (K := K) α.hom β.hom
(CommRingCat.hom_ext_iff.mp hαβ))
let φ : (pullback i₂ f).presheaf.stalk x ⟶ CommRingCat.of R := CommRingCat.ofHom <|
(RingEquiv.ofBijective _ hbij).symm.toRingHom.comp β.hom.rangeRestrict
have hαφ : α ≫ φ = 𝟙 _ := by ext x; exact (RingEquiv.ofBijective _ hbij).symm_apply_apply x
have hαφ' : (pullback.fst i₂ f).stalkMap x ≫ φ = e.inv := by
rw [← cancel_epi e.hom, ← Category.assoc, hαφ, e.hom_inv_id]
have hφβ : φ ≫ CommRingCat.ofHom (algebraMap R K) = β :=
hαβ ▸ CommRingCat.hom_ext (RingHom.ext fun x ↦ congr_arg Subtype.val
((RingEquiv.ofBijective _ hbij).apply_symm_apply (β.hom.rangeRestrict x)))
refine ⟨⟨⟨Spec.map ((pullback.snd i₂ f).stalkMap x ≫ φ) ≫ X.fromSpecStalk _, ?_, ?_⟩⟩⟩
· simp only [← Spec.map_comp_assoc, Category.assoc, hφβ]
simp only [Spec.map_comp, Category.assoc, Scheme.Spec_map_stalkMap_fromSpecStalk,
Scheme.Spec_map_stalkSpecializes_fromSpecStalk_assoc, β]
rw [Scheme.Spec_stalkClosedPointTo_fromSpecStalk_assoc]
simp [lft]
· simp only [Spec.map_comp, Category.assoc, Scheme.Spec_map_stalkMap_fromSpecStalk,
← pullback.condition]
rw [← Scheme.Spec_map_stalkMap_fromSpecStalk_assoc, ← Spec.map_comp_assoc, hαφ']
simp only [Iso.trans_inv, TopCat.Presheaf.stalkCongr_inv, Iso.symm_inv, Spec.map_comp,
Category.assoc, Scheme.Spec_map_stalkSpecializes_fromSpecStalk_assoc, e]
rw [← Spec_stalkClosedPointIso, ← Spec.map_comp_assoc,
Iso.inv_hom_id, Spec.map_id, Category.id_comp] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion",
"Mathlib.AlgebraicGeometry.Morphisms.Proper",
"Mathlib.RingTheory.RingHom.Injective",
"Mathlib.RingTheory.Valuation.LocalSubring"
] | Mathlib/AlgebraicGeometry/ValuativeCriterion.lean | of_specializingMap | null |
stableUnderBaseChange : ValuativeCriterion.Existence.IsStableUnderBaseChange := by
constructor
intro Y' X X' Y Y'_to_Y f X'_to_X f' hP hf commSq
let commSq' : ValuativeCommSq f :=
{ R := commSq.R
K := commSq.K
i₁ := commSq.i₁ ≫ X'_to_X
i₂ := commSq.i₂ ≫ Y'_to_Y
commSq := ⟨by simp only [Category.assoc, hP.w, reassoc_of% commSq.commSq.w]⟩ }
obtain ⟨l₀, hl₁, hl₂⟩ := (hf commSq').exists_lift
refine ⟨⟨⟨hP.lift l₀ commSq.i₂ (by simp_all only [commSq']), ?_, hP.lift_snd _ _ _⟩⟩⟩
apply hP.hom_ext
· simpa
· simp only [Category.assoc]
rw [hP.lift_snd]
rw [commSq.commSq.w]
@[stacks 01KE] | instance | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion",
"Mathlib.AlgebraicGeometry.Morphisms.Proper",
"Mathlib.RingTheory.RingHom.Injective",
"Mathlib.RingTheory.Valuation.LocalSubring"
] | Mathlib/AlgebraicGeometry/ValuativeCriterion.lean | stableUnderBaseChange | null |
protected eq :
ValuativeCriterion.Existence = (topologically @SpecializingMap).universally := by
ext
constructor
· intro _
apply MorphismProperty.universally_mono
· apply specializingMap
· rwa [MorphismProperty.IsStableUnderBaseChange.universally_eq]
· apply of_specializingMap | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion",
"Mathlib.AlgebraicGeometry.Morphisms.Proper",
"Mathlib.RingTheory.RingHom.Injective",
"Mathlib.RingTheory.Valuation.LocalSubring"
] | Mathlib/AlgebraicGeometry/ValuativeCriterion.lean | eq | null |
@[stacks 01KF]
UniversallyClosed.eq_valuativeCriterion :
@UniversallyClosed = ValuativeCriterion.Existence ⊓ @QuasiCompact := by
rw [universallyClosed_eq_universallySpecializing, ValuativeCriterion.Existence.eq] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion",
"Mathlib.AlgebraicGeometry.Morphisms.Proper",
"Mathlib.RingTheory.RingHom.Injective",
"Mathlib.RingTheory.Valuation.LocalSubring"
] | Mathlib/AlgebraicGeometry/ValuativeCriterion.lean | UniversallyClosed.eq_valuativeCriterion | The **valuative criterion** for universally closed morphisms. |
@[stacks 01KF]
UniversallyClosed.of_valuativeCriterion [QuasiCompact f]
(hf : ValuativeCriterion.Existence f) : UniversallyClosed f := by
rw [eq_valuativeCriterion]
exact ⟨hf, ‹_›⟩ | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion",
"Mathlib.AlgebraicGeometry.Morphisms.Proper",
"Mathlib.RingTheory.RingHom.Injective",
"Mathlib.RingTheory.Valuation.LocalSubring"
] | Mathlib/AlgebraicGeometry/ValuativeCriterion.lean | UniversallyClosed.of_valuativeCriterion | The **valuative criterion** for universally closed morphisms. |
@[stacks 01L0]
IsSeparated.of_valuativeCriterion [QuasiSeparated f]
(hf : ValuativeCriterion.Uniqueness f) : IsSeparated f where
diagonal_isClosedImmersion := by
suffices h : ValuativeCriterion.Existence (pullback.diagonal f) by
have : QuasiCompact (pullback.diagonal f) :=
AlgebraicGeometry.QuasiSeparated.diagonalQuasiCompact
apply IsClosedImmersion.of_isPreimmersion
apply IsClosedMap.isClosed_range
apply (topologically @IsClosedMap).universally_le
exact (UniversallyClosed.of_valuativeCriterion (pullback.diagonal f) h).out
intro S
have hc : CommSq S.i₁ (Spec.map (CommRingCat.ofHom (algebraMap S.R S.K)))
f (S.i₂ ≫ pullback.fst f f ≫ f) := ⟨by simp [← S.commSq.w_assoc]⟩
let S' : ValuativeCommSq f := ⟨S.R, S.K, S.i₁, S.i₂ ≫ pullback.fst f f ≫ f, hc⟩
have : Subsingleton S'.commSq.LiftStruct := hf S'
let S'l₁ : S'.commSq.LiftStruct := ⟨S.i₂ ≫ pullback.fst f f,
by simp [S', ← S.commSq.w_assoc], by simp [S']⟩
let S'l₂ : S'.commSq.LiftStruct := ⟨S.i₂ ≫ pullback.snd f f,
by simp [S', ← S.commSq.w_assoc], by simp [S', pullback.condition]⟩
have h₁₂ : S'l₁ = S'l₂ := Subsingleton.elim _ _
constructor
constructor
refine ⟨S.i₂ ≫ pullback.fst _ _, ?_, ?_⟩
· simp [← S.commSq.w_assoc]
· simp only [Category.assoc]
apply IsPullback.hom_ext (IsPullback.of_hasPullback _ _)
· simp
· simp only [Category.assoc, pullback.diagonal_snd, Category.comp_id]
exact congrArg CommSq.LiftStruct.l h₁₂
@[stacks 01KZ] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion",
"Mathlib.AlgebraicGeometry.Morphisms.Proper",
"Mathlib.RingTheory.RingHom.Injective",
"Mathlib.RingTheory.Valuation.LocalSubring"
] | Mathlib/AlgebraicGeometry/ValuativeCriterion.lean | IsSeparated.of_valuativeCriterion | The **valuative criterion** for separated morphisms. |
IsSeparated.valuativeCriterion [IsSeparated f] : ValuativeCriterion.Uniqueness f := by
intro S
constructor
rintro ⟨l₁, hl₁, hl₁'⟩ ⟨l₂, hl₂, hl₂'⟩
ext : 1
dsimp at *
have h := hl₁'.trans hl₂'.symm
let Z := pullback (pullback.diagonal f) (pullback.lift l₁ l₂ h)
let g : Z ⟶ Spec(S.R) := pullback.snd _ _
have : IsClosedImmersion g := MorphismProperty.pullback_snd _ _ inferInstance
have hZ : IsAffine Z := by
rw [@HasAffineProperty.iff_of_isAffine @IsClosedImmersion] at this
exact this.left
suffices IsIso g by
rw [← cancel_epi g]
conv_lhs => rw [← pullback.lift_fst l₁ l₂ h, ← pullback.condition_assoc]
conv_rhs => rw [← pullback.lift_snd l₁ l₂ h, ← pullback.condition_assoc]
simp
suffices h : Function.Bijective (g.appTop) by
refine (HasAffineProperty.iff_of_isAffine (P := MorphismProperty.isomorphisms Scheme)).mpr ?_
exact ⟨hZ, (ConcreteCategory.isIso_iff_bijective _).mpr h⟩
constructor
· let l : Spec(S.K) ⟶ Z :=
pullback.lift S.i₁ (Spec.map (CommRingCat.ofHom (algebraMap S.R S.K))) (by
apply IsPullback.hom_ext (IsPullback.of_hasPullback _ _)
· simpa using hl₁.symm
· simpa using hl₂.symm)
have hg : l ≫ g = Spec.map (CommRingCat.ofHom (algebraMap S.R S.K)) :=
pullback.lift_snd _ _ _
have : Function.Injective ((l ≫ g).appTop) := by
rw [hg]
let e := arrowIsoΓSpecOfIsAffine (CommRingCat.ofHom <| algebraMap S.R S.K)
let P : MorphismProperty CommRingCat :=
RingHom.toMorphismProperty <| fun f ↦ Function.Injective f
have : (RingHom.toMorphismProperty <| fun f ↦ Function.Injective f).RespectsIso :=
RingHom.toMorphismProperty_respectsIso_iff.mp RingHom.injective_respectsIso
change P _
rw [← MorphismProperty.arrow_mk_iso_iff (P := P) e]
exact FaithfulSMul.algebraMap_injective S.R S.K
rw [Scheme.comp_appTop] at this
exact Function.Injective.of_comp this
· rw [@HasAffineProperty.iff_of_isAffine @IsClosedImmersion] at this
exact this.right | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion",
"Mathlib.AlgebraicGeometry.Morphisms.Proper",
"Mathlib.RingTheory.RingHom.Injective",
"Mathlib.RingTheory.Valuation.LocalSubring"
] | Mathlib/AlgebraicGeometry/ValuativeCriterion.lean | IsSeparated.valuativeCriterion | null |
IsSeparated.eq_valuativeCriterion :
@IsSeparated = ValuativeCriterion.Uniqueness ⊓ @QuasiSeparated := by
ext X Y f
exact ⟨fun _ ↦ ⟨IsSeparated.valuativeCriterion f, inferInstance⟩,
fun ⟨H, _⟩ ↦ .of_valuativeCriterion f H⟩ | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion",
"Mathlib.AlgebraicGeometry.Morphisms.Proper",
"Mathlib.RingTheory.RingHom.Injective",
"Mathlib.RingTheory.Valuation.LocalSubring"
] | Mathlib/AlgebraicGeometry/ValuativeCriterion.lean | IsSeparated.eq_valuativeCriterion | The **valuative criterion** for separated morphisms. |
@[stacks 0BX5]
IsProper.eq_valuativeCriterion :
@IsProper = ValuativeCriterion ⊓ @QuasiCompact ⊓ @QuasiSeparated ⊓ @LocallyOfFiniteType := by
rw [isProper_eq, IsSeparated.eq_valuativeCriterion, ValuativeCriterion.eq,
UniversallyClosed.eq_valuativeCriterion]
simp_rw [inf_assoc]
ext X Y f
change _ ∧ _ ∧ _ ∧ _ ∧ _ ↔ _ ∧ _ ∧ _ ∧ _ ∧ _
tauto | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion",
"Mathlib.AlgebraicGeometry.Morphisms.Proper",
"Mathlib.RingTheory.RingHom.Injective",
"Mathlib.RingTheory.Valuation.LocalSubring"
] | Mathlib/AlgebraicGeometry/ValuativeCriterion.lean | IsProper.eq_valuativeCriterion | The **valuative criterion** for proper morphisms. |
@[stacks 0BX5]
IsProper.of_valuativeCriterion [QuasiCompact f] [QuasiSeparated f] [LocallyOfFiniteType f]
(H : ValuativeCriterion f) : IsProper f := by
rw [eq_valuativeCriterion]
exact ⟨⟨⟨‹_›, ‹_›⟩, ‹_›⟩, ‹_›⟩ | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion",
"Mathlib.AlgebraicGeometry.Morphisms.Proper",
"Mathlib.RingTheory.RingHom.Injective",
"Mathlib.RingTheory.Valuation.LocalSubring"
] | Mathlib/AlgebraicGeometry/ValuativeCriterion.lean | IsProper.of_valuativeCriterion | The **valuative criterion** for proper morphisms. |
@[simp]
objD (n : ℕ) : X _⦋n + 1⦌ ⟶ X _⦋n⦌ :=
∑ i : Fin (n + 2), (-1 : ℤ) ^ (i : ℕ) • X.δ i
/-! | def | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | objD | The differential on the alternating face map complex is the alternate
sum of the face maps |
d_squared (n : ℕ) : objD X (n + 1) ≫ objD X n = 0 := by
dsimp
simp only [comp_sum, sum_comp, ← Finset.sum_product']
let P := Fin (n + 2) × Fin (n + 3)
let S : Finset P := {ij : P | (ij.2 : ℕ) ≤ (ij.1 : ℕ)}
rw [Finset.univ_product_univ, ← Finset.sum_add_sum_compl S, ← eq_neg_iff_add_eq_zero,
← Finset.sum_neg_distrib]
/- we are reduced to showing that two sums are equal, and this is obtained
by constructing a bijection φ : S -> Sᶜ, which maps (i,j) to (j,i+1),
and by comparing the terms -/
let φ : ∀ ij : P, ij ∈ S → P := fun ij hij =>
(Fin.castLT ij.2 (lt_of_le_of_lt (Finset.mem_filter.mp hij).right (Fin.is_lt ij.1)), ij.1.succ)
apply Finset.sum_bij φ
· -- φ(S) is contained in Sᶜ
intro ij hij
simp_rw [S, φ, Finset.compl_filter, Finset.mem_filter_univ, Fin.val_succ,
Fin.coe_castLT] at hij ⊢
cutsat
· -- φ : S → Sᶜ is injective
rintro ⟨i, j⟩ hij ⟨i', j'⟩ hij' h
rw [Prod.mk_inj]
exact ⟨by simpa [φ] using congr_arg Prod.snd h,
by simpa [φ, Fin.castSucc_castLT] using congr_arg Fin.castSucc (congr_arg Prod.fst h)⟩
· -- φ : S → Sᶜ is surjective
rintro ⟨i', j'⟩ hij'
simp_rw [S, Finset.compl_filter, Finset.mem_filter_univ, not_le] at hij'
refine ⟨(j'.pred <| ?_, Fin.castSucc i'), ?_, ?_⟩
· rintro rfl
simp only [Fin.val_zero, not_lt_zero'] at hij'
· simpa [S] using Nat.le_sub_one_of_lt hij'
· simp only [φ, Fin.castLT_castSucc, Fin.succ_pred]
· -- identification of corresponding terms in both sums
rintro ⟨i, j⟩ hij
dsimp
simp only [zsmul_comp, comp_zsmul, smul_smul, ← neg_smul]
congr 1
· simp only [φ, Fin.val_succ, pow_add, pow_one, mul_neg, neg_neg, mul_one]
apply mul_comm
· rw [CategoryTheory.SimplicialObject.δ_comp_δ'']
simpa [S] using hij
/-! | theorem | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | d_squared | null |
obj : ChainComplex C ℕ :=
ChainComplex.of (fun n => X _⦋n⦌) (objD X) (d_squared X)
@[simp] | def | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | obj | The alternating face map complex, on objects |
obj_X (X : SimplicialObject C) (n : ℕ) : (AlternatingFaceMapComplex.obj X).X n = X _⦋n⦌ :=
rfl
@[simp] | theorem | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | obj_X | null |
obj_d_eq (X : SimplicialObject C) (n : ℕ) :
(AlternatingFaceMapComplex.obj X).d (n + 1) n
= ∑ i : Fin (n + 2), (-1 : ℤ) ^ (i : ℕ) • X.δ i := by
apply ChainComplex.of_d
variable {X} {Y} | theorem | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | obj_d_eq | null |
map (f : X ⟶ Y) : obj X ⟶ obj Y :=
ChainComplex.ofHom _ _ _ _ _ _ (fun n => f.app (op ⦋n⦌)) fun n => by
dsimp
rw [comp_sum, sum_comp]
refine Finset.sum_congr rfl fun _ _ => ?_
rw [comp_zsmul, zsmul_comp]
congr 1
symm
apply f.naturality
@[simp] | def | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | map | The alternating face map complex, on morphisms |
map_f (f : X ⟶ Y) (n : ℕ) : (map f).f n = f.app (op ⦋n⦌) :=
rfl | theorem | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | map_f | null |
alternatingFaceMapComplex : SimplicialObject C ⥤ ChainComplex C ℕ where
obj := AlternatingFaceMapComplex.obj
map f := AlternatingFaceMapComplex.map f
variable {C}
@[simp] | def | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | alternatingFaceMapComplex | The alternating face map complex, as a functor |
alternatingFaceMapComplex_obj_X (X : SimplicialObject C) (n : ℕ) :
((alternatingFaceMapComplex C).obj X).X n = X _⦋n⦌ :=
rfl
@[simp] | theorem | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | alternatingFaceMapComplex_obj_X | null |
alternatingFaceMapComplex_obj_d (X : SimplicialObject C) (n : ℕ) :
((alternatingFaceMapComplex C).obj X).d (n + 1) n = AlternatingFaceMapComplex.objD X n := by
dsimp only [alternatingFaceMapComplex, AlternatingFaceMapComplex.obj]
apply ChainComplex.of_d
@[simp] | theorem | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | alternatingFaceMapComplex_obj_d | null |
alternatingFaceMapComplex_map_f {X Y : SimplicialObject C} (f : X ⟶ Y) (n : ℕ) :
((alternatingFaceMapComplex C).map f).f n = f.app (op ⦋n⦌) :=
rfl | theorem | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | alternatingFaceMapComplex_map_f | null |
map_alternatingFaceMapComplex {D : Type*} [Category D] [Preadditive D] (F : C ⥤ D)
[F.Additive] :
alternatingFaceMapComplex C ⋙ F.mapHomologicalComplex _ =
(SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D := by
apply CategoryTheory.Functor.ext
· intro X Y f
ext n
simp only [Functor.comp_map, HomologicalComplex.comp_f, alternatingFaceMapComplex_map_f,
Functor.mapHomologicalComplex_map_f, HomologicalComplex.eqToHom_f, eqToHom_refl, comp_id,
id_comp, SimplicialObject.whiskering_obj_map_app]
· intro X
apply HomologicalComplex.ext
· rintro i j (rfl : j + 1 = i)
dsimp only [Functor.comp_obj]
simp only [Functor.mapHomologicalComplex_obj_d, alternatingFaceMapComplex_obj_d,
eqToHom_refl, id_comp, comp_id, AlternatingFaceMapComplex.objD, Functor.map_sum,
Functor.map_zsmul]
rfl
· ext n
rfl | theorem | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | map_alternatingFaceMapComplex | null |
karoubi_alternatingFaceMapComplex_d (P : Karoubi (SimplicialObject C)) (n : ℕ) :
((AlternatingFaceMapComplex.obj (KaroubiFunctorCategoryEmbedding.obj P)).d (n + 1) n).f =
P.p.app (op ⦋n + 1⦌) ≫ (AlternatingFaceMapComplex.obj P.X).d (n + 1) n := by
dsimp
simp only [AlternatingFaceMapComplex.obj_d_eq, Karoubi.sum_hom, Preadditive.comp_sum,
Karoubi.zsmul_hom, Preadditive.comp_zsmul]
rfl | theorem | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | karoubi_alternatingFaceMapComplex_d | null |
ε [Limits.HasZeroObject C] :
SimplicialObject.Augmented.drop ⋙ AlgebraicTopology.alternatingFaceMapComplex C ⟶
SimplicialObject.Augmented.point ⋙ ChainComplex.single₀ C where
app X := by
refine (ChainComplex.toSingle₀Equiv _ _).symm ?_
refine ⟨X.hom.app (op ⦋0⦌), ?_⟩
dsimp
rw [alternatingFaceMapComplex_obj_d, objD, Fin.sum_univ_two, Fin.val_zero,
pow_zero, one_smul, Fin.val_one, pow_one, neg_smul, one_smul, add_comp,
neg_comp, SimplicialObject.δ_naturality, SimplicialObject.δ_naturality]
apply add_neg_cancel
naturality X Y f := by
apply HomologicalComplex.to_single_hom_ext
dsimp
erw [ChainComplex.toSingle₀Equiv_symm_apply_f_zero,
ChainComplex.toSingle₀Equiv_symm_apply_f_zero]
simp only [ChainComplex.single₀_map_f_zero]
exact congr_app f.w _
@[simp] | def | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | ε | The natural transformation which gives the augmentation of the alternating face map
complex attached to an augmented simplicial object. |
ε_app_f_zero [Limits.HasZeroObject C] (X : SimplicialObject.Augmented C) :
(ε.app X).f 0 = X.hom.app (op ⦋0⦌) :=
ChainComplex.toSingle₀Equiv_symm_apply_f_zero _ _
@[simp] | lemma | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | ε_app_f_zero | null |
ε_app_f_succ [Limits.HasZeroObject C] (X : SimplicialObject.Augmented C) (n : ℕ) :
(ε.app X).f (n + 1) = 0 := rfl | lemma | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | ε_app_f_succ | null |
inclusionOfMooreComplexMap (X : SimplicialObject A) :
(normalizedMooreComplex A).obj X ⟶ (alternatingFaceMapComplex A).obj X := by
dsimp only [normalizedMooreComplex, NormalizedMooreComplex.obj,
alternatingFaceMapComplex, AlternatingFaceMapComplex.obj]
apply ChainComplex.ofHom _ _ _ _ _ _ (fun n => (NormalizedMooreComplex.objX X n).arrow)
/- we have to show the compatibility of the differentials on the alternating
face map complex with those defined on the normalized Moore complex:
we first get rid of the terms of the alternating sum that are obviously
zero on the normalized_Moore_complex -/
intro i
simp only [AlternatingFaceMapComplex.objD, comp_sum]
rw [Fin.sum_univ_succ, Fintype.sum_eq_zero]
swap
· intro j
rw [NormalizedMooreComplex.objX_add_one, comp_zsmul,
← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ _ (Finset.mem_univ j)),
Category.assoc, kernelSubobject_arrow_comp, comp_zero, smul_zero]
rw [add_zero, Fin.val_zero, pow_zero, one_zsmul]
dsimp [NormalizedMooreComplex.objD, NormalizedMooreComplex.objX]
cases i <;> simp
@[simp] | def | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | inclusionOfMooreComplexMap | The inclusion map of the Moore complex in the alternating face map complex |
inclusionOfMooreComplexMap_f (X : SimplicialObject A) (n : ℕ) :
(inclusionOfMooreComplexMap X).f n = (NormalizedMooreComplex.objX X n).arrow := by
dsimp only [inclusionOfMooreComplexMap]
exact ChainComplex.ofHom_f _ _ _ _ _ _ _ _ n
variable (A) | theorem | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | inclusionOfMooreComplexMap_f | null |
@[simps]
inclusionOfMooreComplex : normalizedMooreComplex A ⟶ alternatingFaceMapComplex A where
app := inclusionOfMooreComplexMap | def | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | inclusionOfMooreComplex | The inclusion map of the Moore complex in the alternating face map complex,
as a natural transformation |
@[simp]
objD (n : ℕ) : X.obj ⦋n⦌ ⟶ X.obj ⦋n + 1⦌ :=
∑ i : Fin (n + 2), (-1 : ℤ) ^ (i : ℕ) • X.δ i | def | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | objD | The differential on the alternating coface map complex is the alternate
sum of the coface maps |
d_eq_unop_d (n : ℕ) :
objD X n =
(AlternatingFaceMapComplex.objD ((cosimplicialSimplicialEquiv C).functor.obj (op X))
n).unop := by
simp only [objD, AlternatingFaceMapComplex.objD, unop_sum, unop_zsmul]
rfl | theorem | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | d_eq_unop_d | null |
d_squared (n : ℕ) : objD X n ≫ objD X (n + 1) = 0 := by
simp only [d_eq_unop_d, ← unop_comp, AlternatingFaceMapComplex.d_squared, unop_zero] | theorem | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | d_squared | null |
obj : CochainComplex C ℕ :=
CochainComplex.of (fun n => X.obj ⦋n⦌) (objD X) (d_squared X)
variable {X} {Y} | def | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | obj | The alternating coface map complex, on objects |
@[simp]
map (f : X ⟶ Y) : obj X ⟶ obj Y :=
CochainComplex.ofHom _ _ _ _ _ _ (fun n => f.app ⦋n⦌) fun n => by
dsimp
rw [comp_sum, sum_comp]
refine Finset.sum_congr rfl fun x _ => ?_
rw [comp_zsmul, zsmul_comp]
congr 1
symm
apply f.naturality | def | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | map | The alternating face map complex, on morphisms |
@[simps]
alternatingCofaceMapComplex : CosimplicialObject C ⥤ CochainComplex C ℕ where
obj := AlternatingCofaceMapComplex.obj
map f := AlternatingCofaceMapComplex.map f | def | AlgebraicTopology | [
"Mathlib.Algebra.Homology.Additive",
"Mathlib.AlgebraicTopology.MooreComplex",
"Mathlib.Algebra.BigOperators.Fin",
"Mathlib.CategoryTheory.Preadditive.Opposite",
"Mathlib.CategoryTheory.Idempotents.FunctorCategories"
] | Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean | alternatingCofaceMapComplex | The alternating coface map complex, as a functor |
@[simps]
cechNerve : SimplicialObject C where
obj n := widePullback.{0} f.right (fun _ : Fin (n.unop.len + 1) => f.left) fun _ => f.hom
map g := WidePullback.lift (WidePullback.base _)
(fun i => WidePullback.π _ (g.unop.toOrderHom i)) (by simp) | def | AlgebraicTopology | [
"Mathlib.AlgebraicTopology.SimplicialObject.Basic",
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks",
"Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts"
] | Mathlib/AlgebraicTopology/CechNerve.lean | cechNerve | The Čech nerve associated to an arrow. |
@[simps]
mapCechNerve {f g : Arrow C}
[∀ n : ℕ, HasWidePullback f.right (fun _ : Fin (n + 1) => f.left) fun _ => f.hom]
[∀ n : ℕ, HasWidePullback g.right (fun _ : Fin (n + 1) => g.left) fun _ => g.hom] (F : f ⟶ g) :
f.cechNerve ⟶ g.cechNerve where
app n :=
WidePullback.lift (WidePullback.base _ ≫ F.right) (fun i => WidePullback.π _ i ≫ F.left)
fun j => by simp | def | AlgebraicTopology | [
"Mathlib.AlgebraicTopology.SimplicialObject.Basic",
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks",
"Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts"
] | Mathlib/AlgebraicTopology/CechNerve.lean | mapCechNerve | The morphism between Čech nerves associated to a morphism of arrows. |
@[simps]
augmentedCechNerve : SimplicialObject.Augmented C where
left := f.cechNerve
right := f.right
hom := { app := fun _ => WidePullback.base _ } | def | AlgebraicTopology | [
"Mathlib.AlgebraicTopology.SimplicialObject.Basic",
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks",
"Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts"
] | Mathlib/AlgebraicTopology/CechNerve.lean | augmentedCechNerve | The augmented Čech nerve associated to an arrow. |
@[simps]
mapAugmentedCechNerve {f g : Arrow C}
[∀ n : ℕ, HasWidePullback f.right (fun _ : Fin (n + 1) => f.left) fun _ => f.hom]
[∀ n : ℕ, HasWidePullback g.right (fun _ : Fin (n + 1) => g.left) fun _ => g.hom] (F : f ⟶ g) :
f.augmentedCechNerve ⟶ g.augmentedCechNerve where
left := mapCechNerve F
right := F.right | def | AlgebraicTopology | [
"Mathlib.AlgebraicTopology.SimplicialObject.Basic",
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks",
"Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts"
] | Mathlib/AlgebraicTopology/CechNerve.lean | mapAugmentedCechNerve | The morphism between augmented Čech nerve associated to a morphism of arrows. |
@[simps]
cechNerve : Arrow C ⥤ SimplicialObject C where
obj f := f.cechNerve
map F := Arrow.mapCechNerve F | def | AlgebraicTopology | [
"Mathlib.AlgebraicTopology.SimplicialObject.Basic",
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks",
"Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts"
] | Mathlib/AlgebraicTopology/CechNerve.lean | cechNerve | The Čech nerve construction, as a functor from `Arrow C`. |
@[simps!]
augmentedCechNerve : Arrow C ⥤ SimplicialObject.Augmented C where
obj f := f.augmentedCechNerve
map F := Arrow.mapAugmentedCechNerve F | def | AlgebraicTopology | [
"Mathlib.AlgebraicTopology.SimplicialObject.Basic",
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks",
"Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts"
] | Mathlib/AlgebraicTopology/CechNerve.lean | augmentedCechNerve | The augmented Čech nerve construction, as a functor from `Arrow C`. |
@[simps]
equivalenceRightToLeft (X : SimplicialObject.Augmented C) (F : Arrow C)
(G : X ⟶ F.augmentedCechNerve) : Augmented.toArrow.obj X ⟶ F where
left := G.left.app _ ≫ WidePullback.π _ 0
right := G.right
w := by
have := G.w
apply_fun fun e => e.app (Opposite.op ⦋0⦌) at this
simpa using this | def | AlgebraicTopology | [
"Mathlib.AlgebraicTopology.SimplicialObject.Basic",
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks",
"Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts"
] | Mathlib/AlgebraicTopology/CechNerve.lean | equivalenceRightToLeft | A helper function used in defining the Čech adjunction. |
@[simps]
equivalenceLeftToRight (X : SimplicialObject.Augmented C) (F : Arrow C)
(G : Augmented.toArrow.obj X ⟶ F) : X ⟶ F.augmentedCechNerve where
left :=
{ app := fun x =>
Limits.WidePullback.lift (X.hom.app _ ≫ G.right)
(fun i => X.left.map (SimplexCategory.const _ x.unop i).op ≫ G.left) fun i => by simp
naturality := by
intro x y f
dsimp
ext
· simp only [WidePullback.lift_π, Category.assoc, ← X.left.map_comp_assoc]
rfl
· simp }
right := G.right | def | AlgebraicTopology | [
"Mathlib.AlgebraicTopology.SimplicialObject.Basic",
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks",
"Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts"
] | Mathlib/AlgebraicTopology/CechNerve.lean | equivalenceLeftToRight | A helper function used in defining the Čech adjunction. |
@[simps]
cechNerveEquiv (X : SimplicialObject.Augmented C) (F : Arrow C) :
(Augmented.toArrow.obj X ⟶ F) ≃ (X ⟶ F.augmentedCechNerve) where
toFun := equivalenceLeftToRight _ _
invFun := equivalenceRightToLeft _ _
left_inv A := by ext <;> simp
right_inv := by
intro A
ext x : 2
· refine WidePullback.hom_ext _ _ _ (fun j => ?_) ?_
· simp
rfl
· simpa using congr_app A.w.symm x
· simp | def | AlgebraicTopology | [
"Mathlib.AlgebraicTopology.SimplicialObject.Basic",
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks",
"Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts"
] | Mathlib/AlgebraicTopology/CechNerve.lean | cechNerveEquiv | A helper function used in defining the Čech adjunction. |
cechNerveAdjunction : (Augmented.toArrow : _ ⥤ Arrow C) ⊣ augmentedCechNerve :=
Adjunction.mkOfHomEquiv
{ homEquiv := cechNerveEquiv
homEquiv_naturality_left_symm := by dsimp [cechNerveEquiv]; cat_disch
homEquiv_naturality_right := by
dsimp [cechNerveEquiv]
intro X Y Y' f g
change equivalenceLeftToRight X Y' (f ≫ g) =
equivalenceLeftToRight X Y f ≫ augmentedCechNerve.map g
cat_disch
} | abbrev | AlgebraicTopology | [
"Mathlib.AlgebraicTopology.SimplicialObject.Basic",
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks",
"Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts"
] | Mathlib/AlgebraicTopology/CechNerve.lean | cechNerveAdjunction | The augmented Čech nerve construction is right adjoint to the `toArrow` functor. |
@[simps]
cechConerve : CosimplicialObject C where
obj n := widePushout f.left (fun _ : Fin (n.len + 1) => f.right) fun _ => f.hom
map {x y} g := by
refine WidePushout.desc (WidePushout.head _)
(fun i => (@WidePushout.ι _ _ _ _ _ (fun _ => f.hom) (_) (g.toOrderHom i))) (fun j => ?_)
rw [← WidePushout.arrow_ι] | def | AlgebraicTopology | [
"Mathlib.AlgebraicTopology.SimplicialObject.Basic",
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks",
"Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts"
] | Mathlib/AlgebraicTopology/CechNerve.lean | cechConerve | The Čech conerve associated to an arrow. |
@[simps]
mapCechConerve {f g : Arrow C}
[∀ n : ℕ, HasWidePushout f.left (fun _ : Fin (n + 1) => f.right) fun _ => f.hom]
[∀ n : ℕ, HasWidePushout g.left (fun _ : Fin (n + 1) => g.right) fun _ => g.hom] (F : f ⟶ g) :
f.cechConerve ⟶ g.cechConerve where
app n := WidePushout.desc (F.left ≫ WidePushout.head _)
(fun i => F.right ≫ (by apply WidePushout.ι _ i))
(fun i => (by rw [← Arrow.w_assoc F, ← WidePushout.arrow_ι])) | def | AlgebraicTopology | [
"Mathlib.AlgebraicTopology.SimplicialObject.Basic",
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks",
"Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts"
] | Mathlib/AlgebraicTopology/CechNerve.lean | mapCechConerve | The morphism between Čech conerves associated to a morphism of arrows. |
@[simps]
augmentedCechConerve : CosimplicialObject.Augmented C where
left := f.left
right := f.cechConerve
hom :=
{ app := fun _ => (WidePushout.head _ : f.left ⟶ _) } | def | AlgebraicTopology | [
"Mathlib.AlgebraicTopology.SimplicialObject.Basic",
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks",
"Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts"
] | Mathlib/AlgebraicTopology/CechNerve.lean | augmentedCechConerve | The augmented Čech conerve associated to an arrow. |
@[simps]
mapAugmentedCechConerve {f g : Arrow C}
[∀ n : ℕ, HasWidePushout f.left (fun _ : Fin (n + 1) => f.right) fun _ => f.hom]
[∀ n : ℕ, HasWidePushout g.left (fun _ : Fin (n + 1) => g.right) fun _ => g.hom] (F : f ⟶ g) :
f.augmentedCechConerve ⟶ g.augmentedCechConerve where
left := F.left
right := mapCechConerve F | def | AlgebraicTopology | [
"Mathlib.AlgebraicTopology.SimplicialObject.Basic",
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks",
"Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts"
] | Mathlib/AlgebraicTopology/CechNerve.lean | mapAugmentedCechConerve | The morphism between augmented Čech conerves associated to a morphism of arrows. |
@[simps]
cechConerve : Arrow C ⥤ CosimplicialObject C where
obj f := f.cechConerve
map F := Arrow.mapCechConerve F | def | AlgebraicTopology | [
"Mathlib.AlgebraicTopology.SimplicialObject.Basic",
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks",
"Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts"
] | Mathlib/AlgebraicTopology/CechNerve.lean | cechConerve | The Čech conerve construction, as a functor from `Arrow C`. |
@[simps]
augmentedCechConerve : Arrow C ⥤ CosimplicialObject.Augmented C where
obj f := f.augmentedCechConerve
map F := Arrow.mapAugmentedCechConerve F | def | AlgebraicTopology | [
"Mathlib.AlgebraicTopology.SimplicialObject.Basic",
"Mathlib.CategoryTheory.Comma.Arrow",
"Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks",
"Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts"
] | Mathlib/AlgebraicTopology/CechNerve.lean | augmentedCechConerve | The augmented Čech conerve construction, as a functor from `Arrow C`. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.