File size: 4,555 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 | import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionWeights
import OAI.Combinatorics.LowSpaceSubsetSum.Compression.PreparedCompressionPass
namespace OAI
/-! # Building the compression trial's stored arrays
All seven compact lists are materialized once. Their capacity test precedes
raw-list and pair-list construction. The resulting arrays are shared by all
residue passes.
-/
namespace LowSpaceSubsetSum.CompressionArrayBuild
open scoped BigOperators
variable {n : ℕ}
def pairSums : List ℤ → List ℤ → List ℤ × ℕ
| [], _ => ([], 1)
| x :: xs, ys =>
let rest := pairSums xs ys
((ys.map (x + ·)) ++ rest.1, rest.2 + 3 * ys.length + 2)
theorem pairSums_value (xs ys : List ℤ) : (pairSums xs ys).1 = pairSumList xs ys := by
induction xs with
| nil => rfl
| cons x xs ih => simp [pairSums, ih, pairSumList, List.product]
theorem pairSums_work (xs ys : List ℤ) :
(pairSums xs ys).2 = (3 * ys.length + 2) * xs.length + 1 := by
induction xs with
| nil => simp [pairSums]
| cons x xs ih => simp only [pairSums, ih, List.length_cons, Nat.mul_add, Nat.mul_one]; omega
theorem pairSums_work_le (xs ys : List ℤ) (hy : 0 < ys.length) :
(pairSums xs ys).2 ≤ 5 * (pairSumList xs ys).length + 1 := by
rw [pairSums_work, pairSumList_length]
nlinarith only [Nat.le_mul_of_pos_right xs.length hy]
structure Blocks (n : ℕ) where
compact : Fin 7 → List (Fin n)
left : List (Fin n)
right : Fin 2 → List (Fin n)
def compactLists (a : Fin n → ℤ) (V : Blocks n) : Vector (List ℤ × ℕ) 7 :=
Vector.ofFn (fun i => CompressionWeights.compact a (V.compact i))
def passed (lists : Vector (List ℤ × ℕ) 7) (cap : ℕ) : Bool :=
decide (∀ i : Fin 7, (lists[i.val].1).length ≤ cap)
def assemble (lists : Vector (List ℤ × ℕ) 7) (l r₀ r₁ : List ℤ) :
PreparedCompressionPass.Arrays × ℕ :=
let p₀ := pairSums lists[1].1 r₀
let p₁ := pairSums lists[3].1 r₁
let A : PreparedCompressionPass.Arrays :=
⟨![lists[4].1.toArray, lists[6].1.toArray, lists[0].1.toArray, lists[2].1.toArray],
![lists[5].1.toArray, l.toArray, p₀.1.toArray, p₁.1.toArray]⟩
(A, p₀.2 + p₁.2 + PreparedCompressionPass.size A + 10)
def run (a : Fin n → ℤ) (V : Blocks n) (cap : ℕ) :
Option PreparedCompressionPass.Arrays × ℕ :=
let lists := compactLists a V
let cw := ∑ i : Fin 7, (lists[i.val].2 + lists[i.val].1.length)
if passed lists cap then
let l := CompressionWeights.raw a V.left
let r₀ := CompressionWeights.raw a (V.right 0)
let r₁ := CompressionWeights.raw a (V.right 1)
let out := assemble lists l.1 r₀.1 r₁.1
(some out.1, cw + l.2 + r₀.2 + r₁.2 + out.2 + 30)
else (none, cw + 30)
def source (D : CompressionData n) (e : Equiv.Perm (Fin n)) : Blocks n :=
⟨fun i => (D.block e i).sort (· ≤ ·), (D.leftRaw e).sort (· ≤ ·),
fun i => (D.rightRaw e i).sort (· ≤ ·)⟩
theorem compactLists_source (D : CompressionData n) (e : Equiv.Perm (Fin n)) (i : Fin 7) :
((compactLists D.weights (source D e))[i.val]).1 = compactWeightList D.weights (D.block e i) := by
simp only [compactLists, Vector.getElem_ofFn, source, CompressionWeights.compact_source]
theorem passed_source (D : CompressionData n) (e : Equiv.Perm (Fin n)) :
passed (compactLists D.weights (source D e)) (2 ^ CompressionSetup.executableCapExponent n) =
D.compactTests e := by
simp only [passed, compactLists_source, CompressionData.compactTests]
theorem assemble_source (D : CompressionData n) (e : Equiv.Perm (Fin n)) :
(assemble (compactLists D.weights (source D e))
(CompressionWeights.raw D.weights (source D e).left).1
(CompressionWeights.raw D.weights ((source D e).right 0)).1
(CompressionWeights.raw D.weights ((source D e).right 1)).1).1 =
PreparedCompressionPass.source D e := by
simp only [assemble, compactLists, Vector.getElem_ofFn, source,
CompressionWeights.compact_source, CompressionWeights.raw_source, pairSums_value,
PreparedCompressionPass.source, CompressionData.storedFirst, CompressionData.storedSecond]
congr 1 <;> funext i <;> fin_cases i <;> rfl
theorem run_source (D : CompressionData n) (e : Equiv.Perm (Fin n)) :
(run D.weights (source D e) (2 ^ CompressionSetup.executableCapExponent n)).1 =
if D.compactTests e then some (PreparedCompressionPass.source D e) else none := by
simp only [run, passed_source]
split <;> simp only [assemble_source]
end LowSpaceSubsetSum.CompressionArrayBuild
end OAI
|