introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
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