File size: 5,347 Bytes
7f5fab8 | 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 | import Mathlib
import OAI.AlgebraicGeometry.RelativeTriviality.Coordinates
import OAI.AlgebraicGeometry.RelativeTriviality.Charts
namespace OAI
namespace CampanaPeternellSix.RelativeLineGlobalFunctions
noncomputable section
open CategoryTheory AlgebraicGeometry Opposite
open scoped Polynomial LaurentPolynomial
open RelativeLineCharts
universe u
variable (R : Type u) [CommRing R]
attribute [local instance] MvPolynomial.gradedAlgebra
lemma laurent_coeff_nat (p : R[X]) (n : ℕ) : p.toLaurent.coeff (n : ℤ) = p.coeff n := by
rw [LaurentPolynomial.coeff_toLaurent]
exact Finsupp.mapDomain_apply_of_injective Nat.castEmbedding.injective _ n
lemma laurent_coeff_neg (p : R[X]) (n : ℕ) (hn : 0 < n) :
p.toLaurent.coeff (-(n : ℤ)) = 0 := by
rw [LaurentPolynomial.coeff_toLaurent]
apply Finsupp.mapDomain_of_notMem_range
rintro ⟨i, hi⟩
change (i : ℤ) = -(n : ℤ) at hi
omega
lemma polynomial_overlap_constants (p q : R[X])
(h : p.toLaurent = LaurentPolynomial.invert q.toLaurent) :
∃ a : R, p = Polynomial.C a ∧ q = Polynomial.C a := by
have hc : p.coeff 0 = q.coeff 0 := by
have := congrArg (fun z : R[T;T⁻¹] => z.coeff 0) h
change p.toLaurent.coeff (↑(0 : ℕ)) = (LaurentPolynomial.invert q.toLaurent).coeff (↑(0 : ℕ)) at this
rw [laurent_coeff_nat, LaurentPolynomial.invert_apply] at this
rw [Nat.cast_zero, neg_zero] at this
exact this.trans (laurent_coeff_nat R q 0)
have cp : p = Polynomial.C (p.coeff 0) := by
ext k
by_cases hk : k = 0
· subst k; simp
· have he := congrArg (fun z : R[T;T⁻¹] => z.coeff (k : ℤ)) h
rw [laurent_coeff_nat, LaurentPolynomial.invert_apply,
laurent_coeff_neg R q k (Nat.pos_of_ne_zero hk)] at he
simpa only [Polynomial.coeff_C, ite_eq_right hk] using he
have cq : q = Polynomial.C (q.coeff 0) := by
ext k
by_cases hk : k = 0
· subst k; simp
· have he := congrArg (fun z : R[T;T⁻¹] => z.coeff (-(k : ℤ))) h
rw [laurent_coeff_neg R p k (Nat.pos_of_ne_zero hk),
LaurentPolynomial.invert_apply, neg_neg, laurent_coeff_nat] at he
simpa only [Polynomial.coeff_C, ite_eq_right hk] using he.symm
exact ⟨p.coeff 0, cp, by simpa [hc] using cq⟩
def scalars : R →+* Γ(RelativePolynomialEvaluation.space R 1, ⊤) :=
((Scheme.ΓSpecIso (.of R)).inv ≫ (RelativePolynomialEvaluation.toBase R 1).appTop).hom
lemma scalars_restrict_X (i : Fin 2) (a : R) :
(scheme R).presheaf.map (homOfLE (show Proj.basicOpen (grading R) (MvPolynomial.X i) ≤ ⊤ from le_top)).op
(scalars R a) =
Proj.awayToSection (grading R) (MvPolynomial.X i)
(HomogeneousLocalization.fromZeroRingHom (grading R) _ (constants R a)) := by
apply Subtype.ext
funext p
apply HomogeneousLocalization.val_injective
change ((((Scheme.ΓSpecIso (.of R)).inv ≫
(RelativePolynomialEvaluation.toBase R 1).appTop) a).val ⟨p.1, trivial⟩).val = _
rw [RelativePolynomialEvaluation.toBase_section R 1 a p.1]
rfl
lemma scalars_left (a : R) :
leftSectionEquiv R ((scheme R).presheaf.map (homOfLE le_top : leftOpen R ⟶ ⊤).op
(scalars R a)) = Polynomial.C a := by
refine (congrArg (leftSectionEquiv R) (scalars_restrict_X R 0 a)).trans ?_
change chartEquiv R ((leftSectionsIso R).inv ((leftSectionsIso R).hom
(algebraMap R (ChartRing R) a))) = _
simpa using chartEquiv_constant R a
lemma scalars_right (a : R) :
rightSectionEquiv R ((scheme R).presheaf.map (homOfLE le_top : rightOpen R ⟶ ⊤).op
(scalars R a)) = Polynomial.C a := by
refine (congrArg (rightSectionEquiv R) (scalars_restrict_X R 1 a)).trans ?_
change rightChartEquiv R ((rightSectionsIso R).inv ((rightSectionsIso R).hom
(HomogeneousLocalization.fromZeroRingHom (grading R) _ (constants R a)))) = _
simp only [Iso.hom_inv_id_apply]
rw [← chartSwap_constant R a]
change chartEquiv R ((chartSwap R).symm ((chartSwap R) (algebraMap R (ChartRing R) a))) = _
rw [RingEquiv.symm_apply_apply, chartEquiv_constant]
lemma polynomial_restrictions_agree (s : Γ(scheme R, ⊤)) :
(leftSectionEquiv R ((scheme R).presheaf.map
(homOfLE le_top : leftOpen R ⟶ ⊤).op s)).toLaurent =
LaurentPolynomial.invert (rightSectionEquiv R ((scheme R).presheaf.map
(homOfLE le_top : rightOpen R ⟶ ⊤).op s)).toLaurent := by
rw [← (standard_section_restrictions R).1, ← (standard_section_restrictions R).2]
congr 1
theorem scalars_bijective : Function.Bijective (scalars R) := by
constructor
· intro a b h
apply Polynomial.C_injective (R := R)
have he := congrArg (fun s => leftSectionEquiv R ((scheme R).presheaf.map
(homOfLE le_top : leftOpen R ⟶ ⊤).op s)) h
exact (scalars_left R a).symm.trans (he.trans (scalars_left R b))
· intro s
obtain ⟨a, ha, hb⟩ := polynomial_overlap_constants R _ _
(polynomial_restrictions_agree R s)
refine ⟨a, ?_⟩
refine (scheme R).sheaf.eq_of_locally_eq₂
(homOfLE le_top : leftOpen R ⟶ ⊤) (homOfLE le_top : rightOpen R ⟶ ⊤)
(by rw [standard_cover R]) _ _ ?_ ?_
· apply (leftSectionEquiv R).injective
exact (scalars_left R a).trans ha.symm
· apply (rightSectionEquiv R).injective
exact (scalars_right R a).trans hb.symm
end
end CampanaPeternellSix.RelativeLineGlobalFunctions
end OAI
|