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 ⌀ |
|---|---|---|---|---|---|---|
isOpenImmersion_stableUnderBaseChange :
MorphismProperty.IsStableUnderBaseChange @IsOpenImmersion :=
MorphismProperty.IsStableUnderBaseChange.mk' <| by
intro X Y Z f g _ H; infer_instance | instance | AlgebraicGeometry | [
"Mathlib.Geometry.RingedSpace.OpenImmersion",
"Mathlib.AlgebraicGeometry.Scheme",
"Mathlib.CategoryTheory.Limits.Shapes.Pullback.CommSq",
"Mathlib.CategoryTheory.MorphismProperty.Limits"
] | Mathlib/AlgebraicGeometry/OpenImmersion.lean | isOpenImmersion_stableUnderBaseChange | null |
image_basicOpen {U : X.Opens} (r : Γ(X, U)) :
f ''ᵁ X.basicOpen r = Y.basicOpen ((f.appIso U).inv r) := by
have e := Scheme.preimage_basicOpen f ((f.appIso U).inv r)
rw [Scheme.Hom.appIso_inv_app_apply, Scheme.basicOpen_res, inf_eq_right.mpr _] at e
· rw [← e, f.image_preimage_eq_opensRange_inter, inf_eq_right]
refine Set.Subset.trans (Scheme.basicOpen_le _ _) (Set.image_subset_range _ _)
· exact (X.basicOpen_le r).trans (f.preimage_image_eq _).ge | theorem | AlgebraicGeometry | [
"Mathlib.Geometry.RingedSpace.OpenImmersion",
"Mathlib.AlgebraicGeometry.Scheme",
"Mathlib.CategoryTheory.Limits.Shapes.Pullback.CommSq",
"Mathlib.CategoryTheory.MorphismProperty.Limits"
] | Mathlib/AlgebraicGeometry/OpenImmersion.lean | image_basicOpen | null |
image_zeroLocus {U : X.Opens} (s : Set Γ(X, U)) :
f.base '' X.zeroLocus s =
Y.zeroLocus (U := f ''ᵁ U) ((f.appIso U).inv.hom '' s) ∩ Set.range f.base := by
ext x
by_cases hx : x ∈ Set.range f.base
· obtain ⟨x, rfl⟩ := hx
simp only [f.isOpenEmbedding.injective.mem_set_image, Scheme.mem_zeroLocus_iff,
← SetLike.mem_coe, Set.mem_inter_iff, Set.forall_mem_image, ← Scheme.image_basicOpen,
IsOpenMap.coe_functor_obj, Set.mem_range, exists_apply_eq_apply, and_true]
· simp only [Set.mem_inter_iff, hx, and_false, iff_false]
exact fun H ↦ hx (Set.image_subset_range _ _ H) | lemma | AlgebraicGeometry | [
"Mathlib.Geometry.RingedSpace.OpenImmersion",
"Mathlib.AlgebraicGeometry.Scheme",
"Mathlib.CategoryTheory.Limits.Shapes.Pullback.CommSq",
"Mathlib.CategoryTheory.MorphismProperty.Limits"
] | Mathlib/AlgebraicGeometry/OpenImmersion.lean | image_zeroLocus | null |
protected Over (X S : Scheme.{u}) := OverClass X S | abbrev | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Scheme",
"Mathlib.CategoryTheory.Comma.Over.OverClass"
] | Mathlib/AlgebraicGeometry/Over.lean | Over | `X.Over S` is the typeclass containing the data of a structure morphism `X ↘ S : X ⟶ S`. |
CanonicallyOver (X S : Scheme.{u}) := CanonicallyOverClass X S | abbrev | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Scheme",
"Mathlib.CategoryTheory.Comma.Over.OverClass"
] | Mathlib/AlgebraicGeometry/Over.lean | CanonicallyOver | `X.CanonicallyOver S` is the typeclass containing the data of a structure morphism `X ↘ S : X ⟶ S`,
and that `S` is (uniquely) inferable from the structure of `X`. |
Hom.IsOver (f : X.Hom Y) (S : Scheme.{u}) [X.Over S] [Y.Over S] := HomIsOver f S
@[simp] | abbrev | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Scheme",
"Mathlib.CategoryTheory.Comma.Over.OverClass"
] | Mathlib/AlgebraicGeometry/Over.lean | Hom.IsOver | Given `X.Over S` and `Y.Over S` and `f : X ⟶ Y`,
`f.IsOver S` is the typeclass asserting `f` commutes with the structure morphisms. |
Hom.isOver_iff [X.Over S] [Y.Over S] {f : X ⟶ Y} : f.IsOver S ↔ f ≫ Y ↘ S = X ↘ S :=
⟨fun H ↦ H.1, fun h ↦ ⟨h⟩⟩
/-! Also note the existence of `CategoryTheory.IsOverTower X Y S`. -/ | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Scheme",
"Mathlib.CategoryTheory.Comma.Over.OverClass"
] | Mathlib/AlgebraicGeometry/Over.lean | Hom.isOver_iff | null |
asOver (X S : Scheme.{u}) [X.Over S] := OverClass.asOver X S | abbrev | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Scheme",
"Mathlib.CategoryTheory.Comma.Over.OverClass"
] | Mathlib/AlgebraicGeometry/Over.lean | asOver | Given `X.Over S`, this is the bundled object of `Over S`. |
Hom.asOver (f : X.Hom Y) (S : Scheme.{u}) [X.Over S] [Y.Over S] [f.IsOver S] :=
OverClass.asOverHom S f | abbrev | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Scheme",
"Mathlib.CategoryTheory.Comma.Over.OverClass"
] | Mathlib/AlgebraicGeometry/Over.lean | Hom.asOver | Given a morphism `X ⟶ Y` with `f.IsOver S`, this is the bundled morphism in `Over S`. |
Ideal.span_eq_top_of_span_image_evalRingHom
{ι} {R : ι → Type*} [∀ i, CommRing (R i)] (s : Set (Π i, R i))
(hs : s.Finite) (hs' : ∀ i, Ideal.span (Pi.evalRingHom (R ·) i '' s) = ⊤) :
Ideal.span s = ⊤ := by
simp only [Ideal.eq_top_iff_one, ← Subtype.range_val (s := s), ← Set.range_comp,
Finsupp.mem_ideal_span_range_iff_exists_finsupp] at hs' ⊢
choose f hf using hs'
have : Fintype s := hs.fintype
refine ⟨Finsupp.equivFunOnFinite.symm fun i x ↦ f x i, ?_⟩
ext i
simpa [Finsupp.sum_fintype] using hf i | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion"
] | Mathlib/AlgebraicGeometry/PointsPi.lean | Ideal.span_eq_top_of_span_image_evalRingHom | null |
eq_top_of_sigmaSpec_subset_of_isCompact
(U : Spec(Π i, R i).Opens) (V : Set Spec(Π i, R i))
(hV : ↑(sigmaSpec R).opensRange ⊆ V)
(hV' : IsCompact (X := Spec(Π i, R i)) V)
(hVU : V ⊆ U) : U = ⊤ := by
obtain ⟨s, hs⟩ := (PrimeSpectrum.isOpen_iff _).mp U.2
obtain ⟨t, hts, ht, ht'⟩ : ∃ t ⊆ s, t.Finite ∧ V ⊆ ⋃ i ∈ t, (basicOpen i).1 := by
obtain ⟨t, ht⟩ := hV'.elim_finite_subcover
(fun i : s ↦ (basicOpen i.1).1) (fun _ ↦ (basicOpen _).2)
(by simpa [← Set.compl_iInter, ← zeroLocus_iUnion₂ (κ := (· ∈ s)), ← hs])
exact ⟨t.map (Function.Embedding.subtype _), by simp, Finset.finite_toSet _, by simpa using ht⟩
replace ht' : V ⊆ (zeroLocus t)ᶜ := by
simpa [← Set.compl_iInter, ← zeroLocus_iUnion₂ (κ := (· ∈ t))] using ht'
have (i : _) : Ideal.span (Pi.evalRingHom (R ·) i '' t) = ⊤ := by
rw [← zeroLocus_empty_iff_eq_top, zeroLocus_span, ← preimage_comap_zeroLocus,
← Set.compl_univ_iff, ← Set.preimage_compl, Set.preimage_eq_univ_iff]
trans (Sigma.ι _ i ≫ sigmaSpec R).opensRange.1
· simp; rfl
· rw [Scheme.Hom.opensRange_comp]
exact (Set.image_subset_range _ _).trans (hV.trans ht')
have : Ideal.span s = ⊤ := top_le_iff.mp
((Ideal.span_eq_top_of_span_image_evalRingHom _ ht this).ge.trans (Ideal.span_mono hts))
simpa [← zeroLocus_span s, zeroLocus_empty_iff_eq_top.mpr this] using hs | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion"
] | Mathlib/AlgebraicGeometry/PointsPi.lean | eq_top_of_sigmaSpec_subset_of_isCompact | null |
eq_bot_of_comp_quotientMk_eq_sigmaSpec (I : Ideal (Π i, R i))
(f : (∐ fun i ↦ Spec (R i)) ⟶ Spec((Π i, R i) ⧸ I))
(hf : f ≫ Spec.map (CommRingCat.ofHom (Ideal.Quotient.mk I)) = sigmaSpec R) :
I = ⊥ := by
refine le_bot_iff.mp fun x hx ↦ ?_
ext i
simpa [← Category.assoc, Ideal.Quotient.eq_zero_iff_mem.mpr hx] using
congr((Spec.preimage (Sigma.ι (Spec <| R ·) i ≫ $hf)).hom x).symm | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion"
] | Mathlib/AlgebraicGeometry/PointsPi.lean | eq_bot_of_comp_quotientMk_eq_sigmaSpec | null |
isIso_of_comp_eq_sigmaSpec {V : Scheme}
(f : (∐ fun i ↦ Spec (R i)) ⟶ V) (g : V ⟶ Spec(Π i, R i))
[IsImmersion g] [CompactSpace V]
(hU' : f ≫ g = sigmaSpec R) : IsIso g := by
have : g.coborderRange = ⊤ := by
apply eq_top_of_sigmaSpec_subset_of_isCompact (hVU := subset_coborder)
· simpa only [← hU'] using Set.range_comp_subset_range f.base g.base
· exact isCompact_range g.base.hom.2
have : IsClosedImmersion g := by
have : IsIso g.coborderRange.ι := by rw [this, ← Scheme.topIso_hom]; infer_instance
rw [← g.liftCoborder_ι]
infer_instance
obtain ⟨I, e, rfl⟩ := IsClosedImmersion.Spec_iff.mp this
obtain rfl := eq_bot_of_comp_quotientMk_eq_sigmaSpec R I (f ≫ e.hom) (by rwa [Category.assoc])
convert_to IsIso (e.hom ≫ Spec.map (RingEquiv.quotientBot _).toCommRingCatIso.inv)
infer_instance
variable (X : Scheme) | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion"
] | Mathlib/AlgebraicGeometry/PointsPi.lean | isIso_of_comp_eq_sigmaSpec | If `V` is a locally closed subscheme of `Spec (Π Rᵢ)` containing `∐ Spec Rᵢ`, then
`V = Spec (Π Rᵢ)`. |
noncomputable
pointsPi : (Spec(Π i, R i) ⟶ X) → Π i, Spec (R i) ⟶ X :=
fun f i ↦ Spec.map (CommRingCat.ofHom (Pi.evalRingHom (R ·) i)) ≫ f | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion"
] | Mathlib/AlgebraicGeometry/PointsPi.lean | pointsPi | The canonical map `X(Π Rᵢ) ⟶ Π X(Rᵢ)`.
This is injective if `X` is quasi-separated, surjective if `X` is affine,
or if `X` is compact and each `Rᵢ` is local. |
pointsPi_injective [QuasiSeparatedSpace X] : Function.Injective (pointsPi R X) := by
rintro f g e
have := isIso_of_comp_eq_sigmaSpec R (V := equalizer f g)
(equalizer.lift (sigmaSpec R) (by ext1 i; simpa using congr_fun e i))
(equalizer.ι f g) (by simp)
rw [← cancel_epi (equalizer.ι f g), equalizer.condition] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion"
] | Mathlib/AlgebraicGeometry/PointsPi.lean | pointsPi_injective | null |
pointsPi_surjective_of_isAffine [IsAffine X] : Function.Surjective (pointsPi R X) := by
rintro f
refine ⟨Spec.map (CommRingCat.ofHom
(Pi.ringHom fun i ↦ (Spec.preimage (f i ≫ X.isoSpec.hom)).1)) ≫ X.isoSpec.inv, ?_⟩
ext i : 1
simp only [pointsPi, ← Spec.map_comp_assoc, Iso.comp_inv_eq]
exact Spec.map_preimage _ | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion"
] | Mathlib/AlgebraicGeometry/PointsPi.lean | pointsPi_surjective_of_isAffine | null |
pointsPi_surjective [CompactSpace X] [∀ i, IsLocalRing (R i)] :
Function.Surjective (pointsPi R X) := by
intro f
let 𝒰 : X.OpenCover := X.affineCover.finiteSubcover
have (i : _) : ∃ j, Set.range (f i).base ⊆ (𝒰.f j).opensRange := by
refine ⟨𝒰.idx ((f i).base (IsLocalRing.closedPoint (R i))), ?_⟩
rintro _ ⟨x, rfl⟩
exact ((IsLocalRing.specializes_closedPoint x).map (f i).base.hom.2).mem_open
(𝒰.f _).opensRange.2 (𝒰.covers _)
choose j hj using this
have (j₀ : _) := pointsPi_surjective_of_isAffine (ι := { i // j i = j₀ }) (R ·) (𝒰.X j₀)
(fun i ↦ IsOpenImmersion.lift (𝒰.f j₀) (f i.1) (by rcases i with ⟨i, rfl⟩; exact hj i))
choose g hg using this
simp_rw [funext_iff, pointsPi] at hg
let R' (j₀) := CommRingCat.of (Π i : { i // j i = j₀ }, R i)
let e : (Π i, R i) ≃+* Π j₀, R' j₀ :=
{ toFun f _ i := f i
invFun f i := f _ ⟨i, rfl⟩
right_inv _ := funext₂ fun j₀ i ↦ by rcases i with ⟨i, rfl⟩; rfl
map_mul' _ _ := rfl
map_add' _ _ := rfl }
refine ⟨Spec.map (CommRingCat.ofHom e.symm.toRingHom) ≫ inv (sigmaSpec R') ≫
Sigma.desc fun j₀ ↦ g j₀ ≫ 𝒰.f j₀, ?_⟩
ext i : 1
have : (Pi.evalRingHom (R ·) i).comp e.symm.toRingHom =
(Pi.evalRingHom _ ⟨i, rfl⟩).comp (Pi.evalRingHom (R' ·) (j i)) := rfl
rw [pointsPi, ← Spec.map_comp_assoc, ← CommRingCat.ofHom_comp, this, CommRingCat.ofHom_comp,
Spec.map_comp_assoc, ← ι_sigmaSpec R', Category.assoc, IsIso.hom_inv_id_assoc,
Sigma.ι_desc, ← Category.assoc, hg, IsOpenImmersion.lift_fac] | lemma | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.Morphisms.Immersion"
] | Mathlib/AlgebraicGeometry/PointsPi.lean | pointsPi_surjective | null |
IsReduced : Prop where
component_reduced : ∀ U, _root_.IsReduced Γ(X, U) := by infer_instance
attribute [instance] IsReduced.component_reduced | class | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.RingTheory.LocalProperties.Reduced"
] | Mathlib/AlgebraicGeometry/Properties.lean | IsReduced | A scheme `X` is reduced if all `𝒪ₓ(U)` are reduced. |
isReduced_of_isReduced_stalk [∀ x : X, _root_.IsReduced (X.presheaf.stalk x)] :
IsReduced X := by
refine ⟨fun U => ⟨fun s hs => ?_⟩⟩
apply Presheaf.section_ext X.sheaf U s 0
intro x hx
change (X.sheaf.presheaf.germ U x hx) s = (X.sheaf.presheaf.germ U x hx) 0
rw [RingHom.map_zero]
change X.presheaf.germ U x hx s = 0
exact (hs.map _).eq_zero | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.RingTheory.LocalProperties.Reduced"
] | Mathlib/AlgebraicGeometry/Properties.lean | isReduced_of_isReduced_stalk | null |
isReduced_stalk_of_isReduced [IsReduced X] (x : X) :
_root_.IsReduced (X.presheaf.stalk x) := by
constructor
rintro g ⟨n, e⟩
obtain ⟨U, hxU, s, (rfl : (X.presheaf.germ U x hxU) s = g)⟩ := X.presheaf.germ_exist x g
rw [← map_pow, ← map_zero (X.presheaf.germ _ x hxU).hom] at e
obtain ⟨V, hxV, iU, iV, (e' : (X.presheaf.map iU.op) (s ^ n) = (X.presheaf.map iV.op) 0)⟩ :=
X.presheaf.germ_eq x hxU hxU _ 0 e
rw [map_pow, map_zero] at e'
replace e' := (IsNilpotent.mk _ _ e').eq_zero (R := Γ(X, V))
rw [← X.presheaf.germ_res iU x hxV, CommRingCat.comp_apply, e', map_zero] | instance | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.RingTheory.LocalProperties.Reduced"
] | Mathlib/AlgebraicGeometry/Properties.lean | isReduced_stalk_of_isReduced | null |
isReduced_of_isOpenImmersion {X Y : Scheme} (f : X ⟶ Y) [H : IsOpenImmersion f]
[IsReduced Y] : IsReduced X := by
constructor
intro U
have : U = f ⁻¹ᵁ f ''ᵁ U := by
ext1; exact (Set.preimage_image_eq _ H.base_open.injective).symm
rw [this]
exact isReduced_of_injective (inv <| f.app (f ''ᵁ U)).hom
(asIso <| f.app (f ''ᵁ U) : Γ(Y, f ''ᵁ U) ≅ _).symm.commRingCatIsoToRingEquiv.injective | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.RingTheory.LocalProperties.Reduced"
] | Mathlib/AlgebraicGeometry/Properties.lean | isReduced_of_isOpenImmersion | null |
affine_isReduced_iff (R : CommRingCat) :
IsReduced (Spec R) ↔ _root_.IsReduced R := by
refine ⟨?_, fun h => inferInstance⟩
intro h
exact isReduced_of_injective (Scheme.ΓSpecIso R).inv.hom
(Scheme.ΓSpecIso R).symm.commRingCatIsoToRingEquiv.injective | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.RingTheory.LocalProperties.Reduced"
] | Mathlib/AlgebraicGeometry/Properties.lean | affine_isReduced_iff | null |
isReduced_of_isAffine_isReduced [IsAffine X] [_root_.IsReduced Γ(X, ⊤)] :
IsReduced X :=
isReduced_of_isOpenImmersion X.isoSpec.hom | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.RingTheory.LocalProperties.Reduced"
] | Mathlib/AlgebraicGeometry/Properties.lean | isReduced_of_isAffine_isReduced | null |
@[elab_as_elim]
reduce_to_affine_global (P : ∀ {X : Scheme} (_ : X.Opens), Prop)
{X : Scheme} (U : X.Opens)
(h₁ : ∀ (X : Scheme) (U : X.Opens),
(∀ x : U, ∃ (V : _) (_ : x.1 ∈ V) (_ : V ⟶ U), P V) → P U)
(h₂ : ∀ (X Y) (f : X ⟶ Y) [IsOpenImmersion f],
∃ (U : X.Opens) (V : Y.Opens), U = ⊤ ∧ V = f.opensRange ∧ (P U → P V))
(h₃ : ∀ R : CommRingCat, P (X := Spec R) ⊤) : P U := by
apply h₁
intro x
obtain ⟨_, ⟨j, rfl⟩, hx, i⟩ :=
X.affineBasisCover_is_basis.exists_subset_of_mem_open (SetLike.mem_coe.2 x.prop) U.isOpen
let U' : Opens _ := ⟨_, (X.affineBasisCover.map_prop j).base_open.isOpen_range⟩
let i' : U' ⟶ U := homOfLE i
refine ⟨U', hx, i', ?_⟩
obtain ⟨_, _, rfl, rfl, h₂'⟩ := h₂ _ _ (X.affineBasisCover.f j)
apply h₂'
apply h₃ | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.RingTheory.LocalProperties.Reduced"
] | Mathlib/AlgebraicGeometry/Properties.lean | reduce_to_affine_global | To show that a statement `P` holds for all open subsets of all schemes, it suffices to show that
1. In any scheme `X`, if `P` holds for an open cover of `U`, then `P` holds for `U`.
2. For an open immersion `f : X ⟶ Y`, if `P` holds for the entire space of `X`, then `P` holds for
the image of `f`.
3. `P` holds for the entire space of an affine scheme. |
reduce_to_affine_nbhd (P : ∀ (X : Scheme) (_ : X), Prop)
(h₁ : ∀ R x, P (Spec R) x)
(h₂ : ∀ {X Y} (f : X ⟶ Y) [IsOpenImmersion f] (x : X), P X x → P Y (f.base x)) :
∀ (X : Scheme) (x : X), P X x := by
intro X x
obtain ⟨y, e⟩ := X.affineCover.covers x
convert h₂ (X.affineCover.f (X.affineCover.idx x)) y _
· rw [e]
apply h₁ | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.RingTheory.LocalProperties.Reduced"
] | Mathlib/AlgebraicGeometry/Properties.lean | reduce_to_affine_nbhd | null |
eq_zero_of_basicOpen_eq_bot {X : Scheme} [hX : IsReduced X] {U : X.Opens}
(s : Γ(X, U)) (hs : X.basicOpen s = ⊥) : s = 0 := by
apply TopCat.Presheaf.section_ext X.sheaf U
intro x hx
change (X.sheaf.presheaf.germ U x hx) s = (X.sheaf.presheaf.germ U x hx) 0
rw [RingHom.map_zero]
induction U using reduce_to_affine_global generalizing hX with
| h₁ X U H =>
obtain ⟨V, hx, i, H⟩ := H ⟨x, hx⟩
specialize H (X.presheaf.map i.op s)
rw [Scheme.basicOpen_res, hs] at H
specialize H (inf_bot_eq _) x hx
rw [← X.sheaf.presheaf.germ_res_apply i x hx s]
exact H
| h₂ X Y f =>
refine ⟨f ⁻¹ᵁ f.opensRange, f.opensRange, by simp, rfl, ?_⟩
rintro H hX s hs _ ⟨x, rfl⟩
haveI := isReduced_of_isOpenImmersion f
specialize H (f.app _ s) _ x ⟨x, rfl⟩
· rw [← Scheme.preimage_basicOpen, hs]; ext1; simp [Opens.map]
· have H : (X.presheaf.germ _ x _).hom _ = 0 := H
rw [← Scheme.stalkMap_germ_apply f ⟨_, _⟩ x] at H
apply_fun inv <| f.stalkMap x at H
rw [← CommRingCat.comp_apply, CategoryTheory.IsIso.hom_inv_id, map_zero] at H
exact H
| h₃ R =>
rw [basicOpen_eq_of_affine', PrimeSpectrum.basicOpen_eq_bot_iff] at hs
replace hs := (hs.map (Scheme.ΓSpecIso R).inv.hom).eq_zero
rw [← CommRingCat.comp_apply, Iso.hom_inv_id, CommRingCat.id_apply] at hs
rw [hs, map_zero]
@[simp] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.RingTheory.LocalProperties.Reduced"
] | Mathlib/AlgebraicGeometry/Properties.lean | eq_zero_of_basicOpen_eq_bot | null |
basicOpen_eq_bot_iff {X : Scheme} [IsReduced X] {U : X.Opens}
(s : Γ(X, U)) : X.basicOpen s = ⊥ ↔ s = 0 := by
refine ⟨eq_zero_of_basicOpen_eq_bot s, ?_⟩
rintro rfl
simp | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.RingTheory.LocalProperties.Reduced"
] | Mathlib/AlgebraicGeometry/Properties.lean | basicOpen_eq_bot_iff | null |
IsIntegral : Prop where
nonempty : Nonempty X := by infer_instance
component_integral : ∀ (U : X.Opens) [Nonempty U], IsDomain Γ(X, U) := by infer_instance
attribute [instance] IsIntegral.component_integral IsIntegral.nonempty | class | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.RingTheory.LocalProperties.Reduced"
] | Mathlib/AlgebraicGeometry/Properties.lean | IsIntegral | A scheme `X` is integral if its is nonempty,
and `𝒪ₓ(U)` is an integral domain for each `U ≠ ∅`. |
Scheme.component_nontrivial (X : Scheme.{u}) (U : X.Opens) [Nonempty U] :
Nontrivial Γ(X, U) :=
LocallyRingedSpace.component_nontrivial (hU := ‹_›) | instance | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.RingTheory.LocalProperties.Reduced"
] | Mathlib/AlgebraicGeometry/Properties.lean | Scheme.component_nontrivial | null |
irreducibleSpace_of_isIntegral [IsIntegral X] : IrreducibleSpace X := by
by_contra H
replace H : ¬IsPreirreducible (⊤ : Set X) := fun h =>
H { toPreirreducibleSpace := ⟨h⟩
toNonempty := inferInstance }
simp_rw [isPreirreducible_iff_isClosed_union_isClosed, not_forall, not_or] at H
rcases H with ⟨S, T, hS, hT, h₁, h₂, h₃⟩
rw [Set.not_top_subset] at h₂ h₃
haveI : Nonempty (⟨Sᶜ, hS.1⟩ : X.Opens) := ⟨⟨_, h₂.choose_spec⟩⟩
haveI : Nonempty (⟨Tᶜ, hT.1⟩ : X.Opens) := ⟨⟨_, h₃.choose_spec⟩⟩
haveI : Nonempty (⟨Sᶜ, hS.1⟩ ⊔ ⟨Tᶜ, hT.1⟩ : X.Opens) := ⟨⟨_, Or.inl h₂.choose_spec⟩⟩
let e : Γ(X, _) ≅ CommRingCat.of _ :=
(X.sheaf.isProductOfDisjoint ⟨_, hS.1⟩ ⟨_, hT.1⟩ ?_).conePointUniqueUpToIso
(CommRingCat.prodFanIsLimit _ _)
· have : IsDomain (Γ(X, ⟨Sᶜ, hS.1⟩) × Γ(X, ⟨Tᶜ, hT.1⟩)) :=
e.symm.commRingCatIsoToRingEquiv.toMulEquiv.isDomain _
exact false_of_nontrivial_of_product_domain Γ(X, ⟨Sᶜ, hS.1⟩) Γ(X, ⟨Tᶜ, hT.1⟩)
· ext x
constructor
· rintro ⟨hS, hT⟩
rcases h₁ (show x ∈ ⊤ by trivial) with h | h
exacts [hS h, hT h]
· simp | instance | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.RingTheory.LocalProperties.Reduced"
] | Mathlib/AlgebraicGeometry/Properties.lean | irreducibleSpace_of_isIntegral | null |
isIntegral_of_irreducibleSpace_of_isReduced [IsReduced X] [H : IrreducibleSpace X] :
IsIntegral X := by
constructor; · infer_instance
intro U hU
haveI := (@LocallyRingedSpace.component_nontrivial X.toLocallyRingedSpace U hU).1
have : NoZeroDivisors
(X.toLocallyRingedSpace.toSheafedSpace.toPresheafedSpace.presheaf.obj (op U)) := by
refine ⟨fun {a b} e => ?_⟩
simp_rw [← basicOpen_eq_bot_iff, ← Opens.not_nonempty_iff_eq_bot]
by_contra! h
obtain ⟨x, ⟨hxU, hx₁⟩, _, hx₂⟩ :=
nonempty_preirreducible_inter (X.basicOpen a).2 (X.basicOpen b).2 h.1 h.2
replace e := congr_arg (X.presheaf.germ U x hxU) e
rw [RingHom.map_mul, RingHom.map_zero] at e
refine zero_ne_one' (X.presheaf.stalk x) (isUnit_zero_iff.1 ?_)
convert hx₁.mul hx₂
exact e.symm
exact NoZeroDivisors.to_isDomain _ | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.RingTheory.LocalProperties.Reduced"
] | Mathlib/AlgebraicGeometry/Properties.lean | isIntegral_of_irreducibleSpace_of_isReduced | null |
isIntegral_iff_irreducibleSpace_and_isReduced :
IsIntegral X ↔ IrreducibleSpace X ∧ IsReduced X :=
⟨fun _ => ⟨inferInstance, inferInstance⟩, fun ⟨_, _⟩ =>
isIntegral_of_irreducibleSpace_of_isReduced X⟩ | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.RingTheory.LocalProperties.Reduced"
] | Mathlib/AlgebraicGeometry/Properties.lean | isIntegral_iff_irreducibleSpace_and_isReduced | null |
isIntegral_of_isOpenImmersion {X Y : Scheme} (f : X ⟶ Y) [H : IsOpenImmersion f]
[IsIntegral Y] [Nonempty X] : IsIntegral X := by
constructor; · infer_instance
intro U hU
have : U = f ⁻¹ᵁ f ''ᵁ U := by ext1; exact (Set.preimage_image_eq _ H.base_open.injective).symm
rw [this]
have : IsDomain Γ(Y, f ''ᵁ U) := by
apply (config := { allowSynthFailures := true }) IsIntegral.component_integral
exact ⟨⟨_, _, hU.some.prop, rfl⟩⟩
exact (asIso <| f.app (f ''ᵁ U) :
Γ(Y, f ''ᵁ U) ≅ _).symm.commRingCatIsoToRingEquiv.toMulEquiv.isDomain _ | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.RingTheory.LocalProperties.Reduced"
] | Mathlib/AlgebraicGeometry/Properties.lean | isIntegral_of_isOpenImmersion | null |
affine_isIntegral_iff (R : CommRingCat) :
IsIntegral (Spec R) ↔ IsDomain R :=
⟨fun _ => MulEquiv.isDomain Γ(Spec R, ⊤)
(Scheme.ΓSpecIso R).symm.commRingCatIsoToRingEquiv.toMulEquiv, fun _ => inferInstance⟩ | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.RingTheory.LocalProperties.Reduced"
] | Mathlib/AlgebraicGeometry/Properties.lean | affine_isIntegral_iff | null |
isIntegral_of_isAffine_of_isDomain [IsAffine X] [Nonempty X] [IsDomain Γ(X, ⊤)] :
IsIntegral X :=
isIntegral_of_isOpenImmersion X.isoSpec.hom | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.RingTheory.LocalProperties.Reduced"
] | Mathlib/AlgebraicGeometry/Properties.lean | isIntegral_of_isAffine_of_isDomain | null |
map_injective_of_isIntegral [IsIntegral X] {U V : X.Opens} (i : U ⟶ V)
[H : Nonempty U] : Function.Injective (X.presheaf.map i.op) := by
rw [injective_iff_map_eq_zero]
intro x hx
rw [← basicOpen_eq_bot_iff] at hx ⊢
rw [Scheme.basicOpen_res] at hx
revert hx
contrapose!
simp_rw [Ne, ← Opens.not_nonempty_iff_eq_bot, Classical.not_not]
apply nonempty_preirreducible_inter U.isOpen (RingedSpace.basicOpen _ _).isOpen
simpa using H | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.RingTheory.LocalProperties.Reduced"
] | Mathlib/AlgebraicGeometry/Properties.lean | map_injective_of_isIntegral | null |
Triplet {X Y S : Scheme.{u}} (f : X ⟶ S) (g : Y ⟶ S) where
/-- The point of `X`. -/
x : X
/-- The point of `Y`. -/
y : Y
/-- The point of `S` below `x` and `y`. -/
s : S
hx : f.base x = s
hy : g.base y = s
variable {X Y S : Scheme.{u}} {f : X ⟶ S} {g : Y ⟶ S} | structure | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | Triplet | A `Triplet` over `f : X ⟶ S` and `g : Y ⟶ S` is a triple of points `x : X`, `y : Y`,
`s : S` such that `f x = s = f y`. |
@[ext]
protected ext {t₁ t₂ : Triplet f g} (ex : t₁.x = t₂.x) (ey : t₁.y = t₂.y) : t₁ = t₂ := by
cases t₁; cases t₂; simp; aesop | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | ext | null |
@[simps]
mk' (x : X) (y : Y) (h : f.base x = g.base y) : Triplet f g where
x := x
y := y
s := g.base y
hx := h
hy := rfl | def | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | mk' | Make a triplet from `x : X` and `y : Y` such that `f x = g y`. |
tensor (T : Triplet f g) : CommRingCat :=
pushout ((S.residueFieldCongr T.hx).inv ≫ f.residueFieldMap T.x)
((S.residueFieldCongr T.hy).inv ≫ g.residueFieldMap T.y) | def | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | tensor | Given `x : X` and `y : Y` such that `f x = s = g y`, this is `κ(x) ⊗[κ(s)] κ(y)`. |
tensorInl (T : Triplet f g) : X.residueField T.x ⟶ T.tensor := pushout.inl _ _ | def | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | tensorInl | Given `x : X` and `y : Y` such that `f x = s = g y`, this is the
canonical map `κ(x) ⟶ κ(x) ⊗[κ(s)] κ(y)`. |
tensorInr (T : Triplet f g) : Y.residueField T.y ⟶ T.tensor := pushout.inr _ _ | def | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | tensorInr | Given `x : X` and `y : Y` such that `f x = s = g y`, this is the
canonical map `κ(y) ⟶ κ(x) ⊗[κ(s)] κ(y)`. |
Spec_map_tensor_isPullback (T : Triplet f g) : CategoryTheory.IsPullback
(Spec.map T.tensorInl) (Spec.map T.tensorInr)
(Spec.map ((S.residueFieldCongr T.hx).inv ≫ f.residueFieldMap T.x))
(Spec.map ((S.residueFieldCongr T.hy).inv ≫ g.residueFieldMap T.y)) :=
isPullback_Spec_map_pushout _ _ | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | Spec_map_tensor_isPullback | null |
tensorCongr {T₁ T₂ : Triplet f g} (e : T₁ = T₂) :
T₁.tensor ≅ T₂.tensor :=
eqToIso (by subst e; rfl)
@[simp] | def | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | tensorCongr | Given propositionally equal triplets `T₁` and `T₂` over `f` and `g`, the corresponding
`T₁.tensor` and `T₂.tensor` are isomorphic. |
tensorCongr_refl {x : Triplet f g} :
tensorCongr (refl x) = Iso.refl _ := rfl
@[simp] | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | tensorCongr_refl | null |
tensorCongr_symm {x y : Triplet f g} (e : x = y) :
(tensorCongr e).symm = tensorCongr e.symm := rfl
@[simp] | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | tensorCongr_symm | null |
tensorCongr_inv {x y : Triplet f g} (e : x = y) :
(tensorCongr e).inv = (tensorCongr e.symm).hom := rfl
@[simp] | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | tensorCongr_inv | null |
tensorCongr_trans {x y z : Triplet f g} (e : x = y) (e' : y = z) :
tensorCongr e ≪≫ tensorCongr e' =
tensorCongr (e.trans e') := by
subst e e'
rfl
@[reassoc (attr := simp)] | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | tensorCongr_trans | null |
tensorCongr_trans_hom {x y z : Triplet f g} (e : x = y) (e' : y = z) :
(tensorCongr e).hom ≫ (tensorCongr e').hom =
(tensorCongr (e.trans e')).hom := by
subst e e'
rfl | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | tensorCongr_trans_hom | null |
Spec_map_tensorInl_fromSpecResidueField :
(Spec.map T.tensorInl ≫ X.fromSpecResidueField T.x) ≫ f =
(Spec.map T.tensorInr ≫ Y.fromSpecResidueField T.y) ≫ g := by
simp only [residueFieldCongr_inv, Category.assoc, tensorInl, tensorInr,
← Hom.Spec_map_residueFieldMap_fromSpecResidueField]
rw [← residueFieldCongr_fromSpecResidueField T.hx.symm,
← residueFieldCongr_fromSpecResidueField T.hy.symm]
simp only [← Category.assoc, ← Spec.map_comp, pushout.condition] | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | Spec_map_tensorInl_fromSpecResidueField | null |
SpecTensorTo : Spec T.tensor ⟶ pullback f g :=
pullback.lift (Spec.map T.tensorInl ≫ X.fromSpecResidueField T.x)
(Spec.map T.tensorInr ≫ Y.fromSpecResidueField T.y)
(Spec_map_tensorInl_fromSpecResidueField _)
@[simp] | def | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | SpecTensorTo | Given `x : X`, `y : Y` and `s : S` such that `f x = s = g y`,
this is `Spec (κ(x) ⊗[κ(s)] κ(y)) ⟶ X ×ₛ Y`. |
specTensorTo_base_fst (p : Spec T.tensor) :
(pullback.fst f g).base (T.SpecTensorTo.base p) = T.x := by
simp only [SpecTensorTo]
rw [← Scheme.comp_base_apply]
simp
@[simp] | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | specTensorTo_base_fst | null |
specTensorTo_base_snd (p : Spec T.tensor) :
(pullback.snd f g).base (T.SpecTensorTo.base p) = T.y := by
simp only [SpecTensorTo]
rw [← Scheme.comp_base_apply]
simp
@[reassoc (attr := simp)] | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | specTensorTo_base_snd | null |
specTensorTo_fst :
T.SpecTensorTo ≫ pullback.fst f g = Spec.map T.tensorInl ≫ X.fromSpecResidueField T.x :=
pullback.lift_fst _ _ _
@[reassoc (attr := simp)] | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | specTensorTo_fst | null |
specTensorTo_snd :
T.SpecTensorTo ≫ pullback.snd f g = Spec.map T.tensorInr ≫ Y.fromSpecResidueField T.y :=
pullback.lift_snd _ _ _ | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | specTensorTo_snd | null |
@[simps]
ofPoint (t : ↑(pullback f g)) : Triplet f g :=
⟨(pullback.fst f g).base t, (pullback.snd f g).base t, _, rfl,
congr((Scheme.Hom.toLRSHom $(pullback.condition (f := f) (g := g))).base t).symm⟩
@[simp] | def | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | ofPoint | Given `t : X ×[S] Y`, it maps to `X` and `Y` with same image in `S`, yielding a
`Triplet f g`. |
ofPoint_SpecTensorTo (T : Triplet f g) (p : Spec T.tensor) :
ofPoint (T.SpecTensorTo.base p) = T := by
ext <;> simp | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | ofPoint_SpecTensorTo | null |
residueFieldCongr_inv_residueFieldMap_ofPoint (t : ↑(pullback f g)) :
((S.residueFieldCongr (Triplet.ofPoint t).hx).inv ≫ f.residueFieldMap (Triplet.ofPoint t).x) ≫
(pullback.fst f g).residueFieldMap t = ((S.residueFieldCongr (Triplet.ofPoint t).hy).inv ≫
g.residueFieldMap (Triplet.ofPoint t).y) ≫ (pullback.snd f g).residueFieldMap t := by
simp [← residueFieldMap_comp, Scheme.Hom.residueFieldMap_congr pullback.condition] | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | residueFieldCongr_inv_residueFieldMap_ofPoint | null |
ofPointTensor (t : ↑(pullback f g)) :
(Triplet.ofPoint t).tensor ⟶ (pullback f g).residueField t :=
pushout.desc
((pullback.fst f g).residueFieldMap t)
((pullback.snd f g).residueFieldMap t)
(residueFieldCongr_inv_residueFieldMap_ofPoint t)
@[reassoc] | def | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | ofPointTensor | Given `t : X ×[S] Y` with projections to `X`, `Y` and `S` denoted by `x`, `y` and `s`
respectively, this is the canonical map `κ(x) ⊗[κ(s)] κ(y) ⟶ κ(t)`. |
ofPointTensor_SpecTensorTo (t : ↑(pullback f g)) :
Spec.map (ofPointTensor t) ≫ (Triplet.ofPoint t).SpecTensorTo =
(pullback f g).fromSpecResidueField t := by
apply pullback.hom_ext
· rw [← Scheme.Hom.Spec_map_residueFieldMap_fromSpecResidueField]
simp only [Category.assoc, Triplet.specTensorTo_fst, Triplet.ofPoint_x]
rw [← pushout.inl_desc _ _ (residueFieldCongr_inv_residueFieldMap_ofPoint t), Spec.map_comp]
rfl
· rw [← Scheme.Hom.Spec_map_residueFieldMap_fromSpecResidueField]
simp only [Category.assoc, Triplet.specTensorTo_snd, Triplet.ofPoint_y]
rw [← pushout.inr_desc _ _ (residueFieldCongr_inv_residueFieldMap_ofPoint t), Spec.map_comp]
rfl | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | ofPointTensor_SpecTensorTo | null |
SpecOfPoint (t : ↑(pullback f g)) : Spec (Triplet.ofPoint t).tensor :=
(Spec.map (ofPointTensor t)).base (⊥ : PrimeSpectrum _)
@[simp] | def | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | SpecOfPoint | If `t` is a point in `X ×[S] Y` above `(x, y, s)`, then this is the image of the unique
point of `Spec κ(s)` in `Spec κ(x) ⊗[κ(s)] κ(y)`. |
SpecTensorTo_SpecOfPoint (t : ↑(pullback f g)) :
(Triplet.ofPoint t).SpecTensorTo.base (SpecOfPoint t) = t := by
simp [SpecOfPoint, ← Scheme.comp_base_apply, ofPointTensor_SpecTensorTo]
@[reassoc (attr := simp)] | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | SpecTensorTo_SpecOfPoint | null |
tensorCongr_SpecTensorTo {T T' : Triplet f g} (h : T = T') :
Spec.map (Triplet.tensorCongr h).hom ≫ T.SpecTensorTo = T'.SpecTensorTo := by
subst h
simp only [Triplet.tensorCongr_refl, Iso.refl_hom, Spec.map_id, Category.id_comp] | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | tensorCongr_SpecTensorTo | null |
Triplet.Spec_ofPointTensor_SpecTensorTo (T : Triplet f g) (p : Spec T.tensor) :
Spec.map (Hom.residueFieldMap T.SpecTensorTo p) ≫
Spec.map (ofPointTensor (T.SpecTensorTo.base p)) ≫
Spec.map (tensorCongr (T.ofPoint_SpecTensorTo p).symm).hom =
(Spec T.tensor).fromSpecResidueField p := by
apply T.Spec_map_tensor_isPullback.hom_ext
· rw [← cancel_mono <| X.fromSpecResidueField T.x]
simp_rw [Category.assoc, ← T.specTensorTo_fst, tensorCongr_SpecTensorTo_assoc]
rw [← Hom.Spec_map_residueFieldMap_fromSpecResidueField_assoc, ofPointTensor_SpecTensorTo_assoc]
· rw [← cancel_mono <| Y.fromSpecResidueField T.y]
simp_rw [Category.assoc, ← T.specTensorTo_snd, tensorCongr_SpecTensorTo_assoc]
rw [← Hom.Spec_map_residueFieldMap_fromSpecResidueField_assoc, ofPointTensor_SpecTensorTo_assoc] | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | Triplet.Spec_ofPointTensor_SpecTensorTo | null |
carrierEquiv_eq_iff {T₁ T₂ : Σ T : Triplet f g, Spec T.tensor} :
T₁ = T₂ ↔ ∃ e : T₁.1 = T₂.1, (Spec.map (Triplet.tensorCongr e).inv).base T₁.2 = T₂.2 := by
constructor
· rintro rfl
simp
· obtain ⟨T, _⟩ := T₁
obtain ⟨T', _⟩ := T₂
rintro ⟨rfl : T = T', e⟩
simpa [e] | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | carrierEquiv_eq_iff | A helper lemma to work with `AlgebraicGeometry.Scheme.Pullback.carrierEquiv`. |
carrierEquiv : ↑(pullback f g) ≃ Σ T : Triplet f g, Spec T.tensor where
toFun t := ⟨.ofPoint t, SpecOfPoint t⟩
invFun T := T.1.SpecTensorTo.base T.2
left_inv := SpecTensorTo_SpecOfPoint
right_inv := by
intro ⟨T, p⟩
apply carrierEquiv_eq_iff.mpr
use T.ofPoint_SpecTensorTo p
have : (Spec.map (Hom.residueFieldMap T.SpecTensorTo p)).base (⊥ : PrimeSpectrum _) =
(⊥ : PrimeSpectrum _) :=
(PrimeSpectrum.instUnique).uniq _
simp only [SpecOfPoint, Triplet.tensorCongr_inv, ← this, ← Scheme.comp_base_apply,
← Scheme.comp_base_apply]
simp [Triplet.Spec_ofPointTensor_SpecTensorTo]
@[simp] | def | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | carrierEquiv | The points of the underlying topological space of `X ×[S] Y` bijectively correspond to
pairs of triples `x : X`, `y : Y`, `s : S` with `f x = s = f y` and prime ideals of
`κ(x) ⊗[κ(s)] κ(y)`. |
carrierEquiv_symm_fst (T : Triplet f g) (p : Spec T.tensor) :
(pullback.fst f g).base (carrierEquiv.symm ⟨T, p⟩) = T.x := by
simp [carrierEquiv]
@[simp] | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | carrierEquiv_symm_fst | null |
carrierEquiv_symm_snd (T : Triplet f g) (p : Spec T.tensor) :
(pullback.snd f g).base (carrierEquiv.symm ⟨T, p⟩) = T.y := by
simp [carrierEquiv] | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | carrierEquiv_symm_snd | null |
Triplet.exists_preimage (T : Triplet f g) :
∃ t : ↑(pullback f g),
(pullback.fst f g).base t = T.x ∧ (pullback.snd f g).base t = T.y :=
⟨carrierEquiv.symm ⟨T, Nonempty.some inferInstance⟩, by simp⟩ | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | Triplet.exists_preimage | Given a triple `(x, y, s)` with `f x = s = f y` there exists `t : X ×[S] Y` above
`x` and `ỳ`. For the unpacked version without `Triplet`, see
`AlgebraicGeometry.Scheme.Pullback.exists_preimage`. |
exists_preimage_pullback (x : X) (y : Y) (h : f.base x = g.base y) :
∃ z : ↑(pullback f g),
(pullback.fst f g).base z = x ∧ (pullback.snd f g).base z = y :=
(Pullback.Triplet.mk' x y h).exists_preimage | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | exists_preimage_pullback | If `f : X ⟶ S` and `g : Y ⟶ S` are morphisms of schemes and `x : X` and `y : Y` are points such
that `f x = g y`, then there exists `z : X ×[S] Y` lying above `x` and `y`.
In other words, the map from the underlying topological space of `X ×[S] Y` to the fiber product
of the underlying topological spaces of `X` and `Y` over `S` is surjective. |
forget_comparison_surjective {X Y S : Scheme.{u}} (f : X ⟶ S) (g : Y ⟶ S) :
Function.Surjective (pullbackComparison forget f g) := by
apply (Function.Surjective.of_comp_iff'
((PullbackCone.IsLimit.equivPullbackObj (pullbackIsPullback _ _)).bijective) _).mp
intro ⟨⟨x, y⟩, hb⟩
obtain ⟨z, ⟨hz, hz'⟩⟩ := exists_preimage_pullback x y hb
use z
ext
· exact hz.symm ▸ congrFun (pullbackComparison_comp_fst forget f g) z
· exact hz'.symm ▸ congrFun (pullbackComparison_comp_snd forget f g) z | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | forget_comparison_surjective | The comparison map for pullbacks under the forgetful functor `Scheme ⥤ Type u` is surjective. |
_root_.AlgebraicGeometry.Scheme.isEmpty_pullback_iff {f : X ⟶ S} {g : Y ⟶ S} :
IsEmpty ↑(Limits.pullback f g) ↔ Disjoint (Set.range f.base) (Set.range g.base) := by
refine ⟨?_, Scheme.isEmpty_pullback f g⟩
rw [Set.disjoint_iff_forall_ne]
contrapose!
rintro ⟨_, ⟨x, rfl⟩, _, ⟨y, rfl⟩, e⟩
obtain ⟨z, -⟩ := exists_preimage_pullback x y e
exact ⟨z⟩
variable (f g) | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | _root_.AlgebraicGeometry.Scheme.isEmpty_pullback_iff | null |
range_fst : Set.range (pullback.fst f g).base = f.base ⁻¹' Set.range g.base := by
ext x
refine ⟨?_, fun ⟨y, hy⟩ ↦ ?_⟩
· rintro ⟨a, rfl⟩
simp only [Set.mem_preimage, Set.mem_range, ← Scheme.comp_base_apply, pullback.condition]
simp
· obtain ⟨a, ha⟩ := Triplet.exists_preimage (Triplet.mk' x y hy.symm)
use a, ha.left | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | range_fst | null |
range_snd : Set.range (pullback.snd f g).base = g.base ⁻¹' Set.range f.base := by
ext x
refine ⟨?_, fun ⟨y, hy⟩ ↦ ?_⟩
· rintro ⟨a, rfl⟩
simp only [Set.mem_preimage, Set.mem_range, ← Scheme.comp_base_apply, ← pullback.condition]
simp
· obtain ⟨a, ha⟩ := Triplet.exists_preimage (Triplet.mk' y x hy)
use a, ha.right | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | range_snd | null |
range_fst_comp :
Set.range (pullback.fst f g ≫ f).base = Set.range f.base ∩ Set.range g.base := by
simp [Set.range_comp, range_fst, Set.image_preimage_eq_range_inter] | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | range_fst_comp | null |
range_snd_comp :
Set.range (pullback.snd f g ≫ g).base = Set.range f.base ∩ Set.range g.base := by
rw [← pullback.condition, range_fst_comp] | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | range_snd_comp | null |
range_map {X' Y' S' : Scheme.{u}} (f' : X' ⟶ S') (g' : Y' ⟶ S') (i₁ : X ⟶ X')
(i₂ : Y ⟶ Y') (i₃ : S ⟶ S') (e₁ : f ≫ i₃ = i₁ ≫ f')
(e₂ : g ≫ i₃ = i₂ ≫ g') [Mono i₃] :
Set.range (pullback.map f g f' g' i₁ i₂ i₃ e₁ e₂).base =
(pullback.fst f' g').base ⁻¹' Set.range i₁.base ∩
(pullback.snd f' g').base ⁻¹' Set.range i₂.base := by
ext z
constructor
· rintro ⟨t, rfl⟩
constructor
· use (pullback.fst f g).base t
rw [← Scheme.comp_base_apply, ← Scheme.comp_base_apply]
simp
· use (pullback.snd f g).base t
rw [← Scheme.comp_base_apply, ← Scheme.comp_base_apply]
simp
· intro ⟨⟨x, hx⟩, ⟨y, hy⟩⟩
let T₁ : Triplet (pullback.fst f' g') i₁ := Triplet.mk' z x hx.symm
obtain ⟨w₁, hw₁⟩ := T₁.exists_preimage
let T₂ : Triplet (pullback.snd f' g') i₂ := Triplet.mk' z y hy.symm
obtain ⟨w₂, hw₂⟩ := T₂.exists_preimage
let T : Triplet (pullback.fst (pullback.fst f' g') i₁) (pullback.fst (pullback.snd f' g') i₂) :=
Triplet.mk' w₁ w₂ <| by simp [hw₁.left, hw₂.left, T₁, T₂]
obtain ⟨t, _, ht₂⟩ := T.exists_preimage
use (pullbackFstFstIso f g f' g' i₁ i₂ i₃ e₁ e₂).hom.base t
rw [pullback_map_eq_pullbackFstFstIso_inv, ← Scheme.comp_base_apply, Iso.hom_inv_id_assoc]
simp [ht₂, T, hw₂.left, T₂] | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | range_map | null |
isJointlySurjectivePreserving (P : MorphismProperty Scheme.{u}) :
IsJointlySurjectivePreserving P where
exists_preimage_fst_triplet_of_prop {X Y S} f g _ hg x y hxy := by
obtain ⟨a, b, h⟩ := Pullback.exists_preimage_pullback x y hxy
use a | instance | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | isJointlySurjectivePreserving | null |
pullbackComparison_forget_surjective {X Y S : Scheme.{u}} (f : X ⟶ S) (g : Y ⟶ S) :
Function.Surjective (pullbackComparison forget f g) := by
refine .of_comp_left (fun x ↦ ?_) <|
injective_of_mono (Types.pullbackIsoPullback (forget.map f) (forget.map g)).hom
obtain ⟨z, h1, h2⟩ := Pullback.exists_preimage_pullback (f := f) (g := g) x.1.1 x.1.2 x.2
use z
ext
· simp only [Function.comp_apply, Types.pullbackIsoPullback_hom_fst]
rwa [← types_comp_apply (g := pullback.fst _ _), pullbackComparison_comp_fst]
· simp only [Function.comp_apply, Types.pullbackIsoPullback_hom_snd]
rwa [← types_comp_apply (g := pullback.snd _ _), pullbackComparison_comp_snd] | lemma | AlgebraicGeometry | [
"Mathlib.Algebra.Category.Ring.LinearAlgebra",
"Mathlib.AlgebraicGeometry.ResidueField"
] | Mathlib/AlgebraicGeometry/PullbackCarrier.lean | pullbackComparison_forget_surjective | null |
v (i j : 𝒰.I₀) : Scheme :=
pullback ((pullback.fst (𝒰.f i ≫ f) g) ≫ 𝒰.f i) (𝒰.f j) | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.CategoryTheory.Limits.Opposites",
"Mathlib.CategoryTheory.Limits.Shapes.Diagonal",
"Mathlib.CategoryTheory.Monoidal.Cartesian.Over"
] | Mathlib/AlgebraicGeometry/Pullbacks.lean | v | The intersection of `Uᵢ ×[Z] Y` and `Uⱼ ×[Z] Y` is given by (Uᵢ ×[Z] Y) ×[X] Uⱼ |
t (i j : 𝒰.I₀) : v 𝒰 f g i j ⟶ v 𝒰 f g j i := by
have : HasPullback (pullback.snd _ _ ≫ 𝒰.f i ≫ f) g :=
hasPullback_assoc_symm (𝒰.f j) (𝒰.f i) (𝒰.f i ≫ f) g
have : HasPullback (pullback.snd _ _ ≫ 𝒰.f j ≫ f) g :=
hasPullback_assoc_symm (𝒰.f i) (𝒰.f j) (𝒰.f j ≫ f) g
refine (pullbackSymmetry ..).hom ≫ (pullbackAssoc ..).inv ≫ ?_
refine ?_ ≫ (pullbackAssoc ..).hom ≫ (pullbackSymmetry ..).hom
refine pullback.map _ _ _ _ (pullbackSymmetry _ _).hom (𝟙 _) (𝟙 _) ?_ ?_
· rw [pullbackSymmetry_hom_comp_snd_assoc, pullback.condition_assoc, Category.comp_id]
· rw [Category.comp_id, Category.id_comp]
@[simp, reassoc] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.CategoryTheory.Limits.Opposites",
"Mathlib.CategoryTheory.Limits.Shapes.Diagonal",
"Mathlib.CategoryTheory.Monoidal.Cartesian.Over"
] | Mathlib/AlgebraicGeometry/Pullbacks.lean | t | The canonical transition map `(Uᵢ ×[Z] Y) ×[X] Uⱼ ⟶ (Uⱼ ×[Z] Y) ×[X] Uᵢ` given by the fact
that pullbacks are associative and symmetric. |
t_fst_fst (i j : 𝒰.I₀) : t 𝒰 f g i j ≫ pullback.fst _ _ ≫ pullback.fst _ _ =
pullback.snd _ _ := by
simp only [t, Category.assoc, pullbackSymmetry_hom_comp_fst_assoc, pullbackAssoc_hom_snd_fst,
pullback.lift_fst_assoc, pullbackSymmetry_hom_comp_snd, pullbackAssoc_inv_fst_fst,
pullbackSymmetry_hom_comp_fst]
@[simp, reassoc] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.CategoryTheory.Limits.Opposites",
"Mathlib.CategoryTheory.Limits.Shapes.Diagonal",
"Mathlib.CategoryTheory.Monoidal.Cartesian.Over"
] | Mathlib/AlgebraicGeometry/Pullbacks.lean | t_fst_fst | null |
t_fst_snd (i j : 𝒰.I₀) :
t 𝒰 f g i j ≫ pullback.fst _ _ ≫ pullback.snd _ _ = pullback.fst _ _ ≫ pullback.snd _ _ := by
simp only [t, Category.assoc, pullbackSymmetry_hom_comp_fst_assoc, pullbackAssoc_hom_snd_snd,
pullback.lift_snd, Category.comp_id, pullbackAssoc_inv_snd, pullbackSymmetry_hom_comp_snd_assoc]
@[simp, reassoc] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.CategoryTheory.Limits.Opposites",
"Mathlib.CategoryTheory.Limits.Shapes.Diagonal",
"Mathlib.CategoryTheory.Monoidal.Cartesian.Over"
] | Mathlib/AlgebraicGeometry/Pullbacks.lean | t_fst_snd | null |
t_snd (i j : 𝒰.I₀) : t 𝒰 f g i j ≫ pullback.snd _ _ =
pullback.fst _ _ ≫ pullback.fst _ _ := by
simp only [t, Category.assoc, pullbackSymmetry_hom_comp_snd, pullbackAssoc_hom_fst,
pullback.lift_fst_assoc, pullbackSymmetry_hom_comp_fst, pullbackAssoc_inv_fst_snd,
pullbackSymmetry_hom_comp_snd_assoc] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.CategoryTheory.Limits.Opposites",
"Mathlib.CategoryTheory.Limits.Shapes.Diagonal",
"Mathlib.CategoryTheory.Monoidal.Cartesian.Over"
] | Mathlib/AlgebraicGeometry/Pullbacks.lean | t_snd | null |
t_id (i : 𝒰.I₀) : t 𝒰 f g i i = 𝟙 _ := by
apply pullback.hom_ext <;> rw [Category.id_comp]
· apply pullback.hom_ext
· rw [← cancel_mono (𝒰.f i)]; simp only [pullback.condition, Category.assoc, t_fst_fst]
· simp only [Category.assoc, t_fst_snd]
· rw [← cancel_mono (𝒰.f i)]; simp only [pullback.condition, t_snd, Category.assoc] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.CategoryTheory.Limits.Opposites",
"Mathlib.CategoryTheory.Limits.Shapes.Diagonal",
"Mathlib.CategoryTheory.Monoidal.Cartesian.Over"
] | Mathlib/AlgebraicGeometry/Pullbacks.lean | t_id | null |
fV (i j : 𝒰.I₀) : v 𝒰 f g i j ⟶ pullback (𝒰.f i ≫ f) g :=
pullback.fst _ _ | abbrev | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.CategoryTheory.Limits.Opposites",
"Mathlib.CategoryTheory.Limits.Shapes.Diagonal",
"Mathlib.CategoryTheory.Monoidal.Cartesian.Over"
] | Mathlib/AlgebraicGeometry/Pullbacks.lean | fV | The inclusion map of `V i j = (Uᵢ ×[Z] Y) ×[X] Uⱼ ⟶ Uᵢ ×[Z] Y` |
t' (i j k : 𝒰.I₀) :
pullback (fV 𝒰 f g i j) (fV 𝒰 f g i k) ⟶ pullback (fV 𝒰 f g j k) (fV 𝒰 f g j i) := by
refine (pullbackRightPullbackFstIso ..).hom ≫ ?_
refine ?_ ≫ (pullbackSymmetry _ _).hom
refine ?_ ≫ (pullbackRightPullbackFstIso ..).inv
refine pullback.map _ _ _ _ (t 𝒰 f g i j) (𝟙 _) (𝟙 _) ?_ ?_
· simp_rw [Category.comp_id, t_fst_fst_assoc, ← pullback.condition]
· rw [Category.comp_id, Category.id_comp]
@[simp, reassoc] | def | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.CategoryTheory.Limits.Opposites",
"Mathlib.CategoryTheory.Limits.Shapes.Diagonal",
"Mathlib.CategoryTheory.Monoidal.Cartesian.Over"
] | Mathlib/AlgebraicGeometry/Pullbacks.lean | t' | The map `((Xᵢ ×[Z] Y) ×[X] Xⱼ) ×[Xᵢ ×[Z] Y] ((Xᵢ ×[Z] Y) ×[X] Xₖ)` ⟶
`((Xⱼ ×[Z] Y) ×[X] Xₖ) ×[Xⱼ ×[Z] Y] ((Xⱼ ×[Z] Y) ×[X] Xᵢ)` needed for gluing |
t'_fst_fst_fst (i j k : 𝒰.I₀) :
t' 𝒰 f g i j k ≫ pullback.fst _ _ ≫ pullback.fst _ _ ≫ pullback.fst _ _ =
pullback.fst _ _ ≫ pullback.snd _ _ := by
simp only [t', Category.assoc, pullbackSymmetry_hom_comp_fst_assoc,
pullbackRightPullbackFstIso_inv_snd_fst_assoc, pullback.lift_fst_assoc, t_fst_fst,
pullbackRightPullbackFstIso_hom_fst_assoc]
@[simp, reassoc] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.CategoryTheory.Limits.Opposites",
"Mathlib.CategoryTheory.Limits.Shapes.Diagonal",
"Mathlib.CategoryTheory.Monoidal.Cartesian.Over"
] | Mathlib/AlgebraicGeometry/Pullbacks.lean | t'_fst_fst_fst | null |
t'_fst_fst_snd (i j k : 𝒰.I₀) :
t' 𝒰 f g i j k ≫ pullback.fst _ _ ≫ pullback.fst _ _ ≫ pullback.snd _ _ =
pullback.fst _ _ ≫ pullback.fst _ _ ≫ pullback.snd _ _ := by
simp only [t', Category.assoc, pullbackSymmetry_hom_comp_fst_assoc,
pullbackRightPullbackFstIso_inv_snd_fst_assoc, pullback.lift_fst_assoc, t_fst_snd,
pullbackRightPullbackFstIso_hom_fst_assoc]
@[simp, reassoc] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.CategoryTheory.Limits.Opposites",
"Mathlib.CategoryTheory.Limits.Shapes.Diagonal",
"Mathlib.CategoryTheory.Monoidal.Cartesian.Over"
] | Mathlib/AlgebraicGeometry/Pullbacks.lean | t'_fst_fst_snd | null |
t'_fst_snd (i j k : 𝒰.I₀) :
t' 𝒰 f g i j k ≫ pullback.fst _ _ ≫ pullback.snd _ _ =
pullback.snd _ _ ≫ pullback.snd _ _ := by
simp only [t', Category.assoc, pullbackSymmetry_hom_comp_fst_assoc,
pullbackRightPullbackFstIso_inv_snd_snd, pullback.lift_snd, Category.comp_id,
pullbackRightPullbackFstIso_hom_snd]
@[simp, reassoc] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.CategoryTheory.Limits.Opposites",
"Mathlib.CategoryTheory.Limits.Shapes.Diagonal",
"Mathlib.CategoryTheory.Monoidal.Cartesian.Over"
] | Mathlib/AlgebraicGeometry/Pullbacks.lean | t'_fst_snd | null |
t'_snd_fst_fst (i j k : 𝒰.I₀) :
t' 𝒰 f g i j k ≫ pullback.snd _ _ ≫ pullback.fst _ _ ≫ pullback.fst _ _ =
pullback.fst _ _ ≫ pullback.snd _ _ := by
simp only [t', Category.assoc, pullbackSymmetry_hom_comp_snd_assoc,
pullbackRightPullbackFstIso_inv_fst_assoc, pullback.lift_fst_assoc, t_fst_fst,
pullbackRightPullbackFstIso_hom_fst_assoc]
@[simp, reassoc] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.CategoryTheory.Limits.Opposites",
"Mathlib.CategoryTheory.Limits.Shapes.Diagonal",
"Mathlib.CategoryTheory.Monoidal.Cartesian.Over"
] | Mathlib/AlgebraicGeometry/Pullbacks.lean | t'_snd_fst_fst | null |
t'_snd_fst_snd (i j k : 𝒰.I₀) :
t' 𝒰 f g i j k ≫ pullback.snd _ _ ≫ pullback.fst _ _ ≫ pullback.snd _ _ =
pullback.fst _ _ ≫ pullback.fst _ _ ≫ pullback.snd _ _ := by
simp only [t', Category.assoc, pullbackSymmetry_hom_comp_snd_assoc,
pullbackRightPullbackFstIso_inv_fst_assoc, pullback.lift_fst_assoc, t_fst_snd,
pullbackRightPullbackFstIso_hom_fst_assoc]
@[simp, reassoc] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.CategoryTheory.Limits.Opposites",
"Mathlib.CategoryTheory.Limits.Shapes.Diagonal",
"Mathlib.CategoryTheory.Monoidal.Cartesian.Over"
] | Mathlib/AlgebraicGeometry/Pullbacks.lean | t'_snd_fst_snd | null |
t'_snd_snd (i j k : 𝒰.I₀) :
t' 𝒰 f g i j k ≫ pullback.snd _ _ ≫ pullback.snd _ _ =
pullback.fst _ _ ≫ pullback.fst _ _ ≫ pullback.fst _ _ := by
simp only [t', Category.assoc, pullbackSymmetry_hom_comp_snd_assoc,
pullbackRightPullbackFstIso_inv_fst_assoc, pullback.lift_fst_assoc, t_snd,
pullbackRightPullbackFstIso_hom_fst_assoc] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.CategoryTheory.Limits.Opposites",
"Mathlib.CategoryTheory.Limits.Shapes.Diagonal",
"Mathlib.CategoryTheory.Monoidal.Cartesian.Over"
] | Mathlib/AlgebraicGeometry/Pullbacks.lean | t'_snd_snd | null |
cocycle_fst_fst_fst (i j k : 𝒰.I₀) :
t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.fst _ _ ≫ pullback.fst _ _ ≫
pullback.fst _ _ = pullback.fst _ _ ≫ pullback.fst _ _ ≫ pullback.fst _ _ := by
simp only [t'_fst_fst_fst, t'_fst_snd, t'_snd_snd] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.CategoryTheory.Limits.Opposites",
"Mathlib.CategoryTheory.Limits.Shapes.Diagonal",
"Mathlib.CategoryTheory.Monoidal.Cartesian.Over"
] | Mathlib/AlgebraicGeometry/Pullbacks.lean | cocycle_fst_fst_fst | null |
cocycle_fst_fst_snd (i j k : 𝒰.I₀) :
t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.fst _ _ ≫ pullback.fst _ _ ≫
pullback.snd _ _ = pullback.fst _ _ ≫ pullback.fst _ _ ≫ pullback.snd _ _ := by
simp only [t'_fst_fst_snd] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.CategoryTheory.Limits.Opposites",
"Mathlib.CategoryTheory.Limits.Shapes.Diagonal",
"Mathlib.CategoryTheory.Monoidal.Cartesian.Over"
] | Mathlib/AlgebraicGeometry/Pullbacks.lean | cocycle_fst_fst_snd | null |
cocycle_fst_snd (i j k : 𝒰.I₀) :
t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.fst _ _ ≫ pullback.snd _ _ =
pullback.fst _ _ ≫ pullback.snd _ _ := by
simp only [t'_fst_snd, t'_snd_snd, t'_fst_fst_fst] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.CategoryTheory.Limits.Opposites",
"Mathlib.CategoryTheory.Limits.Shapes.Diagonal",
"Mathlib.CategoryTheory.Monoidal.Cartesian.Over"
] | Mathlib/AlgebraicGeometry/Pullbacks.lean | cocycle_fst_snd | null |
cocycle_snd_fst_fst (i j k : 𝒰.I₀) :
t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.snd _ _ ≫ pullback.fst _ _ ≫
pullback.fst _ _ = pullback.snd _ _ ≫ pullback.fst _ _ ≫ pullback.fst _ _ := by
simp only [pullback.condition_assoc, t'_snd_fst_fst, t'_fst_snd, t'_snd_snd] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.CategoryTheory.Limits.Opposites",
"Mathlib.CategoryTheory.Limits.Shapes.Diagonal",
"Mathlib.CategoryTheory.Monoidal.Cartesian.Over"
] | Mathlib/AlgebraicGeometry/Pullbacks.lean | cocycle_snd_fst_fst | null |
cocycle_snd_fst_snd (i j k : 𝒰.I₀) :
t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.snd _ _ ≫ pullback.fst _ _ ≫
pullback.snd _ _ = pullback.snd _ _ ≫ pullback.fst _ _ ≫ pullback.snd _ _ := by
simp only [pullback.condition_assoc, t'_snd_fst_snd] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.CategoryTheory.Limits.Opposites",
"Mathlib.CategoryTheory.Limits.Shapes.Diagonal",
"Mathlib.CategoryTheory.Monoidal.Cartesian.Over"
] | Mathlib/AlgebraicGeometry/Pullbacks.lean | cocycle_snd_fst_snd | null |
cocycle_snd_snd (i j k : 𝒰.I₀) :
t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.snd _ _ ≫ pullback.snd _ _ =
pullback.snd _ _ ≫ pullback.snd _ _ := by
simp only [t'_snd_snd, t'_fst_fst_fst, t'_fst_snd] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.CategoryTheory.Limits.Opposites",
"Mathlib.CategoryTheory.Limits.Shapes.Diagonal",
"Mathlib.CategoryTheory.Monoidal.Cartesian.Over"
] | Mathlib/AlgebraicGeometry/Pullbacks.lean | cocycle_snd_snd | null |
cocycle (i j k : 𝒰.I₀) : t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j = 𝟙 _ := by
apply pullback.hom_ext <;> rw [Category.id_comp]
· apply pullback.hom_ext
· apply pullback.hom_ext
· simp_rw [Category.assoc, cocycle_fst_fst_fst 𝒰 f g i j k]
· simp_rw [Category.assoc, cocycle_fst_fst_snd 𝒰 f g i j k]
· simp_rw [Category.assoc, cocycle_fst_snd 𝒰 f g i j k]
· apply pullback.hom_ext
· apply pullback.hom_ext
· simp_rw [Category.assoc, cocycle_snd_fst_fst 𝒰 f g i j k]
· simp_rw [Category.assoc, cocycle_snd_fst_snd 𝒰 f g i j k]
· simp_rw [Category.assoc, cocycle_snd_snd 𝒰 f g i j k] | theorem | AlgebraicGeometry | [
"Mathlib.AlgebraicGeometry.AffineScheme",
"Mathlib.AlgebraicGeometry.Gluing",
"Mathlib.CategoryTheory.Limits.Opposites",
"Mathlib.CategoryTheory.Limits.Shapes.Diagonal",
"Mathlib.CategoryTheory.Monoidal.Cartesian.Over"
] | Mathlib/AlgebraicGeometry/Pullbacks.lean | cocycle | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.