| import OAI.Computability.RationalHitting.LaurentReduction |
|
|
| namespace OAI |
|
|
| namespace RationalHitting.SmallExpansion |
| open Module Polynomial |
| open scoped BigOperators |
| open LaurentReduction Expansion |
| noncomputable section |
| variable {K : Type*} [Field K] |
|
|
| / |
| def polynomialMap (M : ℕ) : (Fin M → K) →ₗ[K] K[X] := |
| (Polynomial.degreeLT K M).subtype.comp (Polynomial.degreeLTEquiv K M).symm.toLinearMap |
|
|
| lemma polynomialMap_injective (M : ℕ) : Function.Injective (polynomialMap (K := K) M) := |
| Subtype.val_injective.comp (Polynomial.degreeLTEquiv K M).symm.injective |
|
|
| @[simp] lemma polynomialMap_coeff (M : ℕ) (x : Fin M → K) (j : Fin M) : |
| (polynomialMap M x).coeff j = x j := by |
| exact congrFun ((Polynomial.degreeLTEquiv K M).apply_symm_apply x) j |
|
|
| lemma polynomialMap_mem (M : ℕ) (x : Fin M → K) : |
| polynomialMap M x ∈ Polynomial.degreeLT K M := |
| ((Polynomial.degreeLTEquiv K M).symm x).property |
|
|
| lemma polynomialMap_coeff_high (M : ℕ) (x : Fin M → K) (j : ℕ) (hj : M ≤ j) : |
| (polynomialMap M x).coeff j = 0 := by |
| apply coeff_eq_zero_of_degree_lt |
| exact (Polynomial.mem_degreeLT.mp (polynomialMap_mem M x)).trans_le (by exact_mod_cast hj) |
|
|
| def polynomialSpace {M : ℕ} (V : Submodule K (Fin M → K)) : Submodule K K[X] := |
| V.map (polynomialMap M) |
|
|
| lemma finrank_polynomialSpace {M : ℕ} (V : Submodule K (Fin M → K)) : |
| finrank K (polynomialSpace V) = finrank K V := |
| finrank_map_injective _ (polynomialMap_injective M) V |
|
|
| lemma polynomialSpace_bound {M : ℕ} (V : Submodule K (Fin M → K)) : |
| ∀ f ∈ polynomialSpace V, f ≠ 0 → f.natDegree < M := by |
| rintro f ⟨x, hx, rfl⟩ hn |
| exact (natDegree_lt_iff_degree_lt hn).mpr (Polynomial.mem_degreeLT.mp (polynomialMap_mem M x)) |
|
|
| def taylorCoordinates (M : ℕ) (a : K) : (Fin M → K) ≃ₗ[K] (Fin M → K) := |
| (Polynomial.degreeLTEquiv K M).symm.trans |
| ((Polynomial.taylorLinearEquiv a M).trans (Polynomial.degreeLTEquiv K M)) |
|
|
| lemma taylorCoordinates_apply (M : ℕ) (a : K) (x : Fin M → K) (j : Fin M) : |
| taylorCoordinates M a x j = (taylor a (polynomialMap M x)).coeff j := rfl |
|
|
| def reverseCoordinates (M : ℕ) : (Fin M → K) ≃ₗ[K] (Fin M → K) where |
| toFun x j := x j.rev |
| invFun x j := x j.rev |
| left_inv := by intro x; funext j; simp |
| right_inv := by intro x; funext j; simp |
| map_add' := by intros; rfl |
| map_smul' := by intros; rfl |
|
|
| def reverseTaylorCoordinates (M : ℕ) (a : K) : (Fin M → K) ≃ₗ[K] (Fin M → K) := |
| (taylorCoordinates M a).trans (reverseCoordinates M) |
|
|
| / |
| Taylor coefficient by t^a and places it in output degree M-1-a. -/ |
| def testMap (M : ℕ) (a : K) : (Fin M → F K) →ₗ[F K] (Fin M → F K) := |
| conjugatedWeight (taylorCoordinates M a) (reverseTaylorCoordinates M a) Fin.val |
|
|
| lemma testMap_injective (M : ℕ) (a : K) : Function.Injective (testMap M a) := |
| conjugatedWeight_injective _ _ _ |
|
|
| / |
| lemma map_taylor_projection_kernel (M : ℕ) (a : K) (A : ℕ) |
| (V : Submodule K (Fin M → K)) : |
| (V ⊓ ((lowProjection Fin.val A).comp (taylorCoordinates M a).toLinearMap).ker).map |
| (polynomialMap M) = vanishingFiltration (polynomialSpace V) a (A+1) := by |
| ext f |
| constructor |
| · rintro ⟨x, ⟨hxV, hx⟩, rfl⟩ |
| refine ⟨⟨x, hxV, rfl⟩, ?_⟩ |
| intro j hj |
| by_cases hjM : j < M |
| · have he := congrFun hx (⟨⟨j, hjM⟩, by change j ≤ A; omega⟩ : {i : Fin M // i.val ≤ A}) |
| exact he |
| · apply coeff_eq_zero_of_degree_lt |
| have hdeg := Polynomial.mem_degreeLT.mp (polynomialMap_mem M x) |
| rw [degree_taylor] |
| exact hdeg.trans_le (by exact_mod_cast (Nat.le_of_not_gt hjM)) |
| · rintro ⟨⟨x, hxV, rfl⟩, hx⟩ |
| refine ⟨x, ⟨hxV, ?_⟩, rfl⟩ |
| change (lowProjection Fin.val A) (taylorCoordinates M a x) = 0 |
| funext j |
| exact hx j.val.val (by have := j.property; omega) |
|
|
| / |
| lemma map_reverseTaylor_lowSupported (M : ℕ) (a : K) (A : ℕ) |
| (V : Submodule K (Fin M → K)) : |
| ((V.map (reverseTaylorCoordinates M a).toLinearMap) ⊓ lowSupported Fin.val A).map |
| ((polynomialMap M).comp (reverseTaylorCoordinates M a).symm.toLinearMap) = |
| vanishingFiltration (polynomialSpace V) a (M-1-A) := by |
| ext f |
| constructor |
| · rintro ⟨y, ⟨⟨x, hxV, rfl⟩, hy⟩, rfl⟩ |
| simp only [LinearMap.comp_apply, LinearEquiv.coe_coe, LinearEquiv.symm_apply_apply] |
| refine ⟨⟨x, hxV, rfl⟩, ?_⟩ |
| intro j hj |
| have hjM : j < M := by omega |
| have hh := hy (Fin.rev ⟨j, hjM⟩) (by simp only [Fin.val_rev]; omega) |
| change taylorCoordinates M a x ((Fin.rev ⟨j, hjM⟩).rev) = 0 at hh |
| simpa only [Fin.rev_rev, taylorCoordinates_apply] using hh |
| · rintro ⟨⟨x, hxV, rfl⟩, hx⟩ |
| refine ⟨reverseTaylorCoordinates M a x, ⟨⟨x, hxV, rfl⟩, ?_⟩, ?_⟩ |
| · intro j hj |
| change taylorCoordinates M a x j.rev = 0 |
| exact hx j.rev.val (by simp only [Fin.val_rev]; omega) |
| · simp |
|
|
|
|
| lemma finrank_lowTaylor (M : ℕ) (a : K) (A : ℕ) |
| (V : Submodule K (Fin M → K)) {h : ℕ} |
| (b : Basis (Fin h) K (polynomialSpace V)) |
| (hb : Function.Injective (fun j => (b j : K[X]).rootMultiplicity a)) : |
| finrank K ((V.map (taylorCoordinates M a).toLinearMap).map (lowProjection Fin.val A)) = |
| Fintype.card {j : Fin h // (b j : K[X]).rootMultiplicity a ≤ A} := by |
| classical |
| have hd := finrank_map_add_finrank_inf_ker |
| ((lowProjection Fin.val A).comp (taylorCoordinates M a).toLinearMap) V |
| have hk := finrank_map_injective (polynomialMap M) (polynomialMap_injective M) |
| (V ⊓ ((lowProjection Fin.val A).comp (taylorCoordinates M a).toLinearMap).ker) |
| rw [map_taylor_projection_kernel, finrank_vanishingFiltration b a hb] at hk |
| have hdim : finrank K V = h := by |
| rw [← finrank_polynomialSpace, Module.finrank_eq_card_basis b, Fintype.card_fin] |
| rw [Submodule.map_comp, ← hk, hdim] at hd |
| have hc : Fintype.card {j : Fin h // (b j : K[X]).rootMultiplicity a ≤ A} + |
| Fintype.card {j : Fin h // A+1 ≤ (b j : K[X]).rootMultiplicity a} = h := by |
| simp only [Fintype.card_subtype, Nat.add_one_le_iff, ← not_le] |
| simpa only [Finset.card_univ, Fintype.card_fin] using |
| Finset.card_filter_add_card_filter_not (s := Finset.univ) |
| (fun j : Fin h => (b j : K[X]).rootMultiplicity a ≤ A) |
| omega |
|
|
| lemma finrank_reverseTaylor (M : ℕ) (a : K) (A : ℕ) |
| (V : Submodule K (Fin M → K)) {h : ℕ} |
| (b : Basis (Fin h) K (polynomialSpace V)) |
| (hb : Function.Injective (fun j => (b j : K[X]).rootMultiplicity a)) : |
| finrank K ↥((V.map (reverseTaylorCoordinates M a).toLinearMap) ⊓ lowSupported Fin.val A) = |
| Fintype.card {j : Fin h // M-1-A ≤ (b j : K[X]).rootMultiplicity a} := by |
| rw [← finrank_map_injective ((polynomialMap M).comp (reverseTaylorCoordinates M a).symm.toLinearMap) |
| ((polynomialMap_injective M).comp (reverseTaylorCoordinates M a).symm.injective), |
| map_reverseTaylor_lowSupported, finrank_vanishingFiltration b a hb] |
|
|
| / |
| theorem order_reversal_counts (M : ℕ) (a : K) (A : ℕ) |
| (U W : Submodule (F K) (Fin M → F K)) (hW : U.map (testMap M a) ≤ W) |
| {k l : ℕ} (b : Basis (Fin k) K (polynomialSpace (reducedSubspace U))) |
| (c : Basis (Fin l) K (polynomialSpace (reducedSubspace W))) |
| (hb : Function.Injective (fun j => (b j : K[X]).rootMultiplicity a)) |
| (hc : Function.Injective (fun j => (c j : K[X]).rootMultiplicity a)) : |
| Fintype.card {j : Fin k // (b j : K[X]).rootMultiplicity a ≤ A} ≤ |
| Fintype.card {j : Fin l // M-1-A ≤ (c j : K[X]).rootMultiplicity a} := by |
| have hh := conjugated_filtration_rank (taylorCoordinates M a) (reverseTaylorCoordinates M a) |
| Fin.val A U W hW |
| rwa [finrank_lowTaylor M a A _ b hb, finrank_reverseTaylor M a A _ c hc] at hh |
|
|
| / |
| lemma sum_threshold_counts {h : ℕ} (d : Fin h → ℕ) (L : ℕ) : |
| (∑ A ∈ Finset.range L, Fintype.card {j : Fin h // d j ≤ A}) = |
| ∑ j, (L - d j) := by |
| classical |
| simp only [Fintype.card_subtype] |
| simp only [Finset.card_filter] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro j _ |
| have he : (Finset.range L).filter (fun A => d j ≤ A) = Finset.Ico (d j) L := by |
| ext A |
| simp only [Finset.mem_filter, Finset.mem_range, Finset.mem_Ico] |
| tauto |
| rw [← Finset.card_filter, he, Nat.card_Ico] |
|
|
| lemma sum_reversed_counts {h : ℕ} (d : Fin h → ℕ) (L : ℕ) (hd : ∀ j, d j ≤ L) : |
| (∑ A ∈ Finset.range L, Fintype.card {j : Fin h // L-A ≤ d j}) = ∑ j, d j := by |
| have he : ∀ A, (fun j : Fin h => L-A ≤ d j) = (fun j : Fin h => L-d j ≤ A) := by |
| intro A |
| funext j |
| exact propext (by omega) |
| simp_rw [he] |
| rw [sum_threshold_counts] |
| apply Finset.sum_congr rfl |
| intro j _ |
| have := hd j |
| omega |
|
|
| / |
| subspaces: all inequalities concern the fixed filtration of the same W. -/ |
| theorem order_reversal_sum (M : ℕ) (a : K) |
| (U W : Submodule (F K) (Fin M → F K)) (hW : U.map (testMap M a) ≤ W) |
| {k l : ℕ} (b : Basis (Fin k) K (polynomialSpace (reducedSubspace U))) |
| (c : Basis (Fin l) K (polynomialSpace (reducedSubspace W))) |
| (hb : Function.Injective (fun j => (b j : K[X]).rootMultiplicity a)) |
| (hc : Function.Injective (fun j => (c j : K[X]).rootMultiplicity a)) : |
| k * (M-1) ≤ (∑ j, (b j : K[X]).rootMultiplicity a) + |
| (∑ j, (c j : K[X]).rootMultiplicity a) := by |
| classical |
| have hbd : ∀ j, (b j : K[X]).rootMultiplicity a ≤ M-1 := by |
| intro j |
| have hle : (b j : K[X]).rootMultiplicity a ≤ (b j : K[X]).natDegree := by |
| rw [rootMultiplicity_eq_natTrailingDegree, ← taylor_apply] |
| exact (natTrailingDegree_le_natDegree _).trans (le_of_eq (natDegree_taylor _ _)) |
| apply hle.trans |
| have hh := polynomialSpace_bound (reducedSubspace U) _ (b j).property |
| (fun hz => b.ne_zero j (Subtype.ext hz)) |
| omega |
| have hcd : ∀ j, (c j : K[X]).rootMultiplicity a ≤ M-1 := by |
| intro j |
| have hle : (c j : K[X]).rootMultiplicity a ≤ (c j : K[X]).natDegree := by |
| rw [rootMultiplicity_eq_natTrailingDegree, ← taylor_apply] |
| exact (natTrailingDegree_le_natDegree _).trans (le_of_eq (natDegree_taylor _ _)) |
| apply hle.trans |
| have hh := polynomialSpace_bound (reducedSubspace W) _ (c j).property |
| (fun hz => c.ne_zero j (Subtype.ext hz)) |
| omega |
| have hh := Finset.sum_le_sum (s := Finset.range (M-1)) |
| (fun A _ => order_reversal_counts M a A U W hW b c hb hc) |
| rw [sum_threshold_counts, sum_reversed_counts _ _ hcd] at hh |
| have he : (∑ j, (M-1 - (b j : K[X]).rootMultiplicity a)) + |
| (∑ j, (b j : K[X]).rootMultiplicity a) = k * (M-1) := by |
| rw [← Finset.sum_add_distrib] |
| simp only [Nat.sub_add_cancel (hbd _), Finset.sum_const, Finset.card_univ, |
| Fintype.card_fin, smul_eq_mul] |
| omega |
|
|
|
|
| lemma sum_fin_val_le_square (h : ℕ) : (∑ j : Fin h, j.val) ≤ h*h := by |
| calc |
| _ ≤ ∑ _j : Fin h, h := Finset.sum_le_sum fun j _ => Nat.le_of_lt j.isLt |
| _ = h*h := by simp |
|
|
| lemma expansion_numeric (w B M N k l : ℕ) (hw : 1 ≤ w) (hN : 1 ≤ N) |
| (hMN : M = N + 2*w^3*B) (hk : 1 ≤ k) (hkB : k ≤ B) |
| (hh : w * (k*(M-1)) ≤ k*(N-1) + w*(∑ j : Fin k, j.val) + |
| (l*(M-1) + w*(∑ j : Fin l, j.val))) : |
| (w-1)*k < l := by |
| by_contra! hl |
| have hk2 := sum_fin_val_le_square k |
| have hl2 := sum_fin_val_le_square l |
| have hh' : w*(k*(M-1)) ≤ k*(N-1) + w*(k*k) + |
| (l*(M-1) + w*(l*l)) := by |
| exact hh.trans (by gcongr) |
| have hgap : M-1 = N-1 + 2*w^3*B := by omega |
| have hw' : w-1+1 = w := by omega |
| have hmul := Nat.mul_le_mul_right (M-1) hl |
| have hlSq : l*l ≤ ((w-1)*k)*((w-1)*k) := Nat.mul_self_le_mul_self hl |
| have hwSq : (w-1)*(w-1)+1 ≤ w*w := by nlinarith |
| have hsq : k*k + l*l ≤ w*w*(k*k) := by |
| have hm := Nat.mul_le_mul_right (k*k) hwSq |
| nlinarith |
| have hkSq : k*k ≤ B*k := Nat.mul_le_mul_right k hkB |
| have hfinal : w*(k*k + l*l) ≤ w^3*B*k := by |
| calc |
| _ ≤ w*(w*w*(k*k)) := Nat.mul_le_mul_left w hsq |
| _ ≤ w*(w*w*(B*k)) := by gcongr |
| _ = w^3*B*k := by ring |
| have hB : 0 < B := by omega |
| have hpos : 0 < w^3*B*k := by positivity |
| have hbase : k*(M-1) ≤ k*(N-1)+w*(k*k+l*l) := by |
| have he : w*(k*(M-1)) = k*(M-1) + (w-1)*k*(M-1) := by |
| calc |
| _ = (1+(w-1))*(k*(M-1)) := by congr 1; omega |
| _ = _ := by ring |
| have hb : w*(k*(M-1)) ≤ k*(N-1)+w*(k*k+l*l)+(w-1)*k*(M-1) := by |
| calc |
| _ ≤ k*(N-1)+w*(k*k)+((w-1)*k*(M-1)+w*(l*l)) := |
| hh'.trans (by gcongr) |
| _ = _ := by ring |
| rw [he] at hb |
| exact Nat.le_of_add_le_add_right hb |
| have hneed : k*(2*w^3*B) ≤ w*(k*k+l*l) := by |
| rw [hgap] at hbase |
| nlinarith only [hbase] |
| nlinarith |
|
|
| lemma reduced_degree_bound {M N : ℕ} (U : Submodule (F K) (Fin M → F K)) |
| (hU : ∀ x ∈ U, ∀ j : Fin M, N ≤ j.val → x j = 0) : |
| ∀ f ∈ polynomialSpace (reducedSubspace U), f ≠ 0 → f.natDegree < N := by |
| have hr : ∀ y ∈ reducedSubspace U, ∀ j : Fin M, N ≤ j.val → y j = 0 := by |
| intro y hy |
| obtain ⟨b⟩ := exists_integralFrame U |
| have hyy : y ∈ ReducedSet U := by |
| rw [reducedSet_eq_span b] |
| rwa [reducedSubspace_eq_span b] at hy |
| obtain ⟨x, hx, hI, rfl⟩ := hyy |
| intro j hj |
| simp only [reduce, hU x hx j hj, reduction_zero] |
| rintro f ⟨x, hx, rfl⟩ hn |
| apply (natDegree_lt_iff_degree_lt hn).mpr |
| rw [degree_lt_iff_coeff_zero] |
| intro j hj |
| by_cases hjM : j < M |
| · exact (polynomialMap_coeff M x ⟨j, hjM⟩).trans (hr x hx ⟨j, hjM⟩ hj) |
| · exact polynomialMap_coeff_high M x j (Nat.le_of_not_gt hjM) |
|
|
| / |
| The input subspace is restricted to degrees < N, not changed by padding. -/ |
|
|
| theorem small_expansion [CharZero K] (w B M N : ℕ) (hw : 1 ≤ w) (hN : 1 ≤ N) |
| (hMN : M = N + 2*w^3*B) (points : Fin w → K) (hp : Function.Injective points) |
| (U W : Submodule (F K) (Fin M → F K)) |
| (hU : ∀ x ∈ U, ∀ j : Fin M, N ≤ j.val → x j = 0) |
| (hW : ∀ i, U.map (testMap M (points i)) ≤ W) |
| (hk : 1 ≤ finrank (F K) U) (hkB : finrank (F K) U ≤ B) : |
| (w-1) * finrank (F K) U < finrank (F K) W := by |
| classical |
| let k := finrank (F K) U |
| let l := finrank (F K) W |
| let V := polynomialSpace (reducedSubspace U) |
| let Z := polynomialSpace (reducedSubspace W) |
| let : Module.Finite K V := by |
| dsimp [V, polynomialSpace] |
| exact Module.Finite.map (reducedSubspace U) (polynomialMap M) |
| let : Module.Finite K Z := by |
| dsimp [Z, polynomialSpace] |
| exact Module.Finite.map (reducedSubspace W) (polynomialMap M) |
| have hVdim : finrank K V = k := by |
| rw [finrank_polynomialSpace, finrank_reducedSubspace] |
| have hZdim : finrank K Z = l := by |
| rw [finrank_polynomialSpace, finrank_reducedSubspace] |
| let b : Basis (Fin k) K V := (Module.finBasis K V).reindex (finCongr hVdim) |
| let c : Basis (Fin l) K Z := (Module.finBasis K Z).reindex (finCongr hZdim) |
| have hV := reduced_degree_bound U hU |
| have hZ := polynomialSpace_bound (reducedSubspace W) |
| choose be hbe using (fun i : Fin w => exists_echelon_basis_at N V b hV (points i)) |
| choose ce hce using (fun i : Fin w => exists_echelon_basis_at M Z c hZ (points i)) |
| have horder := Finset.sum_le_sum (s := Finset.univ) |
| (fun i _ => order_reversal_sum M (points i) U W (hW i) (be i) (ce i) (hbe i) (hce i)) |
| simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul, |
| Finset.sum_add_distrib] at horder |
| have hWrU := wronskian_order_bound N b points hp be hV hbe |
| have hWrW := wronskian_order_bound M c points hp ce hZ hce |
| exact expansion_numeric w B M N k l hw hN hMN hk hkB |
| (horder.trans (Nat.add_le_add hWrU hWrW)) |
|
|
| end |
| end RationalHitting.SmallExpansion |
|
|
| end OAI |
|
|
