lean/OAI/Combinatorics/LowSpaceSubsetSum/Compression/CompressionArrayCells.lean

import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionWeightCells
import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionPairCells
import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionStorageBounds

namespace OAI

/-! # Constructing compression arrays with an explicit live-cell trace

All seven compact lists are produced before the capacity test. Only its
successful branch allocates the three raw lists and the two pair lists.
The completed arrays are shared by subsequent residue passes.
-/

namespace LowSpaceSubsetSum.CompressionArrayCells

open scoped BigOperators
variable {n : ℕ}

def compactLists (a : Fin n → ℤ) (V : CompressionArrayBuild.Blocks n) :
    Vector (List ℤ × ℕ) 7 × ℕ :=
  let rows := Vector.ofFn (fun i => CompressionWeightCells.compact a (V.compact i))
  (rows.map Prod.fst, (∑ i : Fin 7, rows[i.val].2)+
    4*(∑ i : Fin 7, rows[i.val].1.1.length)+64)

theorem compactLists_value (a : Fin n → ℤ) (V : CompressionArrayBuild.Blocks n) :
    (compactLists a V).1 = CompressionArrayBuild.compactLists a V := by
  apply Vector.ext
  intro i hi
  simp only [compactLists, CompressionArrayBuild.compactLists, Vector.getElem_map,
    Vector.getElem_ofFn, CompressionWeightCells.compact_value]

private theorem compact_length (a : Fin n → ℤ) (xs : List (Fin n)) :
    (CompressionWeightCells.compact a xs).1.1.length ≤ 2^xs.length := by
  rw [CompressionWeightCells.compact_value]
  simp only [CompressionWeights.compact]
  rw [CountedDedup.run_value]
  have h := (List.destutter_sublist (R := (· ≠ ·))
    (MeasuredSort.sort (fun x y : ℤ => (decide (x ≤ y), 1))
      (CompressionWeights.raw a xs).1).1).length_le
  simpa only [MeasuredSort.sort_value, List.length_mergeSort, CompressionWeights.raw_length] using h

theorem compactLists_cells (a : Fin n → ℤ) (V : CompressionArrayBuild.Blocks n) (C : ℕ)
    (hl : ∀ i, (V.compact i).length ≤ n)
    (hc : ∀ i, 2^(V.compact i).length ≤ C) :
    (compactLists a V).2 ≤ 4096*(n+2)^2*(C+1) := by
  have hp (i : Fin 7) := (CompressionWeightCells.compact_cells a (V.compact i) (hl i)).trans
    (Nat.mul_le_mul_left (512*(n+2)^2) (Nat.add_le_add_right (hc i) 1))
  have hlen (i : Fin 7) := (compact_length a (V.compact i)).trans (hc i)
  have hs := Finset.sum_le_sum (fun i (_ : i ∈ (Finset.univ : Finset (Fin 7))) => hp i)
  have ht := Finset.sum_le_sum (fun i (_ : i ∈ (Finset.univ : Finset (Fin 7))) => hlen i)
  simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, smul_eq_mul] at hs ht
  simp only [compactLists, Vector.getElem_ofFn, Fin.eta]
  have hbase : 1 ≤ (n+2)^2 := Nat.one_le_pow _ _ (by omega)
  have hmul := Nat.mul_le_mul_right (C+1) hbase
  nlinarith only [hs, ht, hmul]

def assemble (lists : Vector (List ℤ × ℕ) 7) (l r₀ r₁ : List ℤ) :
    (PreparedCompressionPass.Arrays × ℕ) × ℕ :=
  let p₀ := CompressionPairCells.run lists[1].1 r₀
  let p₁ := CompressionPairCells.run 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.1.toArray, p₁.1.1.toArray]⟩
  ((A,p₀.1.2+p₁.1.2+PreparedCompressionPass.size A+10),
    p₀.2+p₁.2+4*PreparedCompressionPass.size A+
      4*((∑ i : Fin 7, lists[i.val].1.length)+l.length+r₀.length+r₁.length)+64)

