Download data/lean/OAI/AlgebraicGeometry/Seshadri/Configurations/Configurations.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 23.8 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/Seshadri/Configurations/Configurations.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/AlgebraicGeometry/Seshadri/Configurations/Configurations.lean
-
curl -L -o Configurations.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/Seshadri/Configurations/Configurations.lean
23.8 kB
| import Mathlib | |
| import OAI.AlgebraicGeometry.Seshadri.Model | |
| import OAI.AlgebraicGeometry.Seshadri.Bertini.Derivations | |
| import OAI.AlgebraicGeometry.Seshadri.Configurations.SmoothRationalPoints | |
| namespace OAI | |
| section | |
| namespace MaximalSeshadri | |
| noncomputable section | |
| open CategoryTheory CategoryTheory.Limits AlgebraicGeometry TopologicalSpace | |
| open scoped AlgebraicGeometry | |
| open scoped TensorProduct | |
| variable {F : Type} [Field F] [IsAlgClosed F] [Uncountable F] | |
| omit [Uncountable F] in | |
| lemma affine_pullback_isIntegral {A B : CommRingCat} [IsDomain A] [IsDomain B] | |
| (f : Spec A βΆ Spec (CommRingCat.of F)) | |
| (g : Spec B βΆ Spec (CommRingCat.of F)) | |
| [LocallyOfFiniteType f] : IsIntegral (pullback f g) := by | |
| obtain β¨Ο, rflβ© := Spec.map_surjective f | |
| obtain β¨Ο, rflβ© := Spec.map_surjective g | |
| have hft : Ο.hom.FiniteType := HasRingHomProperty.Spec_iff.mp | |
| (inferInstance : LocallyOfFiniteType (Spec.map Ο)) | |
| algebraize [Ο.hom, Ο.hom] | |
| let : IsDomain (A β[F] B) := tensorProduct_isDomain | |
| exact IsIntegral.of_isIso (pullbackSpecIso F A B).inv | |
| def nonemptyAffineCover (X : Scheme) : X.OpenCover where | |
| Iβ := { U : X.Opens // IsAffineOpen U β§ Nonempty U } | |
| X i := Spec Ξ(X, i.1) | |
| f i := i.2.1.fromSpec | |
| memβ := by | |
| rw [Scheme.presieveβ_mem_precoverage_iff] | |
| refine β¨?_, inferInstanceβ© | |
| intro x | |
| obtain β¨U, hU, hxU, _β© := exists_isAffineOpen_mem_and_subset | |
| (show x β (β€ : X.Opens) from trivial) | |
| let i : { U : X.Opens // IsAffineOpen U β§ Nonempty U } := | |
| β¨U, hU, β¨β¨x, hxUβ©β©β© | |
| refine β¨i, ?_β© | |
| rw [hU.range_fromSpec] | |
| exact hxU | |
| instance nonemptyAffineCover_nonempty (X : Scheme) (i : (nonemptyAffineCover X).Iβ) : | |
| Nonempty ((nonemptyAffineCover X).X i) := by | |
| let : Nonempty i.1 := i.2.2 | |
| exact Nonempty.map i.2.1.isoSpec.hom inferInstance | |
| instance nonemptyAffineCover_integral (X : Scheme) [IsIntegral X] | |
| (i : (nonemptyAffineCover X).Iβ) : IsIntegral ((nonemptyAffineCover X).X i) := | |
| isIntegral_of_isOpenImmersion ((nonemptyAffineCover X).f i) | |
| omit [Uncountable F] in | |
| theorem scheme_product_isIntegral {X Y : Scheme} [IsIntegral X] [IsIntegral Y] | |
| (f : X βΆ Spec (CommRingCat.of F)) (g : Y βΆ Spec (CommRingCat.of F)) | |
| [LocallyOfFiniteType f] : IsIntegral (pullback f g) := by | |
| classical | |
| let C := Scheme.Pullback.openCoverOfLeftRight (nonemptyAffineCover X) | |
| (nonemptyAffineCover Y) f g | |
| have hInt (i : C.Iβ) : IsIntegral (C.X i) := by | |
| change IsIntegral (pullback ((nonemptyAffineCover X).f i.1 β« f) | |
| ((nonemptyAffineCover Y).f i.2 β« g)) | |
| let : Nonempty i.1.1 := i.1.2.2 | |
| let : Nonempty i.2.1 := i.2.2.2 | |
| let : IsOpenImmersion ((nonemptyAffineCover X).f i.1) := inferInstance | |
| let : LocallyOfFiniteType ((nonemptyAffineCover X).f i.1) := inferInstance | |
| let hfcomp : LocallyOfFiniteType ((nonemptyAffineCover X).f i.1 β« f) := inferInstance | |
| exact @affine_pullback_isIntegral F _ _ Ξ(X, i.1.1) Ξ(Y, i.2.1) | |
| inferInstance inferInstance ((nonemptyAffineCover X).f i.1 β« f) | |
| ((nonemptyAffineCover Y).f i.2 β« g) hfcomp | |
| let : β i, IsReduced (C.X i) := fun i => by | |
| let := hInt i | |
| infer_instance | |
| let : IsReduced (pullback f g) := IsReduced.of_openCover _ C | |
| let x : X := Classical.ofNonempty | |
| let y : Y := Classical.ofNonempty | |
| obtain β¨i, a, _β© := (nonemptyAffineCover X).exists_eq x | |
| obtain β¨j, b, _β© := (nonemptyAffineCover Y).exists_eq y | |
| let c : C.Iβ := (i, j) | |
| let := hInt c | |
| have hdx : Dense (Set.range ((nonemptyAffineCover X).f i)) := | |
| ((nonemptyAffineCover X).f i).isOpenEmbedding.isOpen_range.dense | |
| (Set.range_nonempty _) | |
| have hdy : Dense (Set.range ((nonemptyAffineCover Y).f j)) := | |
| ((nonemptyAffineCover Y).f j).isOpenEmbedding.isOpen_range.dense | |
| (Set.range_nonempty _) | |
| have hdc : Dense (Set.range (C.f c)) := by | |
| change Dense (Set.range (pullback.map | |
| ((nonemptyAffineCover X).f i β« f) ((nonemptyAffineCover Y).f j β« g) | |
| f g ((nonemptyAffineCover X).f i) ((nonemptyAffineCover Y).f j) | |
| (π _) (Category.comp_id _) (Category.comp_id _))) | |
| rw [Scheme.Pullback.range_map] | |
| exact (hdx.preimage (pullback.fst f g).isOpenMap).inter_of_isOpen_left | |
| (hdy.preimage (pullback.snd f g).isOpenMap) | |
| (((nonemptyAffineCover X).f i).isOpenEmbedding.isOpen_range.preimage | |
| (pullback.fst f g).continuous) | |
| have hic : IsIrreducible (Set.range (C.f c)) := by | |
| simpa only [Set.image_univ] using | |
| (IrreducibleSpace.isIrreducible_univ (X := C.X c)).image (C.f c) | |
| (C.f c).continuous.continuousOn | |
| let : IrreducibleSpace (pullback f g : Scheme) := | |
| (irreducibleSpace_def (pullback f g : Scheme)).mpr (by | |
| change IsIrreducible (Set.univ : Set (pullback f g : Scheme)) | |
| rw [β hdc.closure_eq] | |
| exact hic.closure) | |
| exact isIntegral_of_irreducibleSpace_of_isReduced _ | |
| end | |
| end MaximalSeshadri | |
| namespace MaximalSeshadri | |
| noncomputable section | |
| open CategoryTheory CategoryTheory.Limits AlgebraicGeometry TopologicalSpace | |
| open scoped AlgebraicGeometry | |
| def powerSuccIso {C : Type*} [Category C] [HasFiniteProducts C] (X : C) (n : β) : | |
| (βαΆ (fun _ : Fin (n + 1) => X)) β X β¨― (βαΆ (fun _ : Fin n => X)) where | |
| hom := prod.lift (Pi.Ο _ 0) (Pi.lift fun i => Pi.Ο _ i.succ) | |
| inv := Pi.lift (Fin.cases prod.fst (fun i => prod.snd β« Pi.Ο _ i)) | |
| hom_inv_id := by | |
| apply Pi.hom_ext | |
| intro i | |
| refine Fin.cases ?_ (fun j => ?_) i <;> simp | |
| inv_hom_id := by | |
| apply prod.hom_ext | |
| Β· simp | |
| Β· apply Pi.hom_ext | |
| intro i | |
| simp | |
| def overPowerZeroIso {C : Type*} [Category C] [HasFiniteLimits C] {B : C} | |
| (X : Over B) : (βαΆ (fun _ : Fin 0 => X)) β Over.mk (π B) where | |
| hom := Over.homMk (βαΆ (fun _ : Fin 0 => X)).hom | |
| inv := Pi.lift (fun i => i.elim0) | |
| hom_inv_id := by | |
| apply Pi.hom_ext | |
| intro i | |
| exact i.elim0 | |
| inv_hom_id := Over.mkIdTerminal.hom_ext _ _ | |
| def overLeftIso {C : Type*} [Category C] {B : C} {X Y : Over B} (e : X β Y) : | |
| X.left β Y.left where | |
| hom := e.hom.left | |
| inv := e.inv.left | |
| hom_inv_id := by simp [β Over.comp_left] | |
| inv_hom_id := by simp [β Over.comp_left] | |
| theorem scheme_power_isIntegral {F : Type} [Field F] [IsAlgClosed F] [Uncountable F] | |
| (X : Over (Spec (CommRingCat.of F))) [IsIntegral X.left] | |
| [LocallyOfFiniteType X.hom] (n : β) : | |
| IsIntegral (βαΆ (fun _ : Fin n => X)).left := by | |
| induction n with | |
| | zero => | |
| let : IsIntegral (Over.mk (π (Spec (CommRingCat.of F)))).left := | |
| inferInstanceAs (IsIntegral (Spec (CommRingCat.of F))) | |
| exact IsIntegral.of_isIso (overLeftIso (overPowerZeroIso X)).inv | |
| | succ n hn => | |
| let : IsIntegral (βαΆ (fun _ : Fin n => X)).left := hn | |
| let : IsIntegral (pullback X.hom (βαΆ (fun _ : Fin n => X)).hom) := | |
| scheme_product_isIntegral X.hom _ | |
| let e : (βαΆ (fun _ : Fin (n + 1) => X)).left β | |
| pullback X.hom (βαΆ (fun _ : Fin n => X)).hom := | |
| (overLeftIso (powerSuccIso X n)).trans | |
| (Over.prodLeftIsoPullback X (βαΆ (fun _ : Fin n => X))) | |
| exact IsIntegral.of_isIso e.inv | |
| theorem scheme_power_locallyOfFiniteType {F : Type} [Field F] | |
| (X : Over (Spec (CommRingCat.of F))) [LocallyOfFiniteType X.hom] (n : β) : | |
| LocallyOfFiniteType (βαΆ (fun _ : Fin n => X)).hom := by | |
| induction n with | |
| | zero => | |
| change LocallyOfFiniteType (overLeftIso (overPowerZeroIso X)).hom | |
| infer_instance | |
| | succ n hn => | |
| let e : (βαΆ (fun _ : Fin (n + 1) => X)).left β | |
| pullback X.hom (βαΆ (fun _ : Fin n => X)).hom := | |
| (overLeftIso (powerSuccIso X n)).trans | |
| (Over.prodLeftIsoPullback X (βαΆ (fun _ : Fin n => X))) | |
| have he : (βαΆ (fun _ : Fin (n + 1) => X)).hom = | |
| e.hom β« pullback.fst _ _ β« X.hom := by | |
| dsimp only [e] | |
| simp only [Iso.trans_hom, Category.assoc, | |
| Over.prodLeftIsoPullback_hom_fst_assoc] | |
| change _ = (powerSuccIso X n).hom.left β« | |
| (prod.fst : X β¨― (βαΆ (fun _ : Fin n => X)) βΆ X).left β« X.hom | |
| rw [Over.w, Over.w] | |
| let : LocallyOfFiniteType (βαΆ (fun _ : Fin n => X)).hom := hn | |
| rw [he] | |
| infer_instance | |
| end | |
| end MaximalSeshadri | |
| namespace MaximalSeshadri | |
| noncomputable section | |
| open CategoryTheory AlgebraicGeometry TopologicalSpace | |
| open scoped AlgebraicGeometry | |
| theorem scheme_rational_point_outside_countable_closed | |
| {F : Type} [Field F] [IsAlgClosed F] [Uncountable F] | |
| {X : Scheme} [IsIntegral X] (f : X βΆ Spec (CommRingCat.of F)) | |
| [LocallyOfFiniteType f] | |
| (Z : β β Set X) (hclosed : β n, IsClosed (Z n)) | |
| (hproper : β n, Z n β Set.univ) : | |
| β p : Spec (CommRingCat.of F) βΆ X, | |
| p β« f = π _ β§ β n, p (fieldPoint F) β Z n := by | |
| classical | |
| let x : X := Classical.ofNonempty | |
| obtain β¨U, hU, hxU, _β© := exists_isAffineOpen_mem_and_subset | |
| (show x β (β€ : X.Opens) from trivial) | |
| let : Nonempty U := β¨β¨x, hxUβ©β© | |
| let A := Ξ(X, U) | |
| let i : Spec A βΆ X := hU.fromSpec | |
| let g : CommRingCat.of F βΆ A := Spec.homEquiv (i β« f) | |
| have hg : Spec.map g = i β« f := Spec.homEquiv.symm_apply_apply _ | |
| let : LocallyOfFiniteType (Spec.map g) := hg βΈ inferInstance | |
| have hft : g.hom.FiniteType := HasRingHomProperty.Spec_iff.mp (inferInstance : LocallyOfFiniteType (Spec.map g)) | |
| algebraize [g.hom] | |
| let Z' : β β Set (PrimeSpectrum A) := fun n => i β»ΒΉ' Z n | |
| have hclosed' (n : β) : IsClosed (Z' n) := (hclosed n).preimage i.continuous | |
| have hproper' (n : β) : Z' n β Set.univ := by | |
| intro heq | |
| have hUZ : (U : Set X) β Z n := by | |
| rw [β hU.range_fromSpec] | |
| rintro _ β¨a, rflβ© | |
| have : a β Z' n := heq βΈ Set.mem_univ a | |
| exact this | |
| have hd : Dense (U : Set X) := U.isOpen.dense β¨x, hxUβ© | |
| apply hproper n | |
| apply Set.eq_univ_of_univ_subset | |
| rw [β hd.closure_eq] | |
| exact (hclosed n).closure_subset_iff.mpr hUZ | |
| obtain β¨Ο, hΟβ© := rational_point_outside_countable_closed (F := F) Z' hclosed' hproper' | |
| let p := Spec.map (CommRingCat.ofHom Ο.toRingHom) β« i | |
| refine β¨p, ?_, fun n => ?_β© | |
| Β· dsimp [p] | |
| rw [Category.assoc, β hg, β Spec.map_comp, β Spec.map_id] | |
| congr 1 | |
| apply CommRingCat.hom_ext | |
| exact Ο.comp_algebraMap | |
| Β· change i ((Spec.map (CommRingCat.ofHom Ο.toRingHom)) (fieldPoint F)) β Z n | |
| exact hΟ n | |
| end | |
| end MaximalSeshadri | |
| namespace MaximalSeshadri | |
| noncomputable section | |
| open CategoryTheory AlgebraicGeometry | |
| open scoped AlgebraicGeometry | |
| theorem rationalPoint_image_injective {F : Type} [Field F] | |
| {X : Scheme} (f : X βΆ Spec (CommRingCat.of F)) (o : Spec (CommRingCat.of F)) : | |
| Function.Injective | |
| (fun p : {p : Spec (CommRingCat.of F) βΆ X // p β« f = π _} => p.val o) := by | |
| rintro β¨p, hpβ© β¨q, hqβ© hpq | |
| apply Subtype.ext | |
| obtain β¨β¨x, Οβ©, rflβ© := (Scheme.SpecToEquivOfField F X).symm.surjective p | |
| obtain β¨β¨y, Οβ©, rflβ© := (Scheme.SpecToEquivOfField F X).symm.surjective q | |
| change (Spec.map Ο β« X.fromSpecResidueField x) o = | |
| (Spec.map Ο β« X.fromSpecResidueField y) o at hpq | |
| have hxy : x = y := by simpa only [Scheme.Hom.comp_apply, | |
| Scheme.fromSpecResidueField_apply] using hpq | |
| subst y | |
| change Spec.map Ο β« X.fromSpecResidueField x β« f = π _ at hp | |
| change Spec.map Ο β« X.fromSpecResidueField x β« f = π _ at hq | |
| let a : CommRingCat.of F βΆ X.residueField x := | |
| Spec.homEquiv (X.fromSpecResidueField x β« f) | |
| have ha : Spec.map a = X.fromSpecResidueField x β« f := | |
| Spec.homEquiv.symm_apply_apply _ | |
| have hap : a β« Ο = π _ := by | |
| apply Spec.map_inj.mp | |
| rw [Spec.map_comp, Spec.map_id, ha] | |
| exact hp | |
| have haq : a β« Ο = π _ := by | |
| apply Spec.map_inj.mp | |
| rw [Spec.map_comp, Spec.map_id, ha] | |
| exact hq | |
| have has : Function.Surjective a.hom := by | |
| intro z | |
| refine β¨Ο.hom z, Ο.hom.injective ?_β© | |
| exact congrArg (fun k : CommRingCat.of F βΆ CommRingCat.of F => k.hom (Ο.hom z)) hap | |
| have hΟΟ : Ο = Ο := by | |
| ext z | |
| obtain β¨c, rflβ© := has z | |
| exact (congrArg (fun k : CommRingCat.of F βΆ CommRingCat.of F => k.hom c) hap).trans | |
| (congrArg (fun k : CommRingCat.of F βΆ CommRingCat.of F => k.hom c) haq).symm | |
| exact congrArg (fun k => (Scheme.SpecToEquivOfField F X).symm β¨x, kβ©) hΟΟ | |
| end | |
| end MaximalSeshadri | |
| namespace MaximalSeshadri | |
| noncomputable section | |
| open CategoryTheory CategoryTheory.Limits AlgebraicGeometry TopologicalSpace | |
| open scoped AlgebraicGeometry | |
| variable {F : Type} [Field F] | |
| abbrev RationalPoint (X : Over (Spec (CommRingCat.of F))) := | |
| Over.mk (π (Spec (CommRingCat.of F))) βΆ X | |
| def rationalImage {X : Over (Spec (CommRingCat.of F))} (p : RationalPoint X) : X.left := | |
| p.left (fieldPoint F) | |
| theorem rationalImage_injective (X : Over (Spec (CommRingCat.of F))) : | |
| Function.Injective (rationalImage (X := X)) := by | |
| intro p q h | |
| have hh := rationalPoint_image_injective X.hom (fieldPoint F) | |
| (aβ := β¨p.left, Over.w pβ©) (aβ := β¨q.left, Over.w qβ©) h | |
| apply Over.OverMorphism.ext | |
| exact congrArg Subtype.val hh | |
| def rationalTupleImage (X : Over (Spec (CommRingCat.of F))) (r : β) | |
| (p : Fin r β RationalPoint X) : (βαΆ (fun _ : Fin r => X)).left := | |
| (Pi.lift p).left (fieldPoint F) | |
| lemma rationalImage_projection (X : Over (Spec (CommRingCat.of F))) (r : β) | |
| (p : Fin r β RationalPoint X) (i : Fin r) : | |
| (Pi.Ο (fun _ : Fin r => X) i).left (rationalTupleImage X r p) = | |
| rationalImage (p i) := by | |
| change ((Pi.lift p).left β« (Pi.Ο (fun _ : Fin r => X) i).left) (fieldPoint F) = _ | |
| rw [β Over.comp_left, Pi.lift_comp_Ο] | |
| rfl | |
| theorem exists_distinct_rational_tuple [IsAlgClosed F] [Uncountable F] | |
| (X : Over (Spec (CommRingCat.of F))) [IsIntegral X.left] | |
| (n : β) (hn : 0 < n) [SmoothOfRelativeDimension n X.hom] (r : β) : | |
| β p : Fin r β RationalPoint X, Function.Injective (fun i => rationalImage (p i)) := by | |
| classical | |
| have hu := smooth_scheme_uncountable_rational_points X.hom n hn | |
| let R := Set.range fun p : {p : Spec (CommRingCat.of F) βΆ X.left // p β« X.hom = π _} => | |
| p.val (fieldPoint F) | |
| let : Infinite R := (show R.Infinite from fun h => hu h.countable).to_subtype | |
| let b : β βͺ R := Infinite.natEmbedding R | |
| choose p hp using (fun k : β => (b k).property) | |
| refine β¨fun i => Over.homMk (p i.val).val (p i.val).property, ?_β© | |
| intro i j h | |
| apply Fin.val_injective | |
| apply b.injective | |
| apply Subtype.ext | |
| change (p i.val).val (fieldPoint F) = (p j.val).val (fieldPoint F) at h | |
| simpa only [hp] using h | |
| def pairProjection (X : Over (Spec (CommRingCat.of F))) (r : β) (i j : Fin r) : | |
| (βαΆ (fun _ : Fin r => X)).left βΆ pullback X.hom X.hom := | |
| pullback.lift (Pi.Ο (fun _ : Fin r => X) i).left | |
| (Pi.Ο (fun _ : Fin r => X) j).left ((Over.w _).trans (Over.w _).symm) | |
| def pairDiagonal (X : Over (Spec (CommRingCat.of F))) (r : β) (i j : Fin r) : | |
| Set (βαΆ (fun _ : Fin r => X)).left := | |
| pairProjection X r i j β»ΒΉ' Set.range (pullback.diagonal X.hom) | |
| lemma pairDiagonal_closed (X : Over (Spec (CommRingCat.of F))) [IsSeparated X.hom] | |
| (r : β) (i j : Fin r) : IsClosed (pairDiagonal X r i j) := by | |
| exact (pullback.diagonal X.hom).isClosedEmbedding.isClosed_range.preimage | |
| (pairProjection X r i j).continuous | |
| lemma pairDiagonal_tuple_iff (X : Over (Spec (CommRingCat.of F))) (r : β) | |
| (p : Fin r β RationalPoint X) (i j : Fin r) : | |
| rationalTupleImage X r p β pairDiagonal X r i j β | |
| rationalImage (p i) = rationalImage (p j) := by | |
| constructor | |
| Β· rintro β¨x, hxβ© | |
| have hi := congrArg (pullback.fst X.hom X.hom) hx | |
| have hj := congrArg (pullback.snd X.hom X.hom) hx | |
| have hfst : (pullback.fst X.hom X.hom) (pairProjection X r i j | |
| (rationalTupleImage X r p)) = rationalImage (p i) := by | |
| change (pairProjection X r i j β« pullback.fst X.hom X.hom) | |
| (rationalTupleImage X r p) = _ | |
| simp only [pairProjection, pullback.lift_fst, rationalImage_projection] | |
| have hsnd : (pullback.snd X.hom X.hom) (pairProjection X r i j | |
| (rationalTupleImage X r p)) = rationalImage (p j) := by | |
| change (pairProjection X r i j β« pullback.snd X.hom X.hom) | |
| (rationalTupleImage X r p) = _ | |
| simp only [pairProjection, pullback.lift_snd, rationalImage_projection] | |
| have hid : (pullback.fst X.hom X.hom) ((pullback.diagonal X.hom) x) = x := by | |
| change (pullback.diagonal X.hom β« pullback.fst X.hom X.hom) x = x | |
| simp | |
| have hjd : (pullback.snd X.hom X.hom) ((pullback.diagonal X.hom) x) = x := by | |
| change (pullback.diagonal X.hom β« pullback.snd X.hom X.hom) x = x | |
| simp | |
| exact (hfst.symm.trans (hi.symm.trans hid)).trans (hjd.symm.trans (hj.trans hsnd)) | |
| Β· intro h | |
| have hp := rationalImage_injective X h | |
| refine β¨rationalImage (p i), ?_β© | |
| have hm : (Pi.lift p).left β« pairProjection X r i j = | |
| (p i).left β« pullback.diagonal X.hom := by | |
| apply pullback.hom_ext | |
| Β· simp only [Category.assoc, pairProjection, pullback.lift_fst, | |
| pullback.diagonal_fst, Category.comp_id, β Over.comp_left, Pi.lift_comp_Ο] | |
| Β· simp only [Category.assoc, pairProjection, pullback.lift_snd, | |
| pullback.diagonal_snd, Category.comp_id, β Over.comp_left, Pi.lift_comp_Ο, hp] | |
| exact (congrArg (fun f : Spec (CommRingCat.of F) βΆ pullback X.hom X.hom => | |
| f (fieldPoint F)) hm).symm | |
| def collisionLocus (X : Over (Spec (CommRingCat.of F))) (r : β) : | |
| Set (βαΆ (fun _ : Fin r => X)).left := | |
| β ij : {ij : Fin r Γ Fin r // ij.1 β ij.2}, pairDiagonal X r ij.val.1 ij.val.2 | |
| lemma collisionLocus_closed (X : Over (Spec (CommRingCat.of F))) [IsSeparated X.hom] | |
| (r : β) : IsClosed (collisionLocus X r) := by | |
| exact isClosed_iUnion_of_finite (fun ij => pairDiagonal_closed X r ij.val.1 ij.val.2) | |
| lemma tuple_not_collision_iff (X : Over (Spec (CommRingCat.of F))) (r : β) | |
| (p : Fin r β RationalPoint X) : | |
| rationalTupleImage X r p β collisionLocus X r β | |
| Function.Injective (fun i => rationalImage (p i)) := by | |
| constructor | |
| Β· intro h i j hij | |
| by_contra hne | |
| apply h | |
| exact Set.mem_iUnion.mpr β¨β¨(i, j), hneβ©, | |
| (pairDiagonal_tuple_iff X r p i j).mpr hijβ© | |
| Β· intro h hbad | |
| obtain β¨β¨β¨i, jβ©, hneβ©, hijβ© := Set.mem_iUnion.mp hbad | |
| exact hne (h ((pairDiagonal_tuple_iff X r p i j).mp hij)) | |
| lemma collisionLocus_proper [IsAlgClosed F] [Uncountable F] | |
| (X : Over (Spec (CommRingCat.of F))) [IsIntegral X.left] | |
| (n : β) (hn : 0 < n) [SmoothOfRelativeDimension n X.hom] (r : β) : | |
| collisionLocus X r β Set.univ := by | |
| obtain β¨p, hpβ© := exists_distinct_rational_tuple X n hn r | |
| intro heq | |
| exact (tuple_not_collision_iff X r p).mpr hp (heq βΈ Set.mem_univ _) | |
| lemma rationalTupleImage_projections (X : Over (Spec (CommRingCat.of F))) (r : β) | |
| (q : RationalPoint (βαΆ (fun _ : Fin r => X))) : | |
| rationalTupleImage X r (fun i => q β« Pi.Ο _ i) = rationalImage q := by | |
| have heq : Pi.lift (fun i => q β« Pi.Ο (fun _ : Fin r => X) i) = q := by | |
| apply Pi.hom_ext | |
| intro i | |
| simp | |
| exact congrArg (fun p : RationalPoint (βαΆ (fun _ : Fin r => X)) => | |
| p.left (fieldPoint F)) heq | |
| def SchemeConfiguration (X : Over (Spec (CommRingCat.of F))) (r : β) := | |
| {p : Fin r β RationalPoint X // Function.Injective (fun i => rationalImage (p i))} | |
| instance schemeConfigurationTopology (X : Over (Spec (CommRingCat.of F))) (r : β) : | |
| TopologicalSpace (SchemeConfiguration X r) := | |
| TopologicalSpace.induced (fun p => rationalTupleImage X r p.val) inferInstance | |
| theorem configuration_outside_countable_closed [IsAlgClosed F] [Uncountable F] | |
| (X : Over (Spec (CommRingCat.of F))) [IsIntegral X.left] [IsSeparated X.hom] | |
| (n : β) (hn : 0 < n) [SmoothOfRelativeDimension n X.hom] (r : β) | |
| (Z : β β Set (SchemeConfiguration X r)) (hclosed : β k, IsClosed (Z k)) | |
| (hproper : β k, Z k β Set.univ) : | |
| β p : SchemeConfiguration X r, β k, p β Z k := by | |
| classical | |
| have hex (k : β) : β W : Set (βαΆ (fun _ : Fin r => X)).left, | |
| IsClosed W β§ (fun p : SchemeConfiguration X r => rationalTupleImage X r p.val) β»ΒΉ' W = Z k := | |
| isClosed_induced_iff.mp (hclosed k) | |
| choose W hW hWZ using hex | |
| have hWP (k : β) : W k β Set.univ := by | |
| intro heq | |
| apply hproper k | |
| rw [β hWZ k, heq] | |
| exact Set.preimage_univ | |
| let : Smooth X.hom := SmoothOfRelativeDimension.smooth n X.hom | |
| let Y := βαΆ (fun _ : Fin r => X) | |
| let : IsIntegral Y.left := scheme_power_isIntegral X r | |
| let : LocallyOfFiniteType Y.hom := scheme_power_locallyOfFiniteType X r | |
| let bad : β β Set Y.left := fun k => Nat.casesOn k (collisionLocus X r) W | |
| have hbc (k : β) : IsClosed (bad k) := by | |
| cases k with | |
| | zero => exact collisionLocus_closed X r | |
| | succ k => exact hW k | |
| have hbp (k : β) : bad k β Set.univ := by | |
| cases k with | |
| | zero => exact collisionLocus_proper X n hn r | |
| | succ k => exact hWP k | |
| obtain β¨q, hq, haβ© := scheme_rational_point_outside_countable_closed Y.hom bad hbc hbp | |
| let q' : RationalPoint Y := Over.homMk q hq | |
| let p : Fin r β RationalPoint X := fun i => q' β« Pi.Ο _ i | |
| have hpi : rationalTupleImage X r p = q (fieldPoint F) := | |
| rationalTupleImage_projections X r q' | |
| have hp : Function.Injective (fun i => rationalImage (p i)) := by | |
| apply (tuple_not_collision_iff X r p).mp | |
| rw [hpi] | |
| exact ha 0 | |
| refine β¨β¨p, hpβ©, fun k hk => ?_β© | |
| apply ha (k + 1) | |
| change q (fieldPoint F) β W k | |
| rw [β hpi] | |
| have hmem : (β¨p, hpβ© : SchemeConfiguration X r) β | |
| (fun p : SchemeConfiguration X r => rationalTupleImage X r p.val) β»ΒΉ' W k := by | |
| rw [hWZ k] | |
| exact hk | |
| exact hmem | |
| end | |
| end MaximalSeshadri | |
| namespace MaximalSeshadri.Geometry | |
| noncomputable section | |
| open CategoryTheory CategoryTheory.Limits AlgebraicGeometry TopologicalSpace | |
| open scoped AlgebraicGeometry | |
| attribute [local instance] MvPolynomial.gradedAlgebra | |
| instance complexUncountable : Uncountable β := by | |
| apply not_countable_iff.mp | |
| intro h | |
| let := h | |
| exact not_countable Complex.ofReal_injective.countable | |
| instance projectiveSpaceToSpec_separated (N : β) : IsSeparated (projectiveSpaceToSpec N) := by | |
| unfold projectiveSpaceToSpec | |
| exact IsSeparated.stableUnderComposition.comp_mem _ _ (Proj.isSeparated _) inferInstance | |
| instance Surface.separated (S : Surface) : IsSeparated S.structureMap := by | |
| rw [β S.overComplex] | |
| exact IsSeparated.stableUnderComposition.comp_mem _ _ inferInstance inferInstance | |
| lemma configurationTopology_eq (S : Surface) (r : β) : | |
| configurationTopology S r = | |
| schemeConfigurationTopology (Over.mk S.structureMap) r := by | |
| unfold configurationTopology schemeConfigurationTopology | |
| change TopologicalSpace.induced Subtype.val | |
| (TopologicalSpace.induced (tupleImage S r) inferInstance) = _ | |
| rw [induced_compose] | |
| rfl | |
| theorem surface_configuration_outside_countable_closed | |
| (S : Surface) (r : β) (Z : β β Set (Configuration S r)) | |
| (hclosed : β k, IsClosed (Z k)) (hproper : β k, Z k β Set.univ) : | |
| β p : Configuration S r, β k, p β Z k := by | |
| let : IsIntegral (Over.mk S.structureMap).left := S.integral | |
| let : SmoothOfRelativeDimension 2 (Over.mk S.structureMap).hom := S.smooth | |
| let : IsSeparated (Over.mk S.structureMap).hom := S.separated | |
| have ht := configurationTopology_eq S r | |
| let T : β β Set (SchemeConfiguration (Over.mk S.structureMap) r) := Z | |
| have hc : β k, @IsClosed _ (schemeConfigurationTopology (Over.mk S.structureMap) r) (T k) := by | |
| intro k | |
| rw [β ht] | |
| exact hclosed k | |
| exact configuration_outside_countable_closed (Over.mk S.structureMap) 2 (by norm_num) r T hc hproper | |
| end | |
| end MaximalSeshadri.Geometry | |
| end | |
| end OAI | |