File size: 5,647 Bytes
5d5048e | 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 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 | import OAI.Combinatorics.LowSpaceSubsetSum.Streams.SumReader
import OAI.Combinatorics.LowSpaceSubsetSum.Counting.CountedDedup
import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationIntegerParameters
namespace OAI
/-! # Exact integer mixer parameters from small stored half lists
The count streams all pair occurrences, removing adjacent equal sum keys
with constant extra state. Neither the distinct-sum set nor the full mixer
powerset is stored. The count therefore feeds the integer
ordering and prime-width formulas without a real-valued oracle.
-/
namespace LowSpaceSubsetSum.MixerParameterCount
variable {n : ℕ}
def sortedWeights (a : Fin n → ℤ) (V : Finset (Fin n)) : Array ℤ :=
(CountedSort.sort (fun x y : ℤ => decide (x ≤ y)) (rawWeightList a V)).1.toArray
theorem sortedWeights_sorted (a : Fin n → ℤ) (V : Finset (Fin n)) :
(sortedWeights a V).toList.Pairwise (· ≤ ·) := by
simp only [sortedWeights, CountedSort.sort_value, List.toList_toArray]
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))
theorem sortedWeights_mem (a : Fin n → ℤ) (V : Finset (Fin n)) (x : ℤ) :
x ∈ (sortedWeights a V).toList ↔ x ∈ distinctSums a V := by
simp only [sortedWeights, CountedSort.sort_value, List.toList_toArray,
(List.mergeSort_perm (rawWeightList a V) (fun x y => decide (x ≤ y))).mem_iff]
exact mem_rawWeightList a V x
@[simp] theorem sortedWeights_size (a : Fin n → ℤ) (V : Finset (Fin n)) :
(sortedWeights a V).size = 2 ^ V.card := by
simp only [sortedWeights, List.size_toArray, CountedSort.sort_value,
List.length_mergeSort, rawWeightList_length]
def count (a : Fin n → ℤ) (V W : Finset (Fin n)) : ℕ × ℕ :=
SumReader.count (sortedWeights a V) (sortedWeights a W) (sortedWeights_sorted a W)
theorem count_value (a : Fin n → ℤ) (V W : Finset (Fin n)) (hd : Disjoint V W) :
(count a V W).1 = distinctSumCount a (V ∪ W) := by
rw [count, SumReader.count_value]
unfold distinctSumCount
congr 1
ext z
simp only [List.mem_toFinset, List.mem_map]
rw [distinctSums_union_mem_iff a V W hd]
constructor
· rintro ⟨p, hp, rfl⟩
obtain ⟨hx, hy⟩ := (SumReader.output_mem _ _ (sortedWeights_sorted a W) p).mp hp
exact ⟨p.1, (sortedWeights_mem a V p.1).mp hx,
p.2, (sortedWeights_mem a W p.2).mp hy, rfl⟩
· rintro ⟨x, hx, y, hy, rfl⟩
refine ⟨(x, y), ?_, rfl⟩
exact (SumReader.output_mem _ _ (sortedWeights_sorted a W) (x, y)).mpr
⟨(sortedWeights_mem a V x).mpr hx, (sortedWeights_mem a W y).mpr hy⟩
theorem count_queries (a : Fin n → ℤ) (V W : Finset (Fin n)) :
(count a V W).2 ≤ 2 ^ (V.card + W.card) := by
simpa only [count, sortedWeights_size, pow_add] using
SumReader.count_queries (sortedWeights a V) (sortedWeights a W) (sortedWeights_sorted a W)
def firstHalf (V : Finset (Fin n)) : Finset (Fin n) :=
((V.sort (· ≤ ·)).take (V.card / 2)).toFinset
def secondHalf (V : Finset (Fin n)) : Finset (Fin n) := V \ firstHalf V
theorem firstHalf_subset (V : Finset (Fin n)) : firstHalf V ⊆ V := by
intro i hi
exact (Finset.mem_sort (· ≤ ·)).mp
((List.take_sublist _ _).subset (List.mem_toFinset.mp hi))
theorem firstHalf_card (V : Finset (Fin n)) : (firstHalf V).card = V.card / 2 := by
rw [firstHalf, List.toFinset_card_of_nodup ((Finset.sort_nodup _ _).take),
List.length_take, Finset.length_sort]
exact Nat.min_eq_left (Nat.div_le_self _ _)
theorem halves_union (V : Finset (Fin n)) : firstHalf V ∪ secondHalf V = V :=
Finset.union_sdiff_of_subset (firstHalf_subset V)
theorem halves_disjoint (V : Finset (Fin n)) : Disjoint (firstHalf V) (secondHalf V) :=
Finset.disjoint_left.mpr (fun _ hi hj => (Finset.mem_sdiff.mp hj).2 hi)
theorem secondHalf_card (V : Finset (Fin n)) :
(secondHalf V).card = V.card - V.card / 2 := by
rw [secondHalf, Finset.card_sdiff_of_subset (firstHalf_subset V), firstHalf_card]
/-- This function is determined entirely by the input and the permuted
mixer domain; a designated solution is not an argument. -/
def mixerCount (a : Fin n → ℤ) (V : Finset (Fin n)) : ℕ × ℕ :=
count a (firstHalf V) (secondHalf V)
theorem mixerCount_value (a : Fin n → ℤ) (V : Finset (Fin n)) :
(mixerCount a V).1 = distinctSumCount a V := by
rw [mixerCount, count_value a _ _ (halves_disjoint V), halves_union]
theorem mixerCount_queries (a : Fin n → ℤ) (V : Finset (Fin n)) :
(mixerCount a V).2 ≤ 2 ^ V.card := by
have h := count_queries a (firstHalf V) (secondHalf V)
rw [firstHalf_card, secondHalf_card, Nat.add_sub_of_le (Nat.div_le_self _ _)] at h
exact h
/-- Every possible live state of the count uses only half-mixer arrays
and a tournament of half-mixer rows. -/
theorem mixerCount_footprint (a : Fin n → ℤ) (V : Finset (Fin n))
(hc : V.card = mixerSize n)
(s : SumReader.State (sortedWeights a (firstHalf V)) (sortedWeights a (secondHalf V))) :
SumReader.footprint _ _ s ≤ 42 * 2 ^ (mixerSize n / 2) + 43 := by
have h := SumReader.footprint_bound _ _ s
have hm : mixerSize n = 2 * (mixerSize n / 2) := by unfold mixerSize; omega
simp only [sortedWeights_size, firstHalf_card, secondHalf_card, hc] at h
have he : mixerSize n - mixerSize n / 2 = mixerSize n / 2 := by omega
rw [he] at h
omega
end LowSpaceSubsetSum.MixerParameterCount
end OAI
|