File size: 3,220 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 | import OAI.Combinatorics.BinaryEdit.CodeAdditive
import OAI.Combinatorics.BinaryEdit.UnequalSegments
import OAI.Combinatorics.BinaryEdit.EncodingIndex
namespace OAI
namespace TreeEdit.BinaryLower.Code
universe u v
/-- Simultaneous separation of the actual codeword segments implies the
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)
/-- The actual codebook's segment property gives the full additive deficit
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
|