theorem assemble_value (lists : Vector (List ℤ × ℕ) 7) (l r₀ r₁ : List ℤ) :
    (assemble lists l r₀ r₁).1 = CompressionArrayBuild.assemble lists l r₀ r₁ := by
  simp only [assemble, CompressionArrayBuild.assemble, CompressionPairCells.value]

theorem assemble_cells (lists : Vector (List ℤ × ℕ) 7) (l r₀ r₁ : List ℤ) (C : ℕ)
    (hlist : ∀ i : Fin 7, lists[i.val].1.length ≤ C)
    (hl : l.length ≤ C) (hr₀ : r₀.length ≤ C) (hr₁ : r₁.length ≤ C)
    (hp₀ : lists[1].1.length*r₀.length ≤ C)
    (hp₁ : lists[3].1.length*r₁.length ≤ C) :
    (assemble lists l r₀ r₁).2 ≤ 512*(C+1) := by
  have ha (i : Fin 4) :
      ((assemble lists l r₀ r₁).1.1.first i).size ≤ C ∧
      ((assemble lists l r₀ r₁).1.1.second i).size ≤ C := by
    fin_cases i
    · exact ⟨hlist 4, hlist 5⟩
    · exact ⟨hlist 6, hl⟩
    · simpa [assemble, CompressionPairCells.length] using
        And.intro (hlist 0) hp₀
    · simpa [assemble, CompressionPairCells.length] using
        And.intro (hlist 2) hp₁
  have hs := Finset.sum_le_sum (fun i (_ : i ∈ (Finset.univ : Finset (Fin 4))) =>
    Nat.add_le_add (ha i).1 (ha i).2)
  simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, smul_eq_mul] at hs
  have hsize : PreparedCompressionPass.size (assemble lists l r₀ r₁).1.1 ≤ 8*C+1 := by
    unfold PreparedCompressionPass.size
    omega
  have hsum := Finset.sum_le_sum (fun i (_ : i ∈ (Finset.univ : Finset (Fin 7))) => hlist i)
  simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, smul_eq_mul] at hsum
  have h₀ := CompressionPairCells.cells lists[1].1 r₀
  have h₁ := CompressionPairCells.cells lists[3].1 r₁
  have hc₀ := hlist 1
  have hc₁ := hlist 3
  norm_num at hc₀ hc₁
  change _+_+4*PreparedCompressionPass.size (assemble lists l r₀ r₁).1.1+_+64 ≤ _
  nlinarith only [h₀, h₁, hc₀, hc₁, hl, hr₀, hr₁, hp₀, hp₁, hsize, hsum]

def run (a : Fin n → ℤ) (V : CompressionArrayBuild.Blocks n) (cap : ℕ) :
    (Option PreparedCompressionPass.Arrays × ℕ) × ℕ :=
  let compact := compactLists a V
  let lists := compact.1
  let cw := ∑ i : Fin 7, (lists[i.val].2+lists[i.val].1.length)
  if CompressionArrayBuild.passed lists cap then
    let l := MixerWeightCells.raw a V.left
    let r₀ := MixerWeightCells.raw a (V.right 0)
    let r₁ := MixerWeightCells.raw a (V.right 1)
    let out := assemble lists l.1.1 r₀.1.1 r₁.1.1
    ((some out.1.1,cw+l.1.2+r₀.1.2+r₁.1.2+out.1.2+30),
      compact.2+l.2+r₀.2+r₁.2+out.2+
        4*((∑ i : Fin 7, lists[i.val].1.length)+l.1.1.length+r₀.1.1.length+r₁.1.1.length)+64)
  else ((none,cw+30),compact.2+64)

