File size: 5,833 Bytes
21cfc82 | 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 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 | import OAI.AlgebraicGeometry.StableCoordinate.FrameLiftUniqueness
namespace OAI
/-!
# Normalizing a polynomial determinant frame
A choice of trivialization gives a frame above the desired quadric base, but
its specialization need not be the prescribed initial frame. A constant unit
rescaling corrects it. This construction needs no domain or reducedness
hypothesis; those hypotheses enter only the separate uniqueness theorem.
-/
namespace StableCoordinate.FrameLift
variable {R S : Type*} [CommRing R] [CommRing S]
/-- Fiber scaling: the positive-weight column is multiplied by a unit and the
negative-weight row by its inverse. -/
def Frame.scale (F : Frame R) (u : Rˣ) : Frame R where
a := (u : R) * F.a
d := (u : R) * F.d
b := (↑u⁻¹ : R) * F.b
c := (↑u⁻¹ : R) * F.c
determinant := by
calc
((u : R) * F.a) * ((↑u⁻¹ : R) * F.c) -
((↑u⁻¹ : R) * F.b) * ((u : R) * F.d) =
((u : R) * (↑u⁻¹ : R)) * (F.a * F.c - F.b * F.d) := by ring
_ = 1 := by simp [F.determinant]
@[simp]
theorem Frame.scale_one (F : Frame R) : F.scale 1 = F := by
apply Frame.ext <;> simp [Frame.scale]
@[simp]
theorem Frame.scale_mul (F : Frame R) (u v : Rˣ) :
(F.scale u).scale v = F.scale (v * u) := by
apply Frame.ext <;> simp [Frame.scale, mul_assoc, mul_left_comm, mul_comm]
/-- Scaling acts within a fiber of the map to the quadric. -/
theorem Frame.scale_sameBase (F : Frame R) (u : Rˣ) : SameBase (F.scale u) F := by
dsimp [SameBase, Frame.scale]
constructor
· calc
((u : R) * F.a) * ((↑u⁻¹ : R) * F.b) =
((u : R) * (↑u⁻¹ : R)) * (F.a * F.b) := by ring
_ = F.a * F.b := by simp
constructor
· calc
((u : R) * F.d) * ((↑u⁻¹ : R) * F.c) =
((u : R) * (↑u⁻¹ : R)) * (F.d * F.c) := by ring
_ = F.d * F.c := by simp
· calc
((u : R) * F.d) * ((↑u⁻¹ : R) * F.b) =
((u : R) * (↑u⁻¹ : R)) * (F.d * F.b) := by ring
_ = F.d * F.b := by simp
@[simp]
theorem Frame.map_scale (F : Frame R) (u : Rˣ) (f : R →+* S) :
(F.scale u).map f = (F.map f).scale (Units.map f.toMonoidHom u) := by
apply Frame.ext <;> simp [Frame.scale, Frame.map]
/-- The comparison unit sends the first frame exactly to the second. -/
theorem scale_comparison {F G : Frame R} (h : SameBase F G) :
F.scale (comparisonUnit h) = G := by
apply Frame.ext
· exact comparison_a h
· exact comparison_d h
· exact comparison_b h
· exact comparison_c h
/-- Transitivity of equality of the three base coordinates. -/
theorem sameBase_trans {F G H : Frame R} (hFG : SameBase F G) (hGH : SameBase G H) :
SameBase F H :=
⟨hFG.1.trans hGH.1, hFG.2.1.trans hGH.2.1, hFG.2.2.trans hGH.2.2⟩
section Polynomial
open MvPolynomial
variable {σ : Type*}
/-- Correct an arbitrary polynomial lift to the prescribed initial frame by a
constant, invertible fiber scaling. -/
noncomputable def normalizeFrame (F : Frame (MvPolynomial σ R)) (G : Frame R)
(h : SameBase (F.map constantCoeff) G) : Frame (MvPolynomial σ R) :=
F.scale (Units.map C.toMonoidHom (comparisonUnit h))
/-- Normalization leaves all three base-coordinate polynomials unchanged. -/
theorem normalizeFrame_sameBase (F : Frame (MvPolynomial σ R)) (G : Frame R)
(h : SameBase (F.map constantCoeff) G) : SameBase (normalizeFrame F G h) F :=
F.scale_sameBase _
/-- The normalized polynomial lift has exactly the specified initial frame. -/
@[simp]
theorem normalizeFrame_at_zero (F : Frame (MvPolynomial σ R)) (G : Frame R)
(h : SameBase (F.map constantCoeff) G) :
(normalizeFrame F G h).map constantCoeff = G := by
rw [normalizeFrame, Frame.map_scale]
have hu : Units.map constantCoeff.toMonoidHom
(Units.map (C : R →+* MvPolynomial σ R).toMonoidHom (comparisonUnit h)) =
comparisonUnit h := by
apply Units.ext
simp
rw [hu, scale_comparison h]
/-- Normalization is canonical over a reduced ring. -/
theorem normalizeFrame_unique [IsReduced R]
(F : Frame (MvPolynomial σ R)) (G : Frame R)
(h : SameBase (F.map constantCoeff) G)
(F' : Frame (MvPolynomial σ R)) (hbase : SameBase F' F)
(hzero : F'.map constantCoeff = G) : F' = normalizeFrame F G h := by
apply normalized_polynomial_unique
· exact ⟨hbase.1.trans (normalizeFrame_sameBase F G h).1.symm,
hbase.2.1.trans (normalizeFrame_sameBase F G h).2.1.symm,
hbase.2.2.trans (normalizeFrame_sameBase F G h).2.2.symm⟩
· rw [hzero, normalizeFrame_at_zero]
/-- Coefficient specialization commutes with a coefficient-ring homomorphism. -/
theorem Frame.specialize_map (F : Frame (MvPolynomial σ R)) (θ : R →+* S) :
(F.map (MvPolynomial.map θ)).map constantCoeff =
(F.map constantCoeff).map θ := by
apply Frame.ext <;> simp [Frame.map]
/-- A normalized lift automatically commutes with a fiber scaling whenever
its base-coordinate polynomials are unchanged by that scaling.
For the source's multiplicative fiber action, apply this over the coefficient
ring containing an invertible scaling parameter. The hypothesis on base
coordinates is checked on the embedded quadric algebra. -/
theorem normalized_lift_scaling_equivariance [IsReduced R]
(F : Frame (MvPolynomial σ R)) (F₀ : Frame R)
(hzero : F.map constantCoeff = F₀)
(θ : R →+* R) (u : Rˣ)
(href : F₀.map θ = F₀.scale u)
(hbase : SameBase (F.map (MvPolynomial.map θ)) F) :
F.map (MvPolynomial.map θ) =
F.scale (Units.map (C : R →+* MvPolynomial σ R).toMonoidHom u) := by
apply normalized_polynomial_unique
· exact sameBase_trans hbase (sameBase_symm (F.scale_sameBase _))
· rw [Frame.specialize_map, hzero, href, Frame.map_scale, hzero]
congr 1
apply Units.ext
simp
end Polynomial
end StableCoordinate.FrameLift
end OAI
|