Download data/lean/OAI/Computability/DeterministicSum/Interpolation.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 15.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/DeterministicSum/Interpolation.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/DeterministicSum/Interpolation.lean
-
curl -L -o Interpolation.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/DeterministicSum/Interpolation.lean
15.2 kB
| 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 | |