| import OAI.Combinatorics.EditDistance.CutModels |
| import OAI.Combinatorics.EditDistance.DyadicScales |
| import OAI.Combinatorics.EditDistance.Windows |
|
|
| namespace OAI |
|
|
| /-! |
| |
| -/ |
|
|
| namespace EditUpper |
| attribute [local instance] Classical.propDecidable |
| open scoped BigOperators |
| open Finset EditDistortion EditWindow EditCutModel |
|
|
| variable {A : Type*} |
|
|
| def samples (x : List A) (start l s : ℕ) : Fin s → List (Option A) := |
| fun i => window x (start+i.val) (l-s+1) |
|
|
| noncomputable def piece (M : Model (List (Option A))) (x y : List A) (start l s : ℕ) : ℝ := |
| EditCutHash.meanHistogram M.weight (EditCutHash.rate s) M.cut |
| (samples x start l s) (samples y start l s) |
|
|
| lemma piece_nonneg (M : Model (List (Option A))) (x y : List A) (start l s : ℕ) (hs : 0 < s) : |
| 0 ≤ piece M x y start l s := |
| EditCutHash.meanHistogram_nonneg M.nonneg (EditCutHash.rate_nonneg hs) _ _ _ |
|
|
| noncomputable def lift (M : Model (List (Option A))) (b l : ℕ) : Model (List A) := |
| (Model.total (fun j : Fin b × Fin (Nat.log 2 l+1) => |
| (M.histogram (2^j.2.val) (EditCutHash.rate (2^j.2.val)) |
| (EditCutHash.rate_nonneg (pow_pos (by omega) _))).pullback |
| (fun x => samples x (j.1.val*l) l (2^j.2.val)))).scale 16 (by norm_num) |
| |
| lemma lift_dist (M : Model (List (Option A))) (b l : ℕ) (x y : List A) : |
| (lift M b l).dist x y = |
| 16 * ∑ j : Fin b, ∑ r : Fin (Nat.log 2 l+1), piece M x y (j.val*l) l (2^r.val) := by |
| rw [lift,Model.scale_dist,Model.total_dist,Fintype.sum_prod_type] |
| congr 1 |
| apply sum_congr rfl |
| intro j _ |
| apply sum_congr rfl |
| intro r _ |
| rw [Model.pullback_dist,Model.histogram_dist] |
| rfl |
| |
| lemma block_indel_bound (x y : List A) (start l : ℕ) : |
| indel (window x start l) (window y start l) ≤ 2*l := by |
| have h : indel (window x start l) (window y start l) ≤ |
| (window x start l).length+(window y start l).length := by |
| exact cost_le ((Script.to_nil (s := false) _).trans (Script.to_nil _).symm) |
| simpa only [window_length,two_mul] using h |
| |
| lemma block_lower (M : Model (List (Option A))) (l : ℕ) (hl : 0 < l) |
| (hM : ∀ u v : List (Option A), u.length ≤ l → v.length ≤ l → |
| (indel u v : ℝ) ≤ M.dist u v) (x y : List A) (start : ℕ) : |
| (indel (window x start l) (window y start l) : ℝ) ≤ |
| 16 * ∑ r : Fin (Nat.log 2 l+1), piece M x y start l (2^r.val) := by |
| let delta := indel (window x start l) (window y start l) |
| have hnn (r : Fin (Nat.log 2 l+1)) : 0 ≤ piece M x y start l (2^r.val) := |
| piece_nonneg _ _ _ _ _ _ (pow_pos (by omega) _) |
| by_cases hd : delta = 0 |
| · change (delta : ℝ) ≤ _ |
| rw [hd,Nat.cast_zero] |
| exact mul_nonneg (by norm_num) (sum_nonneg (fun r _ => hnn r)) |
| · obtain ⟨r,hs,hsl,hds,hsd⟩ := EditDyadic.scale hl (Nat.pos_of_ne_zero hd) (block_indel_bound x y start l) |
| have hcross (i j : Fin (2^r.val)) : ((2^r.val : ℕ) : ℝ) ≤ |
| EditCutHash.distance M.weight M.cut (samples x start l (2^r.val) i) (samples y start l (2^r.val) j) := by |
| rw [Model.distance_eq] |
| have htri := segment_cross (fun k => x[k]?) (fun k => y[k]?) start l (2^r.val) hs hsl i j |
| change delta ≤ 2*(2^r.val-1)+indel (samples x start l (2^r.val) i) |
| (samples y start l (2^r.val) j) at htri |
| have hloss : 2^r.val ≤ indel (samples x start l (2^r.val) i) |
| (samples y start l (2^r.val) j) := by omega |
| calc |
| _ ≤ (indel (samples x start l (2^r.val) i) (samples y start l (2^r.val) j) : ℝ) := by exact_mod_cast hloss |
| _ ≤ _ := hM _ _ (by simp only [samples,window_length]; omega) (by simp only [samples,window_length]; omega) |
| have hh := EditCutHash.meanHistogram_separated (by omega : 0 < 2^r.val) M.nonneg M.cut |
| (samples x start l (2^r.val)) (samples y start l (2^r.val)) hcross |
| change ((2^r.val : ℕ) : ℝ) ≤ piece M x y start l (2^r.val) at hh |
| have hsum := single_le_sum (fun j _ => hnn j) (mem_univ r) |
| have hdsr : (delta : ℝ) ≤ 16*((2^r.val : ℕ) : ℝ) := by exact_mod_cast hds |
| change (delta : ℝ) ≤ _ |
| nlinarith |
| |
| lemma lift_lower (M : Model (List (Option A))) (b l : ℕ) (hl : 0 < l) |
| (hM : ∀ u v : List (Option A), u.length ≤ l → v.length ≤ l → |
| (indel u v : ℝ) ≤ M.dist u v) (x y : List A) |
| (hx : x.length ≤ b*l) (hy : y.length ≤ b*l) : |
| (indel x y : ℝ) ≤ (lift M b l).dist x y := by |
| have h1 := indel_le_window x y (b*l) hx hy |
| have h2 := indel_segment_blocks (fun k => x[k]?) (fun k => y[k]?) l b |
| change indel (window x 0 (b*l)) (window y 0 (b*l)) ≤ _ at h2 |
| have h3 : (indel x y : ℝ) ≤ |
| ∑ j : Fin b, (indel (window x (j.val*l) l) (window y (j.val*l) l) : ℝ) := by |
| rw [Fin.sum_univ_eq_sum_range (fun j => (indel (window x (j*l) l) (window y (j*l) l) : ℝ)) b] |
| exact_mod_cast h1.trans h2 |
| rw [lift_dist,mul_sum] |
| apply h3.trans |
| apply sum_le_sum |
| intro j _ |
| exact block_lower M l hl hM x y (j.val*l) |
| |
| lemma piece_insert_general (M : Model (List (Option A))) {D : ℝ} (hD : 0 ≤ D) |
| (hM : ∀ u v, M.dist u v ≤ D*(indel u v : ℝ)) |
| (p q : List A) (a : A) (start l s : ℕ) (hs : 0 < s) : |
| piece M (p++q) (p++a::q) start l s ≤ 4*Real.log (2*(s : ℝ)^2)*D := by |
| have hup := EditCutHash.meanHistogram_upper M.nonneg (EditCutHash.rate_nonneg hs) M.cut |
| (samples (p++q) start l s) (samples (p++a::q) start l s) |
| have hsum : (∑ i : Fin s, EditCutHash.distance M.weight M.cut |
| (samples (p++q) start l s i) (samples (p++a::q) start l s i)) ≤ (s : ℝ)*(2*D) := by |
| calc |
| _ ≤ ∑ _i : Fin s, 2*D := by |
| apply sum_le_sum |
| intro i _ |
| rw [Model.distance_eq] |
| have hcost := window_insert_cost p q a (start+i.val) (l-s+1) |
| have hcr : (indel (samples (p++q) start l s i) (samples (p++a::q) start l s i) : ℝ) ≤ 2 := by exact_mod_cast hcost |
| exact (hM _ _).trans (by nlinarith) |
| _ = _ := by simp only [sum_const,card_univ,Fintype.card_fin,nsmul_eq_mul] |
| have hr := EditCutHash.rate_nonneg hs |
| have h := hup.trans (mul_le_mul_of_nonneg_left hsum (by positivity)) |
| change piece M (p++q) (p++a::q) start l s ≤ _ at h |
| apply h.trans_eq |
| unfold EditCutHash.rate |
| have hs0 : (s : ℝ) ≠ 0 := by exact_mod_cast (Nat.ne_of_gt hs) |
| field_simp |
| ring |
| |
| lemma piece_before (M : Model (List (Option A))) (p q : List A) (a : A) |
| (start l s : ℕ) (_hs : 0 < s) (hsl : s ≤ l) (hp : start+l ≤ p.length) : |
| piece M (p++q) (p++a::q) start l s = 0 := by |
| have he : samples (p++q) start l s = samples (p++a::q) start l s := by |
| funext i |
| exact (window_before p q a (by omega)).symm |
| unfold piece |
| rw [←he,EditCutHash.meanHistogram_self] |
| |
| lemma piece_after (M : Model (List (Option A))) (p q : List A) (a : A) |
| (start l s : ℕ) (hs : 0 < s) (hp : p.length ≤ start) : |
| piece M (p++q) (p++a::q) start l s ≤ 2 := by |
| apply EditCutHash.meanHistogram_shift hs M.nonneg (EditCutHash.rate_nonneg hs) |
| intro i |
| exact (window_after p q a (by omega)).symm |
| |
| end EditUpper |
| |
| namespace EditUpper |
| attribute [local instance] Classical.propDecidable |
| open scoped BigOperators |
| open Finset EditDistortion EditWindow EditCutModel |
| variable {A : Type*} |
| |
| lemma sum_block_insert (M : Model (List (Option A))) {D : ℝ} (hD : 0 ≤ D) |
| (hM : ∀ u v, M.dist u v ≤ D*(indel u v : ℝ)) |
| (p q : List A) (a : A) (b l s : ℕ) (hl : 0 < l) (hs : 0 < s) (hsl : s ≤ l) : |
| (∑ j : Fin b, piece M (p++q) (p++a::q) (j.val*l) l s) ≤ |
| 2*(b : ℝ)+4*Real.log (2*(s : ℝ)^2)*D := by |
| let K := 4*Real.log (2*(s : ℝ)^2)*D |
| have hK : 0 ≤ K := by |
| dsimp [K] |
| have hs1 : (1 : ℝ) ≤ s := by exact_mod_cast hs |
| exact mul_nonneg (mul_nonneg (by norm_num) (Real.log_nonneg (by nlinarith))) hD |
| have hj (j : Fin b) : piece M (p++q) (p++a::q) (j.val*l) l s ≤ |
| 2+(if j.val = p.length/l then K else 0) := by |
| by_cases he : j.val = p.length/l |
| · rw [ite_eq_left he] |
| have hh := piece_insert_general M hD hM p q a (j.val*l) l s hs |
| change _ ≤ K at hh |
| linarith |
| · rw [ite_eq_right he,add_zero] |
| by_cases hlt : j.val < p.length/l |
| · have hp : j.val*l+l ≤ p.length := by |
| have h1 := Nat.mul_le_mul_right l (show j.val+1 ≤ p.length/l by omega) |
| have h2 := Nat.div_mul_le_self p.length l |
| nlinarith |
| rw [piece_before M p q a (j.val*l) l s hs hsl hp] |
| norm_num |
| · have hp : p.length ≤ j.val*l := by |
| have h1 := Nat.mul_le_mul_right l (show p.length/l+1 ≤ j.val by omega) |
| have h2 := Nat.lt_mul_div_succ p.length hl |
| nlinarith |
| exact piece_after M p q a (j.val*l) l s hs hp |
| have hsum := sum_le_sum (fun j (_ : j ∈ (univ : Finset (Fin b))) => hj j) |
| rw [sum_add_distrib] at hsum |
| have hc : (∑ j : Fin b, (if j.val = p.length/l then K else 0)) ≤ K := by |
| rw [Fin.sum_univ_eq_sum_range (fun j => if j = p.length/l then K else 0) b,sum_ite_eq'] |
| split <;> linarith |
| simp only [sum_const,card_univ,Fintype.card_fin,nsmul_eq_mul] at hsum |
| dsimp [K] at hc hsum |
| linarith |
| |
| lemma lift_insert_raw (M : Model (List (Option A))) {D : ℝ} (hD : 0 ≤ D) |
| (hM : ∀ u v, M.dist u v ≤ D*(indel u v : ℝ)) |
| (p q : List A) (a : A) (b l : ℕ) (hl : 0 < l) : |
| (lift M b l).dist (p++q) (p++a::q) ≤ |
| 16*(Nat.log 2 l+1 : ℕ)*(2*(b : ℝ)+4*Real.log (2*(l : ℝ)^2)*D) := by |
| rw [lift_dist,sum_comm] |
| have hscale (r : Fin (Nat.log 2 l+1)) : (∑ j : Fin b, |
| piece M (p++q) (p++a::q) (j.val*l) l (2^r.val)) ≤ |
| 2*(b : ℝ)+4*Real.log (2*(l : ℝ)^2)*D := by |
| have hr := EditDyadic.scale_le hl r |
| have hp : 0 < 2^r.val := pow_pos (by omega) _ |
| have h := sum_block_insert M hD hM p q a b l (2^r.val) hl hp hr |
| apply h.trans |
| have hrr : ((2^r.val : ℕ) : ℝ) ≤ l := by exact_mod_cast hr |
| have hlog : Real.log (2*(((2^r.val : ℕ) : ℝ))^2) ≤ Real.log (2*(l : ℝ)^2) := by |
| apply Real.log_le_log (by positivity) |
| gcongr |
| nlinarith |
| calc |
| _ ≤ 16 * ∑ _r : Fin (Nat.log 2 l+1), (2*(b : ℝ)+4*Real.log (2*(l : ℝ)^2)*D) := |
| mul_le_mul_of_nonneg_left (sum_le_sum (fun r _ => hscale r)) (by norm_num) |
| _ = _ := by simp only [sum_const,card_univ,Fintype.card_fin,nsmul_eq_mul]; ring |
| |
| lemma model_indel_lipschitz (M : Model (List A)) {D : ℝ} |
| (hstep : ∀ (p q : List A) (a : A), M.dist (p++q) (p++a::q) ≤ D) : |
| ∀ x y, M.dist x y ≤ D*(indel x y : ℝ) := by |
| have he {x y : List A} (h : Step false x y) : M.dist x y ≤ D := by |
| cases h with |
| | insert p q a => exact hstep p q a |
| | delete p q a => rw [Model.dist_symm]; exact hstep p q a |
| | substitute h => contradiction |
| have hs {n : ℕ} {x y : List A} (h : Script false n x y) : M.dist x y ≤ D*(n : ℝ) := by |
| induction h with |
| | nil x => simp |
| | @cons n x y z e h ih => |
| have ht := M.dist_triangle x y z |
| have hh := he e |
| push_cast |
| nlinarith |
| intro x y |
| exact hs (cost_spec x y) |
|
|
| end EditUpper |
|
|
| end OAI |
|
|
