| 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 | |