| import OAI.Combinatorics.EditDistance.Model |
| import OAI.Combinatorics.EditApproximation.Definitions |
|
|
|
|
| namespace OAI |
|
|
| /-! |
| # Unrestricted edit scripts, metric inequalities, and common subsequences |
| -/ |
|
|
| namespace EditDistortion |
|
|
| universe u v |
| noncomputable def indel {Alpha : Type u} (x y : List Alpha) : ℕ := |
| sInf {n | Script false n x y} |
|
|
| variable {Alpha : Type u} {Beta : Type v} {s : Bool} |
|
|
| namespace Step |
|
|
| theorem symm {x y : List Alpha} (h : Step s x y) : Step s y x := by |
| cases h with |
| | insert p q a => exact .delete p q a |
| | delete p q a => exact .insert p q a |
| | substitute hs p q a b => exact .substitute hs p q b a |
|
|
| theorem map (f : Alpha → Beta) {x y : List Alpha} (h : Step s x y) : |
| Step s (x.map f) (y.map f) := by |
| cases h with |
| | insert p q a => simpa using Step.insert (substitutions := s) (p.map f) (q.map f) (f a) |
| | delete p q a => simpa using Step.delete (substitutions := s) (p.map f) (q.map f) (f a) |
| | substitute hs p q a b => |
| simpa using Step.substitute hs (p.map f) (q.map f) (f a) (f b) |
|
|
| theorem append_left (p : List Alpha) {x y : List Alpha} (h : Step s x y) : |
| Step s (p ++ x) (p ++ y) := by |
| cases h with |
| | insert q r a => simpa only [List.append_assoc] using Step.insert (substitutions := s) (p ++ q) r a |
| | delete q r a => simpa only [List.append_assoc] using Step.delete (substitutions := s) (p ++ q) r a |
| | substitute hs q r a b => |
| simpa only [List.append_assoc] using Step.substitute hs (p ++ q) r a b |
|
|
| theorem append_right (q : List Alpha) {x y : List Alpha} (h : Step s x y) : |
| Step s (x ++ q) (y ++ q) := by |
| cases h with |
| | insert p r a => |
| simpa only [List.append_assoc, List.cons_append] using |
| Step.insert (substitutions := s) p (r ++ q) a |
| | delete p r a => |
| simpa only [List.append_assoc, List.cons_append] using |
| Step.delete (substitutions := s) p (r ++ q) a |
| | substitute hs p r a b => |
| simpa only [List.append_assoc, List.cons_append] using Step.substitute hs p (r ++ q) a b |
|
|
| theorem length_bounds {x y : List Alpha} (h : Step s x y) : |
| x.length ≤ y.length + 1 ∧ y.length ≤ x.length + 1 := by |
| cases h <;> simp only [List.length_append, List.length_cons] <;> omega |
|
|
| theorem allow_substitution {x y : List Alpha} (h : Step false x y) : Step true x y := by |
| cases h with |
| | insert p q a => exact .insert p q a |
| | delete p q a => exact .delete p q a |
| | substitute hs => cases hs |
|
|
| end Step |
|
|
| namespace Script |
|
|
| theorem trans {m n : ℕ} {x y z : List Alpha} |
| (h : Script s m x y) (k : Script s n y z) : Script s (m + n) x z := by |
| induction h with |
| | nil => simpa using k |
| | @cons l x w y e h ih => |
| simpa only [Nat.add_right_comm] using Script.cons e (ih k) |
|
|
| theorem single {x y : List Alpha} (h : Step s x y) : Script s 1 x y := |
| .cons h (.nil y) |
|
|
| theorem symm {n : ℕ} {x y : List Alpha} (h : Script s n x y) : Script s n y x := by |
| induction h with |
| | nil x => exact .nil x |
| | cons e h ih => exact ih.trans (single e.symm) |
|
|
| theorem map (f : Alpha → Beta) {n : ℕ} {x y : List Alpha} (h : Script s n x y) : |
| Script s n (x.map f) (y.map f) := by |
| induction h with |
| | nil x => exact .nil _ |
| | cons e h ih => exact .cons (e.map f) ih |
|
|
| theorem append_left (p : List Alpha) {n : ℕ} {x y : List Alpha} (h : Script s n x y) : |
| Script s n (p ++ x) (p ++ y) := by |
| induction h with |
| | nil x => exact .nil _ |
| | cons e h ih => exact .cons (e.append_left p) ih |
|
|
| theorem append_right (q : List Alpha) {n : ℕ} {x y : List Alpha} (h : Script s n x y) : |
| Script s n (x ++ q) (y ++ q) := by |
| induction h with |
| | nil x => exact .nil _ |
| | cons e h ih => exact .cons (e.append_right q) ih |
|
|
| theorem to_nil (x : List Alpha) : Script s x.length x [] := by |
| induction x with |
| | nil => exact .nil [] |
| | cons a x ih => exact .cons (.delete [] x a) ih |
|
|
| theorem exists_script (x y : List Alpha) : ∃ n, Script s n x y := |
| ⟨x.length + y.length, (to_nil x).trans (to_nil y).symm⟩ |
|
|
| theorem eq_of_zero {x y : List Alpha} (h : Script s 0 x y) : x = y := by |
| cases h |
| rfl |
|
|
| theorem length_bounds {n : ℕ} {x y : List Alpha} (h : Script s n x y) : |
| x.length ≤ y.length + n ∧ y.length ≤ x.length + n := by |
| induction h with |
| | nil x => omega |
| | cons e h ih => have := e.length_bounds; omega |
|
|
| theorem allow_substitution {n : ℕ} {x y : List Alpha} (h : Script false n x y) : |
| Script true n x y := by |
| induction h with |
| | nil x => exact .nil x |
| | cons e h ih => exact .cons e.allow_substitution ih |
|
|
| end Script |
|
|
|
|
|
|
| theorem cost_le {n : ℕ} {x y : List Alpha} (h : Script s n x y) : cost s x y ≤ n := |
| Nat.sInf_le h |
|
|
| theorem cost_spec (x y : List Alpha) : Script s (cost s x y) x y := |
| Nat.sInf_mem (Script.exists_script x y) |
|
|
| theorem cost_refl (x : List Alpha) : cost s x x = 0 := |
| Nat.eq_zero_of_le_zero (cost_le (.nil x)) |
|
|
| theorem cost_eq_zero_iff {x y : List Alpha} : cost s x y = 0 ↔ x = y := by |
| constructor |
| · intro h |
| have hc := cost_spec (s := s) x y |
| rw [h] at hc |
| exact hc.eq_of_zero |
| · rintro rfl |
| exact cost_refl _ |
|
|
| theorem cost_symm (x y : List Alpha) : cost s x y = cost s y x := by |
| apply Nat.le_antisymm |
| · exact cost_le (cost_spec y x).symm |
| · exact cost_le (cost_spec x y).symm |
|
|
| theorem cost_triangle (x y z : List Alpha) : cost s x z ≤ cost s x y + cost s y z := |
| cost_le ((cost_spec x y).trans (cost_spec y z)) |
|
|
| theorem cost_map_le (f : Alpha → Beta) (x y : List Alpha) : |
| cost s (x.map f) (y.map f) ≤ cost s x y := |
| cost_le ((cost_spec x y).map f) |
|
|
| theorem cost_length_bounds (x y : List Alpha) : |
| x.length ≤ y.length + cost s x y ∧ y.length ≤ x.length + cost s x y := |
| (cost_spec x y).length_bounds |
|
|
| theorem edit_le_indel (x y : List Alpha) : edit x y ≤ indel x y := |
| cost_le ((cost_spec (s := false) x y).allow_substitution) |
|
|
| end EditDistortion |
|
|
| namespace EditDistortion |
|
|
| universe u v |
| variable {Alpha : Type u} {Beta : Type v} {s : Bool} |
|
|
| theorem Step.indel_simulation {x y : List Alpha} (e : Step true x y) : |
| ∃ n ≤ 2, Script false n x y := by |
| cases e with |
| | insert p q a => exact ⟨1, by omega, Script.single (.insert p q a)⟩ |
| | delete p q a => exact ⟨1, by omega, Script.single (.delete p q a)⟩ |
| | substitute _ p q a b => |
| exact ⟨2, le_rfl, (Script.single (.delete p q a)).trans |
| (Script.single (.insert p q b))⟩ |
|
|
| theorem Script.indel_simulation {m : ℕ} {x y : List Alpha} (h : Script true m x y) : |
| ∃ n ≤ 2 * m, Script false n x y := by |
| induction h with |
| | nil x => exact ⟨0, le_rfl, .nil x⟩ |
| | cons e h ih => |
| obtain ⟨n, hn, sn⟩ := ih |
| obtain ⟨k, hk, sk⟩ := e.indel_simulation |
| exact ⟨k + n, by omega, sk.trans sn⟩ |
|
|
| theorem indel_le_two_edit (x y : List Alpha) : indel x y ≤ 2 * edit x y := by |
| obtain ⟨n, hn, hs⟩ := (cost_spec (s := true) x y).indel_simulation |
| exact (cost_le hs).trans hn |
|
|
| theorem Script.max_length (x y : List Alpha) : Script true (max x.length y.length) x y := by |
| induction x generalizing y with |
| | nil => simpa using (Script.to_nil (s := true) y).symm |
| | cons a x ih => |
| cases y with |
| | nil => simpa using Script.to_nil (s := true) (a :: x) |
| | cons b y => |
| have hs := (ih y).append_left [b] |
| have he := Step.substitute rfl [] x a b |
| simpa only [List.length_cons, max_add_add_right, List.singleton_append, List.nil_append] using |
| Script.cons he hs |
|
|
| theorem edit_le_max_length (x y : List Alpha) : edit x y ≤ max x.length y.length := |
| cost_le (Script.max_length x y) |
|
|
| theorem cost_map_eq_of_leftInverse (f : Alpha → Beta) (g : Beta → Alpha) |
| (h : Function.LeftInverse g f) (x y : List Alpha) : |
| cost s (x.map f) (y.map f) = cost s x y := by |
| apply Nat.le_antisymm (cost_map_le f x y) |
| have H := cost_map_le (s := s) g (x.map f) (y.map f) |
| simpa only [List.map_map, h.comp_eq_id, List.map_id] using H |
|
|
| theorem cost_append_le (x y u v : List Alpha) : |
| cost s (x ++ u) (y ++ v) ≤ cost s x y + cost s u v := |
| cost_le (((cost_spec x y).append_right u).trans ((cost_spec u v).append_left y)) |
|
|
| theorem Script.of_sublist {x y : List Alpha} (h : x.Sublist y) : |
| Script false (y.length - x.length) y x := by |
| induction h with |
| | slnil => exact .nil [] |
| | @cons x y a h ih => |
| have hl := h.length_le |
| simpa only [List.length_cons, Nat.succ_sub hl, Nat.succ_eq_add_one, List.nil_append] using |
| Script.cons (.delete [] y a) ih |
| | @cons_cons x y a h ih => |
| simpa only [List.length_cons, Nat.add_sub_add_right, List.singleton_append] using |
| ih.append_left [a] |
|
|
| theorem indel_le_matching_loss {x y z : List Alpha} (hx : z.Sublist x) (hy : z.Sublist y) : |
| indel x y ≤ x.length + y.length - 2 * z.length := by |
| have hs := (Script.of_sublist hx).trans (Script.of_sublist hy).symm |
| have hx' := hx.length_le |
| have hy' := hy.length_le |
| have heq : x.length - z.length + (y.length - z.length) = |
| x.length + y.length - 2 * z.length := by omega |
| rw [heq] at hs |
| exact cost_le hs |
|
|
| end EditDistortion |
|
|
| namespace EditDistortion |
|
|
| universe u |
| variable {Alpha : Type u} |
|
|
| theorem sublist_erase_one {z p q : List Alpha} {a : Alpha} |
| (h : z.Sublist (p ++ a :: q)) : |
| ∃ z' : List Alpha, z'.Sublist z ∧ z'.Sublist (p ++ q) ∧ z.length ≤ z'.length + 1 := by |
| obtain ⟨z₁, z₂, rfl, h₁, h₂⟩ := List.sublist_append_iff.mp h |
| rcases List.sublist_cons_iff.mp h₂ with h₂ | ⟨r, rfl, hr⟩ |
| · exact ⟨z₁ ++ z₂, .refl _, h₁.append h₂, by omega⟩ |
| · refine ⟨z₁ ++ r, (List.Sublist.refl z₁).append ((List.Sublist.refl r).cons a), |
| h₁.append hr, ?_⟩ |
| simp only [List.length_append, List.length_cons] |
| omega |
|
|
| theorem Script.common_sublist {n : ℕ} {x y : List Alpha} (h : Script false n x y) : |
| ∃ z : List Alpha, z.Sublist x ∧ z.Sublist y ∧ x.length + y.length ≤ n + 2 * z.length := by |
| induction h with |
| | nil x => exact ⟨x, .refl _, .refl _, by omega⟩ |
| | @cons n x v y e h ih => |
| obtain ⟨z, hzx, hzy, hz⟩ := ih |
| cases e with |
| | insert p q a => |
| obtain ⟨z', hz'z, hz'x, hz'L⟩ := sublist_erase_one hzx |
| refine ⟨z', hz'x, hz'z.trans hzy, ?_⟩ |
| simp only [List.length_append, List.length_cons] at hz ⊢ |
| omega |
| | delete p q a => |
| refine ⟨z, hzx.middle a, hzy, ?_⟩ |
| simp only [List.length_append, List.length_cons] at hz ⊢ |
| omega |
| | substitute hf => cases hf |
|
|
| theorem indel_matching (x y : List Alpha) : |
| ∃ z : List Alpha, z.Sublist x ∧ z.Sublist y ∧ |
| indel x y = x.length + y.length - 2 * z.length := by |
| obtain ⟨z, hx, hy, hz⟩ := (cost_spec (s := false) x y).common_sublist |
| refine ⟨z, hx, hy, Nat.le_antisymm (indel_le_matching_loss hx hy) ?_⟩ |
| change x.length + y.length - 2 * z.length ≤ cost false x y |
| omega |
|
|
| theorem le_indel_iff {x y : List Alpha} {r : ℕ} : r ≤ indel x y ↔ |
| ∀ z : List Alpha, z.Sublist x → z.Sublist y → r ≤ x.length + y.length - 2 * z.length := by |
| constructor |
| · intro hr z hx hy |
| exact hr.trans (indel_le_matching_loss hx hy) |
| · intro h |
| obtain ⟨z, hx, hy, hz⟩ := indel_matching x y |
| rw [hz] |
| exact h z hx hy |
|
|
| end EditDistortion |
|
|
| end OAI |
|
|
