File size: 3,513 Bytes
e63eb7f | 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 | import OAI.Combinatorics.EditApproximation.Coarse.CoarseSeed
import OAI.Combinatorics.EditApproximation.Geometry.TreeAccounting
import OAI.Combinatorics.EditApproximation.Definitions
namespace OAI
/-!
# The actual balanced interval cuts
The fixed interval tree uses cuts `l + floor(i*width/M)`. Their substring
pieces concatenate exactly to the parent, including repeated cuts and
empty pieces. These facts instantiate optimal alignment splitting on the
manuscript's actual source intervals.
-/
namespace EditApproximation
theorem balancedCut_zero (lo width M : ℕ) : balancedCut lo width M 0 = lo := by
simp [balancedCut]
theorem balancedCut_last (lo width M : ℕ) (hM : 0 < M) :
balancedCut lo width M M = lo + width := by
simp only [balancedCut, Nat.mul_div_cancel_left _ hM]
theorem balancedCut_monotone (lo width M : ℕ) : Monotone (balancedCut lo width M) := by
intro i j hij
exact Nat.add_le_add_left (Nat.div_le_div_right (Nat.mul_le_mul_right width hij)) lo
theorem balancedCut_bounds (lo width M i : ℕ) (hM : 0 < M) (hi : i ≤ M) :
lo ≤ balancedCut lo width M i ∧ balancedCut lo width M i ≤ lo + width := by
constructor
· exact Nat.le_add_right _ _
· rw [← balancedCut_last lo width M hM]
exact balancedCut_monotone lo width M hi
def balancedPieces {α : Type*} (word : List α) (lo width M : ℕ) : List (List α) :=
(List.range M).map fun i => substring word (balancedCut lo width M i) (balancedCut lo width M (i + 1))
theorem balancedPieces_prefix {α : Type*} (word : List α) (lo width M j : ℕ) :
((List.range j).map fun i =>
substring word (balancedCut lo width M i) (balancedCut lo width M (i + 1))).flatten =
substring word lo (balancedCut lo width M j) := by
induction j with
| zero => simp [balancedCut, substring]
| succ j ih =>
rw [List.range_succ, List.map_append, List.flatten_append]
simp only [List.map_cons, List.map_nil, List.flatten_cons, List.flatten_nil, List.append_nil]
rw [ih]
exact (substring_split word lo (balancedCut lo width M j) (balancedCut lo width M (j + 1))
(Nat.le_add_right _ _) (balancedCut_monotone lo width M (Nat.le_succ j))).symm
theorem balancedPieces_flatten {α : Type*} (word : List α) (lo width M : ℕ) (hM : 0 < M) :
(balancedPieces word lo width M).flatten = substring word lo (lo + width) := by
rw [balancedPieces, balancedPieces_prefix, balancedCut_last lo width M hM]
theorem balancedPieces_length {α : Type*} (word : List α) (lo width M : ℕ) :
(balancedPieces word lo width M).length = M := by
simp only [balancedPieces, List.length_map, List.length_range]
theorem sourceChild_partition {α : Type*} (word : List α) {M : ℕ} (hM : 0 < M)
(parent : TargetInterval word.length) :
(List.ofFn fun child : Fin M =>
substring word (sourceChild parent child).lo (sourceChild parent child).hi).flatten =
substring word parent.lo parent.hi := by
have hlist : (List.ofFn fun child : Fin M =>
substring word (sourceChild parent child).lo (sourceChild parent child).hi) =
balancedPieces word parent.lo (parent.hi - parent.lo) M := by
apply List.ext_getElem
· simp only [List.length_ofFn, balancedPieces_length]
· intro i hi hj
simp only [List.getElem_ofFn, balancedPieces, List.getElem_map, List.getElem_range, sourceChild]
rw [hlist, balancedPieces_flatten word parent.lo (parent.hi - parent.lo) M hM,
Nat.add_sub_of_le parent.ordered]
end EditApproximation
end OAI
|