Download data/lean/OAI/Combinatorics/MatchingPSD/PolynomialInterpolation.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 9.65 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/MatchingPSD/PolynomialInterpolation.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Combinatorics/MatchingPSD/PolynomialInterpolation.lean
-
curl -L -o PolynomialInterpolation.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Combinatorics/MatchingPSD/PolynomialInterpolation.lean
9.65 kB
| import OAI.Combinatorics.MatchingPSD.MatrixAverages | |
| namespace OAI | |
| namespace MatchingInterpolation | |
| open Polynomial | |
| open MatchingSmoothing | |
| abbrev Point := Fin 3 β β | |
| abbrev GridIndex (d : β) := Fin 3 β Fin (d+1) | |
| def coord (i : Fin 3) (x : Point) : β := x i | |
| noncomputable def lagrange (d : β) (k : Fin (d+1)) : β[X] := | |
| Lagrange.basis Finset.univ (fun j : Fin (d+1) => (j:β)) k | |
| noncomputable def tensorBasis (d : β) (g : GridIndex d) (x : Point) : β := | |
| β a, (lagrange d (g a)).eval (x a) | |
| def gridNode {d : β} (g : GridIndex d) : Point := fun a => (g a:β) | |
| lemma power_interpolation (d k : β) (hk : k β€ d) (x : β) : | |
| x^k = β j : Fin (d+1), (j:β)^k * (lagrange d j).eval x := by | |
| have hinj : Set.InjOn (fun j : Fin (d+1) => (j:β)) (Finset.univ : Finset (Fin (d+1))) := by | |
| intro i _ j _ h | |
| apply Fin.ext | |
| change (i.val:β) = (j.val:β) at h | |
| exact Nat.cast_inj.mp h | |
| have hdeg : (Polynomial.X^k : β[X]).degree < (Finset.univ : Finset (Fin (d+1))).card := by | |
| simp only [Polynomial.degree_X_pow, Finset.card_univ, Fintype.card_fin] | |
| exact_mod_cast Nat.lt_succ_of_le hk | |
| have he := congrArg (Polynomial.eval x) (Lagrange.eq_interpolate hinj hdeg) | |
| simpa [Lagrange.interpolate_apply, lagrange, Polynomial.eval_finsetSum] using he | |
| lemma list_product_counts (l : List (Fin 3)) (x : Point) : | |
| (l.map x).prod = β a, x a ^ l.count a := by | |
| rw [Finset.prod_list_map_count] | |
| apply Finset.prod_subset (Finset.subset_univ _) | |
| intro a _ ha | |
| have hn : a β l := fun hx => ha (List.mem_toFinset.mpr hx) | |
| simp [List.count_eq_zero_of_not_mem hn] | |
| lemma monomial_interpolation (d : β) (l : List (Fin 3)) (hl : l.length β€ d) (x : Point) : | |
| (l.map x).prod = β g : GridIndex d, tensorBasis d g x * (l.map (gridNode g)).prod := by | |
| rw [list_product_counts] | |
| have hp (a : Fin 3) := power_interpolation d (l.count a) | |
| (List.count_le_length.trans hl) (x a) | |
| simp_rw [hp] | |
| rw [Fintype.prod_sum] | |
| apply Finset.sum_congr rfl | |
| intro g _ | |
| rw [Finset.prod_mul_distrib, list_product_counts, mul_comm] | |
| rfl | |
| lemma lowDegree_interpolation (d : β) (P : Point β β) (hP : P β lowDegree coord d) | |
| (x : Point) : P x = β g : GridIndex d, tensorBasis d g x * P (gridNode g) := by | |
| induction hP using Submodule.span_induction with | |
| | mem P hP => | |
| obtain β¨l, hl, rflβ© := hP | |
| have he (v : Point) : (l.map coord).prod v = (l.map v).prod := by | |
| induction l with | |
| | nil => rfl | |
| | cons a l ih => simpa [coord] using congrArg (fun t => v a*t) (ih (by simpa only [List.length_cons] using Nat.le_trans (Nat.le_succ l.length) hl)) | |
| simp_rw [he] | |
| exact monomial_interpolation d l hl x | |
| | zero => simp | |
| | add f g _ _ hf hg => simp only [Pi.add_apply, mul_add, Finset.sum_add_distrib, hf, hg] | |
| | smul c f _ hf => | |
| simp only [Pi.smul_apply, smul_eq_mul, β mul_assoc, mul_comm _ c, Finset.mul_sum, hf] | |
| noncomputable def linePolynomial (d : β) (g : GridIndex d) (v : Point) : β[X] := | |
| β a, (lagrange d (g a)).comp (Polynomial.C (v a) * Polynomial.X) | |
| lemma linePolynomial_eval (d : β) (g : GridIndex d) (v : Point) (t : β) : | |
| (linePolynomial d g v).eval t = tensorBasis d g (fun a => t * v a) := by | |
| simp only [linePolynomial, tensorBasis, Polynomial.eval_prod, Polynomial.eval_comp, | |
| Polynomial.eval_mul, Polynomial.eval_C, Polynomial.eval_X] | |
| apply Finset.prod_congr rfl | |
| intro a _ | |
| rw [mul_comm] | |
| lemma linePolynomial_zero (d : β) (g : GridIndex d) (v : Point) : | |
| (linePolynomial d g v).coeff 0 = β a, (lagrange d (g a)).eval 0 := by | |
| rw [Polynomial.coeff_zero_eq_eval_zero, linePolynomial_eval] | |
| simp [tensorBasis] | |
| lemma linePolynomial_one (d : β) (g : GridIndex d) (v : Point) : | |
| (linePolynomial d g v).coeff 1 = | |
| β a, v a * ((β b β Finset.univ.erase a, (lagrange d (g b)).eval 0) * | |
| (lagrange d (g a)).derivative.eval 0) := by | |
| have he (P : β[X]) : P.coeff 1 = P.derivative.eval 0 := by | |
| simp [β Polynomial.coeff_zero_eq_eval_zero, Polynomial.coeff_derivative] | |
| rw [he, linePolynomial, Polynomial.derivative_prod_finset, Polynomial.eval_finsetSum] | |
| apply Finset.sum_congr rfl | |
| intro a _ | |
| simp only [Polynomial.derivative_comp, Polynomial.derivative_mul, Polynomial.derivative_C, | |
| Polynomial.derivative_X, zero_mul, mul_one, zero_add, Polynomial.eval_mul, | |
| Polynomial.eval_comp, Polynomial.eval_prod, Polynomial.eval_C, Polynomial.eval_X, | |
| mul_zero] | |
| ring | |
| def origin : Point := ![1,0,0] | |
| def dirA : Point := ![0,2,0] | |
| def dirB : Point := ![0,0,2] | |
| def dirStar : Point := ![2,0,0] | |
| def dirP : Point := ![-1,1,1] | |
| noncomputable def weightPolynomial (d : β) (g : GridIndex d) : β[X] := | |
| linePolynomial d g dirA + linePolynomial d g dirB - linePolynomial d g dirStar - | |
| (2:β) β’ linePolynomial d g dirP + linePolynomial d g 0 | |
| lemma weightPolynomial_zero (d : β) (g : GridIndex d) : | |
| (weightPolynomial d g).coeff 0 = 0 := by | |
| simp only [weightPolynomial, Polynomial.coeff_add, Polynomial.coeff_sub, | |
| Polynomial.coeff_smul, smul_eq_mul, linePolynomial_zero] | |
| ring | |
| lemma weightPolynomial_one (d : β) (g : GridIndex d) : | |
| (weightPolynomial d g).coeff 1 = 0 := by | |
| simp only [weightPolynomial, Polynomial.coeff_add, Polynomial.coeff_sub, | |
| Polynomial.coeff_smul, smul_eq_mul, linePolynomial_one, Pi.zero_apply, zero_mul, | |
| Finset.sum_const_zero, add_zero] | |
| rw [β Finset.sum_add_distrib, β Finset.sum_sub_distrib, Finset.mul_sum, | |
| β Finset.sum_sub_distrib] | |
| apply Finset.sum_eq_zero | |
| intro a _ | |
| fin_cases a <;> simp [dirA, dirB, dirStar, dirP] | |
| lemma weightPolynomial_bound (d : β) (g : GridIndex d) : | |
| β c : β, 0 β€ c β§ β t β Set.Icc (0:β) 1, | |
| |(weightPolynomial d g).eval t| β€ c * t^2 := by | |
| have hd : (Polynomial.X^2 : β[X]) β£ weightPolynomial d g := by | |
| apply Polynomial.X_pow_dvd_iff.mpr | |
| intro k hk | |
| interval_cases k | |
| Β· exact weightPolynomial_zero d g | |
| Β· exact weightPolynomial_one d g | |
| obtain β¨P, hPβ© := hd | |
| obtain β¨b, hbβ© := (isCompact_Icc : IsCompact (Set.Icc (0:β) 1)).exists_bound_of_continuousOn | |
| P.continuous.continuousOn | |
| refine β¨max b 0, le_max_right _ _, ?_β© | |
| intro t ht | |
| rw [hP, Polynomial.eval_mul, Polynomial.eval_pow, Polynomial.eval_X, abs_mul, | |
| abs_of_nonneg (sq_nonneg t), mul_comm] | |
| have htbound : |P.eval t| β€ b := by simpa only [Real.norm_eq_abs] using hb t ht | |
| exact mul_le_mul_of_nonneg_right (htbound.trans (le_max_left b 0)) (sq_nonneg t) | |
| noncomputable def weight (d : β) (L : β) (g : GridIndex d) : β := | |
| (weightPolynomial d g).eval Lβ»ΒΉ | |
| lemma weights_bound (d : β) : β c : β, 0 < c β§ β L : β, 1 β€ L β | |
| β g : GridIndex d, |weight d L g| β€ c / L^2 := by | |
| classical | |
| choose c hc hb using weightPolynomial_bound d | |
| refine β¨1 + β g, c g, by have hsum := Finset.sum_nonneg (fun g (_ : g β Finset.univ) => hc g); linarith, ?_β© | |
| intro L hL g | |
| have hLp : 0 < L := lt_of_lt_of_le zero_lt_one hL | |
| have ht : Lβ»ΒΉ β Set.Icc (0:β) 1 := β¨inv_nonneg.mpr hLp.le, | |
| (inv_le_oneβ hLp).mpr hLβ© | |
| calc | |
| |weight d L g| β€ c g * (Lβ»ΒΉ)^2 := hb g Lβ»ΒΉ ht | |
| _ β€ (1+β a, c a) * (Lβ»ΒΉ)^2 := by | |
| apply mul_le_mul_of_nonneg_right _ (sq_nonneg _) | |
| have hh := Finset.single_le_sum (fun a (_ : a β Finset.univ) => hc a) | |
| (Finset.mem_univ g) | |
| linarith | |
| _ = (1+β a, c a)/L^2 := by simp [div_eq_mul_inv] | |
| lemma lowDegree_affine_pullback (d : β) (P : Point β β) | |
| (hP : P β lowDegree coord d) (b : Point) (L : β) : | |
| (fun x : Point => P (fun a => b a + L*x a)) β lowDegree coord d := by | |
| have hcoord (a : Fin 3) : (fun x : Point => b a + L*x a) β lowDegree coord 1 := by | |
| have hc := (lowDegree coord 1).smul_mem (b a) (one_mem_lowDegree coord 1) | |
| have hx := (lowDegree coord 1).smul_mem L (coord_mem_lowDegree coord a) | |
| convert (lowDegree coord 1).add_mem hc hx using 1 | |
| ext x | |
| simp [coord] | |
| induction hP using Submodule.span_induction with | |
| | mem P hP => | |
| obtain β¨l, hl, rflβ© := hP | |
| apply lowDegree_mono coord hl | |
| clear hl | |
| induction l with | |
| | nil => exact one_mem_lowDegree coord 0 | |
| | cons a l ih => | |
| convert mul_mem_lowDegree coord (hcoord a) ih using 1 | |
| Β· simp only [List.length_cons, Nat.add_comm] | |
| Β· rfl | |
| | zero => exact (lowDegree coord d).zero_mem | |
| | add f g _ _ hf hg => exact (lowDegree coord d).add_mem hf hg | |
| | smul c f _ hf => exact (lowDegree coord d).smul_mem c hf | |
| lemma weighted_interpolation (d : β) (P : Point β β) (hP : P β lowDegree coord d) | |
| (L : β) (hL : L β 0) : | |
| P (origin + dirA) + P (origin + dirB) - P (origin + dirStar) - | |
| 2 * P (origin + dirP) + P origin = | |
| β g : GridIndex d, weight d L g * P (fun a => origin a + L*(g a:β)) := by | |
| let Q : Point β β := fun x => P (fun a => origin a + L*x a) | |
| have hQ : Q β lowDegree coord d := lowDegree_affine_pullback d P hP origin L | |
| have he (v : Point) : P (origin + v) = | |
| β g : GridIndex d, (linePolynomial d g v).eval Lβ»ΒΉ * | |
| P (fun a => origin a + L*(g a:β)) := by | |
| have hi := lowDegree_interpolation d Q hQ (fun a => Lβ»ΒΉ*v a) | |
| have hx : (fun a => origin a + L*(Lβ»ΒΉ*v a)) = origin + v := by | |
| funext a | |
| simp [hL] | |
| simpa only [Q, hx, β linePolynomial_eval, gridNode] using hi | |
| have he0 := he 0 | |
| rw [add_zero] at he0 | |
| rw [he dirA, he dirB, he dirStar, he dirP, he0] | |
| simp only [weight, weightPolynomial, Polynomial.eval_add, Polynomial.eval_sub, | |
| Polynomial.eval_smul, smul_eq_mul, Finset.sum_add_distrib, Finset.sum_sub_distrib, | |
| add_mul, sub_mul, mul_assoc, β Finset.mul_sum] | |
| end MatchingInterpolation | |
| end OAI | |