File size: 6,070 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 | import OAI.AlgebraicGeometry.CartierSections.InitialExponents
import Mathlib.Data.Finsupp.Multiset
import Mathlib.RingTheory.MvPowerSeries.Derivative
namespace OAI
/-!
# Euler operators on formal power series
Euler operators act diagonally on coefficients, and iterated transverse derivatives shift
the coefficient exponent. These formulas yield finite operators that isolate bounded exponents.
-/
open scoped BigOperators
namespace CartierSections
section EulerOperators
variable {ι k : Type*} [Field k] [CharZero k]
/-- The Euler differential operator minus a scalar. -/
noncomputable def eulerStep (i : ι) (l : ℕ) (f : MvPowerSeries ι k) :
MvPowerSeries ι k :=
MvPowerSeries.X i * MvPowerSeries.pderiv (R := k) i f - (l : k) • f
@[simp] theorem coeff_eulerStep (i : ι) (l : ℕ) (f : MvPowerSeries ι k)
(d : ι →₀ ℕ) :
MvPowerSeries.coeff d (eulerStep i l f) =
((d i : k) - l) * MvPowerSeries.coeff d f := by
classical
have hX : (MvPowerSeries.X i : MvPowerSeries ι k) =
MvPowerSeries.monomial (Finsupp.single i 1) 1 := rfl
simp only [eulerStep, map_sub, map_smul, smul_eq_mul, hX,
MvPowerSeries.coeff_monomial_mul]
by_cases hi : Finsupp.single i 1 ≤ d
· rw [ite_eq_left hi, one_mul, MvPowerSeries.coeff_pderiv, tsub_add_cancel_of_le hi]
have hd : 1 ≤ d i := by simpa using hi i
simp only [Finsupp.tsub_apply, Finsupp.single_eq_same]
rw [Nat.cast_sub hd]
ring
· have hd : d i = 0 := by
by_contra h
apply hi
intro j
by_cases hj : j = i
· subst j; simpa using Nat.one_le_iff_ne_zero.mpr h
· simp [Finsupp.single_eq_of_ne hj]
simp [hd]
noncomputable def iterEuler : List (ι × ℕ) → MvPowerSeries ι k → MvPowerSeries ι k
| [] => id
| (i,l) :: L => fun f => eulerStep i l (iterEuler L f)
@[simp] theorem coeff_iterEuler (L : List (ι × ℕ)) (f : MvPowerSeries ι k)
(d : ι →₀ ℕ) :
MvPowerSeries.coeff d (iterEuler L f) =
(L.map (fun a => ((d a.1 : k) - a.2))).prod * MvPowerSeries.coeff d f := by
induction L with
| nil => simp [iterEuler]
| cons a L ih =>
simp only [iterEuler, coeff_eulerStep, List.map_cons, List.prod_cons, ih, mul_assoc]
/-- Euler factors selecting one boundary exponent among those bounded by `N`. -/
noncomputable def eulerFactors (B : Finset ι) (N : ℕ) (α : ι →₀ ℕ) :
List (ι × ℕ) := by
classical
exact ((B ×ˢ Finset.range (N+1)).filter (fun a => a.2 ≠ α a.1)).toList
@[simp] theorem mem_eulerFactors (B : Finset ι) (N : ℕ) (α : ι →₀ ℕ)
(i : ι) (l : ℕ) :
(i,l) ∈ eulerFactors B N α ↔ i ∈ B ∧ l ≤ N ∧ l ≠ α i := by
classical
simp [eulerFactors, and_assoc]
/-- The chosen coefficient survives over a field of characteristic zero. -/
theorem coeff_eulerFactors_self_ne_zero (B : Finset ι) (N : ℕ)
(α γ : ι →₀ ℕ) (hαγ : ∀ i ∈ B, γ i = α i)
{f : MvPowerSeries ι k} (hf : MvPowerSeries.coeff γ f ≠ 0) :
MvPowerSeries.coeff γ (iterEuler (eulerFactors B N α) f) ≠ 0 := by
classical
rw [coeff_iterEuler]
apply mul_ne_zero _ hf
apply List.prod_ne_zero
intro hc
obtain ⟨⟨i,l⟩, hil, hz⟩ := List.mem_map.mp hc
have h := (mem_eulerFactors B N α i l).mp hil
have hne : (γ i : k) - l ≠ 0 := sub_ne_zero.mpr (by
rw [hαγ i h.1]
exact_mod_cast h.2.2.symm)
exact hne hz
/-- Every other bounded exponent in the boundary coordinates is killed. -/
theorem coeff_eulerFactors_eq_zero (B : Finset ι) (N : ℕ)
(α d : ι →₀ ℕ) (hd : ∃ i ∈ B, d i ≤ N ∧ d i ≠ α i)
(f : MvPowerSeries ι k) :
MvPowerSeries.coeff d (iterEuler (eulerFactors B N α) f) = 0 := by
classical
rw [coeff_iterEuler]
obtain ⟨i, hi, hdi, hne⟩ := hd
have hm : (0 : k) ∈ (eulerFactors B N α).map (fun a => (d a.1 : k) - a.2) := by
apply List.mem_map.mpr
exact ⟨(i,d i), (mem_eulerFactors B N α i (d i)).mpr ⟨hi,hdi,hne⟩, sub_self _⟩
rw [List.prod_eq_zero_iff.mpr hm, zero_mul]
/-- The number of Euler factors is at most s(N+1), uniformly in the weights. -/
theorem eulerFactors_length_le (B : Finset ι) (N : ℕ) (α : ι →₀ ℕ) :
(eulerFactors B N α).length ≤ B.card * (N+1) := by
classical
simpa [eulerFactors] using
(Finset.card_filter_le (B ×ˢ Finset.range (N+1)) (fun a => a.2 ≠ α a.1))
noncomputable def iterPartial : List ι → MvPowerSeries ι k → MvPowerSeries ι k
| [] => id
| i :: L => fun f => MvPowerSeries.pderiv (R := k) i (iterPartial L f)
noncomputable def listExponent (L : List ι) : ι →₀ ℕ := by
classical
exact (L : Multiset ι).toFinsupp
@[simp] theorem listExponent_nil : listExponent ([] : List ι) = 0 := by
classical
simp [listExponent]
@[simp] theorem listExponent_cons (i : ι) (L : List ι) :
listExponent (i :: L) = Finsupp.single i 1 + listExponent L := by
classical
ext j
by_cases h : j = i
· subst j; simp [listExponent, add_comm]
· simp [listExponent, h, Ne.symm h]
/-- Iterated transverse derivatives shift coefficients by their multidegree; the factorial coefficient is nonzero in characteristic zero. -/
theorem coeff_iterPartial_ne_zero_iff (L : List ι) (f : MvPowerSeries ι k)
(d : ι →₀ ℕ) :
MvPowerSeries.coeff d (iterPartial L f) ≠ 0 ↔
MvPowerSeries.coeff (d + listExponent L) f ≠ 0 := by
induction L generalizing d with
| nil => simp [iterPartial]
| cons i L ih =>
rw [iterPartial, MvPowerSeries.coeff_pderiv, mul_ne_zero_iff, ih]
have hn : (d i : k) + 1 ≠ 0 := by
exact_mod_cast Nat.succ_ne_zero (d i)
simp [listExponent_cons, hn, add_assoc]
@[simp] theorem listExponent_toList (β : ι →₀ ℕ) :
listExponent β.toMultiset.toList = β := by
classical
simp [listExponent]
@[simp] theorem length_exponent_toList [Fintype ι] (β : ι →₀ ℕ) :
β.toMultiset.toList.length = exponentDegree β := by
simp [exponentDegree, Finsupp.card_toMultiset, Finsupp.sum_fintype]
end EulerOperators
end CartierSections
end OAI
|