math / data /lean /OAI /Combinatorics /LowSpaceSubsetSum /Compression /CompressionArrayBuild.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
4.56 kB
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