| import OAI.AlgebraicGeometry.StableCoordinate.FrameLiftUniqueness |
|
|
| namespace OAI |
|
|
| /-! |
| |
|
|
| 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 |
|
|
