| import OAI.Combinatorics.BinaryEdit.CodeAdditive |
| import OAI.Combinatorics.BinaryEdit.UnequalSegments |
| import OAI.Combinatorics.BinaryEdit.EncodingIndex |
|
|
| namespace OAI |
|
|
| namespace TreeEdit.BinaryLower.Code |
|
|
| universe u v |
|
|
| / |
| concrete within-block separation predicate used by unequal matching counts. |
| Optional lookup makes the bad-pair predicate total on natural block indices; |
| the predicate is only used at the explicitly valid indices in this theorem. -/ |
| theorem encoded_block_segment_separation {α : Type u} {β : Type v} |
| {M P a₀ : ℕ} (c : α → Word β P) |
| (hsep : ∀ k l : α, k ≠ l → ∀ a i j : ℕ, a₀ ≤ a → |
| i + a ≤ P → j + a ≤ P → |
| 100 * lcs (((c k).val.drop i).take a) (((c l).val.drop j).take a) ≤ 99 * a) |
| (x y : List α) (hx : x.length = M) (hy : y.length = M) : |
| BlockSegmentSeparation (encodedBit c x hx) (encodedBit c y hy) |
| (fun b => x[b.1]? ≠ y[b.2]?) a₀ := by |
| intro b hb hb₁ hb₂ i j a hi hi' hj hj' ha w hwx hwy |
| have hb₁' : b.1 < x.length := by simpa only [hx] using hb₁ |
| have hb₂' : b.2 < y.length := by simpa only [hy] using hb₂ |
| have hletters : x[b.1] ≠ y[b.2] := by |
| simpa only [List.getElem?_eq_getElem hb₁', List.getElem?_eq_getElem hb₂', |
| ne_eq, Option.some.injEq] using hb |
| have hioff : i - b.1 * P + a ≤ P := by |
| simp only [Nat.add_mul, Nat.one_mul] at hi' |
| omega |
| have hjoff : j - b.2 * P + a ≤ P := by |
| simp only [Nat.add_mul, Nat.one_mul] at hj' |
| omega |
| have heqx : ((encode c x).drop i).take a = |
| (((c x[b.1]).val).drop (i - b.1 * P)).take a := by |
| have h := encode_segment_eq c x b.1 (i - b.1 * P) a hb₁' hioff |
| simpa only [Nat.add_sub_of_le hi] using h |
| have heqy : ((encode c y).drop j).take a = |
| (((c y[b.2]).val).drop (j - b.2 * P)).take a := by |
| have h := encode_segment_eq c y b.2 (j - b.2 * P) a hb₂' hjoff |
| simpa only [Nat.add_sub_of_le hj] using h |
| rw [ofFn_encodedBit, heqx] at hwx |
| rw [ofFn_encodedBit, heqy] at hwy |
| exact (Nat.mul_le_mul_left 100 (length_le_lcs hwx hwy)).trans |
| (hsep x[b.1] y[b.2] hletters a (i - b.1 * P) (j - b.2 * P) ha hioff hjoff) |
|
|
| / |
| bound, with no remaining local charge or matching-count hypothesis. -/ |
| theorem additive_of_codeword_separation {α : Type u} {β : Type v} |
| {M P a₀ : ℕ} (hP : 0 < P) (c : α → Word β P) |
| (hsep : ∀ k l : α, k ≠ l → ∀ a i j : ℕ, a₀ ≤ a → |
| i + a ≤ P → j + a ≤ P → |
| 100 * lcs (((c k).val.drop i).take a) (((c l).val.drop j).take a) ≤ 99 * a) |
| (x y : List α) (hx : x.length = M) (hy : y.length = M) : |
| P * deficit M x y ≤ |
| 201 * deficit (M * P) (encode c x) (encode c y) + 2 * M * a₀ := by |
| classical |
| apply additive_of_unequal_matching_bound c x y hx hy hP |
| intro r f g hf hg hmatch |
| rw [unequalEdges_eq_filter_getElem?] |
| exact unequal_matches_le_of_segment_separation hP |
| (encodedBit c x hx) (encodedBit c y hy) f g hf hg hmatch |
| (fun b => x[b.1]? ≠ y[b.2]?) a₀ |
| (encoded_block_segment_separation c hsep x y hx hy) |
|
|
| end TreeEdit.BinaryLower.Code |
|
|
| end OAI |
|
|