theorem value (a : Fin n → ℤ) (V : CompressionArrayBuild.Blocks n) (cap : ℕ) :
    (run a V cap).1 = CompressionArrayBuild.run a V cap := by
  simp only [run, compactLists_value, CompressionArrayBuild.run]
  split
  · simp only [MixerWeightCells.raw_value, assemble_value]
  · rfl

private theorem source_pair_bounds (D : CompressionData n) (e : Equiv.Perm (Fin n))
    (hn : 10000 ≤ n) (he : D.compactTests e = true) :
    ((compactLists D.weights (CompressionArrayBuild.source D e)).1[1].1).length *
        (MixerWeightCells.raw D.weights ((CompressionArrayBuild.source D e).right 0)).1.1.length ≤
          compressionDictionaryCapacity n ∧
    ((compactLists D.weights (CompressionArrayBuild.source D e)).1[3].1).length *
        (MixerWeightCells.raw D.weights ((CompressionArrayBuild.source D e).right 1)).1.1.length ≤
          compressionDictionaryCapacity n := by
  have h₀ := (D.stored_lists_capacity e he (by omega) 2).2
  have h₁ := (D.stored_lists_capacity e he (by omega) 3).2
  change (pairSumList (compactWeightList D.weights (D.block e 1))
    (rawWeightList D.weights (D.rightRaw e 0))).length ≤ _ at h₀
  change (pairSumList (compactWeightList D.weights (D.block e 3))
    (rawWeightList D.weights (D.rightRaw e 1))).length ≤ _ at h₁
  simp only [pairSumList_length] at h₀ h₁
  have hc₀ : ((CompressionArrayBuild.compactLists D.weights
      (CompressionArrayBuild.source D e))[1]).1 = compactWeightList D.weights (D.block e 1) :=
    CompressionArrayBuild.compactLists_source D e 1
  have hc₁ : ((CompressionArrayBuild.compactLists D.weights
      (CompressionArrayBuild.source D e))[3]).1 = compactWeightList D.weights (D.block e 3) :=
    CompressionArrayBuild.compactLists_source D e 3
  simp only [compactLists_value, hc₀, hc₁]
  simpa only [MixerWeightCells.raw_value, CompressionArrayBuild.source,
    CompressionWeights.raw_source] using And.intro h₀ h₁

