File size: 5,348 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 | import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionBucket
import OAI.Combinatorics.LowSpaceSubsetSum.Streams.FilteredStream
namespace OAI
/-! # Concrete compressed-group streams from their two stored arrays -/
namespace LowSpaceSubsetSum
def mapReader {α β σ : Type*} (f : α → β) (read : σ → Option (α × σ))
(s : σ) : Option (β × σ) := (read s).map (fun p => (f p.1, p.2))
theorem mapReader_law {α β σ : Type*} (f : α → β) (read : σ → Option (α × σ))
(view : σ → List α) (hread : RowMerge.IsReader read view) :
RowMerge.IsReader (mapReader f read) (fun s => (view s).map f) := by
intro s
have h := hread s
cases hs : read s with
| none =>
simp only [hs] at h
simp [mapReader, hs, h]
| some p =>
obtain ⟨a, s'⟩ := p
simp only [hs] at h
simp [mapReader, hs, h]
namespace CompressionSetup
variable {n : ℕ} (R : CompressionSetup n)
def storedRightArray (e : Equiv.Perm (Fin n)) (q : PrimeSpace n) (i : Fin 4) : Array ℤ :=
ResidueSort.sort (R.storedSecond e i).toArray id 1 q.val
abbrev GroupState (e : Equiv.Perm (Fin n)) (q : PrimeSpace n)
(i : Fin 4) (mode : FilteredStream.Mode) :=
MergedReader.State (FilteredStream.key (id : ℤ → ℤ) id q.val mode)
(FilteredStream.view (α := ℤ) (R.storedRightArray e q i))
(Nat.clog 2 (R.storedFirst e i).toArray.size)
def groupStart (e : Equiv.Perm (Fin n)) (q : PrimeSpace n)
(i : Fin 4) (mode : FilteredStream.Mode) : R.GroupState e q i mode :=
FilteredStream.sortedStart (R.storedFirst e i).toArray (R.storedSecond e i).toArray
id id 1 q.val 0 (by exact_mod_cast (primeRange_prime q.property).pos) mode
def groupRead (e : Equiv.Perm (Fin n)) (q : PrimeSpace n)
(i : Fin 4) (mode : FilteredStream.Mode) :
R.GroupState e q i mode → Option (ℤ × R.GroupState e q i mode) :=
mapReader (fun p : ℤ × ℤ => p.1 + p.2)
(MergedReader.next (FilteredStream.key id id q.val mode)
(FilteredStream.read (R.storedRightArray e q i))
(FilteredStream.view (R.storedRightArray e q i)) (FilteredStream.reader _))
def groupOutput (e : Equiv.Perm (Fin n)) (q : PrimeSpace n)
(i : Fin 4) (mode : FilteredStream.Mode) (s : R.GroupState e q i mode) : List ℤ :=
(MergedReader.output (FilteredStream.key id id q.val mode)
(FilteredStream.read (R.storedRightArray e q i))
(FilteredStream.view (R.storedRightArray e q i)) s).map (fun p => p.1 + p.2)
theorem groupRead_law (e : Equiv.Perm (Fin n)) (q : PrimeSpace n)
(i : Fin 4) (mode : FilteredStream.Mode) :
RowMerge.IsReader (R.groupRead e q i mode) (R.groupOutput e q i mode) :=
mapReader_law _ _ _ (MergedReader.reader _ _ _ (FilteredStream.reader _))
theorem groupOutput_mem (e : Equiv.Perm (Fin n)) (q : PrimeSpace n)
(i : Fin 4) (mode : FilteredStream.Mode) (z : ℤ) :
z ∈ R.groupOutput e q i mode (R.groupStart e q i mode) ↔ z ∈ R.groupList e i := by
change z ∈ (MergedReader.output _ _ _
(FilteredStream.sortedStart (R.storedFirst e i).toArray (R.storedSecond e i).toArray
id id 1 q.val 0 _ mode)).map (fun p : ℤ × ℤ => p.1 + p.2) ↔ _
simp only [List.mem_map]
constructor
· rintro ⟨p, hp, he⟩
have h := (FilteredStream.sorted_output_mem _ _ id id 1 q.val 0 _ mode p).mp hp
exact (mem_pairSumList _ _ _).mpr
⟨p.1, by simpa using h.1, p.2, by simpa using h.2.1, he⟩
· intro hz
obtain ⟨x, hx, y, hy, he⟩ := (mem_pairSumList _ _ _).mp hz
refine ⟨(x, y), ?_, he⟩
apply (FilteredStream.sorted_output_mem _ _ id id 1 q.val 0 _ mode _).mpr
exact ⟨by simpa using hx, by simpa using hy, by simp⟩
def groupKey (q : PrimeSpace n) : FilteredStream.Mode → ℤ → ℤ
| .direct, x => x % q.val
| .complementary v, x => (v - x) % q.val
theorem groupOutput_sorted (e : Equiv.Perm (Fin n)) (q : PrimeSpace n)
(i : Fin 4) (mode : FilteredStream.Mode) :
(R.groupOutput e q i mode (R.groupStart e q i mode)).Pairwise
(fun x y => groupKey q mode x ≤ groupKey q mode y) := by
have h := FilteredStream.sorted_output_sorted (R.storedFirst e i).toArray
(R.storedSecond e i).toArray id id 1 q.val 0
(by exact_mod_cast (primeRange_prime q.property).pos) mode
change ((MergedReader.output _ _ _ _).map (fun p : ℤ × ℤ => p.1 + p.2)).Pairwise _
rw [List.pairwise_map]
cases mode <;> simpa only [storedRightArray, groupStart, FilteredStream.key,
groupKey, id_eq, sub_add_eq_sub_sub] using h
theorem groupOutput_length (e : Equiv.Perm (Fin n)) (q : PrimeSpace n)
(i : Fin 4) (mode : FilteredStream.Mode) :
(R.groupOutput e q i mode (R.groupStart e q i mode)).length =
(R.groupList e i).length := by
have h := congrArg Multiset.card (FilteredStream.sorted_output_bag
(R.storedFirst e i).toArray (R.storedSecond e i).toArray id id 1 q.val 0
(by exact_mod_cast (primeRange_prime q.property).pos) mode)
simp only [Multiset.coe_card, Multiset.card_sum, List.length_map, id_eq,
Int.emod_one, decide_true, List.filter_true,
List.size_toArray, Finset.sum_const, Finset.card_univ,
Fintype.card_fin, smul_eq_mul] at h
change (List.map (fun p : ℤ × ℤ => p.1 + p.2) (MergedReader.output _ _ _ _)).length = _
rw [List.length_map, groupList, pairSumList_length]
exact h
end CompressionSetup
end LowSpaceSubsetSum
end OAI
|