| import Mathlib.RingTheory.Ideal.Quotient.Operations |
| import Mathlib.RingTheory.MvPowerSeries.Order |
|
|
| namespace OAI |
|
|
| namespace PiExponent.JetGeometry |
|
|
| noncomputable section |
|
|
| open MvPowerSeries |
|
|
| variable {σ R : Type*} [CommRing R] |
|
|
| def weightedIdeal (w : σ → ℕ) (N : ℕ) : Ideal (MvPowerSeries σ R) where |
| carrier := {f | (N : ℕ∞) ≤ f.weightedOrder w} |
| zero_mem' := by simp |
| add_mem' hf hg := (le_min hf hg).trans (min_weightedOrder_le_add w) |
| smul_mem' a f hf := by |
| change (N : ℕ∞) ≤ weightedOrder w (a * f) |
| exact hf.trans (le_add_self.trans (le_weightedOrder_mul w)) |
|
|
| @[simp] theorem mem_weightedIdeal (w : σ → ℕ) (N : ℕ) |
| (f : MvPowerSeries σ R) : |
| f ∈ weightedIdeal w N ↔ (N : ℕ∞) ≤ f.weightedOrder w := Iff.rfl |
|
|
| theorem mem_weightedIdeal_iff (w : σ → ℕ) (N : ℕ) |
| (f : MvPowerSeries σ R) : |
| f ∈ weightedIdeal w N ↔ ∀ d, Finsupp.weight w d < N → coeff d f = 0 := by |
| constructor |
| · intro hf d hd |
| have hd' : (Finsupp.weight w d : ℕ∞) < (N : ℕ∞) := by exact_mod_cast hd |
| exact coeff_eq_zero_of_lt_weightedOrder w (hd'.trans_le hf) |
| · intro hf |
| exact nat_le_weightedOrder w hf |
|
|
| theorem weightedIdeal_mul_le (w : σ → ℕ) (M N : ℕ) : |
| (weightedIdeal w M : Ideal (MvPowerSeries σ R)) * weightedIdeal w N ≤ |
| weightedIdeal w (M + N) := by |
| apply Ideal.mul_le.mpr |
| intro f hf g hg |
| change ((M + N : ℕ) : ℕ∞) ≤ weightedOrder w (f * g) |
| rw [Nat.cast_add] |
| exact (add_le_add hf hg).trans (le_weightedOrder_mul w) |
|
|
| theorem ideal_pow_le_weightedIdeal (w : σ → ℕ) (I : Ideal (MvPowerSeries σ R)) |
| (R₀ : ℕ) (hI : I ≤ weightedIdeal w R₀) (n : ℕ) : |
| I ^ n ≤ weightedIdeal w (n * R₀) := by |
| induction n with |
| | zero => |
| intro f hf |
| change ((0 * R₀ : ℕ) : ℕ∞) ≤ weightedOrder w f |
| simp |
| | succ n ih => |
| rw [pow_succ, Nat.succ_mul] |
| apply Ideal.mul_le.mpr |
| intro f hf g hg |
| exact (Ideal.mul_le.mp (weightedIdeal_mul_le w (n * R₀) R₀)) f (ih hf) g (hI hg) |
|
|
| def coordinatePowerIdeal (e : σ → ℕ) : Ideal (MvPowerSeries σ R) := |
| Ideal.span (Set.range (fun i => (X i : MvPowerSeries σ R) ^ e i)) |
|
|
| theorem X_pow_mem_weightedIdeal (w e : σ → ℕ) (R₀ : ℕ) |
| (he : ∀ i, R₀ ≤ e i * w i) (i : σ) : |
| (X i : MvPowerSeries σ R) ^ e i ∈ weightedIdeal w R₀ := by |
| classical |
| apply (mem_weightedIdeal_iff w R₀ _).mpr |
| intro d hd |
| rw [coeff_X_pow] |
| split_ifs with h |
| · subst d |
| have hweight : Finsupp.weight w (Finsupp.single i (e i)) = e i * w i := by |
| simp [Finsupp.weight] |
| rw [hweight] at hd |
| exact False.elim ((not_lt_of_ge (he i)) hd) |
| · rfl |
|
|
| theorem coordinatePowerIdeal_pow_le (w e : σ → ℕ) (R₀ : ℕ) |
| (he : ∀ i, R₀ ≤ e i * w i) (n : ℕ) : |
| (coordinatePowerIdeal e : Ideal (MvPowerSeries σ R)) ^ n ≤ |
| weightedIdeal w (n * R₀) := by |
| apply ideal_pow_le_weightedIdeal w _ R₀ _ n |
| apply Ideal.span_le.mpr |
| rintro _ ⟨i, rfl⟩ |
| exact X_pow_mem_weightedIdeal w e R₀ he i |
|
|
| theorem quotient_surjective_of_le {A α : Type*} [CommRing A] |
| (I J : Ideal A) (hIJ : I ≤ J) (f : α → A) |
| (hf : Function.Surjective (fun a => Ideal.Quotient.mk I (f a))) : |
| Function.Surjective (fun a => Ideal.Quotient.mk J (f a)) := by |
| intro y |
| obtain ⟨x, hx⟩ := Ideal.Quotient.factor_surjective hIJ y |
| obtain ⟨a, ha⟩ := hf x |
| refine ⟨a, ?_⟩ |
| rw [← hx, ← ha] |
| exact (Ideal.Quotient.factor_mk hIJ (f a)).symm |
|
|
| def CoefficientPacket (w : σ → ℕ) (N : ℕ) := |
| {d : σ →₀ ℕ // Finsupp.weight w d < N} → R |
|
|
| def coefficientPacket (w : σ → ℕ) (N : ℕ) (f : MvPowerSeries σ R) : |
| CoefficientPacket (R := R) w N := fun d => coeff d.val f |
|
|
| theorem coefficientPacket_surjective_of_quotient {α : Type*} |
| (w : σ → ℕ) (N : ℕ) (I : Ideal (MvPowerSeries σ R)) |
| (hI : I ≤ weightedIdeal w N) (f : α → MvPowerSeries σ R) |
| (hf : Function.Surjective (fun a => Ideal.Quotient.mk I (f a))) : |
| Function.Surjective (fun a => coefficientPacket w N (f a)) := by |
| classical |
| intro packet |
| let F : MvPowerSeries σ R := fun d => |
| if hd : Finsupp.weight w d < N then packet ⟨d, hd⟩ else 0 |
| obtain ⟨a, ha⟩ := hf (Ideal.Quotient.mk I F) |
| have hdiff : f a - F ∈ weightedIdeal w N := |
| hI (Ideal.Quotient.eq.mp ha) |
| refine ⟨a, ?_⟩ |
| funext d |
| have hzero := (mem_weightedIdeal_iff w N (f a - F)).mp hdiff d.val d.property |
| rw [map_sub, sub_eq_zero] at hzero |
| change coeff d.val (f a) = packet d |
| rw [hzero] |
| change (if hd : Finsupp.weight w d.val < N then packet ⟨d.val, hd⟩ else 0) = packet d |
| simp only [dite_eq_left d.property] |
|
|
| theorem coefficientPacket_surjective_of_coordinatePowerIdeal {α : Type*} |
| (w e : σ → ℕ) (R₀ : ℕ) (he : ∀ i, R₀ ≤ e i * w i) |
| (n : ℕ) (f : α → MvPowerSeries σ R) |
| (hf : Function.Surjective (fun a => |
| Ideal.Quotient.mk ((coordinatePowerIdeal e : Ideal (MvPowerSeries σ R)) ^ n) (f a))) : |
| Function.Surjective (fun a => coefficientPacket w (n * R₀) (f a)) := |
| coefficientPacket_surjective_of_quotient w (n * R₀) _ |
| (coordinatePowerIdeal_pow_le w e R₀ he n) f hf |
|
|
| theorem rational_weight_nonneg (v : σ → ℚ) (hv : ∀ i, 0 ≤ v i) |
| (d : σ →₀ ℕ) : 0 ≤ Finsupp.weight v d := by |
| rw [Finsupp.weight_apply, Finsupp.sum] |
| exact Finset.sum_nonneg (fun i _ => nsmul_nonneg (hv i) (d i)) |
|
|
| def rationalWeightedIdeal (v : σ → ℚ) (hv : ∀ i, 0 ≤ v i) (H : ℚ) : |
| Ideal (MvPowerSeries σ R) where |
| carrier := {f | ∀ d, Finsupp.weight v d < H → coeff d f = 0} |
| zero_mem' := by simp |
| add_mem' hf hg := by |
| intro d hd |
| rw [map_add, hf d hd, hg d hd, add_zero] |
| smul_mem' a f hf := by |
| classical |
| intro d hd |
| change coeff d (a * f) = 0 |
| rw [coeff_mul] |
| apply Finset.sum_eq_zero |
| intro ij hij |
| have he : ij.1 + ij.2 = d := Finset.mem_antidiagonal.mp hij |
| have hw : Finsupp.weight v ij.2 ≤ Finsupp.weight v d := by |
| rw [← he, map_add] |
| exact le_add_of_nonneg_left (rational_weight_nonneg v hv ij.1) |
| rw [hf ij.2 (hw.trans_lt hd), mul_zero] |
|
|
| @[simp] theorem mem_rationalWeightedIdeal (v : σ → ℚ) (hv : ∀ i, 0 ≤ v i) |
| (H : ℚ) (f : MvPowerSeries σ R) : |
| f ∈ rationalWeightedIdeal v hv H ↔ |
| ∀ d, Finsupp.weight v d < H → coeff d f = 0 := Iff.rfl |
|
|
| theorem rationalWeightedIdeal_mul_le (v : σ → ℚ) (hv : ∀ i, 0 ≤ v i) (H K : ℚ) : |
| (rationalWeightedIdeal v hv H : Ideal (MvPowerSeries σ R)) * |
| rationalWeightedIdeal v hv K ≤ rationalWeightedIdeal v hv (H + K) := by |
| classical |
| apply Ideal.mul_le.mpr |
| intro f hf g hg d hd |
| rw [coeff_mul] |
| apply Finset.sum_eq_zero |
| intro ij hij |
| have he : ij.1 + ij.2 = d := Finset.mem_antidiagonal.mp hij |
| by_cases hfirst : Finsupp.weight v ij.1 < H |
| · rw [hf ij.1 hfirst, zero_mul] |
| · have hsecond : Finsupp.weight v ij.2 < K := by |
| apply lt_of_not_ge |
| intro hsecond |
| have hsum := add_le_add (le_of_not_gt hfirst) hsecond |
| rw [← map_add, he] at hsum |
| exact (not_le_of_gt hd) hsum |
| rw [hg ij.2 hsecond, mul_zero] |
|
|
| theorem ideal_pow_le_rationalWeightedIdeal (v : σ → ℚ) (hv : ∀ i, 0 ≤ v i) |
| (I : Ideal (MvPowerSeries σ R)) (H : ℚ) |
| (hI : I ≤ rationalWeightedIdeal v hv H) (n : ℕ) : |
| I ^ n ≤ rationalWeightedIdeal v hv (n * H) := by |
| induction n with |
| | zero => |
| intro f hf d hd |
| have hzero := rational_weight_nonneg v hv d |
| simp only [Nat.cast_zero, zero_mul] at hd |
| exact False.elim ((not_lt_of_ge hzero) hd) |
| | succ n ih => |
| rw [pow_succ, Nat.cast_add, Nat.cast_one, add_mul, one_mul] |
| apply Ideal.mul_le.mpr |
| intro f hf g hg |
| exact (Ideal.mul_le.mp (rationalWeightedIdeal_mul_le v hv (n * H) H)) |
| f (ih hf) g (hI hg) |
|
|
| theorem coordinatePowerIdeal_pow_le_rational (v : σ → ℚ) (hv : ∀ i, 0 ≤ v i) |
| (e : σ → ℕ) (H : ℚ) (he : ∀ i, H ≤ (e i : ℚ) * v i) (n : ℕ) : |
| (coordinatePowerIdeal e : Ideal (MvPowerSeries σ R)) ^ n ≤ |
| rationalWeightedIdeal v hv (n * H) := by |
| classical |
| apply ideal_pow_le_rationalWeightedIdeal v hv _ H _ n |
| apply Ideal.span_le.mpr |
| rintro _ ⟨i, rfl⟩ d hd |
| rw [coeff_X_pow] |
| split_ifs with h |
| · subst d |
| rw [Finsupp.weight_single, nsmul_eq_mul] at hd |
| exact False.elim ((not_lt_of_ge (he i)) hd) |
| · rfl |
|
|
| def RationalCoefficientPacket (v : σ → ℚ) (H : ℚ) := |
| {d : σ →₀ ℕ // Finsupp.weight v d < H} → R |
|
|
| def rationalCoefficientPacket (v : σ → ℚ) (H : ℚ) (f : MvPowerSeries σ R) : |
| RationalCoefficientPacket (R := R) v H := fun d => coeff d.val f |
|
|
| theorem rationalCoefficientPacket_surjective_of_coordinatePowerIdeal {α : Type*} |
| (v : σ → ℚ) (hv : ∀ i, 0 ≤ v i) (e : σ → ℕ) (H : ℚ) |
| (he : ∀ i, H ≤ (e i : ℚ) * v i) (n : ℕ) |
| (f : α → MvPowerSeries σ R) |
| (hf : Function.Surjective (fun a => |
| Ideal.Quotient.mk ((coordinatePowerIdeal e : Ideal (MvPowerSeries σ R)) ^ n) (f a))) : |
| Function.Surjective (fun a => rationalCoefficientPacket v (n * H) (f a)) := by |
| classical |
| intro packet |
| let F : MvPowerSeries σ R := fun d => |
| if hd : Finsupp.weight v d < n * H then packet ⟨d, hd⟩ else 0 |
| obtain ⟨a, ha⟩ := hf (Ideal.Quotient.mk _ F) |
| have hdiff : f a - F ∈ rationalWeightedIdeal v hv (n * H) := |
| coordinatePowerIdeal_pow_le_rational v hv e H he n (Ideal.Quotient.eq.mp ha) |
| refine ⟨a, ?_⟩ |
| funext d |
| have hzero := hdiff d.val d.property |
| rw [map_sub, sub_eq_zero] at hzero |
| change coeff d.val (f a) = packet d |
| rw [hzero] |
| change (if hd : Finsupp.weight v d.val < n * H then packet ⟨d.val, hd⟩ else 0) = packet d |
| simp only [dite_eq_left d.property] |
|
|
| theorem rationalCoefficientPackets_surjective_of_coordinatePowerIdeal {α J : Type*} |
| (v : σ → ℚ) (hv : ∀ i, 0 ≤ v i) (e : σ → ℕ) (H : ℚ) |
| (he : ∀ i, H ≤ (e i : ℚ) * v i) (n : ℕ) |
| (f : α → J → MvPowerSeries σ R) |
| (hf : Function.Surjective (fun a j => |
| Ideal.Quotient.mk ((coordinatePowerIdeal e : Ideal (MvPowerSeries σ R)) ^ n) (f a j))) : |
| Function.Surjective (fun a j => rationalCoefficientPacket v (n * H) (f a j)) := by |
| classical |
| intro packets |
| let F : J → MvPowerSeries σ R := fun j d => |
| if hd : Finsupp.weight v d < n * H then packets j ⟨d, hd⟩ else 0 |
| obtain ⟨a, ha⟩ := hf (fun j => Ideal.Quotient.mk _ (F j)) |
| refine ⟨a, ?_⟩ |
| funext j d |
| have hdiff : f a j - F j ∈ rationalWeightedIdeal v hv (n * H) := |
| coordinatePowerIdeal_pow_le_rational v hv e H he n |
| (Ideal.Quotient.eq.mp (congrFun ha j)) |
| have hzero := hdiff d.val d.property |
| rw [map_sub, sub_eq_zero] at hzero |
| change coeff d.val (f a j) = packets j d |
| rw [hzero] |
| change (if hd : Finsupp.weight v d.val < n * H then packets j ⟨d.val, hd⟩ else 0) = packets j d |
| simp only [dite_eq_left d.property] |
|
|
| end |
|
|
| end PiExponent.JetGeometry |
|
|
| end OAI |
|
|