theorem cells (D : CompressionData n) (e : Equiv.Perm (Fin n)) (hn : 10000 ≤ n) :
    (run D.weights (CompressionArrayBuild.source D e)
      (2^CompressionSetup.executableCapExponent n)).2 ≤
        8192*(n+2)^2*(compressionDictionaryCapacity n+1) := by
  let V := CompressionArrayBuild.source D e
  let C := compressionDictionaryCapacity n
  have hl := CompressionStorageBounds.source_lengths D e hn
  have hexp : 199*n/1000 ≤ n := by omega
  have hcompact (i : Fin 7) : (V.compact i).length ≤ n := (hl.1 i).trans hexp
  have hpow (i : Fin 7) : 2^(V.compact i).length ≤ C :=
    Nat.pow_le_pow_right (by decide) (hl.1 i)
  have hrawL := CompressionStorageBounds.raw_bound D.weights V.left hl.2.1
  have hraw₀ := CompressionStorageBounds.raw_bound D.weights (V.right 0) (hl.2.2 0)
  have hraw₁ := CompressionStorageBounds.raw_bound D.weights (V.right 1) (hl.2.2 1)
  have hlist (i : Fin 7) : ((compactLists D.weights V).1[i.val].1).length ≤ C := by
    rw [compactLists_value]
    simpa only [CompressionArrayBuild.compactLists, Vector.getElem_ofFn,
      CompressionWeightCells.compact_value] using
      ((compact_length D.weights (V.compact i)).trans (hpow i))
  have hsum := Finset.sum_le_sum (fun i (_ : i ∈ (Finset.univ : Finset (Fin 7))) => hlist i)
  simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, smul_eq_mul] at hsum
  have hc := compactLists_cells D.weights V C hcompact hpow
  have rawCells (xs : List (Fin n)) (hx : xs.length ≤ 199*n/1000) :
      (MixerWeightCells.raw D.weights xs).2 ≤ 64*(n+2)*(C+1) :=
    (MixerWeightCells.raw_cells D.weights xs (hx.trans hexp)).trans
      (Nat.mul_le_mul_left (64*(n+2))
        (Nat.add_le_add_right (Nat.pow_le_pow_right (by decide) hx) 1))
  have hL := rawCells V.left hl.2.1
  have h₀ := rawCells (V.right 0) (hl.2.2 0)
  have h₁ := rawCells (V.right 1) (hl.2.2 1)
  have hdegree : n+2 ≤ (n+2)^2 := by nlinarith
  have hbase : 1 ≤ (n+2)^2 := Nat.one_le_pow _ _ (by omega)
  have hm := Nat.mul_le_mul_right (C+1) hdegree
  have hb := Nat.mul_le_mul_right (C+1) hbase
  change (run D.weights V _).2 ≤ 8192*(n+2)^2*(C+1)
  unfold run
  dsimp only
  split
  next hp =>
    have he : D.compactTests e = true := by
      simpa only [V, compactLists_value, CompressionArrayBuild.passed_source] using hp
    have hpairs := source_pair_bounds D e hn he
    have ha := assemble_cells (compactLists D.weights V).1
      (MixerWeightCells.raw D.weights V.left).1.1
      (MixerWeightCells.raw D.weights (V.right 0)).1.1
      (MixerWeightCells.raw D.weights (V.right 1)).1.1 C hlist
      (by simpa only [MixerWeightCells.raw_value] using hrawL)
      (by simpa only [MixerWeightCells.raw_value] using hraw₀)
      (by simpa only [MixerWeightCells.raw_value] using hraw₁) hpairs.1 hpairs.2
    have hlenL : (MixerWeightCells.raw D.weights V.left).1.1.length ≤ C := by
      simpa only [MixerWeightCells.raw_value] using hrawL
    have hlen₀ : (MixerWeightCells.raw D.weights (V.right 0)).1.1.length ≤ C := by
      simpa only [MixerWeightCells.raw_value] using hraw₀
    have hlen₁ : (MixerWeightCells.raw D.weights (V.right 1)).1.1.length ≤ C := by
      simpa only [MixerWeightCells.raw_value] using hraw₁
    change _+_+_+_+_+4*(_+_+_+_)+64 ≤ _
    simp only [Nat.mul_assoc] at hc hL h₀ h₁ hm hb ⊢
    nlinarith only [hc, hL, h₀, h₁, hm, hb, ha, hsum, hlenL, hlen₀, hlen₁]
  · change _+64 ≤ _
    simp only [Nat.mul_assoc] at hc hb ⊢
    nlinarith only [hc, hb]

theorem cells_scale (D : CompressionData n) (e : Equiv.Perm (Fin n)) (hn : 10000 ≤ n) :
    (run D.weights (CompressionArrayBuild.source D e)
      (2^CompressionSetup.executableCapExponent n)).2 ≤
        inputScale D.input^4*(compressionDictionaryCapacity n+1) := by
  have hu : n+2 ≤ inputScale D.input := by unfold inputScale; omega
  have hu0 : 10000 ≤ inputScale D.input := by omega
  have hs := Nat.pow_le_pow_left hu 2
  have hc : 8192 ≤ inputScale D.input^2 := by nlinarith only [hu0]
  have hm := Nat.mul_le_mul hc hs
  have he : 8192*(n+2)^2 ≤ inputScale D.input^4 := by
    simpa only [← pow_add] using hm
  exact (cells D e hn).trans (Nat.mul_le_mul_right _ he)

end LowSpaceSubsetSum.CompressionArrayCells

end OAI