| import OAI.Combinatorics.EditDistance.DelimiterAlignment |
|
|
| namespace OAI |
|
|
| /-! |
| # Binary delimiter codes and padding |
| -/ |
|
|
| namespace EditCode |
| open EditDistortion |
| variable {A : Type*} {t : ℕ} |
|
|
| def width (t : ℕ) : ℕ := 2 * t + 3 |
|
|
| def bit (label : A → Fin t → Bool) (a : A) (r : ℕ) : Bool := |
| if r < 2 then true else |
| if h : r % 2 = 1 ∧ r / 2 - 1 < t then label a ⟨r / 2 - 1,h.2⟩ else false |
|
|
| def block (label : A → Fin t → Bool) (a : A) : List Bool := |
| List.ofFn (fun r : Fin (width t) => bit label a r) |
|
|
| def encode (label : A → Fin t → Bool) (x : List A) : List Bool := x.flatMap (block label) |
|
|
| def padded (label : A → Fin t → Bool) (x : List A) (r : ℕ) : List Bool := |
| encode label x ++ List.replicate r false |
|
|
| @[simp] lemma block_length (label : A → Fin t → Bool) (a : A) : |
| (block label a).length = width t := List.length_ofFn |
|
|
| @[simp] lemma width_pos : 0 < width t := by unfold width; omega |
|
|
| @[simp] lemma encode_length (label : A → Fin t → Bool) (x : List A) : |
| (encode label x).length = width t * x.length := by |
| induction x with |
| | nil => simp [encode] |
| | cons a x ih => simp_all [encode, Nat.mul_add, Nat.add_comm] |
|
|
| @[simp] lemma padded_length (label : A → Fin t → Bool) (x : List A) (r : ℕ) : |
| (padded label x r).length = width t * x.length + r := by simp [padded] |
|
|
| @[simp] lemma bit_zero (label : A → Fin t → Bool) (a : A) : bit label a 0 = true := by simp [bit] |
| @[simp] lemma bit_one (label : A → Fin t → Bool) (a : A) : bit label a 1 = true := by simp [bit] |
|
|
| lemma bit_label (label : A → Fin t → Bool) (a : A) (i : Fin t) : |
| bit label a (2 * i.val + 3) = label a i := by |
| have hm : (2 * i.val + 3) % 2 = 1 := by omega |
| have hd : (2 * i.val + 3) / 2 - 1 = i.val := by omega |
| simp [bit, show ¬2*i.val+3<2 by omega, hm, hd] |
|
|
| lemma bit_even (label : A → Fin t → Bool) (a : A) {r : ℕ} |
| (hr : 2 ≤ r) (he : r % 2 = 0) : bit label a r = false := by |
| simp [bit,show ¬r<2 by omega,he] |
|
|
| lemma bit_last (label : A → Fin t → Bool) (a : A) : |
| bit label a (width t - 1) = false := by |
| apply bit_even |
| · unfold width; omega |
| · unfold width; omega |
|
|
| lemma bit_consecutive (label : A → Fin t → Bool) {a : A} {r : ℕ} |
| (h₁ : bit label a r = true) (h₂ : bit label a (r+1) = true) : r = 0 := by |
| by_contra h |
| by_cases he : r % 2 = 0 |
| · have hr : 2 ≤ r := by omega |
| rw [bit_even label a hr he] at h₁ |
| cases h₁ |
| · have he : (r+1)%2=0 := by omega |
| rw [bit_even label a (by omega) he] at h₂ |
| cases h₂ |
|
|
| lemma encode_get_block (label : A → Fin t → Bool) (x : List A) |
| (i : Fin x.length) (r : Fin (width t)) : |
| (encode label x)[width t * i.val + r.val]'(by |
| rw [encode_length] |
| have hm := Nat.mul_le_mul_left (width t) i.isLt |
| simp only [Nat.mul_succ] at hm |
| have := r.isLt |
| omega) = bit label (x.get i) r := by |
| induction x with |
| | nil => exact Fin.elim0 i |
| | cons a x ih => |
| by_cases hi : i.val = 0 |
| · simp only [encode, List.flatMap_cons] |
| rw [List.getElem_append_left (by simp [hi])] |
| simp [block,hi,List.get_eq_getElem] |
| · let j : Fin x.length := ⟨i.val-1,by simpa only [List.length_cons] using (show i.val-1<x.length by |
| have := i.isLt; simp only [List.length_cons] at this; omega)⟩ |
| have hij : i.val = j.val+1 := by dsimp [j]; omega |
| simp only [encode, List.flatMap_cons] |
| rw [List.getElem_append_right (by rw [block_length]; rw [hij]; nlinarith)] |
| simp only [block_length] |
| have he : width t * i.val + r.val - width t = width t * j.val + r.val := by rw [hij,Nat.mul_add,Nat.mul_one]; omega |
| simp only [he] |
| have hget : (a :: x).get i = x.get j := by |
| simp only [List.get_eq_getElem,hij,List.getElem_cons_succ] |
| rw [hget] |
| exact ih j |
|
|
| lemma padded_get_block (label : A → Fin t → Bool) (x : List A) (pad : ℕ) |
| (i : Fin x.length) (r : Fin (width t)) : |
| (padded label x pad)[width t * i.val + r.val]'(by |
| rw [padded_length] |
| have hm := Nat.mul_le_mul_left (width t) i.isLt |
| simp only [Nat.mul_succ] at hm |
| have := r.isLt |
| omega) = bit label (x.get i) r := by |
| unfold padded |
| rw [List.getElem_append_left (by |
| rw [encode_length] |
| have hm := Nat.mul_le_mul_left (width t) i.isLt |
| simp only [Nat.mul_succ] at hm |
| have := r.isLt |
| omega),encode_get_block] |
|
|
| lemma padded_get_padding (label : A → Fin t → Bool) (x : List A) (pad n : ℕ) |
| (hn : n < (padded label x pad).length) (hp : width t * x.length ≤ n) : |
| (padded label x pad)[n] = false := by |
| unfold padded at hn ⊢ |
| rw [List.getElem_append_right (by simpa using hp)] |
| simp |
|
|
| lemma padded_delimiter (label : A → Fin t → Bool) (x : List A) (pad n : ℕ) |
| (hn : n+1 < (padded label x pad).length) |
| (h₁ : (padded label x pad)[n]'(by omega) = true) |
| (h₂ : (padded label x pad)[n+1] = true) : |
| ∃ i : Fin x.length, n = width t * i.val := by |
| have hnp : n < width t * x.length := by |
| by_contra h |
| rw [padded_get_padding label x pad n (by omega) (by omega)] at h₁ |
| cases h₁ |
| let i : Fin x.length := ⟨n / width t, (Nat.div_lt_iff_lt_mul width_pos).mpr (by nlinarith)⟩ |
| let r : Fin (width t) := ⟨n % width t, Nat.mod_lt _ width_pos⟩ |
| have hnE : n = width t * i.val + r.val := by |
| dsimp [i,r] |
| have := Nat.mod_add_div n (width t) |
| omega |
| have hrLast : r.val ≠ width t - 1 := by |
| intro he |
| have h := padded_get_block label x pad i r |
| simp only [←hnE] at h |
| have hb := bit_last label (x.get i) |
| simp only [show (r : ℕ) = width t-1 from he,hb] at h |
| rw [h] at h₁ |
| cases h₁ |
| let r' : Fin (width t) := ⟨r.val+1,by have := r.isLt; omega⟩ |
| have hb₁ : bit label (x.get i) r = true := by |
| have hv := padded_get_block label x pad i r |
| simp only [←hnE] at hv |
| exact hv.symm.trans h₁ |
| have hb₂ : bit label (x.get i) (r.val+1) = true := by |
| rw [← padded_get_block label x pad i r'] |
| have he : width t*i.val+r'.val=n+1 := by dsimp [r']; omega |
| simpa only [he] using h₂ |
| have hr0 := bit_consecutive label hb₁ hb₂ |
| exact ⟨i,by omega⟩ |
|
|
| lemma block_injective (label : A → Fin t → Bool) (hi : Function.Injective label) : |
| Function.Injective (block label) := by |
| intro a b he |
| apply hi |
| funext i |
| have hir : 2*i.val+3<width t := by unfold width; omega |
| have hv := congrArg (fun l : List Bool => l[2*i.val+3]?) he |
| simp only [block, List.getElem?_ofFn] at hv |
| simp only [dite_eq_left hir] at hv |
| simpa only [bit_label, Option.some.injEq] using hv |
|
|
| end EditCode |
|
|
| end OAI |
|
|
