| import OAI.Combinatorics.EditDistance.BinaryCode |
| import OAI.Combinatorics.EditDistance.RowSeparation |
|
|
| namespace OAI |
|
|
| /-! |
| # Contraction of arbitrary bit alignments to letter blocks |
| -/ |
|
|
| namespace EditCode |
| open EditDistortion |
| open scoped BigOperators |
| attribute [local instance] Classical.propDecidable |
| variable {A : Type*} {t k : ℕ} |
|
|
| def BlockPair (f g : Fin k → ℕ) (w i j : ℕ) : Prop := |
| ∀ r : ℕ, r < w → ∃ a : Fin k, f a = w*i+r ∧ g a = w*j+r |
|
|
| lemma BlockPair.symm {f g : Fin k → ℕ} {w i j : ℕ} (h : BlockPair f g w i j) : |
| BlockPair g f w j i := by |
| intro r hr |
| obtain ⟨a,ha,hb⟩ := h r hr |
| exact ⟨a,hb,ha⟩ |
|
|
| lemma BlockPair.span {f g : Fin k → ℕ} {w i j : ℕ} (h : BlockPair f g w i j) : |
| BlockSpan f g w i := ⟨w*j,h⟩ |
|
|
| lemma pair_strict {f g : Fin k → ℕ} {w i j i' j' : ℕ} |
| (hf : StrictMono f) (hg : StrictMono g) (hw : 0 < w) |
| (h : BlockPair f g w i j) (h' : BlockPair f g w i' j') (hi : i < i') : j < j' := by |
| obtain ⟨a,ha,hga⟩ := h 0 hw |
| obtain ⟨b,hb,hgb⟩ := h' 0 hw |
| have hab : a < b := hf.lt_iff_lt.mp (by simpa only [ha,hb,Nat.add_zero] using Nat.mul_lt_mul_of_pos_left hi hw) |
| have := hg hab |
| nlinarith |
|
|
| lemma pair_unique {f g : Fin k → ℕ} {w i j j' : ℕ} |
| (hf : Function.Injective f) (hw : 0 < w) |
| (h : BlockPair f g w i j) (h' : BlockPair f g w i j') : j = j' := by |
| obtain ⟨a,ha,hga⟩ := h 0 hw |
| obtain ⟨b,hb,hgb⟩ := h' 0 hw |
| have hab : a = b := hf (ha.trans hb.symm) |
| rw [hab] at hga |
| nlinarith |
|
|
| lemma span_pair (label : A → Fin t → Bool) (x y : List A) (r s : ℕ) |
| {f g : Fin k → ℕ} |
| (hf : ∀ a, f a < (padded label x r).length) |
| (hg : ∀ a, g a < (padded label y s).length) |
| (heq : ∀ a, (padded label x r)[f a]'(hf a) = (padded label y s)[g a]'(hg a)) |
| (i : Fin x.length) (hi : BlockSpan f g (width t) i.val) : |
| ∃ j : Fin y.length, BlockPair f g (width t) i.val j.val := by |
| obtain ⟨q,hq⟩ := hi |
| obtain ⟨a,ha,hga⟩ := hq 0 width_pos |
| obtain ⟨b,hb,hgb⟩ := hq 1 (by unfold width; omega) |
| have hqLen : q+1 < (padded label y s).length := by rw [←hgb]; exact hg b |
| have hq₀ : (padded label y s)[q]'(by omega) = true := by |
| have he := heq a |
| have hv := padded_get_block label x r i ⟨0,width_pos⟩ |
| simp only [bit_zero,Nat.add_zero] at hv |
| simpa only [ha,hga,Nat.add_zero,hv] using he.symm |
| have hq₁ : (padded label y s)[q+1] = true := by |
| have he := heq b |
| have hv := padded_get_block label x r i ⟨1,by unfold width; omega⟩ |
| simp only [bit_one] at hv |
| simpa only [hb,hgb,hv] using he.symm |
| obtain ⟨j,hj⟩ := padded_delimiter label y s q hqLen hq₀ hq₁ |
| refine ⟨j,?_⟩ |
| intro a ha |
| simpa only [hj] using hq a ha |
|
|
| lemma pair_letters (label : A → Fin t → Bool) (hinj : Function.Injective label) |
| (x y : List A) (r s : ℕ) {f g : Fin k → ℕ} |
| (hf : ∀ a, f a < (padded label x r).length) |
| (hg : ∀ a, g a < (padded label y s).length) |
| (heq : ∀ a, (padded label x r)[f a]'(hf a) = (padded label y s)[g a]'(hg a)) |
| (i : Fin x.length) (j : Fin y.length) (h : BlockPair f g (width t) i.val j.val) : |
| x.get i = y.get j := by |
| apply hinj |
| funext v |
| have hv : 2*v.val+3<width t := by unfold width; omega |
| obtain ⟨a,ha,hb⟩ := h (2*v.val+3) hv |
| have he := heq a |
| have hx := padded_get_block label x r i ⟨2*v.val+3,hv⟩ |
| have hy := padded_get_block label y s j ⟨2*v.val+3,hv⟩ |
| simp only [ha,hb,hx,hy] at he |
| simpa only [bit_label] using he |
|
|
| end EditCode |
|
|
| namespace EditCode |
| open EditDistortion |
| attribute [local instance] Classical.propDecidable |
| variable {A : Type*} {t k : ℕ} |
|
|
| theorem letter_loss_le (label : A → Fin t → Bool) (hinj : Function.Injective label) |
| (x y : List A) (r s : ℕ) {f g : Fin k → ℕ} |
| (hf : StrictMono f) (hg : StrictMono g) |
| (hfB : ∀ a, f a < (padded label x r).length) |
| (hgB : ∀ a, g a < (padded label y s).length) |
| (heq : ∀ a, (padded label x r)[f a]'(hfB a) = (padded label y s)[g a]'(hgB a)) : |
| indel x y ≤ 2 * (((padded label x r).length-k) + ((padded label y s).length-k)) := by |
| classical |
| let K := Finset.univ.filter (fun i : Fin x.length => BlockSpan f g (width t) i.val) |
| let B := {i : Fin x.length // BlockSpan f g (width t) i.val} |
| let C := {j : Fin y.length // BlockSpan g f (width t) j.val} |
| have hpair (i : B) : ∃ j : Fin y.length, BlockPair f g (width t) i.val j.val := |
| span_pair label x y r s hfB hgB heq i.val i.property |
| let next (i : B) : Fin y.length := (hpair i).choose |
| have next_pair (i : B) : BlockPair f g (width t) i.val (next i).val := (hpair i).choose_spec |
| let e : Fin K.card ↪o Fin x.length := K.orderEmbOfFin rfl |
| have he (i : Fin K.card) : BlockSpan f g (width t) (e i).val := |
| (Finset.mem_filter.mp (K.orderEmbOfFin_mem rfl i)).2 |
| let q (i : Fin K.card) : Fin y.length := next ⟨e i,he i⟩ |
| have hq : StrictMono q := by |
| intro i j hij |
| exact pair_strict hf hg width_pos (next_pair ⟨e i,he i⟩) (next_pair ⟨e j,he j⟩) |
| (e.strictMono hij) |
| have hletter : ∀ i, x.get (e i) = y.get (q i) := by |
| intro i |
| exact pair_letters label hinj x y r s hfB hgB heq _ _ (next_pair ⟨e i,he i⟩) |
| have hcost := indel_le_of_matching x.get y.get e (OrderEmbedding.ofStrictMono q hq) hletter |
| simp only [List.ofFn_get] at hcost |
| have hback (j : C) : ∃ i : Fin x.length, BlockPair g f (width t) j.val i.val := |
| span_pair label y x s r hgB hfB (fun a => (heq a).symm) j.val j.property |
| let back (j : C) : B := ⟨(hback j).choose,(hback j).choose_spec.symm.span⟩ |
| have hbackinj : Function.Injective back := by |
| intro j j' he |
| have hh : (hback j).choose.val = (hback j').choose.val := |
| congrArg (fun i : B => i.val.val) he |
| apply Subtype.ext |
| apply Fin.ext |
| apply pair_unique hf.injective width_pos (hback j).choose_spec.symm |
| rw [hh] |
| exact (hback j').choose_spec.symm |
| have hcard := Fintype.card_le_of_injective back hbackinj |
| have hcard' : (Finset.univ.filter (fun j : Fin y.length => BlockSpan g f (width t) j.val)).card ≤ K.card := by |
| simpa only [B,C,Fintype.card_subtype,K] using hcard |
| have hbadX := bad_blocks_le_loss hf hg width_pos hfB hgB |
| (show width t * x.length ≤ (padded label x r).length by simp) |
| have hbadY := bad_blocks_le_loss hg hf width_pos hgB hfB |
| (show width t * y.length ≤ (padded label y s).length by simp) |
| have hsplitX := Finset.card_filter_add_card_filter_not (s := Finset.univ) |
| (fun i : Fin x.length => BlockSpan f g (width t) i.val) |
| have hsplitY := Finset.card_filter_add_card_filter_not (s := Finset.univ) |
| (fun j : Fin y.length => BlockSpan g f (width t) j.val) |
| simp only [Finset.card_univ,Fintype.card_fin] at hsplitX hsplitY |
| change K.card + _ = _ at hsplitX |
| omega |
|
|
| theorem indel_code_lower (label : A → Fin t → Bool) (hinj : Function.Injective label) |
| (x y : List A) (r s : ℕ) : |
| indel x y ≤ 2 * indel (padded label x r) (padded label y s) := by |
| obtain ⟨z,hx,hy,hcost⟩ := indel_matching (padded label x r) (padded label y s) |
| obtain ⟨f,hf⟩ := List.sublist_iff_exists_fin_orderEmbedding_get_eq.mp hx |
| obtain ⟨g,hg⟩ := List.sublist_iff_exists_fin_orderEmbedding_get_eq.mp hy |
| have h := letter_loss_le label hinj x y r s |
| (f := fun a => (f a).val) (g := fun a => (g a).val) |
| (fun _ _ h => f.strictMono h) (fun _ _ h => g.strictMono h) |
| (fun a => (f a).isLt) (fun a => (g a).isLt) |
| (fun a => (hf a).symm.trans (hg a)) |
| have hzX := hx.length_le |
| have hzY := hy.length_le |
| have he : (padded label x r).length-z.length + ((padded label y s).length-z.length) = |
| (padded label x r).length+(padded label y s).length-2*z.length := by omega |
| rwa [he,←hcost] at h |
|
|
| end EditCode |
|
|
| end OAI |
|
|
