Download data/lean/OAI/AlgebraicGeometry/PELModuli/IntegralModel/Finite/ActionLoci.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 9.65 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/PELModuli/IntegralModel/Finite/ActionLoci.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/AlgebraicGeometry/PELModuli/IntegralModel/Finite/ActionLoci.lean
-
curl -L -o ActionLoci.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/PELModuli/IntegralModel/Finite/ActionLoci.lean
9.65 kB
| import OAI.AlgebraicGeometry.PELModuli.IntegralModel.Finite.Actions | |
| import OAI.AlgebraicGeometry.HilbertScheme.Presentations.EquationLoci | |
| import Mathlib.Algebra.Category.Ring.Basic | |
| /-! # Action Loci -/ | |
| namespace OAI.AlgebraicGeometry.PELModuli.IntegralModel.Finite.ActionLoci | |
| noncomputable section | |
| /-! The finite multiplication-table action locus in a represented ring | |
| functor. The closed parameter scheme is constructed from actual finite | |
| equations. This supplies the ring-action part of the PEL parameter problem; | |
| it does not assert that the entire PEL functor is already represented. -/ | |
| open _root_.CategoryTheory _root_.CategoryTheory.Limits _root_.AlgebraicGeometry _root_.Module Opposite | |
| universe u | |
| theorem basisExtension_map {R V W : Type*} [Ring R] [Ring V] [Ring W] | |
| {Idx : Type*} (b : Basis Idx ℤ R) (v : Idx → V) (f : V →+* W) (x : R) : | |
| f (Actions.basisExtension b v x) = Actions.basisExtension b (fun i => f (v i)) x := by | |
| have h : f.toAddMonoidHom.toIntLinearMap.comp (Actions.basisExtension b v) = | |
| Actions.basisExtension b (fun i => f (v i)) := b.ext fun i => by | |
| change f (Actions.basisExtension b v (b i)) = Actions.basisExtension b (fun i => f (v i)) (b i) | |
| rw [Actions.basisExtension_basis, Actions.basisExtension_basis] | |
| exact LinearMap.congr_fun h x | |
| namespace FiniteActionLocus | |
| variable {S : Scheme.{u}} (F : (Over S)ᵒᵖ ⥤ RingCat.{u}) (H : Over S) | |
| (e : (F ⋙ forget RingCat).RepresentableBy H) | |
| {R : Type u} [Ring R] {d : ℕ} (b : Basis (Fin d) ℤ R) | |
| abbrev parameters : Over S := ∏ᶜ fun _ : Fin d => H | |
| def values {T : Over S} (f : T ⟶ parameters (d := d) H) (i : Fin d) : F.obj (op T) := | |
| e.homEquiv (f ≫ Pi.π (fun _ : Fin d => H) i) | |
| def universalValues (i : Fin d) : F.obj (op (parameters (d := d) H)) := | |
| e.homEquiv (Pi.π (fun _ : Fin d => H) i) | |
| theorem values_eq_map {T : Over S} (f : T ⟶ parameters (d := d) H) (i : Fin d) : | |
| values F H e f i = (F.map f.op).hom (universalValues F H e i) := | |
| e.homEquiv_comp f _ | |
| theorem classify_element {T : Over S} (f : T ⟶ parameters (d := d) H) | |
| (x : F.obj (op (parameters (d := d) H))) : | |
| e.homEquiv (f ≫ e.homEquiv.symm x) = (F.map f.op).hom x := by | |
| rw [e.homEquiv_comp, e.homEquiv.apply_symm_apply] | |
| rfl | |
| def valuesEquiv (T : Over S) : | |
| (T ⟶ parameters (d := d) H) ≃ (Fin d → F.obj (op T)) where | |
| toFun := values F H e | |
| invFun v := Pi.lift (fun i => e.homEquiv.symm (v i)) | |
| left_inv f := by | |
| apply Pi.hom_ext | |
| intro i | |
| rw [Pi.lift_comp_π] | |
| exact e.homEquiv.symm_apply_apply _ | |
| right_inv v := by | |
| funext i | |
| change e.homEquiv (Pi.lift (fun j => e.homEquiv.symm (v j)) ≫ Pi.π _ i) = v i | |
| rw [Pi.lift_comp_π, e.homEquiv.apply_symm_apply] | |
| theorem values_comp {T U : Over S} (f : T ⟶ U) (h : U ⟶ parameters (d := d) H) | |
| (i : Fin d) : | |
| values F H e (f ≫ h) i = (F.map f.op).hom (values F H e h i) := by | |
| change e.homEquiv ((f ≫ h) ≫ Pi.π _ i) = _ | |
| rw [Category.assoc, e.homEquiv_comp] | |
| rfl | |
| variable [IsSeparated H.hom] | |
| def unitEquation : HilbertScheme.Presentations.EquationLoci.MorphismEquation (parameters (d := d) H) where | |
| target := H | |
| separated := inferInstance | |
| lhs := e.homEquiv.symm (Actions.basisExtension b (universalValues F H e) 1) | |
| rhs := e.homEquiv.symm 1 | |
| def multiplicationEquation (i j : Fin d) : HilbertScheme.Presentations.EquationLoci.MorphismEquation (parameters (d := d) H) where | |
| target := H | |
| separated := inferInstance | |
| lhs := e.homEquiv.symm (Actions.basisExtension b (universalValues F H e) (b i * b j)) | |
| rhs := e.homEquiv.symm (universalValues F H e i * universalValues F H e j) | |
| def equations : List (HilbertScheme.Presentations.EquationLoci.MorphismEquation (parameters (d := d) H)) := | |
| unitEquation F H e b :: (List.ofFn fun i : Fin d => | |
| List.ofFn fun j : Fin d => multiplicationEquation F H e b i j).flatten | |
| def TableCondition {T : Over S} (f : T ⟶ parameters (d := d) H) : Prop := | |
| Actions.basisExtension b (values F H e f) 1 = 1 ∧ | |
| ∀ i j, Actions.basisExtension b (values F H e f) (b i * b j) = | |
| values F H e f i * values F H e f j | |
| theorem equation_unit_iff {T : Over S} (f : T ⟶ parameters (d := d) H) : | |
| f ≫ (unitEquation F H e b).lhs = f ≫ (unitEquation F H e b).rhs ↔ | |
| Actions.basisExtension b (values F H e f) 1 = 1 := by | |
| let c : (T ⟶ H) ≃ F.obj (op T) := e.homEquiv | |
| refine Iff.trans c.injective.eq_iff.symm ?_ | |
| change e.homEquiv (f ≫ e.homEquiv.symm _) = e.homEquiv (f ≫ e.homEquiv.symm _) ↔ _ | |
| rw [classify_element, classify_element, (F.map f.op).hom.map_one, basisExtension_map] | |
| rw [show values F H e f = fun i => (F.map f.op).hom (universalValues F H e i) from | |
| funext (values_eq_map F H e f)] | |
| theorem equation_multiplication_iff {T : Over S} (f : T ⟶ parameters (d := d) H) | |
| (i j : Fin d) : | |
| f ≫ (multiplicationEquation F H e b i j).lhs = | |
| f ≫ (multiplicationEquation F H e b i j).rhs ↔ | |
| Actions.basisExtension b (values F H e f) (b i * b j) = | |
| values F H e f i * values F H e f j := by | |
| let c : (T ⟶ H) ≃ F.obj (op T) := e.homEquiv | |
| refine Iff.trans c.injective.eq_iff.symm ?_ | |
| change e.homEquiv (f ≫ e.homEquiv.symm _) = e.homEquiv (f ≫ e.homEquiv.symm _) ↔ _ | |
| rw [classify_element, classify_element, (F.map f.op).hom.map_mul, basisExtension_map] | |
| rw [show values F H e f = fun i => (F.map f.op).hom (universalValues F H e i) from | |
| funext (values_eq_map F H e f)] | |
| /-- The finite scheme equations express the full ring law, through the | |
| proved finite-basis extension. -/ | |
| theorem satisfies_iff {T : Over S} (f : T ⟶ parameters (d := d) H) : | |
| HilbertScheme.Presentations.EquationLoci.Satisfies (equations F H e b) f ↔ TableCondition F H e b f := by | |
| constructor | |
| · intro hf | |
| refine ⟨(equation_unit_iff F H e b f).mp (hf _ List.mem_cons_self), ?_⟩ | |
| intro i j | |
| apply (equation_multiplication_iff F H e b f i j).mp | |
| apply hf | |
| exact List.mem_cons_of_mem _ (List.mem_flatten.mpr | |
| ⟨List.ofFn fun k => multiplicationEquation F H e b i k, | |
| List.mem_ofFn.mpr ⟨i, rfl⟩, List.mem_ofFn.mpr ⟨j, rfl⟩⟩) | |
| · rintro ⟨hunit, hmul⟩ q hq | |
| rcases List.mem_cons.mp hq with rfl | hq | |
| · exact (equation_unit_iff F H e b f).mpr hunit | |
| · obtain ⟨qs, hqs, hq⟩ := List.mem_flatten.mp hq | |
| obtain ⟨i, rfl⟩ := List.mem_ofFn.mp hqs | |
| obtain ⟨j, rfl⟩ := List.mem_ofFn.mp hq | |
| exact (equation_multiplication_iff F H e b f i j).mpr (hmul i j) | |
| /-- The actual finite equation locus uniquely classifies ring maps on | |
| every test scheme through their values on the integral basis. -/ | |
| theorem exists_closed_action_locus : | |
| ∃ (Z : Over S) (j : Z ⟶ parameters (d := d) H), IsClosedImmersion j.left ∧ | |
| TableCondition F H e b j ∧ | |
| ∀ (T : Over S) (ρ : R →+* F.obj (op T)), | |
| ∃! f : T ⟶ Z, ∀ i, values F H e (f ≫ j) i = ρ (b i) := by | |
| obtain ⟨Z, j, hj, hZ⟩ := HilbertScheme.Presentations.EquationLoci.finite_equations_closed_locus (equations F H e b) | |
| let := hj | |
| have : Mono j := Over.mono_of_mono_left j | |
| have hjTable : TableCondition F H e b j := (satisfies_iff F H e b j).mp | |
| ((hZ Z j).mpr ⟨𝟙 Z, Category.id_comp j, fun f hf => | |
| (cancel_mono j).mp (hf.trans (Category.id_comp j).symm)⟩) | |
| refine ⟨Z, j, hj, hjTable, ?_⟩ | |
| intro T ρ | |
| let p := (valuesEquiv F H e T).symm (fun i => ρ (b i)) | |
| have hp : values F H e p = fun i => ρ (b i) := (valuesEquiv F H e T).apply_symm_apply _ | |
| have hL : Actions.basisExtension b (fun i => ρ (b i)) = ρ.toAddMonoidHom.toIntLinearMap := | |
| b.ext fun i => Actions.basisExtension_basis _ _ i | |
| have hpTable : TableCondition F H e b p := by | |
| change Actions.basisExtension b (values F H e p) 1 = 1 ∧ _ | |
| rw [hp, hL] | |
| exact ⟨ρ.map_one, fun i j => ρ.map_mul (b i) (b j)⟩ | |
| obtain ⟨f, hf, huniq⟩ := (hZ T p).mp ((satisfies_iff F H e b p).mpr hpTable) | |
| refine ⟨f, ?_, ?_⟩ | |
| · intro i | |
| rw [hf] | |
| exact congrFun hp i | |
| · intro g hg | |
| apply huniq | |
| exact (valuesEquiv F H e T).injective ((funext hg).trans hp.symm) | |
| /-- Construct the universal ring action on the closed locus and its | |
| all-test-scheme classifying property in the ring-valued functor itself. -/ | |
| theorem exists_universal_action_scheme : | |
| ∃ (Z : Over S) (j : Z ⟶ parameters (d := d) H), IsClosedImmersion j.left ∧ | |
| ∃ ρZ : R →+* F.obj (op Z), | |
| (∀ i, ρZ (b i) = values F H e j i) ∧ | |
| ∀ (T : Over S) (ρ : R →+* F.obj (op T)), | |
| ∃! f : T ⟶ Z, (F.map f.op).hom.comp ρZ = ρ := by | |
| obtain ⟨Z, j, hj, htable, hclass⟩ := exists_closed_action_locus F H e b | |
| let ρZ := Actions.ringHomOfBasis b (values F H e j) htable.1 htable.2 | |
| have hρZ (i) : ρZ (b i) = values F H e j i := Actions.ringHomOfBasis_basis _ _ _ _ i | |
| refine ⟨Z, j, hj, ρZ, hρZ, ?_⟩ | |
| intro T ρ | |
| have iff_basis (f : T ⟶ Z) : (F.map f.op).hom.comp ρZ = ρ ↔ | |
| ∀ i, values F H e (f ≫ j) i = ρ (b i) := by | |
| constructor | |
| · intro hf i | |
| have h := RingHom.congr_fun hf (b i) | |
| simpa only [RingHom.comp_apply, hρZ, ← values_comp] using h | |
| · intro hf | |
| have h : ((F.map f.op).hom.comp ρZ).toAddMonoidHom.toIntLinearMap = | |
| ρ.toAddMonoidHom.toIntLinearMap := b.ext fun i => by | |
| change (F.map f.op).hom (ρZ (b i)) = ρ (b i) | |
| rw [hρZ, ← values_comp] | |
| exact hf i | |
| exact RingHom.ext fun x => LinearMap.congr_fun h x | |
| obtain ⟨f, hf, huniq⟩ := hclass T ρ | |
| exact ⟨f, (iff_basis f).mpr hf, fun g hg => huniq g ((iff_basis g).mp hg)⟩ | |
| end FiniteActionLocus | |
| end | |
| end OAI.AlgebraicGeometry.PELModuli.IntegralModel.Finite.ActionLoci | |