File size: 3,501 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 | import Mathlib
import OAI.Combinatorics.BinaryEdit.MatchingSublist
import OAI.Combinatorics.TreeEdit.Alignments
namespace OAI
/-! Ordered equal-label bit matches can be colored by their ordinal modulo
block width. This avoids the bipartite edge-coloring theorem in the source. -/
namespace TreeEdit.BinaryLower.Code
/-- If every increasing block matching has at most `L` edges, then an increasing
bit matching whose edges all join equal original labels has at most `P * L`
edges. The hypothesis on each finite subset is precisely the longest-common-
subsequence bound after the two block maps become strictly increasing. -/
theorem equal_match_count_le {N P L : ℕ} (hP : 0 < P)
(f g : Fin N → ℕ) (hf : StrictMono f) (hg : StrictMono g)
(hL : ∀ s : Finset (Fin N),
StrictMonoOn (fun i => f i / P) (s : Set (Fin N)) →
StrictMonoOn (fun i => g i / P) (s : Set (Fin N)) → s.card ≤ L) :
N ≤ P * L := by
classical
have bound := Finset.card_le_mul_card_image_of_maps_to
(s := Finset.univ) (t := Finset.range P) (f := fun i : Fin N => i.val % P)
(fun i _ => Finset.mem_range.mpr (Nat.mod_lt i.val hP)) L
(by
intro r hr
apply hL
· intro i hi j hj hij
exact div_strict_of_equal_residue hP f hf hij
((Finset.mem_filter.mp hi).2.trans (Finset.mem_filter.mp hj).2.symm)
· intro i hi j hj hij
exact div_strict_of_equal_residue hP g hg hij
((Finset.mem_filter.mp hi).2.trans (Finset.mem_filter.mp hj).2.symm))
simpa [Nat.mul_comm] using bound
/-- Concrete equal-label case of the modular coloring estimate. The strictly
increasing lists `f,g` are the bit positions of the equal-label matches; their
quotients index the original words. -/
theorem equal_label_match_count_le {α : Type*} {N P : ℕ} (hP : 0 < P)
(x y : List α) (f g : Fin N → ℕ) (hf : StrictMono f) (hg : StrictMono g)
(hfx : ∀ i, f i / P < x.length) (hgy : ∀ i, g i / P < y.length)
(heq : ∀ i, x.get ⟨f i / P, hfx i⟩ = y.get ⟨g i / P, hgy i⟩) :
N ≤ P * lcs x y := by
apply equal_match_count_le hP f g hf hg
intro s hs₁ hs₂
let e := s.orderEmbOfFin rfl
let f' : Fin s.card → Fin x.length := fun i => ⟨f (e i) / P, hfx (e i)⟩
let g' : Fin s.card → Fin y.length := fun i => ⟨g (e i) / P, hgy (e i)⟩
have hf' : StrictMono f' := by
intro i j hij
exact hs₁ (s.orderEmbOfFin_mem rfl i) (s.orderEmbOfFin_mem rfl j)
(e.strictMono hij)
have hg' : StrictMono g' := by
intro i j hij
exact hs₂ (s.orderEmbOfFin_mem rfl i) (s.orderEmbOfFin_mem rfl j)
(e.strictMono hij)
exact matching_length_le_lcs x y f' g' hf' hg' (fun i => heq (e i))
/-- The same estimate for a selected subset of a larger increasing bit matching.
This is convenient when selecting exactly the equal-label edges. -/
theorem equal_label_subset_card_le {α : Type*} {N P : ℕ} (hP : 0 < P)
(x y : List α) (f g : Fin N → ℕ) (hf : StrictMono f) (hg : StrictMono g)
(hfx : ∀ i, f i / P < x.length) (hgy : ∀ i, g i / P < y.length)
(s : Finset (Fin N))
(heq : ∀ i ∈ s, x.get ⟨f i / P, hfx i⟩ = y.get ⟨g i / P, hgy i⟩) :
s.card ≤ P * lcs x y := by
let e := s.orderEmbOfFin rfl
exact equal_label_match_count_le hP x y (f ∘ e) (g ∘ e)
(hf.comp e.strictMono) (hg.comp e.strictMono)
(fun i => hfx (e i)) (fun i => hgy (e i))
(fun i => heq (e i) (s.orderEmbOfFin_mem rfl i))
end TreeEdit.BinaryLower.Code
end OAI
|