| import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationResourceMoments |
| import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionDictionary |
|
|
| namespace OAI |
|
|
| /-! |
|
|
| namespace LowSpaceSubsetSum |
|
|
| variable {n : ℕ} |
|
|
| /-- Each indexed subset is generated in the fixed input-index order. -/ |
| def subsetList (V : Finset (Fin n)) : List (Finset (Fin n)) := |
| (V.sort (· ≤ ·)).sublists.map List.toFinset |
|
|
| /-- Fixed-size selections use the corresponding finite sublist generator. -/ |
| def fixedSubsetList (V : Finset (Fin n)) (k : ℕ) : List (Finset (Fin n)) := |
| ((V.sort (· ≤ ·)).sublistsLen k).map List.toFinset |
|
|
| theorem subsetList_mem (V S : Finset (Fin n)) : S ∈ subsetList V ↔ S ⊆ V := by |
| constructor |
| · intro h |
| obtain ⟨indices, hi, rfl⟩ := List.mem_map.mp h |
| intro i hm |
| exact (Finset.mem_sort (· ≤ ·)).mp |
| ((List.mem_sublists.mp hi).subset (List.mem_toFinset.mp hm)) |
| · intro hS |
| let indices := (V.sort (· ≤ ·)).filter (fun i => i ∈ S) |
| have he : indices.toFinset = S := by |
| ext i |
| simp only [indices, List.mem_toFinset, List.mem_filter, Finset.mem_sort, decide_eq_true_eq] |
| exact ⟨And.right, fun hi => ⟨hS hi, hi⟩⟩ |
| exact List.mem_map.mpr ⟨indices, List.mem_sublists.mpr List.filter_sublist, he⟩ |
|
|
| theorem fixedSubsetList_mem (V S : Finset (Fin n)) (k : ℕ) : |
| S ∈ fixedSubsetList V k ↔ S ⊆ V ∧ S.card = k := by |
| constructor |
| · intro h |
| obtain ⟨indices, hi, rfl⟩ := List.mem_map.mp h |
| obtain ⟨hi, hlen⟩ := List.mem_sublistsLen.mp hi |
| refine ⟨?_, ?_⟩ |
| · intro i hm |
| exact (Finset.mem_sort (· ≤ ·)).mp (hi.subset (List.mem_toFinset.mp hm)) |
| · rw [List.toFinset_card_of_nodup (hi.nodup (Finset.sort_nodup _ _)), hlen] |
| · rintro ⟨hS, hcard⟩ |
| let indices := (V.sort (· ≤ ·)).filter (fun i => i ∈ S) |
| have he : indices.toFinset = S := by |
| ext i |
| simp only [indices, List.mem_toFinset, List.mem_filter, Finset.mem_sort, decide_eq_true_eq] |
| exact ⟨And.right, fun hi => ⟨hS hi, hi⟩⟩ |
| have hlen : indices.length = k := by |
| rw [← List.toFinset_card_of_nodup ((Finset.sort_nodup V (· ≤ ·)).filter _), he, hcard] |
| exact List.mem_map.mpr ⟨indices, List.mem_sublistsLen.mpr ⟨List.filter_sublist, hlen⟩, he⟩ |
|
|
| @[simp] theorem subsetList_length (V : Finset (Fin n)) : (subsetList V).length = 2 ^ V.card := by |
| simp [subsetList, List.length_sublists] |
|
|
| @[simp] theorem fixedSubsetList_length (V : Finset (Fin n)) (k : ℕ) : |
| (fixedSubsetList V k).length = V.card.choose k := by |
| simp [fixedSubsetList] |
|
|
| namespace RepresentationLeaf |
|
|
| /-- Raw leaves retain the three subset choices, including repeated weights. -/ |
| def enumerate (L : RepresentationLeaf (Fin n)) : List (Occurrence (Fin n)) := |
| ((fixedSubsetList L.top L.topCount) ×ˢ (fixedSubsetList L.mixer L.localCount)) ×ˢ |
| (subsetList L.background) |
|
|
| theorem enumerate_mem (L : RepresentationLeaf (Fin n)) (x : Occurrence (Fin n)) : |
| x ∈ L.enumerate ↔ x ∈ L.occurrences := by |
| rcases x with ⟨⟨x, y⟩, z⟩ |
| simp only [enumerate, List.mem_product, fixedSubsetList_mem, subsetList_mem, |
| occurrences, Finset.mem_product, Finset.mem_powersetCard, Finset.mem_powerset] |
|
|
| @[simp] theorem enumerate_length (L : RepresentationLeaf (Fin n)) : |
| L.enumerate.length = L.occurrences.card := by |
| unfold enumerate |
| rw [List.length_product, List.length_product, fixedSubsetList_length, |
| fixedSubsetList_length, subsetList_length, occurrences_card] |
|
|
| theorem enumerate_toFinset (L : RepresentationLeaf (Fin n)) : L.enumerate.toFinset = L.occurrences := by |
| ext x |
| simp only [List.mem_toFinset, enumerate_mem] |
|
|
| theorem enumerate_nodup (L : RepresentationLeaf (Fin n)) : L.enumerate.Nodup := by |
| rw [← Multiset.coe_nodup] |
| apply Multiset.toFinset_card_eq_card_iff_nodup.mp |
| change L.enumerate.toFinset.card = L.enumerate.length |
| rw [enumerate_toFinset, enumerate_length] |
|
|
| end RepresentationLeaf |
| end LowSpaceSubsetSum |
|
|
| end OAI |
|
|
