| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.MeasuredMixerCount |
|
|
| namespace OAI |
|
|
| /-! |
|
|
| namespace LowSpaceSubsetSum.MixerHalfLists |
|
|
| variable {n : ℕ} |
|
|
| def split (xs : List (Fin n)) : (List (Fin n) × List (Fin n)) × ℕ := |
| ((xs.take (xs.length / 2), xs.drop (xs.length / 2)), 4 * xs.length + 3) |
|
|
| theorem first_source (V : Finset (Fin n)) : |
| (split (V.sort (· ≤ ·))).1.1 = (MixerParameterCount.firstHalf V).sort (· ≤ ·) := by |
| simp only [split, Finset.length_sort, MixerParameterCount.firstHalf] |
| symm |
| exact (List.toFinset_sort (r := (· ≤ ·)) ((Finset.sort_nodup V (· ≤ ·)).take)).mpr |
| ((Finset.pairwise_sort V (· ≤ ·)).sublist (List.take_sublist _ _)) |
|
|
| theorem drop_set (V : Finset (Fin n)) : |
| ((V.sort (· ≤ ·)).drop (V.card / 2)).toFinset = MixerParameterCount.secondHalf V := by |
| let xs := V.sort (· ≤ ·) |
| have hnd : (xs.take (V.card / 2) ++ xs.drop (V.card / 2)).Nodup := by |
| rw [List.take_append_drop] |
| exact Finset.sort_nodup V (· ≤ ·) |
| have hd := (List.nodup_append.mp hnd).2.2 |
| ext i |
| simp only [MixerParameterCount.secondHalf, Finset.mem_sdiff, |
| MixerParameterCount.firstHalf, List.mem_toFinset] |
| change i ∈ xs.drop (V.card / 2) ↔ i ∈ V ∧ i ∉ xs.take (V.card / 2) |
| have hmem : i ∈ xs ↔ i ∈ V := Finset.mem_sort (· ≤ ·) |
| have happ : i ∈ xs ↔ i ∈ xs.take (V.card / 2) ∨ i ∈ xs.drop (V.card / 2) := by |
| rw [← List.mem_append, List.take_append_drop] |
| constructor |
| · intro hi |
| exact ⟨hmem.mp (happ.mpr (Or.inr hi)), fun hj => hd i hj i hi rfl⟩ |
| · rintro ⟨hi, hn⟩ |
| exact (happ.mp (hmem.mpr hi)).resolve_left hn |
|
|
| theorem second_source (V : Finset (Fin n)) : |
| (split (V.sort (· ≤ ·))).1.2 = (MixerParameterCount.secondHalf V).sort (· ≤ ·) := by |
| simp only [split, Finset.length_sort] |
| rw [← drop_set] |
| symm |
| exact (List.toFinset_sort (r := (· ≤ ·)) ((Finset.sort_nodup V (· ≤ ·)).drop)).mpr |
| ((Finset.pairwise_sort V (· ≤ ·)).sublist (List.drop_sublist _ _)) |
|
|
| def count (a : Fin n → ℤ) (xs : List (Fin n)) : ℕ × ℕ := |
| let halves := split xs |
| let out := MeasuredMixerCount.run a halves.1.1 halves.1.2 |
| (out.1, halves.2 + out.2 + 1) |
|
|
| theorem count_source (a : Fin n → ℤ) (V : Finset (Fin n)) : |
| (count a (V.sort (· ≤ ·))).1 = distinctSumCount a V := by |
| simp only [count, first_source, second_source] |
| exact MeasuredMixerCount.mixerCount_value a V |
|
|
| theorem count_work (a : Fin n → ℤ) (xs : List (Fin n)) (hx : xs.length ≤ n) : |
| (count a xs).2 ≤ |
| MeasuredMixerCount.coefficient n * 2 ^ (xs.length / 2) + |
| MeasuredMixerCount.coefficient n * 2 ^ (xs.length - xs.length / 2) + |
| (4 * (xs.length / 2 + 1) ^ 2 + 32) * 2 ^ (xs.length / 2) + |
| (10 * (xs.length / 2) + 21) * 2 ^ xs.length + 4 * xs.length + 10 := by |
| have hl : (xs.take (xs.length / 2)).length = xs.length / 2 := by |
| rw [List.length_take, Nat.min_eq_left (Nat.div_le_self _ _)] |
| have hr : (xs.drop (xs.length / 2)).length = xs.length - xs.length / 2 := |
| List.length_drop |
| have h := MeasuredMixerCount.run_work a (xs.take (xs.length / 2)) |
| (xs.drop (xs.length / 2)) (by rw [hl]; omega) (by rw [hr]; omega) |
| rw [hl, hr, Nat.add_sub_of_le (Nat.div_le_self _ _)] at h |
| change 4 * xs.length + 3 + |
| (MeasuredMixerCount.run a (xs.take (xs.length / 2)) (xs.drop (xs.length / 2))).2 + 1 ≤ _ |
| omega |
| |
| |
| theorem count_scale (I : Instance n) (hn : 10000 ≤ n) (a : Fin n → ℤ) |
| (xs : List (Fin n)) (hx : xs.length ≤ n) : |
| (count a xs).2 ≤ inputScale I ^ 4 * 2 ^ xs.length := by |
| let u := inputScale I |
| have hu : n + 1 ≤ u := by dsimp [u, inputScale]; omega |
| have hu0 : 10000 ≤ u := by omega |
| have hnu : n ≤ u := by omega |
| have hxu : xs.length / 2 + 1 ≤ u := by omega |
| have hn2 := Nat.pow_le_pow_left hnu 2 |
| have hx2 := Nat.pow_le_pow_left hxu 2 |
| have hu2 : 1 ≤ u ^ 2 := Nat.one_le_pow _ _ (by omega) |
| have hc : MeasuredMixerCount.coefficient n ≤ 40 * u ^ 2 := by |
| unfold MeasuredMixerCount.coefficient |
| nlinarith only [hn2, hu, hu2] |
| have hbig : 40 * u ^ 2 ≤ u ^ 3 := by |
| calc |
| _ ≤ u * u ^ 2 := Nat.mul_le_mul_right _ (by omega) |
| _ = _ := (pow_succ' _ _).symm |
| have hp : 4 * (xs.length / 2 + 1) ^ 2 + 32 ≤ u ^ 3 := by omega |
| have hlinear : 10 * (xs.length / 2) + 21 ≤ u ^ 3 := by |
| nlinarith only [hxu, hu2, hbig] |
| have hend : 4 * xs.length + 10 ≤ u ^ 3 := by |
| nlinarith only [hx, hu, hu2, hbig] |
| have hleft : 2 ^ (xs.length / 2) ≤ 2 ^ xs.length := |
| Nat.pow_le_pow_right (by decide) (Nat.div_le_self _ _) |
| have hright : 2 ^ (xs.length - xs.length / 2) ≤ 2 ^ xs.length := |
| Nat.pow_le_pow_right (by decide) (Nat.sub_le _ _) |
| have hT : 1 ≤ 2 ^ xs.length := Nat.one_le_two_pow |
| have hcL := Nat.mul_le_mul (hc.trans hbig) hleft |
| have hcR := Nat.mul_le_mul (hc.trans hbig) hright |
| have hpL := Nat.mul_le_mul hp hleft |
| have hl := Nat.mul_le_mul_right (2 ^ xs.length) hlinear |
| have he := hend.trans (Nat.le_mul_of_pos_right _ hT) |
| have hw := count_work a xs hx |
| have hf : 5 * u ^ 3 ≤ u ^ 4 := by |
| calc |
| _ ≤ u * u ^ 3 := Nat.mul_le_mul_right _ (by omega) |
| _ = _ := (pow_succ' _ _).symm |
| have hfinal := Nat.mul_le_mul_right (2 ^ xs.length) hf |
| change (count a xs).2 ≤ u ^ 4 * 2 ^ xs.length |
| nlinarith only [hw, hcL, hcR, hpL, hl, he, hfinal] |
|
|
| end LowSpaceSubsetSum.MixerHalfLists |
|
|
| end OAI |
|
|
