| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.CountedSort |
| import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionDictionary |
| import Mathlib.Data.List.Destutter |
|
|
| namespace OAI |
|
|
| /-! # Linear duplicate removal after sorting compressed weights |
|
|
| The output is exactly the compact list used by the decision core. |
| The implementation removes adjacent repeats and never searches the tail for |
| a duplicate. Its counter charges one equality test and constant list work |
| per input occurrence. |
| -/ |
|
|
| namespace LowSpaceSubsetSum.CountedDedup |
|
|
| variable {α : Type*} [DecidableEq α] |
|
|
| def tail (previous : α) : List α → List α × ℕ |
| | [] => ([previous], 1) |
| | x :: xs => |
| if previous = x then |
| let rest := tail previous xs |
| (rest.1, rest.2 + 1) |
| else |
| let rest := tail x xs |
| (previous :: rest.1, rest.2 + 1) |
|
|
| def run : List α → List α × ℕ |
| | [] => ([], 1) |
| | x :: xs => tail x xs |
|
|
| theorem tail_value (previous : α) (xs : List α) : |
| (tail previous xs).1 = xs.destutter' (· ≠ ·) previous := by |
| induction xs generalizing previous with |
| | nil => rfl |
| | cons x xs ih => |
| by_cases he : previous = x <;> simp [tail, he, ih] |
|
|
| theorem tail_work (previous : α) (xs : List α) : |
| (tail previous xs).2 = xs.length + 1 := by |
| induction xs generalizing previous with |
| | nil => rfl |
| | cons x xs ih => by_cases he : previous = x <;> simp [tail, he, ih] |
|
|
| theorem run_value (xs : List α) : (run xs).1 = xs.destutter (· ≠ ·) := by |
| cases xs with |
| | nil => rfl |
| | cons x xs => simpa only [run, List.destutter_cons'] using tail_value x xs |
|
|
| theorem run_sorted_value (xs : List α) {r : α → α → Prop} [Std.Antisymm r] |
| (hs : xs.Pairwise r) : (run xs).1 = xs.dedup := by |
| rw [run_value, hs.destutter_eq_dedup] |
|
|
| theorem run_work (xs : List α) : (run xs).2 ≤ xs.length + 1 := by |
| cases xs with |
| | nil => rfl |
| | cons x xs => simp only [run, tail_work, List.length_cons]; omega |
|
|
| end CountedDedup |
|
|
| namespace CompactWeightWork |
|
|
| variable {n : ℕ} |
|
|
| def run (a : Fin n → ℤ) (V : Finset (Fin n)) : List ℤ × ℕ := |
| let sorted := CountedSort.sort (fun x y : ℤ => decide (x ≤ y)) (rawWeightList a V) |
| let compact := CountedDedup.run sorted.1 |
| (compact.1, sorted.2 + compact.2) |
|
|
| theorem run_value (a : Fin n → ℤ) (V : Finset (Fin n)) : |
| (run a V).1 = compactWeightList a V := by |
| have hs : ((rawWeightList a V).mergeSort (fun x y => decide (x ≤ y))).Pairwise (· ≤ ·) := by |
| simpa only [decide_eq_true_eq] using |
| (List.pairwise_mergeSort (le := fun x y : ℤ => decide (x ≤ y)) |
| (fun x y z hxy hyz => decide_eq_true (le_trans (of_decide_eq_true hxy) (of_decide_eq_true hyz))) |
| (fun x y => by simpa only [Bool.or_eq_true, decide_eq_true_eq] using le_total x y) |
| (rawWeightList a V)) |
| simp only [run, CountedSort.sort_value, CountedDedup.run_sorted_value _ hs, compactWeightList] |
|
|
| theorem run_work (a : Fin n → ℤ) (V : Finset (Fin n)) : |
| (run a V).2 ≤ (6 * n + 2) * 2 ^ V.card + 2 := by |
| have hc : V.card ≤ n := (Finset.card_le_univ V).trans_eq (Fintype.card_fin n) |
| have hlen : (rawWeightList a V).length ≤ 2 ^ n := by |
| rw [rawWeightList_length] |
| exact Nat.pow_le_pow_right (by decide) hc |
| have hs := CountedSort.sort_steps_of_index_bits (fun x y : ℤ => decide (x ≤ y)) |
| (rawWeightList a V) n hlen |
| have hd := CountedDedup.run_work |
| (CountedSort.sort (fun x y : ℤ => decide (x ≤ y)) (rawWeightList a V)).1 |
| rw [CountedSort.sort_value, List.length_mergeSort, rawWeightList_length] at hd |
| rw [rawWeightList_length] at hs |
| change (CountedSort.sort (fun x y : ℤ => decide (x ≤ y)) (rawWeightList a V)).2 + |
| (CountedDedup.run (CountedSort.sort (fun x y : ℤ => decide (x ≤ y)) (rawWeightList a V)).1).2 ≤ _ |
| rw [CountedSort.sort_value] |
| nlinarith only [hs, hd] |
|
|
| end CompactWeightWork |
| end LowSpaceSubsetSum |
|
|
| end OAI |
|
|
