| import Mathlib | |
| import OAI.Computability.DeterministicSum.WordArithmetic | |
| namespace OAI | |
| /-! Prime-power Newton interpolation, digit ranks and truncated filters. -/ | |
| namespace DeterministicThreeSum | |
| namespace Newton | |
| open scoped BigOperators | |
| open Finset | |
| variable {R : Type*} [CommRing R] {q d : ℕ} | |
| def entry (node : Fin q → R) : Matrix (Fin q) (Fin q) R := | |
| fun i j => ∏ k ∈ Iio j, (node i - node k) | |
| lemma entry_zero (node : Fin q → R) {i j : Fin q} (hij : i < j) : | |
| entry node i j = 0 := by | |
| apply Finset.prod_eq_zero (mem_Iio.mpr hij) | |
| simp | |
| lemma entry_lowerTriangular (node : Fin q → R) : | |
| (entry node).IsLowerTriangular := by | |
| intro i j hij | |
| exact entry_zero node hij | |
| lemma entry_det_unit (node : Fin q → R) | |
| (hu : ∀ i j : Fin q, j < i → IsUnit (node i - node j)) : | |
| IsUnit (Matrix.det (entry node)) := by | |
| rw [Matrix.det_of_isLowerTriangular _ (entry_lowerTriangular node)] | |
| apply IsUnit.prod_iff.mpr | |
| intro i hi | |
| apply IsUnit.prod_iff.mpr | |
| intro j hj | |
| exact hu i j (mem_Iio.mp hj) | |
| def tensor (A : Matrix (Fin q) (Fin q) R) : | |
| Matrix (Fin d → Fin q) (Fin d → Fin q) R := | |
| fun i j => ∏ k, A (i k) (j k) | |
| lemma tensor_mul (A B : Matrix (Fin q) (Fin q) R) : | |
| tensor (d := d) (A * B) = tensor A * tensor B := by | |
| classical | |
| ext i j | |
| simp only [tensor, Matrix.mul_apply] | |
| rw [Fintype.prod_sum] | |
| apply Finset.sum_congr rfl | |
| intro x hx | |
| exact Finset.prod_mul_distrib | |
| lemma tensor_one : tensor (d := d) (1 : Matrix (Fin q) (Fin q) R) = 1 := by | |
| classical | |
| ext i j | |
| by_cases hij : i = j | |
| · subst j | |
| simp [tensor] | |
| · have hex : ∃ k, i k ≠ j k := Function.ne_iff.mp hij | |
| obtain ⟨k, hk⟩ := hex | |
| rw [Matrix.one_apply_ne hij] | |
| apply Finset.prod_eq_zero (mem_univ k) | |
| exact Matrix.one_apply_ne hk | |
| noncomputable def coefficients (node : Fin q → R) (f : (Fin d → Fin q) → R) : | |
| (Fin d → Fin q) → R := | |
| (tensor ((entry node)⁻¹)).mulVec f | |
| lemma interpolate (node : Fin q → R) | |
| (hu : ∀ i j : Fin q, j < i → IsUnit (node i - node j)) | |
| (f : (Fin d → Fin q) → R) : | |
| (tensor (entry node)).mulVec (coefficients node f) = f := by | |
| classical | |
| unfold coefficients | |
| rw [Matrix.mulVec_mulVec, ← tensor_mul, | |
| Matrix.mul_nonsing_inv _ (entry_det_unit node hu), tensor_one, Matrix.one_mulVec] | |
| def degree (j : Fin d → Fin q) : ℕ := ∑ k, (j k).val | |
| lemma exists_coordinate_lt {i j : Fin d → Fin q} (h : degree i < degree j) : | |
| ∃ k, i k < j k := by | |
| by_contra! hn | |
| have hle : degree j ≤ degree i := Finset.sum_le_sum (fun k _ => hn k) | |
| omega | |
| lemma tensor_entry_zero (node : Fin q → R) {i j : Fin d → Fin q} | |
| (h : degree i < degree j) : tensor (entry node) i j = 0 := by | |
| obtain ⟨k, hk⟩ := exists_coordinate_lt h | |
| exact Finset.prod_eq_zero (mem_univ k) (entry_zero node hk) | |
| noncomputable def basisPolynomial (node : Fin q → R) (j : Fin d → Fin q) : | |
| MvPolynomial (Fin d) R := | |
| ∏ k, ∏ a ∈ Iio (j k), (MvPolynomial.X k - MvPolynomial.C (node a)) | |
| lemma eval_basisPolynomial (node : Fin q → R) (i j : Fin d → Fin q) : | |
| MvPolynomial.eval (node ∘ i) (basisPolynomial node j) = | |
| tensor (entry node) i j := by | |
| simp [basisPolynomial, tensor, entry] | |
| noncomputable def truncatedPolynomial (node : Fin q → R) | |
| (f : (Fin d → Fin q) → R) (Δ : ℕ) : MvPolynomial (Fin d) R := | |
| ∑ j ∈ (univ.filter (fun j : Fin d → Fin q => degree j ≤ Δ)), | |
| MvPolynomial.C (coefficients node f j) * basisPolynomial node j | |
| theorem truncated_agreement (node : Fin q → R) | |
| (hu : ∀ i j : Fin q, j < i → IsUnit (node i - node j)) | |
| (f : (Fin d → Fin q) → R) (Δ : ℕ) (i : Fin d → Fin q) | |
| (hi : degree i ≤ Δ) : | |
| MvPolynomial.eval (node ∘ i) (truncatedPolynomial node f Δ) = f i := by | |
| classical | |
| have hinterp := congrFun (interpolate node hu f) i | |
| rw [Matrix.mulVec, dotProduct] at hinterp | |
| calc | |
| MvPolynomial.eval (node ∘ i) (truncatedPolynomial node f Δ) = | |
| ∑ j ∈ univ.filter (fun j : Fin d → Fin q => degree j ≤ Δ), | |
| tensor (entry node) i j * coefficients node f j := by | |
| simp [truncatedPolynomial, eval_basisPolynomial, mul_comm] | |
| _ = ∑ j, tensor (entry node) i j * coefficients node f j := by | |
| apply Finset.sum_subset (filter_subset _ _) | |
| intro j hj hnot | |
| have hdeg : Δ < degree j := by simpa using hnot | |
| rw [tensor_entry_zero node (lt_of_le_of_lt hi hdeg), zero_mul] | |
| _ = f i := hinterp | |
| lemma basisPolynomial_degree (node : Fin q → R) (j : Fin d → Fin q) : | |
| (basisPolynomial node j).totalDegree ≤ degree j := by | |
| classical | |
| rcases subsingleton_or_nontrivial R with hR | hR | |
| · have := hR | |
| have hz : basisPolynomial node j = 0 := Subsingleton.elim _ _ | |
| rw [hz, MvPolynomial.totalDegree_zero] | |
| exact Nat.zero_le _ | |
| have := hR | |
| unfold basisPolynomial degree | |
| apply (MvPolynomial.totalDegree_finsetProd _ _).trans | |
| apply Finset.sum_le_sum | |
| intro k hk | |
| apply (MvPolynomial.totalDegree_finsetProd _ _).trans | |
| calc | |
| ∑ a ∈ Iio (j k), (MvPolynomial.X k - MvPolynomial.C (node a)).totalDegree ≤ | |
| ∑ _a ∈ Iio (j k), 1 := by | |
| apply Finset.sum_le_sum | |
| intro a ha | |
| rw [sub_eq_add_neg, ← MvPolynomial.C_neg] | |
| simpa using MvPolynomial.totalDegree_add | |
| (MvPolynomial.X k : MvPolynomial (Fin d) R) (MvPolynomial.C (-node a)) | |
| _ = (j k).val := by simp | |
| lemma truncatedPolynomial_degree (node : Fin q → R) | |
| (f : (Fin d → Fin q) → R) (Δ : ℕ) : | |
| (truncatedPolynomial node f Δ).totalDegree ≤ Δ := by | |
| classical | |
| apply MvPolynomial.totalDegree_finsetSum_le | |
| intro j hj | |
| apply (MvPolynomial.totalDegree_mul _ _).trans | |
| rw [MvPolynomial.totalDegree_C, zero_add] | |
| exact (basisPolynomial_degree node j).trans (mem_filter.mp hj).2 | |
| lemma coefficients_unique (node : Fin q → R) | |
| (hu : ∀ i j : Fin q, j < i → IsUnit (node i - node j)) | |
| (f : (Fin d → Fin q) → R) (c : (Fin d → Fin q) → R) | |
| (hc : (tensor (entry node)).mulVec c = f) : c = coefficients node f := by | |
| classical | |
| rw [coefficients, ← hc, Matrix.mulVec_mulVec, ← tensor_mul, | |
| Matrix.nonsing_inv_mul _ (entry_det_unit node hu), tensor_one, Matrix.one_mulVec] | |
| lemma small_difference_unit {p e a b : ℕ} (hp : p.Prime) (he : 0 < e) | |
| (ha : a < p) (hb : b < p) (hab : a ≠ b) : | |
| IsUnit ((a : ZMod (p ^ e)) - (b : ZMod (p ^ e))) := by | |
| have hposunit : ∀ {u v : ℕ}, v < u → u < p → | |
| IsUnit ((u : ZMod (p ^ e)) - (v : ZMod (p ^ e))) := by | |
| intro u v hvu hup | |
| have hdpos : 0 < u - v := Nat.sub_pos_of_lt hvu | |
| have hdlt : u - v < p := lt_of_le_of_lt (Nat.sub_le u v) hup | |
| have hunit := (ZMod.isUnit_natCast_iff_not_dvd_pow hp he).mpr | |
| (Nat.not_dvd_of_pos_of_lt hdpos hdlt) | |
| simpa only [Nat.cast_sub (le_of_lt hvu)] using hunit | |
| rcases lt_or_gt_of_ne hab with hab | hab | |
| · simpa only [neg_sub] using (hposunit hab hb).neg | |
| · exact hposunit hab ha | |
| lemma primePower_node_units {p e : ℕ} (hp : p.Prime) (he : 0 < e) | |
| (hq : q < p) (order : Equiv.Perm (Fin q)) : | |
| ∀ i j : Fin q, j < i → | |
| IsUnit (((order i).val : ZMod (p ^ e)) - ((order j).val : ZMod (p ^ e))) := by | |
| intro i j hji | |
| apply small_difference_unit hp he | |
| · exact (order i).isLt.trans hq | |
| · exact (order j).isLt.trans hq | |
| · intro heq | |
| have hij := order.injective (Fin.ext heq) | |
| exact (ne_of_gt hji) hij | |
| theorem primePower_truncated_agreement {p e : ℕ} (hp : p.Prime) (he : 0 < e) | |
| (hq : q < p) (order : Equiv.Perm (Fin q)) | |
| (f : (Fin d → Fin q) → ZMod (p ^ e)) (Δ : ℕ) (i : Fin d → Fin q) | |
| (hi : degree i ≤ Δ) : | |
| MvPolynomial.eval (fun k => ((order (i k)).val : ZMod (p ^ e))) | |
| (truncatedPolynomial (fun j => ((order j).val : ZMod (p ^ e))) f Δ) = f i := by | |
| exact truncated_agreement _ (primePower_node_units hp he hq order) f Δ i hi | |
| end Newton | |
| end DeterministicThreeSum | |
| namespace DeterministicThreeSum | |
| namespace Digits | |
| open scoped BigOperators | |
| open Finset | |
| def rank (b m z : ℕ) : ℕ := | |
| if z < m - 1 then b - (m - 1) + z | |
| else if z < b then z - (m - 1) | |
| else z | |
| def node (b m r : ℕ) : ℕ := | |
| if r < b - (m - 1) then m - 1 + r | |
| else if r < b then r - (b - (m - 1)) | |
| else r | |
| lemma node_rank {b m : ℕ} (hm : 1 ≤ m) (hmb : m ≤ b) (z : ℕ) : | |
| node b m (rank b m z) = z := by | |
| unfold rank node | |
| split_ifs <;> omega | |
| lemma rank_node {b m : ℕ} (hm : 1 ≤ m) (hmb : m ≤ b) (r : ℕ) : | |
| rank b m (node b m r) = r := by | |
| unfold rank node | |
| split_ifs <;> omega | |
| lemma rank_lt {b m z : ℕ} (hm : 1 ≤ m) (_hmb : m ≤ b) | |
| (hz : z < b + m - 1) : rank b m z < b + m - 1 := by | |
| unfold rank | |
| split_ifs <;> omega | |
| lemma node_lt {b m r : ℕ} (hm : 1 ≤ m) (hmb : m ≤ b) | |
| (hr : r < b + m - 1) : node b m r < b + m - 1 := by | |
| unfold node | |
| split_ifs <;> omega | |
| def order {b m : ℕ} (hm : 1 ≤ m) (hmb : m ≤ b) : | |
| Equiv.Perm (Fin (b + m - 1)) where | |
| toFun r := ⟨node b m r.val, node_lt hm hmb r.isLt⟩ | |
| invFun z := ⟨rank b m z.val, rank_lt hm hmb z.isLt⟩ | |
| left_inv r := Fin.ext (rank_node hm hmb r.val) | |
| right_inv z := Fin.ext (node_rank hm hmb z.val) | |
| @[simp] lemma order_val {b m : ℕ} (hm : 1 ≤ m) (hmb : m ≤ b) | |
| (r : Fin (b + m - 1)) : (order hm hmb r).val = node b m r.val := rfl | |
| @[simp] lemma order_symm_val {b m : ℕ} (hm : 1 ≤ m) (hmb : m ≤ b) | |
| (z : Fin (b + m - 1)) : ((order hm hmb).symm z).val = rank b m z.val := rfl | |
| variable {d : ℕ} | |
| def value (b : ℕ) (z : Fin d → ℕ) : ℕ := ∑ i, z i * b ^ i.val | |
| lemma value_add (b : ℕ) (x y : Fin d → ℕ) : | |
| value b (fun i => x i + y i) = value b x + value b y := by | |
| simp [value, add_mul, Finset.sum_add_distrib] | |
| lemma value_succ (b : ℕ) (z : Fin (d+1) → ℕ) : | |
| value b z = z 0 + b * value b (fun i => z i.succ) := by | |
| simp only [value, Fin.sum_univ_succ, Fin.val_zero, pow_zero, mul_one, | |
| Fin.val_succ, pow_succ, Finset.mul_sum] | |
| congr 1 | |
| apply Finset.sum_congr rfl | |
| intro i hi | |
| ring | |
| lemma value_lt_pow {b : ℕ} (z : Fin d → Fin b) : | |
| value b (fun i => (z i).val) < b ^ d := by | |
| induction d with | |
| | zero => simp [value] | |
| | succ d ih => | |
| rw [value_succ, pow_succ] | |
| have ht := ih (fun i => z i.succ) | |
| have hz := (z 0).isLt | |
| nlinarith [Nat.mul_le_mul_left b (Nat.succ_le_iff.mpr ht)] | |
| lemma value_injective {b : ℕ} : | |
| Function.Injective (fun z : Fin d → Fin b => value b (fun i => (z i).val)) := by | |
| induction d with | |
| | zero => intro x y h; exact Subsingleton.elim _ _ | |
| | succ d ih => | |
| intro x y hxy | |
| dsimp only at hxy | |
| rw [value_succ, value_succ] at hxy | |
| have hmod := congrArg (fun v => v % b) hxy | |
| have hhead : (x 0).val = (y 0).val := by | |
| simpa only [Nat.add_mul_mod_self_left, Nat.mod_eq_of_lt (x 0).isLt, | |
| Nat.mod_eq_of_lt (y 0).isLt] using hmod | |
| have htail : value b (fun i => (x i.succ).val) = | |
| value b (fun i => (y i.succ).val) := by | |
| rw [hhead] at hxy | |
| have hb : 0 < b := (Nat.zero_le (x 0).val).trans_lt (x 0).isLt | |
| exact Nat.eq_of_mul_eq_mul_left hb (Nat.add_left_cancel hxy) | |
| have hind := ih htail | |
| funext i | |
| refine Fin.cases (Fin.ext hhead) (fun j => congrFun hind j) i | |
| def sumIndex {b m : ℕ} (x : Fin d → Fin m) (y : Fin d → Fin b) : | |
| Fin d → Fin (b + m - 1) := fun i => | |
| ⟨(x i).val + (y i).val, by have hx := (x i).isLt; have hy := (y i).isLt; omega⟩ | |
| def rankTuple {b m : ℕ} (hm : 1 ≤ m) (hmb : m ≤ b) | |
| (x : Fin d → Fin m) (y : Fin d → Fin b) : Fin d → Fin (b + m - 1) := | |
| fun i => (order hm hmb).symm (sumIndex x y i) | |
| @[simp] lemma node_rankTuple {b m : ℕ} (hm : 1 ≤ m) (hmb : m ≤ b) | |
| (x : Fin d → Fin m) (y : Fin d → Fin b) (i : Fin d) : | |
| (order hm hmb (rankTuple hm hmb x y i)).val = (x i).val + (y i).val := by | |
| simp [rankTuple, sumIndex] | |
| def cutoff (b d : ℕ) : ℕ := ((b + 3) * d) / 2 | |
| end Digits | |
| end DeterministicThreeSum | |
| namespace DeterministicThreeSum | |
| namespace Filter | |
| open scoped BigOperators | |
| open Finset | |
| variable {p e b m d J : ℕ} | |
| def table (hm : 1 ≤ m) (hmb : m ≤ b) (hJ : 0 < J) | |
| (h : Fin d → ℕ) (f : Fin J → ZMod (p ^ e)) | |
| (r : Fin d → Fin (b + m - 1)) : ZMod (p ^ e) := | |
| f ⟨Digits.value b (fun i => h i + (Digits.order hm hmb (r i)).val) % J, | |
| Nat.mod_lt _ hJ⟩ | |
| noncomputable def polynomial (hm : 1 ≤ m) (hmb : m ≤ b) (hJ : 0 < J) | |
| (h : Fin d → ℕ) (f : Fin J → ZMod (p ^ e)) : MvPolynomial (Fin d) (ZMod (p ^ e)) := | |
| Newton.truncatedPolynomial (fun j => ((Digits.order hm hmb j).val : ZMod (p ^ e))) | |
| (table hm hmb hJ h f) (Digits.cutoff b d) | |
| def exceptionalTuples (hm : 1 ≤ m) (hmb : m ≤ b) (x : Fin d → Fin m) : | |
| Finset (Fin d → Fin b) := | |
| univ.filter (fun y => Digits.cutoff b d < Newton.degree (Digits.rankTuple hm hmb x y)) | |
| def exceptionalResidues (hm : 1 ≤ m) (hmb : m ≤ b) (x : Fin d → Fin m) : Finset ℕ := | |
| (exceptionalTuples hm hmb x).image (fun y => Digits.value b (fun i => (y i).val)) | |
| lemma exceptionalResidues_subset (hm : 1 ≤ m) (hmb : m ≤ b) (x : Fin d → Fin m) : | |
| exceptionalResidues hm hmb x ⊆ range (b ^ d) := by | |
| intro v hv | |
| obtain ⟨y, _, rfl⟩ := mem_image.mp hv | |
| exact mem_range.mpr (Digits.value_lt_pow y) | |
| lemma exceptional_card (hm : 1 ≤ m) (hmb : m ≤ b) (x : Fin d → Fin m) : | |
| (exceptionalResidues hm hmb x).card = (exceptionalTuples hm hmb x).card := by | |
| exact Finset.card_image_of_injective _ Digits.value_injective | |
| lemma rank_sum_le_of_not_exceptional (hm : 1 ≤ m) (hmb : m ≤ b) | |
| (x : Fin d → Fin m) (y : Fin d → Fin b) | |
| (hy : Digits.value b (fun i => (y i).val) ∉ exceptionalResidues hm hmb x) : | |
| Newton.degree (Digits.rankTuple hm hmb x y) ≤ Digits.cutoff b d := by | |
| by_contra! hdeg | |
| apply hy | |
| exact mem_image.mpr ⟨y, mem_filter.mpr ⟨mem_univ y, hdeg⟩, rfl⟩ | |
| theorem agreement (hp : p.Prime) (he : 0 < e) (hq : b + m - 1 < p) | |
| (hm : 1 ≤ m) (hmb : m ≤ b) (hJ : 0 < J) | |
| (h : Fin d → ℕ) (f : Fin J → ZMod (p ^ e)) | |
| (x : Fin d → Fin m) (y : Fin d → Fin b) | |
| (hy : Digits.value b (fun i => (y i).val) ∉ exceptionalResidues hm hmb x) : | |
| MvPolynomial.eval (fun i => ((x i).val : ZMod (p ^ e)) + ((y i).val : ZMod (p ^ e))) | |
| (polynomial hm hmb hJ h f) = | |
| f ⟨(Digits.value b (fun i => h i + (x i).val) + | |
| Digits.value b (fun i => (y i).val)) % J, Nat.mod_lt _ hJ⟩ := by | |
| have hrank := rank_sum_le_of_not_exceptional hm hmb x y hy | |
| have hagree := Newton.primePower_truncated_agreement hp he hq (Digits.order hm hmb) | |
| (table hm hmb hJ h f) (Digits.cutoff b d) (Digits.rankTuple hm hmb x y) hrank | |
| simp only [Digits.node_rankTuple, Nat.cast_add] at hagree | |
| rw [show Digits.value b (fun i => h i + (x i).val) + | |
| Digits.value b (fun i => (y i).val) = | |
| Digits.value b (fun i => h i + ((x i).val + (y i).val)) by | |
| rw [← Digits.value_add]; congr 1; funext i; omega] | |
| simpa only [polynomial, table, Digits.node_rankTuple] using hagree | |
| lemma polynomial_degree (hm : 1 ≤ m) (hmb : m ≤ b) (hJ : 0 < J) | |
| (h : Fin d → ℕ) (f : Fin J → ZMod (p ^ e)) : | |
| (polynomial hm hmb hJ h f).totalDegree ≤ Digits.cutoff b d := | |
| Newton.truncatedPolynomial_degree _ _ _ | |
| end Filter | |
| end DeterministicThreeSum | |
| end OAI | |