| import OAI.Combinatorics.EditDistance.FourierAverages |
| import OAI.Combinatorics.EditDistance.Cuts |
|
|
| namespace OAI |
|
|
| /-! |
| # Prime-product displacement for absolutely summable maps |
| -/ |
|
|
| namespace EditFourier |
| open scoped BigOperators |
| open Finset EditAverage |
|
|
| noncomputable def variation {G E : Type*} [AddCommGroup G] [Fintype G] |
| [NormedAddCommGroup E] (H : G → E) (l : G) : ℝ := |
| avg (fun z => ‖H (z + l) - H z‖) |
|
|
| section CutTransport |
| variable {G : Type*} [AddCommGroup G] [Fintype G] [DecidableEq G] |
|
|
| lemma quadraticVariation_cut (A : Finset G) (l : G) : |
| quadraticVariation (fun z => (EditCuts.cut A z : ℂ)) l = |
| variation (EditCuts.cut A) l := by |
| unfold quadraticVariation variation avg |
| congr 1 |
| apply sum_congr rfl |
| intro z _ |
| by_cases hz : z ∈ A <;> by_cases hzl : z + l ∈ A <;> |
| simp [EditCuts.cut, hz, hzl] |
|
|
| lemma variation_cut_decomposition (H : G → EditCuts.RealL1) (c : Finset G → ℝ) |
| (hd : ∀ x y, ‖H x - H y‖ = ∑ A : Finset G, c A * |EditCuts.cut A x - EditCuts.cut A y|) |
| (l : G) : variation H l = ∑ A : Finset G, c A * variation (EditCuts.cut A) l := by |
| simp_rw [variation, hd, avg_sum, avg_mul, Real.norm_eq_abs] |
|
|
| end CutTransport |
|
|
| section PrimeProductL1 |
| variable {J : Type*} [Fintype J] [DecidableEq J] |
| variable (p : J → ℕ) [∀ j, NeZero (p j)] |
| variable {G : Type*} [AddCommGroup G] [Fintype G] |
|
|
| theorem prime_product_displacement |
| (hcop : Pairwise (fun i j => (p i).Coprime (p j))) |
| (B : ℝ) (hB : 1 ≤ B) (hpB : ∀ j, (p j : ℝ) ≤ B) |
| (h : ℕ) (hh : 0 < h) (φ : (∀ j, ZMod (p j)) →+ G) |
| (H : G → EditCuts.RealL1) (i : J) (u : ZMod (p i)) : |
| variation H (φ (Pi.single i u)) ≤ |
| B ^ (2 * h) * variation H (φ 1) + (2 / (h : ℝ)) * |
| ∑ j, avg (fun a : ZMod (p j) => variation H (φ (Pi.single j a))) := by |
| classical |
| have hcut (A : Finset G) : |
| variation (EditCuts.cut A) (φ (Pi.single i u)) ≤ |
| B ^ (2 * h) * variation (EditCuts.cut A) (φ 1) + (2 / (h : ℝ)) * |
| ∑ j, avg (fun a : ZMod (p j) => variation (EditCuts.cut A) (φ (Pi.single j a))) := by |
| simpa only [quadraticVariation_cut] using group_quadratic_comparison p hcop B hB hpB h hh φ |
| (fun z => (EditCuts.cut A z : ℂ)) i u |
| obtain ⟨c, hc, _, _, hd⟩ := EditCuts.l1_decomposition H |
| simp_rw [variation_cut_decomposition H c hd] |
| calc |
| _ ≤ ∑ A : Finset G, c A * |
| (B ^ (2 * h) * variation (EditCuts.cut A) (φ 1) + (2 / (h : ℝ)) * |
| ∑ j, avg (fun a : ZMod (p j) => variation (EditCuts.cut A) (φ (Pi.single j a)))) := by |
| apply sum_le_sum |
| intro A _ |
| exact mul_le_mul_of_nonneg_left (hcut A) (hc A) |
| _ = _ := by |
| simp_rw [mul_add, sum_add_distrib, avg_sum, avg_mul] |
| congr 1 |
| · simp_rw [mul_left_comm _ (B ^ (2 * h)), ← mul_sum] |
| · simp_rw [mul_left_comm _ (2 / (h : ℝ)), ← mul_sum, mul_sum] |
| rw [sum_comm] |
|
|
| end PrimeProductL1 |
| end EditFourier |
|
|
| namespace EditFourier |
| open scoped BigOperators |
| open Finset EditAverage |
|
|
| def torsionHom {G : Type*} [AddCommGroup G] (p : ℕ) (v : G) (hv : p • v = 0) : |
| ZMod p →+ G := |
| ZMod.lift p ⟨{ toFun := fun z : ℤ => z • v |
| map_zero' := zero_zsmul v |
| map_add' := fun x y => add_zsmul v x y }, by simpa using hv⟩ |
|
|
| lemma torsionHom_natCast {G : Type*} [AddCommGroup G] (p : ℕ) (v : G) (hv : p • v = 0) |
| (a : ℕ) : torsionHom p v hv (a : ZMod p) = a • v := by |
| simpa [torsionHom] using ZMod.lift_coe p |
| (⟨{ toFun := fun z : ℤ => z • v |
| map_zero' := zero_zsmul v |
| map_add' := fun x y => add_zsmul v x y }, by simpa using hv⟩) (a : ℤ) |
|
|
| lemma torsionHom_apply {G : Type*} [AddCommGroup G] (p : ℕ) [NeZero p] |
| (v : G) (hv : p • v = 0) (a : ZMod p) : torsionHom p v hv a = a.val • v := by |
| rw [← torsionHom_natCast p v hv a.val, ZMod.natCast_zmod_val] |
|
|
| section Vectors |
| variable {J G : Type*} [Fintype J] [DecidableEq J] [AddCommGroup G] |
| variable (p : J → ℕ) (v : J → G) (hv : ∀ j, p j • v j = 0) |
|
|
| def vectorHom : (∀ j, ZMod (p j)) →+ G where |
| toFun a := ∑ j, torsionHom (p j) (v j) (hv j) (a j) |
| map_zero' := by simp |
| map_add' a b := by simp [map_add, Finset.sum_add_distrib] |
|
|
| lemma vectorHom_single (i : J) (a : ZMod (p i)) : |
| vectorHom p v hv (Pi.single i a) = torsionHom (p i) (v i) (hv i) a := by |
| classical |
| simp only [vectorHom, AddMonoidHom.coe_mk, ZeroHom.coe_mk] |
| rw [Finset.sum_eq_single i] |
| · simp |
| · intro j _ hj |
| simp [Pi.single_eq_of_ne hj] |
| · simp |
|
|
| omit [DecidableEq J] in |
| lemma vectorHom_one : vectorHom p v hv 1 = ∑ j, v j := by |
| change (∑ j, torsionHom (p j) (v j) (hv j) 1) = _ |
| apply Finset.sum_congr rfl |
| intro j _ |
| simpa using torsionHom_natCast (p j) (v j) (hv j) 1 |
|
|
| variable [Fintype G] [∀ j, NeZero (p j)] |
|
|
| include hv |
|
|
| theorem vector_displacement |
| (hcop : Pairwise (fun i j => (p i).Coprime (p j))) |
| (B : ℝ) (hB : 1 ≤ B) (hpB : ∀ j, (p j : ℝ) ≤ B) |
| (h : ℕ) (hh : 0 < h) (H : G → EditCuts.RealL1) (i : J) (u : ZMod (p i)) : |
| variation H (u.val • v i) ≤ B ^ (2 * h) * variation H (∑ j, v j) + |
| (2 / (h : ℝ)) * ∑ j, avg (fun a : ZMod (p j) => variation H (a.val • v j)) := by |
| simpa only [vectorHom_single, vectorHom_one, torsionHom_apply] using |
| prime_product_displacement p hcop B hB hpB h hh (vectorHom p v hv) H i u |
|
|
| theorem prime_vector_displacement (hp : ∀ j, (p j).Prime) (hinj : Function.Injective p) |
| (P : ℝ) (hP : 1 ≤ 2 * P) (hpP : ∀ j, (p j : ℝ) ≤ 2 * P) |
| (h : ℕ) (hh : 0 < h) (H : G → EditCuts.RealL1) (i : J) (u : ZMod (p i)) : |
| variation H (u.val • v i) ≤ (2 * P) ^ (2 * h) * variation H (∑ j, v j) + |
| (2 / (h : ℝ)) * ∑ j, avg (fun a : ZMod (p j) => variation H (a.val • v j)) := by |
| apply vector_displacement p v hv (fun i j hij => ?_) (2 * P) hP hpP h hh H i u |
| exact (hp i).coprime_iff_not_dvd.mpr (fun hd => |
| hij (hinj ((Nat.dvd_prime (hp j)).mp hd |>.resolve_left (hp i).ne_one))) |
|
|
| end Vectors |
| end EditFourier |
|
|
| end OAI |
|
|
