| import Mathlib |
| import OAI.AlgebraicGeometry.SectionFields.Constants |
|
|
| namespace OAI |
|
|
| /-! Rational Cartier divisors, pullback and exact principal presentations. -/ |
|
|
| noncomputable section |
| open AlgebraicGeometry CategoryTheory CategoryTheory.Limits TopologicalSpace Order Polynomial |
| open scoped TensorProduct WithZero |
| universe u |
|
|
| namespace RelativeDenominators |
| section |
|
|
| open Order TopologicalSpace |
|
|
| |
| theorem ord_one (X : Scheme) [IsIntegral X] [IsNoetherian X] (x : X) : |
| X.ord (1 : X.functionField) x = 0 := by |
| simpa using X.ord_of_isUnit (U := ⊤) (f := 1) isUnit_one (x := x) trivial |
|
|
| theorem ord_inv (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (u : X.functionField) (hu : u ≠ 0) (x : X) : |
| X.ord u⁻¹ x = -X.ord u x := by |
| have h := X.ord_mul (x := x) hu (inv_ne_zero hu) |
| rw [mul_inv_cancel₀ hu, ord_one] at h |
| omega |
|
|
| theorem ord_pow (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (u : X.functionField) (hu : u ≠ 0) (n : ℕ) (x : X) : |
| X.ord (u ^ n) x = (n : ℤ) * X.ord u x := by |
| induction n with |
| | zero => simp [ord_one] |
| | succ n ih => |
| rw [pow_succ, X.ord_mul (pow_ne_zero _ hu) hu, ih] |
| push_cast |
| ring |
|
|
| theorem ord_zpow (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (u : X.functionField) (hu : u ≠ 0) (n : ℤ) (x : X) : |
| X.ord (u ^ n) x = n * X.ord u x := by |
| cases n with |
| | ofNat n => simpa using ord_pow X u hu n x |
| | negSucc n => |
| rw [zpow_negSucc, ord_inv X _ (pow_ne_zero _ hu), ord_pow X u hu, Int.negSucc_eq] |
| push_cast |
| ring |
|
|
| theorem ord_div (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (u v : X.functionField) (hu : u ≠ 0) (hv : v ≠ 0) (x : X) : |
| X.ord (u / v) x = X.ord u x - X.ord v x := by |
| rw [div_eq_mul_inv, X.ord_mul hu (inv_ne_zero hv), ord_inv X _ hv, sub_eq_add_neg] |
|
|
| |
|
|
| theorem pullback_ord_zero_on |
| {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z] |
| (hNormal : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z)) |
| (f : X ⟶ Z) [IsDominant f] (U : Z.Opens) [Nonempty U] |
| (u : Z.functionFieldˣ) |
| (hord : ∀ z : Z, z ∈ U → coheight z = 1 → Z.ord (u : Z.functionField) z = 0) |
| (x : X) (hx : f x ∈ U) : |
| X.ord (functionFieldPullback f (u : Z.functionField)) x = 0 := by |
| obtain ⟨s, hs⟩ := exists_section_unit_of_ord_eq_zero Z hNormal U u hord |
| change Z.germToFunctionField U (s : Γ(Z, U)) = (u : Z.functionField) at hs |
| rw [← hs, functionFieldPullback_germ] |
| exact X.ord_of_isUnit (s.isUnit.map (f.app U).hom) hx |
|
|
| |
|
|
| abbrev RationalWeilDivisor (X : Scheme) := PrimeDivisor X →₀ ℚ |
|
|
| |
| noncomputable def rationalPrincipalDivisor (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (u : X.functionFieldˣ) : RationalWeilDivisor X := |
| (principalDivisor X u).mapRange (Int.castRingHom ℚ) (by simp) |
|
|
| @[simp] theorem rationalPrincipalDivisor_apply (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (u : X.functionFieldˣ) (p : PrimeDivisor X) : |
| rationalPrincipalDivisor X u p = (X.ord (u : X.functionField) p.1 : ℚ) := rfl |
|
|
| |
|
|
| def IsQCartier (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (D : RationalWeilDivisor X) : Prop := |
| ∃ n : ℕ, 0 < n ∧ ∀ z : X, ∃ U : X.Opens, z ∈ U ∧ |
| ∃ u : X.functionFieldˣ, ∀ p : PrimeDivisor X, p.1 ∈ U → |
| (n : ℚ) * D p = (X.ord (u : X.functionField) p.1 : ℚ) |
|
|
|
|
| |
|
|
| theorem pullback_local_equations_agree |
| {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z] |
| (hNormal : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z)) |
| (f : X ⟶ Z) [IsDominant f] (D : RationalWeilDivisor Z) |
| (n m : ℕ) (hn : 0 < n) (hm : 0 < m) (U V : Z.Opens) |
| (u v : Z.functionFieldˣ) |
| (hu : ∀ q : PrimeDivisor Z, q.1 ∈ U → |
| (n : ℚ) * D q = (Z.ord (u : Z.functionField) q.1 : ℚ)) |
| (hv : ∀ q : PrimeDivisor Z, q.1 ∈ V → |
| (m : ℚ) * D q = (Z.ord (v : Z.functionField) q.1 : ℚ)) |
| (p : PrimeDivisor X) (hpU : f p.1 ∈ U) (hpV : f p.1 ∈ V) : |
| (X.ord (functionFieldPullback f (u : Z.functionField)) p.1 : ℚ) / n = |
| (X.ord (functionFieldPullback f (v : Z.functionField)) p.1 : ℚ) / m := by |
| let W := U ⊓ V |
| let : Nonempty W := ⟨⟨f p.1, hpU, hpV⟩⟩ |
| let w : Z.functionFieldˣ := u ^ m / v ^ n |
| have hzero : ∀ z : Z, z ∈ W → coheight z = 1 → Z.ord (w : Z.functionField) z = 0 := by |
| intro z hz hcodim |
| have hrel : (m : ℤ) * Z.ord (u : Z.functionField) z = |
| (n : ℤ) * Z.ord (v : Z.functionField) z := by |
| have hq : (m : ℚ) * (Z.ord (u : Z.functionField) z : ℚ) = |
| (n : ℚ) * (Z.ord (v : Z.functionField) z : ℚ) := by |
| rw [← hu ⟨z, hcodim⟩ hz.1, ← hv ⟨z, hcodim⟩ hz.2] |
| ring |
| exact_mod_cast hq |
| simp only [w, Units.val_div_eq_div_val, Units.val_pow_eq_pow_val] |
| change Z.ord ((u : Z.functionField) ^ m / (v : Z.functionField) ^ n) z = 0 |
| rw [ord_div Z _ _ (pow_ne_zero _ (Units.ne_zero u)) (pow_ne_zero _ (Units.ne_zero v)), |
| ord_pow Z _ (Units.ne_zero u), ord_pow Z _ (Units.ne_zero v), hrel, sub_self] |
| have he := pullback_ord_zero_on hNormal f W w hzero p.1 ⟨hpU, hpV⟩ |
| have hfu : functionFieldPullback f (u : Z.functionField) ≠ 0 := |
| by simp |
| have hfv : functionFieldPullback f (v : Z.functionField) ≠ 0 := |
| by simp |
| simp only [w, Units.val_div_eq_div_val, Units.val_pow_eq_pow_val] at he |
| rw [map_div₀, map_pow, map_pow, |
| ord_div X _ _ (pow_ne_zero _ hfu) (pow_ne_zero _ hfv), |
| ord_pow X _ hfu, ord_pow X _ hfv, sub_eq_zero] at he |
| apply (div_eq_div_iff (by exact_mod_cast hn.ne') (by exact_mod_cast hm.ne')).mpr |
| norm_cast |
| nlinarith only [he] |
|
|
|
|
| |
| structure QCartierData (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (D : RationalWeilDivisor X) where |
| index : ℕ |
| index_pos : 0 < index |
| chart : X → X.Opens |
| mem_chart : ∀ x, x ∈ chart x |
| equation : X → X.functionFieldˣ |
| ord_eq : ∀ x (p : PrimeDivisor X), p.1 ∈ chart x → |
| (index : ℚ) * D p = (X.ord (equation x : X.functionField) p.1 : ℚ) |
|
|
| noncomputable def IsQCartier.data {X : Scheme} [IsIntegral X] [IsNoetherian X] |
| {D : RationalWeilDivisor X} (hD : IsQCartier X D) : QCartierData X D := |
| Classical.choice (by |
| obtain ⟨n, hn, hloc⟩ := hD |
| choose U hU u hu using hloc |
| exact ⟨⟨n, hn, U, hU, u, hu⟩⟩) |
|
|
| noncomputable def QCartierData.pullbackCoeff |
| {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z] |
| {D : RationalWeilDivisor Z} (c : QCartierData Z D) |
| (f : X ⟶ Z) [IsDominant f] (p : PrimeDivisor X) : ℚ := |
| (X.ord (functionFieldPullback f (c.equation (f p.1) : Z.functionField)) p.1 : ℚ) / c.index |
|
|
| theorem QCartierData.pullbackCoeff_eq_local |
| {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z] |
| (hNormal : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z)) |
| {D : RationalWeilDivisor Z} (c : QCartierData Z D) |
| (f : X ⟶ Z) [IsDominant f] |
| (n : ℕ) (hn : 0 < n) (U : Z.Opens) (u : Z.functionFieldˣ) |
| (hu : ∀ q : PrimeDivisor Z, q.1 ∈ U → |
| (n : ℚ) * D q = (Z.ord (u : Z.functionField) q.1 : ℚ)) |
| (p : PrimeDivisor X) (hp : f p.1 ∈ U) : |
| c.pullbackCoeff f p = |
| (X.ord (functionFieldPullback f (u : Z.functionField)) p.1 : ℚ) / n := by |
| exact pullback_local_equations_agree hNormal f D c.index n c.index_pos hn |
| (c.chart (f p.1)) U (c.equation (f p.1)) u (c.ord_eq (f p.1)) hu p |
| (c.mem_chart (f p.1)) hp |
|
|
| theorem QCartierData.pullbackCoeff_finite_support |
| {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z] |
| (hNormal : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z)) |
| {D : RationalWeilDivisor Z} (c : QCartierData Z D) |
| (f : X ⟶ Z) [IsDominant f] : |
| (Function.support (c.pullbackCoeff f)).Finite := by |
| classical |
| obtain ⟨t, ht⟩ := isCompact_univ.elim_finite_subcover |
| (fun z : Z => (c.chart z : Set Z)) (fun z => (c.chart z).isOpen) |
| (fun z _ => Set.mem_iUnion.mpr ⟨z, c.mem_chart z⟩) |
| have hfin : (⋃ z ∈ t, Function.support (fun p : PrimeDivisor X => |
| X.ord (functionFieldPullback f (c.equation z : Z.functionField)) p.1)).Finite := by |
| apply t.finite_toSet.biUnion |
| intro z _ |
| apply finite_support_ord X |
| simp |
| apply hfin.subset |
| intro p hp |
| obtain ⟨z, hz, hpz⟩ := Set.mem_iUnion₂.mp (ht (Set.mem_univ (f p.1))) |
| refine Set.mem_iUnion₂.mpr ⟨z, hz, ?_⟩ |
| intro hz0 |
| change X.ord (functionFieldPullback f (c.equation z : Z.functionField)) p.1 = 0 at hz0 |
| apply hp |
| rw [c.pullbackCoeff_eq_local hNormal f c.index c.index_pos (c.chart z) (c.equation z) |
| (c.ord_eq z) p hpz, hz0] |
| simp |
|
|
| |
|
|
| noncomputable def pullbackQCartier |
| {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z] |
| (hNormal : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z)) |
| (f : X ⟶ Z) [IsDominant f] (D : RationalWeilDivisor Z) (hD : IsQCartier Z D) : |
| RationalWeilDivisor X := |
| Finsupp.ofSupportFinite (hD.data.pullbackCoeff f) |
| (hD.data.pullbackCoeff_finite_support hNormal f) |
|
|
| |
|
|
| theorem pullbackQCartier_apply_of_local |
| {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z] |
| (hNormal : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z)) |
| (f : X ⟶ Z) [IsDominant f] (D : RationalWeilDivisor Z) (hD : IsQCartier Z D) |
| (n : ℕ) (hn : 0 < n) (U : Z.Opens) (u : Z.functionFieldˣ) |
| (hu : ∀ q : PrimeDivisor Z, q.1 ∈ U → |
| (n : ℚ) * D q = (Z.ord (u : Z.functionField) q.1 : ℚ)) |
| (p : PrimeDivisor X) (hp : f p.1 ∈ U) : |
| pullbackQCartier hNormal f D hD p = |
| (X.ord (functionFieldPullback f (u : Z.functionField)) p.1 : ℚ) / n := |
| hD.data.pullbackCoeff_eq_local hNormal f n hn U u hu p hp |
|
|
| theorem isQCartier_pullback |
| {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z] |
| (hNormal : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z)) |
| (f : X ⟶ Z) [IsDominant f] (D : RationalWeilDivisor Z) (hD : IsQCartier Z D) : |
| IsQCartier X (pullbackQCartier hNormal f D hD) := by |
| let c := hD.data |
| refine ⟨c.index, c.index_pos, fun x => ?_⟩ |
| refine ⟨f ⁻¹ᵁ c.chart (f x), c.mem_chart (f x), |
| Units.map (functionFieldPullback f).toMonoidHom (c.equation (f x)), ?_⟩ |
| intro p hp |
| rw [pullbackQCartier_apply_of_local hNormal f D hD c.index c.index_pos |
| (c.chart (f x)) (c.equation (f x)) (c.ord_eq (f x)) p hp] |
| have hn : (c.index : ℚ) ≠ 0 := by exact_mod_cast c.index_pos.ne' |
| field_simp |
| rfl |
|
|
|
|
| |
|
|
| theorem ord_pullback_eq_zero_of_mapsToGeneric |
| {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] |
| (f : X ⟶ Z) [IsDominant f] (u : Z.functionFieldˣ) |
| (x : X) (hx : f x = genericPoint Z) : |
| X.ord (functionFieldPullback f (u : Z.functionField)) x = 0 := by |
| obtain ⟨U, _, s, hU, hs, hu⟩ := AlgebraicGeometry.exists_isUnit_germ_eq (X := Z) _ (Units.ne_zero u) |
| let := hU |
| have hgen : genericPoint Z ∈ U := |
| ((genericPoint_spec Z).mem_open_set_iff U.isOpen).mpr (by simpa using hU) |
| rw [← hs, functionFieldPullback_germ] |
| exact X.ord_of_isUnit (hu.map (f.app U).hom) (by simpa [hx] using hgen) |
|
|
| |
|
|
| def IsVerticalRationalDivisor {X Z : Scheme} [IsIntegral Z] |
| (f : X ⟶ Z) (D : RationalWeilDivisor X) : Prop := |
| ∀ p : PrimeDivisor X, D p ≠ 0 → f p.1 ≠ genericPoint Z |
|
|
| theorem isVertical_pullbackQCartier |
| {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z] |
| (hNormal : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z)) |
| (f : X ⟶ Z) [IsDominant f] (D : RationalWeilDivisor Z) (hD : IsQCartier Z D) : |
| IsVerticalRationalDivisor f (pullbackQCartier hNormal f D hD) := by |
| intro p hp hgen |
| apply hp |
| change hD.data.pullbackCoeff f p = 0 |
| unfold QCartierData.pullbackCoeff |
| rw [ord_pullback_eq_zero_of_mapsToGeneric f _ p.1 hgen] |
| simp |
|
|
| theorem isQCartier_principal (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (u : X.functionFieldˣ) : IsQCartier X (rationalPrincipalDivisor X u) := by |
| refine ⟨1, Nat.one_pos, fun x => ⟨⊤, trivial, u, ?_⟩⟩ |
| intro p _ |
| simp |
|
|
| theorem pullbackQCartier_principal |
| {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z] |
| (hNormal : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z)) |
| (f : X ⟶ Z) [IsDominant f] (u : Z.functionFieldˣ) |
| (hD : IsQCartier Z (rationalPrincipalDivisor Z u)) : |
| pullbackQCartier hNormal f (rationalPrincipalDivisor Z u) hD = |
| rationalPrincipalDivisor X (Units.map (functionFieldPullback f).toMonoidHom u) := by |
| ext p |
| rw [pullbackQCartier_apply_of_local hNormal f _ hD 1 Nat.one_pos ⊤ u |
| (fun _ _ => by simp) p trivial] |
| simp |
|
|
| theorem isQCartier_add |
| {X : Scheme} [IsIntegral X] [IsNoetherian X] |
| {D E : RationalWeilDivisor X} (hD : IsQCartier X D) (hE : IsQCartier X E) : |
| IsQCartier X (D + E) := by |
| obtain ⟨n, hn, hD⟩ := hD |
| obtain ⟨m, hm, hE⟩ := hE |
| refine ⟨n * m, Nat.mul_pos hn hm, fun x => ?_⟩ |
| obtain ⟨U, hxU, u, hu⟩ := hD x |
| obtain ⟨V, hxV, v, hv⟩ := hE x |
| refine ⟨U ⊓ V, ⟨hxU, hxV⟩, u ^ m * v ^ n, fun p hp => ?_⟩ |
| simp only [Finsupp.add_apply, Units.val_mul, Units.val_pow_eq_pow_val, |
| X.ord_mul (pow_ne_zero _ (Units.ne_zero u)) (pow_ne_zero _ (Units.ne_zero v)), |
| ord_pow X _ (Units.ne_zero u), ord_pow X _ (Units.ne_zero v)] |
| push_cast |
| rw [← hu p hp.1, ← hv p hp.2] |
| ring |
|
|
| theorem isQCartier_smul |
| {X : Scheme} [IsIntegral X] [IsNoetherian X] |
| {D : RationalWeilDivisor X} (hD : IsQCartier X D) (q : ℚ) : |
| IsQCartier X (q • D) := by |
| obtain ⟨n, hn, hD⟩ := hD |
| refine ⟨n * q.den, Nat.mul_pos hn q.den_pos, fun x => ?_⟩ |
| obtain ⟨U, hx, u, hu⟩ := hD x |
| refine ⟨U, hx, u ^ q.num, fun p hp => ?_⟩ |
| simp only [Finsupp.smul_apply, smul_eq_mul, Units.val_zpow_eq_zpow_val, |
| ord_zpow X _ (Units.ne_zero u)] |
| push_cast |
| rw [← hu p hp] |
| have hq : (q.den : ℚ) * q = q.num := by |
| simp [mul_comm] |
| calc (n : ℚ) * q.den * (q * D p) = n * ((q.den : ℚ) * q) * D p := by ring |
| _ = (q.num : ℚ) * ((n : ℚ) * D p) := by rw [hq]; ring |
|
|
|
|
| theorem pullbackQCartier_add |
| {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z] |
| (hNormal : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z)) |
| (f : X ⟶ Z) [IsDominant f] {D E : RationalWeilDivisor Z} |
| (hD : IsQCartier Z D) (hE : IsQCartier Z E) (hDE : IsQCartier Z (D + E)) : |
| pullbackQCartier hNormal f (D + E) hDE = |
| pullbackQCartier hNormal f D hD + pullbackQCartier hNormal f E hE := by |
| ext p |
| let c := hD.data |
| let e := hE.data |
| let U := c.chart (f p.1) |
| let V := e.chart (f p.1) |
| let u := c.equation (f p.1) |
| let v := e.equation (f p.1) |
| have hu := c.ord_eq (f p.1) |
| have hv := e.ord_eq (f p.1) |
| have huv : ∀ q : PrimeDivisor Z, q.1 ∈ U ⊓ V → |
| ((c.index * e.index : ℕ) : ℚ) * (D + E) q = |
| (Z.ord ((u ^ e.index * v ^ c.index : Z.functionFieldˣ) : Z.functionField) q.1 : ℚ) := by |
| intro q hq |
| simp only [Finsupp.add_apply, Units.val_mul, Units.val_pow_eq_pow_val, |
| Z.ord_mul (pow_ne_zero _ (Units.ne_zero u)) (pow_ne_zero _ (Units.ne_zero v)), |
| ord_pow Z _ (Units.ne_zero u), ord_pow Z _ (Units.ne_zero v)] |
| push_cast |
| rw [← hu q hq.1, ← hv q hq.2] |
| ring |
| rw [Finsupp.add_apply, |
| pullbackQCartier_apply_of_local hNormal f (D + E) hDE (c.index * e.index) |
| (Nat.mul_pos c.index_pos e.index_pos) (U ⊓ V) (u ^ e.index * v ^ c.index) huv p |
| ⟨c.mem_chart _, e.mem_chart _⟩, |
| pullbackQCartier_apply_of_local hNormal f D hD c.index c.index_pos U u hu p (c.mem_chart _), |
| pullbackQCartier_apply_of_local hNormal f E hE e.index e.index_pos V v hv p (e.mem_chart _)] |
| have hfu : functionFieldPullback f (u : Z.functionField) ≠ 0 := |
| by simp |
| have hfv : functionFieldPullback f (v : Z.functionField) ≠ 0 := |
| by simp |
| simp only [Units.val_mul, Units.val_pow_eq_pow_val, map_mul, map_pow, |
| X.ord_mul (pow_ne_zero _ hfu) (pow_ne_zero _ hfv), ord_pow X _ hfu, ord_pow X _ hfv] |
| have hn : (c.index : ℚ) ≠ 0 := by exact_mod_cast c.index_pos.ne' |
| have hm : (e.index : ℚ) ≠ 0 := by exact_mod_cast e.index_pos.ne' |
| push_cast |
| field_simp |
|
|
| theorem pullbackQCartier_smul |
| {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z] |
| (hNormal : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z)) |
| (f : X ⟶ Z) [IsDominant f] {D : RationalWeilDivisor Z} |
| (hD : IsQCartier Z D) (q : ℚ) (hqD : IsQCartier Z (q • D)) : |
| pullbackQCartier hNormal f (q • D) hqD = q • pullbackQCartier hNormal f D hD := by |
| ext p |
| let c := hD.data |
| let U := c.chart (f p.1) |
| let u := c.equation (f p.1) |
| have hu := c.ord_eq (f p.1) |
| have hq : (q.den : ℚ) * q = q.num := by |
| simp [mul_comm] |
| have hqu : ∀ r : PrimeDivisor Z, r.1 ∈ U → |
| ((c.index * q.den : ℕ) : ℚ) * (q • D) r = |
| (Z.ord ((u ^ q.num : Z.functionFieldˣ) : Z.functionField) r.1 : ℚ) := by |
| intro r hr |
| simp only [Finsupp.smul_apply, smul_eq_mul, Units.val_zpow_eq_zpow_val, |
| ord_zpow Z _ (Units.ne_zero u)] |
| push_cast |
| rw [← hu r hr] |
| calc (c.index : ℚ) * q.den * (q * D r) = c.index * ((q.den : ℚ) * q) * D r := by ring |
| _ = (q.num : ℚ) * ((c.index : ℚ) * D r) := by rw [hq]; ring |
| rw [Finsupp.smul_apply, |
| pullbackQCartier_apply_of_local hNormal f (q • D) hqD (c.index * q.den) |
| (Nat.mul_pos c.index_pos q.den_pos) U (u ^ q.num) hqu p (c.mem_chart _), |
| pullbackQCartier_apply_of_local hNormal f D hD c.index c.index_pos U u hu p (c.mem_chart _)] |
| have hfu : functionFieldPullback f (u : Z.functionField) ≠ 0 := |
| by simp |
| simp only [Units.val_zpow_eq_zpow_val, map_zpow₀, ord_zpow X _ hfu, smul_eq_mul] |
| have hn : (c.index : ℚ) ≠ 0 := by exact_mod_cast c.index_pos.ne' |
| have hd : (q.den : ℚ) ≠ 0 := by exact_mod_cast q.den_ne_zero |
| push_cast |
| rw [← hq] |
| field_simp |
|
|
| theorem rationalPrincipalDivisor_mul (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (u v : X.functionFieldˣ) : |
| rationalPrincipalDivisor X (u * v) = |
| rationalPrincipalDivisor X u + rationalPrincipalDivisor X v := by |
| ext p |
| simp [X.ord_mul (Units.ne_zero u) (Units.ne_zero v)] |
|
|
| theorem rationalPrincipalDivisor_div (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (u v : X.functionFieldˣ) : |
| rationalPrincipalDivisor X (u / v) = |
| rationalPrincipalDivisor X u - rationalPrincipalDivisor X v := by |
| ext p |
| simp [ord_div X _ _ (Units.ne_zero u) (Units.ne_zero v)] |
|
|
| theorem rationalPrincipalDivisor_pow (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (u : X.functionFieldˣ) (n : ℕ) : |
| rationalPrincipalDivisor X (u ^ n) = (n : ℚ) • rationalPrincipalDivisor X u := by |
| ext p |
| simp [ord_pow X _ (Units.ne_zero u)] |
|
|
| end |
|
|
| |
|
|
| theorem exact_presentation_of_vertical_principalization |
| {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z] |
| (hXNormal : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x)) |
| (hZNormal : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z)) |
| (f : X ⟶ Z) [IsDominant f] [IsIso f.c] |
| (A : RationalWeilDivisor X) (D : RationalWeilDivisor Z) (hD : IsQCartier Z D) |
| (p a : ℕ) (hp : 0 < p) (ha : 0 < a) (hpa : p ∣ a) |
| (ψ φ : X.functionFieldˣ) |
| (hvertical : IsVerticalRationalDivisor f ((p : ℚ) • A + rationalPrincipalDivisor X ψ)) |
| (hlinear : (a : ℚ) • A + rationalPrincipalDivisor X φ = |
| pullbackQCartier hZNormal f ((a : ℚ) • D) (isQCartier_smul hD (a : ℚ))) : |
| ∃ (h : Z.functionFieldˣ) |
| (hDZ : IsQCartier Z (D + (a : ℚ)⁻¹ • rationalPrincipalDivisor Z h)), |
| A + (p : ℚ)⁻¹ • rationalPrincipalDivisor X ψ = |
| pullbackQCartier hZNormal f (D + (a : ℚ)⁻¹ • rationalPrincipalDivisor Z h) hDZ := by |
| let b := a / p |
| have hbp : (b : ℚ) * (p : ℚ) = (a : ℚ) := by |
| exact_mod_cast Nat.div_mul_cancel hpa |
| have hpq : (p : ℚ) ≠ 0 := by exact_mod_cast hp.ne' |
| have haq : (a : ℚ) ≠ 0 := by exact_mod_cast ha.ne' |
| have hlin : (a : ℚ) • A + rationalPrincipalDivisor X φ = |
| (a : ℚ) • pullbackQCartier hZNormal f D hD := |
| hlinear.trans (pullbackQCartier_smul hZNormal f hD (a : ℚ) _) |
| let w : X.functionFieldˣ := ψ ^ b / φ |
| have hwdiv : rationalPrincipalDivisor X w = |
| (b : ℚ) • rationalPrincipalDivisor X ψ - rationalPrincipalDivisor X φ := by |
| change rationalPrincipalDivisor X (ψ ^ b / φ) = _ |
| rw [rationalPrincipalDivisor_div, rationalPrincipalDivisor_pow] |
| have hwvertical : IsVerticalDivisor f (principalDivisor X w) := by |
| intro r hr hgen |
| have hv0 : ((p : ℚ) • A + rationalPrincipalDivisor X ψ) r = 0 := by |
| by_contra hn |
| exact hvertical r hn hgen |
| have hd0 : pullbackQCartier hZNormal f D hD r = 0 := by |
| by_contra hn |
| exact isVertical_pullbackQCartier hZNormal f D hD r hn hgen |
| have hl := congrArg (fun E : RationalWeilDivisor X => E r) hlin |
| simp only [Finsupp.add_apply, Finsupp.smul_apply, smul_eq_mul, hd0, mul_zero] at hl hv0 |
| have hw0 : rationalPrincipalDivisor X w r = 0 := by |
| rw [hwdiv, Finsupp.sub_apply, Finsupp.smul_apply, smul_eq_mul] |
| have hψ : rationalPrincipalDivisor X ψ r = -(p : ℚ) * A r := by linarith |
| have hφ : rationalPrincipalDivisor X φ r = -(a : ℚ) * A r := by linarith |
| rw [hψ, hφ] |
| calc (b : ℚ) * (-(p : ℚ) * A r) - -(a : ℚ) * A r = |
| ((a : ℚ) - (b : ℚ) * p) * A r := by ring |
| _ = 0 := by rw [hbp, sub_self, zero_mul] |
| apply hr |
| change ((principalDivisor X w r : ℤ) : ℚ) = 0 at hw0 |
| exact_mod_cast hw0 |
| obtain ⟨h, hh⟩ := rational_function_descends_of_vertical_divisor hXNormal f w hwvertical |
| have hunit : Units.map (functionFieldPullback f).toMonoidHom h = w := Units.ext hh |
| let hH := isQCartier_principal Z h |
| let hscaled := isQCartier_smul hH ((a : ℚ)⁻¹) |
| let hDZ := isQCartier_add hD hscaled |
| refine ⟨h, hDZ, ?_⟩ |
| rw [pullbackQCartier_add hZNormal f hD hscaled hDZ, |
| pullbackQCartier_smul hZNormal f hH ((a : ℚ)⁻¹) hscaled, |
| pullbackQCartier_principal hZNormal f h hH, hunit, hwdiv] |
| ext r |
| have hl := congrArg (fun E : RationalWeilDivisor X => E r) hlin |
| simp only [Finsupp.add_apply, Finsupp.smul_apply, Finsupp.sub_apply, smul_eq_mul] at hl ⊢ |
| have hb : (b : ℚ) = (a : ℚ) / p := (eq_div_iff hpq).mpr hbp |
| rw [hb] |
| field_simp |
| linear_combination (p : ℚ) * hl |
|
|
| |
|
|
| def RationallyLinearlyEquivalent (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (D E : RationalWeilDivisor X) : Prop := |
| ∃ n : ℕ, 0 < n ∧ ∃ u : X.functionFieldˣ, |
| (n : ℚ) • (D - E) = rationalPrincipalDivisor X u |
|
|
| |
|
|
| theorem relative_exact_presentation_of_vertical_principalization |
| {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z] |
| (hXNormal : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x)) |
| (hZNormal : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z)) |
| (f : X ⟶ Z) [IsDominant f] [IsIso f.c] |
| (A : RationalWeilDivisor X) (D : RationalWeilDivisor Z) (hD : IsQCartier Z D) |
| (p a : ℕ) (hp : 0 < p) (ha : 0 < a) (hpa : p ∣ a) |
| (ψ φ : X.functionFieldˣ) |
| (hvertical : IsVerticalRationalDivisor f ((p : ℚ) • A + rationalPrincipalDivisor X ψ)) |
| (hlinear : (a : ℚ) • A + rationalPrincipalDivisor X φ = |
| pullbackQCartier hZNormal f ((a : ℚ) • D) (isQCartier_smul hD (a : ℚ))) : |
| ∃ (DZ : RationalWeilDivisor Z) (hDZ : IsQCartier Z DZ), |
| RationallyLinearlyEquivalent Z DZ D ∧ |
| A + (p : ℚ)⁻¹ • rationalPrincipalDivisor X ψ = pullbackQCartier hZNormal f DZ hDZ := by |
| obtain ⟨h, hDZ, heq⟩ := exact_presentation_of_vertical_principalization |
| hXNormal hZNormal f A D hD p a hp ha hpa ψ φ hvertical hlinear |
| refine ⟨_, hDZ, ⟨a, ha, h, ?_⟩, heq⟩ |
| rw [add_sub_cancel_left, smul_smul] |
| have haq : (a : ℚ) ≠ 0 := by exact_mod_cast ha.ne' |
| rw [mul_inv_cancel₀ haq, one_smul] |
|
|
| theorem principalDivisor_div (X : Scheme) [IsIntegral X] [IsNoetherian X] |
| (u v : X.functionFieldˣ) : |
| principalDivisor X (u / v) = principalDivisor X u - principalDivisor X v := by |
| ext p |
| change X.ord ((u / v : X.functionFieldˣ) : X.functionField) p.1 = |
| X.ord (u : X.functionField) p.1 - X.ord (v : X.functionField) p.1 |
| simpa only [Units.val_div_eq_div_val] using |
| ord_div X _ _ (Units.ne_zero u) (Units.ne_zero v) p.1 |
|
|
| theorem principalDivisor_constant |
| (K : Type u) [Field K] {X : Scheme.{u}} [IsIntegral X] [IsNoetherian X] |
| (f : X ⟶ Spec (.of K)) (c : Kˣ) : |
| principalDivisor X (Units.map (constantToFunctionField K f).toMonoidHom c) = 0 := by |
| ext p |
| change X.ord (X.germToFunctionField ⊤ |
| (((Scheme.ΓSpecIso (.of K)).inv ≫ f.appTop) (c : K))) p.1 = 0 |
| exact X.ord_of_isUnit (c.isUnit.map ((Scheme.ΓSpecIso (.of K)).inv ≫ f.appTop).hom) trivial |
|
|
| attribute [local instance] Units.mulDistribMulActionRight |
|
|
| |
|
|
| theorem invariant_rescaling_of_conjugate_divisor_eq |
| (K L : Type u) [Field K] [Field L] [Algebra K L] [FiniteDimensional K L] |
| {X : Scheme.{u}} [IsIntegral X] [IsNoetherian X] |
| (f : X ⟶ Spec (.of L)) [UniversallyClosed f] [GeometricallyIntegral f] |
| (hNormal : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x)) |
| [MulSemiringAction (Gal(L/K)) X.functionField] |
| (hsemilinear : ∀ (σ : Gal(L/K)) (c : L), |
| σ • constantToFunctionField L f c = constantToFunctionField L f (σ c)) |
| (u : X.functionFieldˣ) |
| (hdiv : ∀ σ : Gal(L/K), principalDivisor X (σ • u) = principalDivisor X u) : |
| ∃ c : Lˣ, let v := u / Units.map (constantToFunctionField L f).toMonoidHom c |
| (∀ σ : Gal(L/K), σ • v = v) ∧ principalDivisor X v = principalDivisor X u := by |
| classical |
| let C : Lˣ →* X.functionFieldˣ := Units.map (constantToFunctionField L f).toMonoidHom |
| have hCinjective : Function.Injective C := |
| Units.map_injective (constantToFunctionField L f).injective |
| have hCsemi (σ : Gal(L/K)) (c : Lˣ) : σ • C c = C (σ • c) := by |
| apply Units.ext |
| exact hsemilinear σ c |
| have hzero (σ : Gal(L/K)) : principalDivisor X (σ • u / u) = 0 := by |
| rw [principalDivisor_div, hdiv, sub_self] |
| choose c hc using fun σ : Gal(L/K) => |
| rational_function_constant_of_divisor_zero L f hNormal (σ • u / u) (hzero σ) |
| have hcu (σ : Gal(L/K)) : C (c σ) = σ • u / u := Units.ext (hc σ) |
| have hcocycle : groupCohomology.IsMulCocycle₁ c := by |
| intro σ τ |
| apply hCinjective |
| rw [map_mul, ← hCsemi, hcu, hcu, smul_div', hcu, mul_smul] |
| exact (div_mul_div_cancel _ _ _).symm |
| obtain ⟨β, hβ⟩ := |
| groupCohomology.isMulCoboundary₁_of_isMulCocycle₁_of_aut_to_units c hcocycle |
| refine ⟨β, ?_, ?_⟩ |
| · intro σ |
| have he := congrArg C (hβ σ) |
| rw [_root_.map_div, ← hCsemi, hcu] at he |
| change σ • (u / C β) = u / C β |
| rw [smul_div'] |
| apply div_eq_div_iff_mul_eq_mul.mpr |
| have hh := div_eq_div_iff_mul_eq_mul.mp he |
| simpa only [mul_comm] using hh.symm |
| · change principalDivisor X (u / C β) = principalDivisor X u |
| rw [principalDivisor_div, principalDivisor_constant, sub_zero] |
|
|
| end RelativeDenominators |
| end |
|
|
| end OAI |
|
|
