| import OAI.Combinatorics.EditApproximation.Geometry.AlignmentSplitting |
| import OAI.Combinatorics.EditApproximation.Geometry.Leaves |
|
|
| namespace OAI |
|
|
| /-! |
| # An executable exact cut recurrence |
|
|
| This is the exact source-cut dynamic programming recurrence on ordinary |
| lists and natural numbers. The proof identifies its value with unrestricted |
| unit-cost edit distance. Storage and evaluation costs are separate from |
| this value-level recurrence. |
| -/ |
|
|
| namespace EditApproximation |
|
|
| open EditDistortion |
|
|
| def finiteNatMinimum (fallback : ℕ) : List ℕ → ℕ |
| | [] => fallback |
| | value :: rest => min value (finiteNatMinimum fallback rest) |
|
|
| theorem le_finiteNatMinimum_iff (lower fallback : ℕ) (values : List ℕ) : |
| lower ≤ finiteNatMinimum fallback values ↔ |
| lower ≤ fallback ∧ ∀ value ∈ values, lower ≤ value := by |
| induction values with |
| | nil => simp [finiteNatMinimum] |
| | cons value rest ih => |
| simp only [finiteNatMinimum, le_min_iff, ih, List.mem_cons, forall_eq_or_imp] |
| tauto |
|
|
| theorem finiteNatMinimum_le_member (fallback : ℕ) (values : List ℕ) |
| {value : ℕ} (hvalue : value ∈ values) : finiteNatMinimum fallback values ≤ value := by |
| induction values with |
| | nil => simp at hvalue |
| | cons first rest ih => |
| rcases List.mem_cons.mp hvalue with rfl | hvalue |
| · exact min_le_left _ _ |
| · exact (min_le_right _ _).trans (ih hvalue) |
|
|
| def exactCutCost {α : Type*} [DecidableEq α] : List α → List α → ℕ |
| | [], target => target.length |
| | a :: rest, target => finiteNatMinimum (rest.length + 1 + target.length) |
| ((List.range (target.length + 1)).map fun cut => |
| singletonCost a (target.take cut) + exactCutCost rest (target.drop cut)) |
|
|
| theorem edit_nil_left {α : Type*} (target : List α) : edit [] target = target.length := by |
| have hlo := (cost_length_bounds (s := true) ([] : List α) target).2 |
| have hup := cost_le (Script.to_nil (s := true) target).symm |
| change edit [] target ≤ target.length at hup |
| change target.length ≤ 0 + edit [] target at hlo |
| omega |
|
|
| theorem exactCutCost_eq_edit {α : Type*} [DecidableEq α] (source target : List α) : |
| exactCutCost source target = edit source target := by |
| induction source generalizing target with |
| | nil => exact (edit_nil_left target).symm |
| | cons a rest ih => |
| have hcandidate (cut : ℕ) : edit (a :: rest) target ≤ |
| singletonCost a (target.take cut) + exactCutCost rest (target.drop cut) := by |
| rw [singletonCost_eq_edit, ih] |
| have happend := cost_append_le (s := true) [a] (target.take cut) rest (target.drop cut) |
| simpa only [List.singleton_append, List.take_append_drop, cost, edit] using happend |
| apply Nat.le_antisymm |
| · obtain ⟨tl, tr, ht, hc⟩ := edit_append_split [a] rest target |
| let cut := tl.length |
| have hcut : cut < target.length + 1 := by simp only [ht, List.length_append]; omega |
| have htake : target.take cut = tl := by simp [ht, cut] |
| have hdrop : target.drop cut = tr := by simp [ht, cut] |
| have hmin := finiteNatMinimum_le_member (rest.length + 1 + target.length) |
| ((List.range (target.length + 1)).map fun j => |
| singletonCost a (target.take j) + exactCutCost rest (target.drop j)) |
| (List.mem_map.mpr ⟨cut, List.mem_range.mpr hcut, rfl⟩) |
| change exactCutCost (a :: rest) target ≤ |
| singletonCost a (target.take cut) + exactCutCost rest (target.drop cut) at hmin |
| rw [htake, hdrop, singletonCost_eq_edit, ih] at hmin |
| simpa only [List.singleton_append] using hmin.trans_eq hc.symm |
| · apply (le_finiteNatMinimum_iff _ _ _).2 |
| constructor |
| · have hup := edit_le_total_length (a :: rest) target |
| simpa only [List.length_cons, Nat.add_assoc] using hup |
| · intro value hvalue |
| obtain ⟨cut, _, rfl⟩ := List.mem_map.mp hvalue |
| exact hcandidate cut |
|
|
| end EditApproximation |
|
|
| end OAI |
|
|
