| 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 |
|
|
