File size: 7,084 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 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 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 | import Lean.Elab.Tactic.Omega
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Algebra.MvPolynomial.Eval
import Mathlib.Data.Fintype.BigOperators
namespace OAI
/-!
# Guarded homogenization of affine incidence equations
-/
section
noncomputable section
namespace Nagata.W27
open scoped BigOperators
open MvPolynomial
variable {r : ℕ} {R : Type*} [CommRing R]
/-- Affine degree in one point-coordinate block. -/
def blockOrder (a : (Fin r × Fin 2) →₀ ℕ) (i : Fin r) : ℕ :=
a (i, 0) + a (i, 1)
/-- A separate degree bound for each point-coordinate block. -/
def blockDegreeBound (f : MvPolynomial (Fin r × Fin 2) R) (i : Fin r) : ℕ :=
f.support.sup (fun a => blockOrder a i)
theorem blockOrder_le_bound (f : MvPolynomial (Fin r × Fin 2) R)
(a : (Fin r × Fin 2) →₀ ℕ) (ha : a ∈ f.support) (i : Fin r) :
blockOrder a i ≤ blockDegreeBound f i := by
exact Finset.le_sup (f := fun a => blockOrder a i) ha
/-- Insert the distinguished projective-coordinate exponent. The extra one
is the guard: every term vanishes outside the chosen product affine chart. -/
def guardedExponent (c : Fin r → Fin 3) (D : Fin r → ℕ)
(a : (Fin r × Fin 2) →₀ ℕ) : (Fin r × Fin 3) →₀ ℕ :=
Finsupp.equivFunOnFinite.symm fun ij : Fin r × Fin 3 =>
Fin.insertNth (α := fun _ : Fin 3 => ℕ) (c ij.1)
(D ij.1 - blockOrder a ij.1 + 1)
(fun j => a (ij.1, j)) ij.2
@[simp] theorem guardedExponent_same (c : Fin r → Fin 3) (D : Fin r → ℕ)
(a : (Fin r × Fin 2) →₀ ℕ) (i : Fin r) :
guardedExponent c D a (i, c i) = D i - blockOrder a i + 1 := by
simp [guardedExponent]
@[simp] theorem guardedExponent_other (c : Fin r → Fin 3) (D : Fin r → ℕ)
(a : (Fin r × Fin 2) →₀ ℕ) (i : Fin r) (j : Fin 2) :
guardedExponent c D a (i, (c i).succAbove j) = a (i, j) := by
simp [guardedExponent]
theorem guardedExponent_block_sum (c : Fin r → Fin 3) (D : Fin r → ℕ)
(a : (Fin r × Fin 2) →₀ ℕ) (i : Fin r) (ha : blockOrder a i ≤ D i) :
(∑ j : Fin 3, guardedExponent c D a (i, j)) = D i + 1 := by
rw [Fin.sum_univ_succAbove _ (c i)]
simp only [guardedExponent_same, guardedExponent_other, Fin.sum_univ_two]
unfold blockOrder at *
omega
/-- Guarded block homogenization of an arbitrary affine polynomial. -/
def guardedHomogenize (c : Fin r → Fin 3)
(f : MvPolynomial (Fin r × Fin 2) R) : MvPolynomial (Fin r × Fin 3) R :=
∑ a ∈ f.support, monomial (guardedExponent c (blockDegreeBound f) a) (f.coeff a)
/-- Each actual support monomial has the prescribed degree in every block. -/
theorem guardedHomogenize_homogeneous (c : Fin r → Fin 3)
(f : MvPolynomial (Fin r × Fin 2) R)
(b : (Fin r × Fin 3) →₀ ℕ) (hb : b ∈ (guardedHomogenize c f).support)
(i : Fin r) : (∑ j : Fin 3, b (i, j)) = blockDegreeBound f i + 1 := by
classical
have hcoeff : (guardedHomogenize c f).coeff b ≠ 0 := mem_support_iff.mp hb
simp only [guardedHomogenize, coeff_sum] at hcoeff
obtain ⟨a, ha, hterm⟩ := Finset.exists_ne_zero_of_sum_ne_zero hcoeff
have heq : guardedExponent c (blockDegreeBound f) a = b := by
by_contra hne
exact hterm (by simp [coeff_monomial, hne])
rw [← heq]
exact guardedExponent_block_sum c _ a i (blockOrder_le_bound f a ha i)
/-- A zero distinguished coordinate kills every guarded term. -/
theorem eval_guardedHomogenize_zero (c : Fin r → Fin 3)
(f : MvPolynomial (Fin r × Fin 2) R) (v : Fin r × Fin 3 → R)
(i : Fin r) (hi : v (i, c i) = 0) :
eval v (guardedHomogenize c f) = 0 := by
classical
simp only [guardedHomogenize, map_sum]
apply Finset.sum_eq_zero
intro a ha
rw [eval_monomial, Finsupp.prod_fintype _ _ (fun _ => pow_zero _)]
apply mul_eq_zero_of_right
apply Finset.prod_eq_zero (Finset.mem_univ (i, c i))
rw [guardedExponent_same, hi]
exact zero_pow (by omega)
/-- On normalized homogeneous representatives the homogenized polynomial
evaluates to the original affine polynomial. -/
theorem eval_guardedHomogenize_normalized (c : Fin r → Fin 3)
(f : MvPolynomial (Fin r × Fin 2) R) (v : Fin r × Fin 3 → R)
(hv : ∀ i, v (i, c i) = 1) :
eval v (guardedHomogenize c f) =
eval (fun ij => v (ij.1, (c ij.1).succAbove ij.2)) f := by
classical
rw [eval_eq' _ f]
simp only [guardedHomogenize, map_sum, eval_monomial]
apply Finset.sum_congr rfl
intro a ha
congr 1
rw [Finsupp.prod_fintype _ _ (fun _ => pow_zero _),
Fintype.prod_prod_type, Fintype.prod_prod_type]
apply Finset.prod_congr rfl
intro i hi
rw [Fin.prod_univ_succAbove _ (c i)]
simp only [guardedExponent_same, guardedExponent_other, hv, one_pow, one_mul]
/-- Scaling each homogeneous coordinate block scales the polynomial by its
actual block degree. -/
theorem eval_guardedHomogenize_scale (c : Fin r → Fin 3)
(f : MvPolynomial (Fin r × Fin 2) R)
(a : Fin r → R) (v : Fin r × Fin 3 → R) :
eval (fun ij => a ij.1 * v ij) (guardedHomogenize c f) =
(∏ i, a i ^ (blockDegreeBound f i + 1)) * eval v (guardedHomogenize c f) := by
classical
simp only [eval_eq', Finset.mul_sum]
apply Finset.sum_congr rfl
intro b hb
simp only [mul_pow, Finset.prod_mul_distrib]
have hprod : (∏ ij : Fin r × Fin 3, a ij.1 ^ b ij) =
∏ i, a i ^ (blockDegreeBound f i + 1) := by
rw [Fintype.prod_prod_type]
apply Finset.prod_congr rfl
intro i hi
change (∏ j : Fin 3, a i ^ b (i, j)) = a i ^ (blockDegreeBound f i + 1)
rw [Finset.prod_pow_eq_pow_sum, guardedHomogenize_homogeneous c f b hb i]
rw [hprod]
ac_rfl
/-- For arbitrary nonzero chart coordinates the denominator-clearing factor
is explicit and nonzero. -/
theorem eval_guardedHomogenize_chart {K : Type*} [Field K]
(c : Fin r → Fin 3) (f : MvPolynomial (Fin r × Fin 2) K)
(v : Fin r × Fin 3 → K) (hv : ∀ i, v (i, c i) ≠ 0) :
eval v (guardedHomogenize c f) =
(∏ i, v (i, c i) ^ (blockDegreeBound f i + 1)) *
eval (fun ij => v (ij.1, (c ij.1).succAbove ij.2) / v (ij.1, c ij.1)) f := by
have h := eval_guardedHomogenize_scale c f
(fun i => v (i, c i)) (fun ij => v ij / v (ij.1, c ij.1))
have heq : (fun ij : Fin r × Fin 3 =>
v (ij.1, c ij.1) * (v ij / v (ij.1, c ij.1))) = v := by
funext ij
exact mul_div_cancel₀ _ (hv ij.1)
rw [heq] at h
rw [eval_guardedHomogenize_normalized c f
(fun ij => v ij / v (ij.1, c ij.1)) (fun i => div_self (hv i))] at h
exact h
theorem eval_guardedHomogenize_eq_zero_iff {K : Type*} [Field K]
(c : Fin r → Fin 3) (f : MvPolynomial (Fin r × Fin 2) K)
(v : Fin r × Fin 3 → K) (hv : ∀ i, v (i, c i) ≠ 0) :
eval v (guardedHomogenize c f) = 0 ↔
eval (fun ij => v (ij.1, (c ij.1).succAbove ij.2) / v (ij.1, c ij.1)) f = 0 := by
rw [eval_guardedHomogenize_chart c f v hv]
have hfactor : (∏ i, v (i, c i) ^ (blockDegreeBound f i + 1)) ≠ 0 :=
Finset.prod_ne_zero_iff.mpr fun i hi => pow_ne_zero _ (hv i)
exact mul_eq_zero.trans (or_iff_right hfactor)
end Nagata.W27
end
end
end OAI
|