File size: 6,520 Bytes
f0f05de | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 | import OAI.Combinatorics.BinaryEdit.CodeEqualMatches
import OAI.Combinatorics.BinaryEdit.CodeNumerics
import OAI.Combinatorics.BinaryEdit.EncodingUpper
import OAI.Combinatorics.BinaryEdit.LCS
namespace OAI
/-! The longest encoded matching is partitioned by equality of its
original block labels. Segment separation and the span loss budget bound
the number of unequal-label matches. -/
namespace TreeEdit.BinaryLower.Code
universe u v
/-- The original letter whose block contains a specified encoded position. -/
def originalLetterAtBit {α : Type u} {M P : ℕ} (x : List α)
(hx : x.length = M) (hP : 0 < P) (q : Fin (M*P)) : α :=
x.get ⟨q.val/P, by rw [hx]; exact (Nat.div_lt_iff_lt_mul hP).mpr q.isLt⟩
/-- A bit of the actual concatenation, with its prescribed-length indexing. -/
def encodedBit {α : Type u} {β : Type v} {M P : ℕ}
(c : α → Word β P) (x : List α) (hx : x.length = M)
(q : Fin (M*P)) : β :=
(encode c x).get ⟨q.val, by rw [length_encode, hx]; exact q.isLt⟩
/-- Reading all encoded positions reconstructs the concrete concatenation. -/
@[simp] theorem ofFn_encodedBit {α : Type u} {β : Type v} {M P : ℕ}
(c : α → Word β P) (x : List α) (hx : x.length = M) :
List.ofFn (encodedBit c x hx) = encode c x := by
apply List.ext_getElem
· simp only [List.length_ofFn, length_encode, hx]
· intro i hi hi'
simp only [List.getElem_ofFn, encodedBit, List.get_eq_getElem]
/-- Optional lookup at an encoded position's block always succeeds and
returns exactly its original letter. This avoids partial-label conventions. -/
theorem getElem?_blockLetter {α : Type u} {M P : ℕ} (x : List α)
(hx : x.length = M) (hP : 0 < P) (q : Fin (M*P)) :
x[q.val/P]? = some (originalLetterAtBit x hx hP q) := by
have hq : q.val/P < x.length := by
rw [hx]
exact (Nat.div_lt_iff_lt_mul hP).mpr q.isLt
simp only [List.getElem?_eq_getElem hq, originalLetterAtBit, List.get_eq_getElem]
/-- Precisely the selected unequal-original-label edges of a matching. -/
noncomputable def unequalEdges {α : Type u} {M P r : ℕ}
(x y : List α) (hx : x.length = M) (hy : y.length = M) (hP : 0 < P)
(f g : Fin r → Fin (M*P)) : Finset (Fin r) := by
classical
exact Finset.univ.filter (fun t =>
originalLetterAtBit x hx hP (f t) ≠ originalLetterAtBit y hy hP (g t))
/-- Unequal-edge selection can equivalently be expressed by a total predicate
on the two natural-number block indices using optional original-word lookup. -/
theorem unequalEdges_eq_filter_getElem? {α : Type u} [DecidableEq α] {M P r : ℕ}
(x y : List α) (hx : x.length = M) (hy : y.length = M) (hP : 0 < P)
(f g : Fin r → Fin (M*P)) :
unequalEdges x y hx hy hP f g =
Finset.univ.filter (fun t => x[(f t).val/P]? ≠ y[(g t).val/P]?) := by
classical
ext t
simp only [unequalEdges, Finset.mem_filter, Finset.mem_univ, true_and,
getElem?_blockLetter x hx hP, getElem?_blockLetter y hy hP, ne_eq, Option.some.injEq]
/-- Equal-label coloring and the unequal-label estimate, for actual encoded
words and a matching of their longest-common-subsequence length. -/
theorem additive_of_longest_unequal_bound {α : Type u} {β : Type v}
{M P a₀ : ℕ} (c : α → Word β P) (x y : List α)
(hx : x.length = M) (hy : y.length = M) (hP : 0 < P)
(f g : Fin (lcs (encode c x) (encode c y)) → Fin (M*P))
(hf : StrictMono f) (hg : StrictMono g)
(hunequal : (unequalEdges x y hx hy hP f g).card ≤
200*(M*P-lcs (encode c x) (encode c y))+2*M*a₀) :
P*deficit M x y ≤ 201*deficit (M*P) (encode c x) (encode c y)+2*M*a₀ := by
classical
let r := lcs (encode c x) (encode c y)
let eqedges : Finset (Fin r) := Finset.univ.filter fun t =>
originalLetterAtBit x hx hP (f t) = originalLetterAtBit y hy hP (g t)
have hfx : ∀ t, (f t).val/P < x.length := by
intro t
rw [hx]
exact (Nat.div_lt_iff_lt_mul hP).mpr (f t).isLt
have hgy : ∀ t, (g t).val/P < y.length := by
intro t
rw [hy]
exact (Nat.div_lt_iff_lt_mul hP).mpr (g t).isLt
have hequal : eqedges.card ≤ P*lcs x y := by
apply equal_label_subset_card_le hP x y (fun t => (f t).val) (fun t => (g t).val)
(Fin.val_strictMono.comp hf) (Fin.val_strictMono.comp hg) hfx hgy eqedges
intro t ht
exact (Finset.mem_filter.mp ht).2
have hpartition : r = eqedges.card + (unequalEdges x y hx hy hP f g).card := by
have h := Finset.card_filter_add_card_filter_not
(s := (Finset.univ : Finset (Fin r)))
(p := fun t => originalLetterAtBit x hx hP (f t) =
originalLetterAtBit y hy hP (g t))
simpa only [eqedges, unequalEdges, Finset.card_univ, Fintype.card_fin] using h.symm
have hr : r ≤ M*P := by
have h := lcs_le_length_left (encode c x) (encode c y)
simpa only [length_encode, hx] using h
have hL : lcs x y ≤ M := by simpa only [hx] using lcs_le_length_left x y
exact block_counts_to_additive hpartition
(show r+deficit (M*P) (encode c x) (encode c y) = M*P by
simp only [deficit]; exact Nat.add_sub_of_le hr)
(show deficit M x y+lcs x y=M by
simp only [deficit]; exact Nat.sub_add_cancel hL)
hequal hunequal
/-- An unequal count proved for every actual encoded matching yields the
source additive estimate by choosing a longest encoded matching. -/
theorem additive_of_unequal_matching_bound {α : Type u} {β : Type v}
{M P a₀ : ℕ} (c : α → Word β P) (x y : List α)
(hx : x.length = M) (hy : y.length = M) (hP : 0 < P)
(hunequal : ∀ (r : ℕ) (f g : Fin r → Fin (M*P)),
StrictMono f → StrictMono g →
(∀ t, encodedBit c x hx (f t) = encodedBit c y hy (g t)) →
(unequalEdges x y hx hy hP f g).card ≤ 200*(M*P-r)+2*M*a₀) :
P*deficit M x y ≤ 201*deficit (M*P) (encode c x) (encode c y)+2*M*a₀ := by
have hencx : (encode c x).length = M*P := by rw [length_encode, hx]
have hency : (encode c y).length = M*P := by rw [length_encode, hy]
obtain ⟨⟨f₀, g₀, hmatch⟩⟩ := exists_lcs_alignment (encode c x) (encode c y)
let f := fun t => Fin.cast hencx (f₀ t)
let g := fun t => Fin.cast hency (g₀ t)
have hf : StrictMono f := (Fin.cast_strictMono hencx).comp f₀.strictMono
have hg : StrictMono g := (Fin.cast_strictMono hency).comp g₀.strictMono
apply additive_of_longest_unequal_bound c x y hx hy hP f g hf hg
apply hunequal _ f g hf hg
intro t
simpa only [encodedBit, f, g, Fin.cast] using hmatch t
end TreeEdit.BinaryLower.Code
end OAI
|