| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.MeasuredSumReader |
| import OAI.Combinatorics.LowSpaceSubsetSum.Counting.MixerParameterCount |
| import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionWeights |
|
|
| namespace OAI |
|
|
| /-! # Mixer counts from generated and sorted half-sum arrays |
|
|
| All subset weights, comparisons, array copies and streamed sum keys are |
| charged. The returned natural number is the exact distinct-sum count. |
| -/ |
|
|
| namespace LowSpaceSubsetSum.MeasuredMixerCount |
|
|
| variable {n : ℕ} |
|
|
| def sortedWeights (a : Fin n → ℤ) (indices : List (Fin n)) : Array ℤ × ℕ := |
| let raw := CompressionWeights.raw a indices |
| let out := MeasuredSort.sort (fun x y : ℤ => (decide (x ≤ y), 1)) raw.1 |
| (out.1.toArray, raw.2 + out.2 + out.1.length + 1) |
|
|
| theorem sortedWeights_value (a : Fin n → ℤ) (V : Finset (Fin n)) : |
| (sortedWeights a (V.sort (· ≤ ·))).1 = MixerParameterCount.sortedWeights a V := by |
| simp only [sortedWeights, CompressionWeights.raw_source, MeasuredSort.sort_value, |
| MixerParameterCount.sortedWeights, CountedSort.sort_value] |
|
|
| theorem sortedWeights_size (a : Fin n → ℤ) (indices : List (Fin n)) : |
| (sortedWeights a indices).1.size = 2 ^ indices.length := by |
| simp only [sortedWeights, List.size_toArray, MeasuredSort.sort_value, |
| List.length_mergeSort, CompressionWeights.raw_length] |
|
|
| theorem sortedWeights_sorted (a : Fin n → ℤ) (indices : List (Fin n)) : |
| (sortedWeights a indices).1.toList.Pairwise (· ≤ ·) := by |
| simp only [sortedWeights, List.toList_toArray, MeasuredSort.sort_value] |
| 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) |
| (CompressionWeights.raw a indices).1) |
|
|
| def coefficient (n : ℕ) : ℕ := (n + 4) * n + 12 * n + 20 |
|
|
| theorem sortedWeights_work (a : Fin n → ℤ) (indices : List (Fin n)) |
| (hi : indices.length ≤ n) : |
| (sortedWeights a indices).2 ≤ coefficient n * 2 ^ indices.length := by |
| have hr := CompressionWeights.raw_work a indices hi |
| have hs := MeasuredSort.sort_work (fun x y : ℤ => (decide (x ≤ y), 1)) |
| 1 (fun _ _ => le_rfl) (CompressionWeights.raw a indices).1 n |
| (by rw [CompressionWeights.raw_length]; exact Nat.pow_le_pow_right (by decide) hi) |
| have hp : 1 ≤ 2 ^ indices.length := Nat.one_le_two_pow |
| simp only [CompressionWeights.raw_length] at hs |
| change _ + _ + _ + 1 ≤ _ |
| simp only [MeasuredSort.sort_value, List.length_mergeSort, CompressionWeights.raw_length] |
| unfold coefficient |
| nlinarith only [hr, hs, hp] |
|
|
| def run (a : Fin n → ℤ) (left right : List (Fin n)) : ℕ × ℕ := |
| let xs := sortedWeights a left |
| let ys := sortedWeights a right |
| let out := MeasuredSumReader.count xs.1 ys.1 (sortedWeights_sorted a right) |
| (out.1, xs.2 + ys.2 + out.2 + 3) |
|
|
| theorem run_source (a : Fin n → ℤ) (V W : Finset (Fin n)) (hd : Disjoint V W) : |
| (run a (V.sort (· ≤ ·)) (W.sort (· ≤ ·))).1 = distinctSumCount a (V ∪ W) := by |
| simp only [run, MeasuredSumReader.count_value, sortedWeights_value] |
| exact MixerParameterCount.count_value a V W hd |
|
|
| theorem run_work (a : Fin n → ℤ) (left right : List (Fin n)) |
| (hleft : left.length ≤ n) (hright : right.length ≤ n) : |
| (run a left right).2 ≤ |
| coefficient n * 2 ^ left.length + coefficient n * 2 ^ right.length + |
| (4 * (left.length + 1) ^ 2 + 32) * 2 ^ left.length + |
| (10 * left.length + 21) * 2 ^ (left.length + right.length) + 6 := by |
| have hl := sortedWeights_work a left hleft |
| have hr := sortedWeights_work a right hright |
| have hc := MeasuredSumReader.count_work (sortedWeights a left).1 |
| (sortedWeights a right).1 (sortedWeights_sorted a right) |
| simp only [sortedWeights_size, Nat.clog_pow 2 _ (by decide), ← pow_add] at hc |
| change _ + _ + _ + 3 ≤ _ |
| omega |
|
|
| def mixerCount (a : Fin n → ℤ) (V : Finset (Fin n)) : ℕ × ℕ := |
| run a ((MixerParameterCount.firstHalf V).sort (· ≤ ·)) |
| ((MixerParameterCount.secondHalf V).sort (· ≤ ·)) |
|
|
| theorem mixerCount_value (a : Fin n → ℤ) (V : Finset (Fin n)) : |
| (mixerCount a V).1 = distinctSumCount a V := by |
| rw [mixerCount, run_source a _ _ (MixerParameterCount.halves_disjoint V), |
| MixerParameterCount.halves_union] |
|
|
| end LowSpaceSubsetSum.MeasuredMixerCount |
|
|
| end OAI |
|
|
