File size: 4,240 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
import Mathlib
import OAI.AlgebraicGeometry.Seshadri.Projective.PolynomialCharts

namespace OAI

section
noncomputable section
                                             
section

namespace MaximalSeshadri.Projective
noncomputable section
open MvPolynomial
variable {R A Οƒ : Type*} [CommRing R] [CommRing A] [Algebra R A]
  (π’œ : β„• β†’ Submodule R A) [GradedAlgebra π’œ]

lemma aeval_mem_grade (x : Οƒ β†’ A) (hx : βˆ€ i, x i ∈ π’œ 1)
    {p : MvPolynomial Οƒ R} {d : β„•} (hp : p.IsHomogeneous d) :
    aeval x p ∈ π’œ d := by
  classical
  rw [p.as_sum]
  simp only [map_sum, aeval_monomial]
  apply sum_mem
  intro m hm
  have h := SetLike.prod_pow_mem_graded π’œ (fun _ : Οƒ => (1 : β„•)) x
    (F := m.support) m (fun i _ => hx i)
  simp only [smul_eq_mul, mul_one] at h
  rw [← hp.degree_eq_sum_deg_support hm] at h
  simpa only [Algebra.smul_def, Finsupp.prod] using (π’œ d).smul_mem (p.coeff m) h

attribute [local instance] MvPolynomial.gradedAlgebra

def gradedPolynomialEval (x : Οƒ β†’ A) (hx : βˆ€ i, x i ∈ π’œ 1) :
    homogeneousSubmodule Οƒ R β†’+*ᡍ π’œ where
  toRingHom := (aeval x).toRingHom
  map_mem := fun hp => aeval_mem_grade π’œ x hx hp

end

noncomputable section
open AlgebraicGeometry CategoryTheory HomogeneousIdeal MvPolynomial
universe u
variable {K Οƒ : Type u} [CommRing K]
attribute [local instance] MvPolynomial.gradedAlgebra

def shiftedVariable (c : Οƒ β†’ K) : Option Οƒ β†’ MvPolynomial (Option Οƒ) K
  | none => X none
  | some i => X (some i) + C (c i) * X none

lemma shiftedVariable_homogeneous (c : Οƒ β†’ K) (i : Option Οƒ) :
    shiftedVariable c i ∈ PolyGrade K (Option Οƒ) 1 := by
  cases i with
  | none => exact isHomogeneous_X _ _
  | some i =>
    exact (isHomogeneous_X _ _).add (by
      simpa using (isHomogeneous_C (Option Οƒ) (c i)).mul (isHomogeneous_X K none))

def projectiveShiftHom (c : Οƒ β†’ K) :
    PolyGrade K (Option Οƒ) β†’+*ᡍ PolyGrade K (Option Οƒ) :=
  gradedPolynomialEval _ (shiftedVariable c) (shiftedVariable_homogeneous c)

@[simp] lemma projectiveShiftHom_X (c : Οƒ β†’ K) (i : Option Οƒ) :
    projectiveShiftHom c (X i) = shiftedVariable c i := aeval_X _ _

@[simp] lemma projectiveShiftHom_C (c : Οƒ β†’ K) (a : K) :
    projectiveShiftHom c (C a) = C a := aeval_C _ _

lemma projectiveShiftHom_inverse (c : Οƒ β†’ K) :
    (projectiveShiftHom (fun i => -c i)).comp (projectiveShiftHom c) =
      GradedRingHom.id (PolyGrade K (Option Οƒ)) := by
  have h : ((projectiveShiftHom (fun i => -c i)).comp
      (projectiveShiftHom c)).toRingHom = RingHom.id _ := by
    apply MvPolynomial.ringHom_ext
    Β· intro a
      simp
    Β· intro i
      cases i <;> simp [shiftedVariable]
  exact GradedRingHom.ext (RingHom.congr_fun h)

lemma projectiveShiftHom_surjective (c : Οƒ β†’ K) :
    Function.Surjective (projectiveShiftHom c) := by
  intro p
  refine ⟨projectiveShiftHom (fun i => -c i) p, ?_⟩
  have h := projectiveShiftHom_inverse (fun i => -c i)
  simp only [neg_neg] at h
  exact DFunLike.congr_fun h p

lemma shift_irrelevant (c : Οƒ β†’ K) :
    (PolyGrade K (Option Οƒ))β‚Š ≀
      (PolyGrade K (Option Οƒ))β‚Š.map (projectiveShiftHom c) := by
  apply (HomogeneousIdeal.irrelevant_le _).mpr
  intro d hd b hb
  have eqb : projectiveShiftHom c (projectiveShiftHom (fun i => -c i) b) = b := by
    have hh := projectiveShiftHom_inverse (fun i => -c i)
    simp only [neg_neg] at hh
    exact DFunLike.congr_fun hh b
  rw [← eqb]
  exact Ideal.mem_map_of_mem _
    (HomogeneousIdeal.mem_irrelevant_of_mem _ hd ((projectiveShiftHom _).map_mem hb))

def projectiveShift (c : Οƒ β†’ K) :
    Proj (PolyGrade K (Option Οƒ)) β‰… Proj (PolyGrade K (Option Οƒ)) where
  hom := Proj.map (projectiveShiftHom c) (shift_irrelevant c)
  inv := Proj.map (projectiveShiftHom (fun i => -c i)) (shift_irrelevant _)
  hom_inv_id := by
    rw [← Proj.map_comp]
    have hh := projectiveShiftHom_inverse (fun i => -c i)
    simp only [neg_neg] at hh
    simpa only [hh] using (Proj.map_id (π’œ := PolyGrade K (Option Οƒ)))
  inv_hom_id := by
    rw [← Proj.map_comp]
    simpa only [projectiveShiftHom_inverse] using
      (Proj.map_id (π’œ := PolyGrade K (Option Οƒ)))

end
end MaximalSeshadri.Projective

end


end
end

end OAI