| import OAI.Combinatorics.FiniteCircle.Histograms |
|
|
| namespace OAI |
|
|
| namespace FiniteCircle |
|
|
| open scoped BigOperators List |
| open scoped ComplexConjugate |
| open RCLike Module |
| open Classical |
|
|
| noncomputable def coordDist {X ι : Type*} [Fintype ι] (F : X → ι → ℝ) (x y : X) : ℝ := |
| ∑ i, |F x i - F y i| |
|
|
| theorem coordDist_nonneg {X ι : Type*} [Fintype ι] (F : X → ι → ℝ) (x y : X) : |
| 0 ≤ coordDist F x y := Finset.sum_nonneg (fun _ _ => abs_nonneg _) |
|
|
| theorem coordDist_symm {X ι : Type*} [Fintype ι] (F : X → ι → ℝ) (x y : X) : |
| coordDist F x y = coordDist F y x := by simp only [coordDist, abs_sub_comm] |
|
|
| theorem coordDist_triangle {X ι : Type*} [Fintype ι] (F : X → ι → ℝ) (x y z : X) : |
| coordDist F x z ≤ coordDist F x y + coordDist F y z := by |
| unfold coordDist |
| rw [← Finset.sum_add_distrib] |
| exact Finset.sum_le_sum (fun _ _ => abs_sub_le _ _ _) |
|
|
| def normalizeWord {α : Type*} (a : α) (m : ℕ) (x : List α) : List.Vector α m := |
| ⟨x.take m ++ List.replicate (m - x.length) a, by simp; omega⟩ |
|
|
| theorem normalizeWord_val {α : Type*} (a : α) {m : ℕ} {x : List α} (h : x.length ≤ m) : |
| (normalizeWord a m x).val = x ++ List.replicate (m-x.length) a := by |
| simp only [normalizeWord, List.take_of_length_le h] |
|
|
| theorem normalizeWord_deficit {α : Type*} (a : α) {m : ℕ} {x y : List α} |
| (hx : x.length ≤ m) (hy : x.length = y.length) : |
| deficit (normalizeWord a m x).val (normalizeWord a m y).val = deficit x y := by |
| rw [normalizeWord_val a hx, normalizeWord_val a (by omega), ← hy] |
| simp only [deficit, List.length_append, List.length_replicate, lcs_append_common_right] |
| omega |
|
|
| def windowWords {α : Type*} (a : α) (x : List α) (start m s : ℕ) : List (List.Vector α m) := |
| (windows x start m s).map (normalizeWord a m) |
|
|
| @[simp] theorem length_windowWords {α : Type*} (a : α) (x : List α) (start m s : ℕ) : |
| (windowWords a x start m s).length = s := by simp [windowWords] |
|
|
| theorem windowWords_ofFn {α : Type*} (a : α) (x : List α) (start m s : ℕ) : |
| windowWords a x start m s = |
| List.ofFn (fun r : Fin s => normalizeWord a m (segment x (start+r) (m-s+1))) := by |
| simp [windowWords, windows, List.map_ofFn, Function.comp_def] |
|
|
| theorem windows_segment {α : Type*} (x : List α) {start m s : ℕ} |
| (_hs : 1 ≤ s) (hsm : s ≤ m) : |
| windows (segment x start m) 0 m s = windows x start m s := by |
| unfold windows |
| congr 1 |
| funext r |
| simp only [Nat.zero_add] |
| exact segment_segment x start m r (m-s+1) (by have := r.isLt; omega) |
|
|
| theorem windowWords_segment {α : Type*} (a : α) (x : List α) {start m s : ℕ} |
| (hs : 1 ≤ s) (hsm : s ≤ m) : |
| windowWords a (segment x start m) 0 m s = windowWords a x start m s := by |
| simp only [windowWords, windows_segment x hs hsm] |
|
|
| theorem cross_window_deficit {α : Type*} (a : α) {x y : List α} {m s : ℕ} |
| (hx : x.length = m) (hy : y.length = m) (hs : 1 ≤ s) (hsm : s ≤ m) |
| (hq : 2*s ≤ deficit x y + 1) (i j : Fin s) : |
| s ≤ deficit (normalizeWord a m (segment x i (m-s+1))).val |
| (normalizeWord a m (segment y j (m-s+1))).val := by |
| have hxi : (segment x i (m-s+1)).length = m-s+1 := |
| length_segment (by have := i.isLt; omega) |
| have hyj : (segment y j (m-s+1)).length = m-s+1 := |
| length_segment (by have := j.isLt; omega) |
| rw [normalizeWord_deficit a (by omega) (by omega)] |
| have hmono := lcs_mono (segment_sublist x i (m-s+1)) (segment_sublist y j (m-s+1)) |
| have hb := lcs_le_length_left x y |
| simp only [deficit, hxi] at * |
| omega |
|
|
| theorem exists_separating_scale {m q : ℕ} (hq : 0 < q) (hqm : q ≤ m) : |
| ∃ k : Fin (Nat.log 2 m + 1), 1 ≤ 2^k.val ∧ 2^k.val ≤ m ∧ |
| q ≤ 4 * 2^k.val ∧ 2 * 2^k.val ≤ q+1 := by |
| let n := (q+1)/2 |
| have hn : 0 < n := by dsimp [n]; omega |
| have hnm : n ≤ m := by dsimp [n]; omega |
| let k := Nat.log 2 n |
| have hk : k ≤ Nat.log 2 m := Nat.log_mono_right hnm |
| have hpow : 2^k ≤ n := Nat.pow_le_of_le_log hn.ne' le_rfl |
| have hlt : n < 2^(k+1) := Nat.lt_pow_succ_log_self (by norm_num) n |
| refine ⟨⟨k, by omega⟩, ?_, hpow.trans hnm, ?_, ?_⟩ |
| · change 1 ≤ 2^k |
| have hp : 0 < 2^k := pow_pos (by norm_num) _ |
| omega |
| · change q ≤ 4 * 2^k |
| simp only [pow_succ] at hlt |
| dsimp [n] at * |
| omega |
| · change 2 * 2^k ≤ q+1 |
| dsimp [n] at hpow |
| omega |
|
|
| noncomputable def partitionRate (s : ℕ) : ℝ := 4 * Real.log (s+1) / s |
|
|
| theorem partitionRate_nonneg (s : ℕ) : 0 ≤ partitionRate s := by |
| unfold partitionRate |
| exact div_nonneg (mul_nonneg (by norm_num) (Real.log_nonneg (by norm_num))) (Nat.cast_nonneg _) |
|
|
| theorem partition_collision_bound {s : ℕ} (hs : 1 ≤ s) {ρ : ℝ} (hρ : s ≤ ρ) : |
| Real.exp (-partitionRate s * ρ) ≤ ((s : ℝ)+1)⁻¹ ^ 4 := by |
| have hspos : (0 : ℝ) < s := by exact_mod_cast hs |
| calc |
| _ ≤ Real.exp (-partitionRate s * s) := Real.exp_le_exp.mpr |
| (mul_le_mul_of_nonpos_left hρ (neg_nonpos.mpr (partitionRate_nonneg s))) |
| _ = _ := by |
| rw [show -partitionRate s * s = -(4 * Real.log ((s:ℝ)+1)) by |
| unfold partitionRate; field_simp] |
| rw [Real.exp_neg, show 4 * Real.log ((s:ℝ)+1) = (4:ℕ) * Real.log ((s:ℝ)+1) by norm_num, |
| Real.exp_nat_mul, Real.exp_log (by positivity), inv_pow] |
|
|
| theorem scale_collision_union {s : ℕ} : (s : ℝ)^2 * (((s:ℝ)+1)⁻¹ ^ 4) ≤ 1/2 := by |
| have hs : (0 : ℝ) ≤ s := Nat.cast_nonneg s |
| rw [inv_pow, mul_inv_le_iff₀ (by positivity)] |
| nlinarith [sq_nonneg ((s:ℝ)^2), sq_nonneg ((s:ℝ)-1)] |
|
|
| theorem block_histogram_lower {α Ω Y ι : Type*} [Fintype Ω] [Fintype Y] [Fintype ι] |
| (a : α) {m s : ℕ} (F : List.Vector α m → ι → ℝ) |
| (hF : ∀ u v, (deficit u.val v.val : ℝ) ≤ coordDist F u v) |
| (μ : FiniteLaw Ω) (label : Ω → List.Vector α m → Y) |
| (he : ∀ u v, μ.event (fun ω => label ω u = label ω v) = |
| Real.exp (-partitionRate s * coordDist F u v)) |
| {x y : List α} (hx : x.length = m) (hy : y.length = m) |
| (hs : 1 ≤ s) (hsm : s ≤ m) (hq : 2*s ≤ deficit x y + 1) : |
| (s:ℝ) ≤ μ.expect (fun ω => histDist (label ω) (windowWords a x 0 m s) (windowWords a y 0 m s)) := by |
| rw [windowWords_ofFn, windowWords_ofFn] |
| simp only [Nat.zero_add] |
| apply expect_histDist_ofFn_ge μ label _ _ (((s:ℝ)+1)⁻¹^4) _ scale_collision_union |
| intro i j |
| rw [he] |
| apply partition_collision_bound hs |
| exact (Nat.cast_le.mpr (cross_window_deficit a hx hy hs hsm hq i j)).trans (hF _ _) |
|
|
| theorem normalized_slide_segment {α : Type*} (a : α) {x y : List α} (h : Slide x y) |
| {m len start : ℕ} (hlen : len ≤ m) : |
| deficit (normalizeWord a m (segment x start len)).val |
| (normalizeWord a m (segment y start len)).val ≤ 2 := by |
| have hx : (segment x start len).length ≤ m := by |
| simp only [segment, List.length_take, List.length_drop] |
| exact (min_le_left _ _).trans hlen |
| have hy : (segment x start len).length = (segment y start len).length := by |
| simp only [segment, List.length_take, List.length_drop, h.length_eq] |
| rw [normalizeWord_deficit a hx hy, deficit_eq_unequalDeficit hy] |
| exact h.segment_deficit_le_two _ _ |
|
|
| theorem block_histogram_pairing {α Ω Y ι : Type*} [Fintype Ω] [Fintype Y] [Fintype ι] |
| (a : α) {m s : ℕ} (F : List.Vector α m → ι → ℝ) (Λ : ℝ) (hΛ : 0 ≤ Λ) |
| (hF : ∀ u v, coordDist F u v ≤ Λ * deficit u.val v.val) |
| (μ : FiniteLaw Ω) (label : Ω → List.Vector α m → Y) |
| (he : ∀ u v, μ.event (fun ω => label ω u = label ω v) = |
| Real.exp (-partitionRate s * coordDist F u v)) |
| {x y : List α} (hxy : Slide x y) (start : ℕ) (hs : 1 ≤ s) (hsm : s ≤ m) : |
| μ.expect (fun ω => histDist (label ω) (windowWords a x start m s) (windowWords a y start m s)) ≤ |
| 16 * Real.log ((s:ℝ)+1) * Λ := by |
| rw [windowWords_ofFn, windowWords_ofFn] |
| calc |
| _ ≤ 2 * s * (2 * partitionRate s * Λ) := by |
| apply expect_histDist_ofFn_le |
| intro i |
| have hr := partition_separation_le μ label (coordDist F) (partitionRate s) he |
| (normalizeWord a m (segment x (start+i) (m-s+1))) |
| (normalizeWord a m (segment y (start+i) (m-s+1))) |
| refine hr.trans ?_ |
| calc |
| _ ≤ partitionRate s * (Λ * 2) := by |
| apply mul_le_mul_of_nonneg_left _ (partitionRate_nonneg s) |
| refine (hF _ _).trans ?_ |
| apply mul_le_mul_of_nonneg_left _ hΛ |
| exact_mod_cast normalized_slide_segment a hxy (by omega : m-s+1 ≤ m) |
| _ = _ := by ring |
| _ = _ := by |
| have hs0 : (s:ℝ) ≠ 0 := by exact_mod_cast (by omega : s ≠ 0) |
| unfold partitionRate |
| field_simp |
| ring |
|
|
| theorem fin_index_indicator_sum (b p : ℕ) : |
| (∑ j : Fin b, if j.val = p then (1:ℝ) else 0) ≤ 1 := by |
| classical |
| by_cases hp : p < b |
| · have he (j : Fin b) : j.val = p ↔ j = ⟨p,hp⟩ := by simp only [Fin.ext_iff] |
| simp only [he] |
| simp |
| · have hn (j : Fin b) : j.val ≠ p := by have := j.isLt; omega |
| simp [hn] |
|
|
| theorem histogram_forward_bound {α Ω Y ι : Type*} [Fintype Ω] [Fintype Y] [Fintype ι] |
| (a : α) {m s : ℕ} (F : List.Vector α m → ι → ℝ) (Λ : ℝ) (hΛ : 0 ≤ Λ) |
| (hF : ∀ u v, coordDist F u v ≤ Λ * deficit u.val v.val) |
| (μ : FiniteLaw Ω) (label : Ω → List.Vector α m → Y) |
| (he : ∀ u v, μ.event (fun ω => label ω u = label ω v) = |
| Real.exp (-partitionRate s * coordDist F u v)) |
| (u v t : List α) (c d : α) (b : ℕ) (hs : 1 ≤ s) (hsm : s ≤ m) : |
| (∑ j : Fin b, μ.expect (fun ω => histDist (label ω) |
| (windowWords a (u ++ c :: (v ++ t)) (j*m) m s) |
| (windowWords a (u ++ v ++ d :: t) (j*m) m s))) ≤ |
| 2*b + 32 * Real.log ((s:ℝ)+1) * Λ := by |
| classical |
| let B := 16 * Real.log ((s:ℝ)+1) * Λ |
| have hB : 0 ≤ B := mul_nonneg (mul_nonneg (by norm_num) (Real.log_nonneg (by have := Nat.cast_nonneg (α := ℝ) s; linarith))) hΛ |
| let p := u.length / m |
| let q := (u.length + v.length) / m |
| have hb (j : Fin b) : μ.expect (fun ω => histDist (label ω) |
| (windowWords a (u ++ c :: (v ++ t)) (j*m) m s) |
| (windowWords a (u ++ v ++ d :: t) (j*m) m s)) ≤ |
| 2 + B * ((if j.val = p then 1 else 0) + (if j.val = q then 1 else 0)) := by |
| have hexc : μ.expect (fun ω => histDist (label ω) |
| (windowWords a (u ++ c :: (v ++ t)) (j*m) m s) |
| (windowWords a (u ++ v ++ d :: t) (j*m) m s)) ≤ B := |
| block_histogram_pairing a F Λ hΛ hF μ label he (.forward u v t c d) (j*m) hs hsm |
| by_cases hp : j.val = p |
| · refine hexc.trans ?_ |
| rw [ite_eq_left hp] |
| split_ifs <;> linarith |
| · by_cases hq : j.val = q |
| · refine hexc.trans ?_ |
| rw [ite_eq_right hp, ite_eq_left hq] |
| linarith |
| · rw [ite_eq_right hp, ite_eq_right hq] |
| simp only [add_zero, mul_zero] |
| obtain ⟨zs, hz, hx, hy⟩ := windows_nonexceptional u v t c d hs hsm hp hq |
| have hbω (ω : Ω) : histDist (label ω) |
| (windowWords a (u ++ c :: (v ++ t)) (j*m) m s) |
| (windowWords a (u ++ v ++ d :: t) (j*m) m s) ≤ 2 := by |
| have h := histDist_common_sublist_le (label ω) (hx.map (normalizeWord a m)) |
| (hy.map (normalizeWord a m)) |
| simp only [List.length_map, length_windows] at h |
| have hr : (2:ℝ) * s ≤ 2 * zs.length + 2 := by |
| exact_mod_cast (by omega : 2*s ≤ 2*zs.length+2) |
| exact h.trans (by linarith) |
| simpa using μ.expect_mono hbω |
| calc |
| _ ≤ ∑ j : Fin b, (2 + B * ((if j.val = p then 1 else 0) + (if j.val = q then 1 else 0))) := |
| Finset.sum_le_sum (fun j _ => hb j) |
| _ = 2*b + B * ((∑ j : Fin b, if j.val=p then (1:ℝ) else 0) + |
| (∑ j : Fin b, if j.val=q then (1:ℝ) else 0)) := by |
| rw [Finset.sum_add_distrib, ← Finset.mul_sum, Finset.sum_add_distrib] |
| simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul] |
| ring |
| _ ≤ 2*b + B * (1+1) := by |
| exact add_le_add le_rfl (mul_le_mul_of_nonneg_left |
| (add_le_add (fin_index_indicator_sum b p) (fin_index_indicator_sum b q)) hB) |
| _ = _ := by dsimp [B]; ring |
|
|
| theorem histogram_slide_bound {α Ω Y ι : Type*} [Fintype Ω] [Fintype Y] [Fintype ι] |
| (a : α) {m s : ℕ} (F : List.Vector α m → ι → ℝ) (Λ : ℝ) (hΛ : 0 ≤ Λ) |
| (hF : ∀ u v, coordDist F u v ≤ Λ * deficit u.val v.val) |
| (μ : FiniteLaw Ω) (label : Ω → List.Vector α m → Y) |
| (he : ∀ u v, μ.event (fun ω => label ω u = label ω v) = |
| Real.exp (-partitionRate s * coordDist F u v)) |
| {x y : List α} (hxy : Slide x y) (b : ℕ) (hs : 1 ≤ s) (hsm : s ≤ m) : |
| (∑ j : Fin b, μ.expect (fun ω => histDist (label ω) |
| (windowWords a x (j*m) m s) (windowWords a y (j*m) m s))) ≤ |
| 2*b + 32 * Real.log ((s:ℝ)+1) * Λ := by |
| cases hxy with |
| | forward u v t c d => exact histogram_forward_bound a F Λ hΛ hF μ label he u v t c d b hs hsm |
| | backward u v t c d => |
| simp only [histDist_symm (label _) |
| (windowWords a (u ++ v ++ d :: t) _ _ _)] |
| exact histogram_forward_bound a F Λ hΛ hF μ label he u v t c d b hs hsm |
|
|
| theorem SlidePath.coordDist_le {α ι : Type*} [Fintype ι] {x y : List α} {n : ℕ} |
| (h : SlidePath n x y) (F : List α → ι → ℝ) (K : ℝ) |
| (hF : ∀ u v, Slide u v → coordDist F u v ≤ K) : coordDist F x y ≤ n*K := by |
| induction h with |
| | nil => simp [coordDist] |
| | @cons n x y z h hs ih => |
| calc |
| _ ≤ coordDist F x y + coordDist F y z := coordDist_triangle F x y z |
| _ ≤ K + n*K := add_le_add (hF x y h) ih |
| _ = _ := by push_cast; ring |
|
|
| end FiniteCircle |
|
|
| end OAI |
|
|
