File size: 11,339 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 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 | import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionQueryBounds
namespace OAI
/-! # A complete compression-join ledger and its live data structures
The counters retain the actual compact-test and overflow branches. The
storage bound describes the arrays, current cursors, replay snapshots, tie
buffer and bounded trie.
-/
noncomputable section
namespace LowSpaceSubsetSum
open scoped BigOperators
structure CompressionLedger where
queries : ℕ
reports : ℕ
copies : ℕ
controls : ℕ
namespace CompressionData
variable {n : ℕ} (D : CompressionData n)
/-- No right-hand work is counted after dictionary overflow. The control
count includes even the unused fuel suffix of the original `run` loop. -/
def residueLedger (B : ℕ) (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n)
(z : Fin q.val) : CompressionLedger :=
if D.compactTests e then
let lf := D.streamLength e 0 + D.streamLength e 1 + 1
let left := D.leftJoin B e q z lf
if left.user.overflow then
⟨left.queries, left.reports, left.copies, lf⟩
else
let rf := D.streamLength e 2 + D.streamLength e 3 + 1
let right := D.rightJoin B e q z left.user.tree rf
⟨left.queries + right.queries, left.reports + right.reports,
left.copies + right.copies, lf + rf⟩
else ⟨0, 0, 0, 0⟩
def trialLedger (B : ℕ) (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n) :
CompressionLedger :=
⟨∑ z, (D.residueLedger B e q z).queries,
∑ z, (D.residueLedger B e q z).reports,
∑ z, (D.residueLedger B e q z).copies,
∑ z, (D.residueLedger B e q z).controls⟩
theorem residueLedger_queries (B : ℕ) (e : Equiv.Perm (Fin n))
(q : CompressionSetup.PrimeSpace n) (z : Fin q.val) :
(D.residueLedger B e q z).queries = D.residueQueries B e q z := by
simp only [residueLedger, residueQueries]
split
· split <;> rfl
· rfl
theorem residueLedger_bounds (B : ℕ) (e : Equiv.Perm (Fin n))
(q : CompressionSetup.PrimeSpace n) (z : Fin q.val) :
(D.residueLedger B e q z).reports ≤ D.leftPotential e q z + D.rightPotential e q z ∧
B * (D.residueLedger B e q z).copies ≤ 2 * (D.leftPotential e q z + D.rightPotential e q z) ∧
(D.residueLedger B e q z).controls ≤ (∑ i : Fin 4, D.streamLength e i) + 2 := by
have hl := D.leftJoin_bounds B e q z (D.streamLength e 0 + D.streamLength e 1 + 1)
have hr := D.rightJoin_bounds B e q z
(D.leftJoin B e q z (D.streamLength e 0 + D.streamLength e 1 + 1)).user.tree
(D.streamLength e 2 + D.streamLength e 3 + 1)
simp only [residueLedger]
split
· split <;> dsimp only
· simp only [Fin.sum_univ_four]
omega
· simp only [Nat.mul_add, Fin.sum_univ_four]
omega
· simp
theorem trialLedger_reports_copies (B : ℕ) (e : Equiv.Perm (Fin n))
(q : CompressionSetup.PrimeSpace n) :
(D.trialLedger B e q).reports ≤
D.streamLength e 0 * D.streamLength e 1 + D.streamLength e 2 * D.streamLength e 3 ∧
B * (D.trialLedger B e q).copies ≤
2 * (D.streamLength e 0 * D.streamLength e 1 + D.streamLength e 2 * D.streamLength e 3) ∧
(D.trialLedger B e q).controls ≤ q.val * (∑ i : Fin 4, D.streamLength e i) + 2 * q.val := by
have hr := Finset.sum_le_sum (fun z (_ : z ∈ (Finset.univ : Finset (Fin q.val))) =>
(D.residueLedger_bounds B e q z).1)
have hc := Finset.sum_le_sum (fun z (_ : z ∈ (Finset.univ : Finset (Fin q.val))) =>
(D.residueLedger_bounds B e q z).2.1)
have ht := Finset.sum_le_sum (fun z (_ : z ∈ (Finset.univ : Finset (Fin q.val))) =>
(D.residueLedger_bounds B e q z).2.2)
simp only [Finset.sum_add_distrib, D.sum_leftPotential, D.sum_rightPotential] at hr
simp_rw [Nat.mul_add] at hc
rw [← Finset.mul_sum, Finset.sum_add_distrib, ← Finset.mul_sum, ← Finset.mul_sum,
D.sum_leftPotential, D.sum_rightPotential] at hc
simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, smul_eq_mul] at ht
exact ⟨hr, by simpa only [trialLedger, Nat.mul_add] using hc,
by simpa only [trialLedger, Nat.mul_add, Nat.add_mul, Nat.mul_comm] using ht⟩
/-- A compact bound for all measured join activity in one compression
trial. Copy work is measured in units of a full `B`-word snapshot. -/
theorem trialLedger_half_exponential (B : ℕ) (e : Equiv.Perm (Fin n))
(q : CompressionSetup.PrimeSpace n) (hn : 2000 ≤ n) :
((D.trialLedger B e q).queries : ℝ) ≤ 30 * (2 : ℝ) ^ ((n : ℝ) / 2) ∧
((D.trialLedger B e q).reports : ℝ) ≤ 2 * (2 : ℝ) ^ ((n : ℝ) / 2) ∧
(B * (D.trialLedger B e q).copies : ℕ) ≤ 4 * (2 : ℝ) ^ ((n : ℝ) / 2) ∧
((D.trialLedger B e q).controls : ℝ) ≤ 6 * (2 : ℝ) ^ ((n : ℝ) / 2) := by
have hquery := D.queries_half_exponential B e q hn
have heq : (D.trialLedger B e q).queries = ∑ z, D.residueQueries B e q z := by
simp only [trialLedger, D.residueLedger_queries]
rw [heq]
refine ⟨by simpa only [Nat.cast_sum] using hquery, ?_⟩
by_cases he : D.compactTests e = true
· have h := D.trialLedger_reports_copies B e q
have hp := D.matching_product_bound e he hn
have hs : ((q.val * ∑ i : Fin 4, D.streamLength e i : ℕ) : ℝ) ≤
4 * (2 : ℝ) ^ ((n : ℝ) / 2) := by
rw [Finset.mul_sum, Nat.cast_sum]
apply (Finset.sum_le_sum (fun i _ => D.prime_regeneration_bound e he hn q i)).trans_eq
simp
have hq : (q.val : ℝ) ≤ (2 : ℝ) ^ ((n : ℝ) / 2) := by
have hz : 1 ≤ D.streamLength e 0 := by
have hnonempty (i : Fin 7) : 0 < (compactWeightList D.weights (D.block e i)).length := by
rw [compactWeightList_length]
exact Nat.zero_lt_of_lt (Finset.card_pos.mpr ⟨0, zero_mem_distinctSums _ _⟩)
have h0 := hnonempty 4
have h1 := hnonempty 5
change 1 ≤ (compactWeightList D.weights (D.block e 4)).length *
(compactWeightList D.weights (D.block e 5)).length
nlinarith
exact (Nat.cast_le.mpr (Nat.le_mul_of_pos_right _ (by omega))).trans
(D.prime_regeneration_bound e he hn q 0)
have hr : ((D.trialLedger B e q).reports : ℝ) ≤
(D.streamLength e 0 * D.streamLength e 1 : ℕ) +
(D.streamLength e 2 * D.streamLength e 3 : ℕ) := by exact_mod_cast h.1
have hc : ((B * (D.trialLedger B e q).copies : ℕ) : ℝ) ≤
2 * ((D.streamLength e 0 * D.streamLength e 1 : ℕ) +
(D.streamLength e 2 * D.streamLength e 3 : ℕ)) := by exact_mod_cast h.2.1
have ht : ((D.trialLedger B e q).controls : ℝ) ≤
(q.val * ∑ i : Fin 4, D.streamLength e i : ℕ) + 2 * (q.val : ℝ) := by
exact_mod_cast h.2.2
exact ⟨by linarith [hp.1, hp.2], by linarith [hp.1, hp.2], by linarith⟩
· have hf : D.compactTests e = false := Bool.eq_false_iff.mpr he
simp only [trialLedger, residueLedger, hf, Bool.false_eq_true, ↓reduceIte,
Finset.sum_const_zero, Nat.mul_zero, Nat.cast_zero]
exact ⟨by positivity, by positivity, by positivity⟩
/-- Only the mutable tournament and its cached cursors are copied. The
immutable stored arrays are shared by every replay snapshot. -/
def snapshotCells (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n)
(i : Fin 4) (mode : FilteredStream.Mode) (s : D.GroupState e q i mode) : ℕ :=
10 * (Tournament.nodes s.tree + 1)
theorem snapshotCells_le_buffer (e : Equiv.Perm (Fin n)) (he : D.compactTests e = true)
(hn : 2000 ≤ n) (q : CompressionSetup.PrimeSpace n) (i : Fin 4)
(mode : FilteredStream.Mode) (s : D.GroupState e q i mode) :
D.snapshotCells e q i mode s ≤ 2 ^ (19 * n / 100) := by
have ha := compression_cap_rate (by omega : 40 ≤ n)
have hfloor : 19 * n < 100 * (19 * n / 100 + 1) := by omega
have hfloorR : (19 : ℝ) * n < 100 * ((19 * n / 100 : ℕ) + 1 : ℝ) := by
exact_mod_cast hfloor
have hnR : (2000 : ℝ) ≤ n := by exact_mod_cast hn
have hexp : compressionCapExponent n + 7 ≤ 19 * n / 100 := by
have hR : (compressionCapExponent n : ℝ) + 7 ≤ (19 * n / 100 : ℕ) := by linarith
exact_mod_cast hR
have ht := Tournament.padded_nodes_le (D.storedFirst e i).toArray.size s.tree
simp only [List.size_toArray] at ht
have hl := D.storedFirst_length_bound e he i
have hpos : 1 ≤ 2 ^ compressionCapExponent n := Nat.one_le_pow _ _ (by decide)
calc
D.snapshotCells e q i mode s ≤ 80 * 2 ^ compressionCapExponent n := by
unfold snapshotCells
omega
_ ≤ 2 ^ (compressionCapExponent n + 7) := by
rw [pow_add]
norm_num
omega
_ ≤ _ := Nat.pow_le_pow_right (by decide) hexp
/-- A conservative simultaneous footprint, including the preliminary
single-block enumeration and three copies of every group state. -/
def storageCells (B : ℕ) (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n)
(z : Fin q.val) (fuel : ℕ) (mode : Fin 4 → FilteredStream.Mode)
(states : ∀ i, D.GroupState e q i (mode i)) : ℕ :=
2 ^ compressionHalfSize n + 7 * 2 ^ compressionCapExponent n +
3 * (∑ i, D.groupFootprint e q i (mode i) (states i)) + 10 * (B + 1) +
3 * BinaryTrie.nodes (D.leftJoin B e q z fuel).user.tree
theorem storageCells_bound (B : ℕ) (hB : B ≤ compressionDictionaryCapacity n)
(e : Equiv.Perm (Fin n)) (he : D.compactTests e = true) (hn : 2000 ≤ n)
(q : CompressionSetup.PrimeSpace n) (z : Fin q.val) (fuel : ℕ)
(mode : Fin 4 → FilteredStream.Mode) (states : ∀ i, D.GroupState e q i (mode i)) :
D.storageCells B e q z fuel mode states ≤
(800 + 3 * (WeightEncoding.weightWidth D.input + 1)) * (compressionDictionaryCapacity n + 1) := by
have hs : (∑ i, D.groupFootprint e q i (mode i) (states i)) ≤
40 * (6 * compressionDictionaryCapacity n + 4) := by
apply (Finset.sum_le_sum (fun i _ => D.groupFootprint_bound e he hn q i (mode i) (states i))).trans_eq
simp
ring
have ht := D.leftJoin_nodes B e q z fuel
have hnR : (2000 : ℝ) ≤ n := by exact_mod_cast hn
have hlow : (2 : ℝ) ^ ((3 / 25 : ℝ) * n) ≤ compressionDictionaryCapacity n := by
apply (Real.rpow_le_rpow_of_exponent_le (by norm_num)
(show (3 / 25 : ℝ) * n ≤ (199 / 1000 : ℝ) * n - 1 by linarith)).trans
exact compression_capacity_lower n
have hhalf : 2 ^ compressionHalfSize n ≤ compressionDictionaryCapacity n := by
have hb := (mixerSize_bounds n).2
have hhalfR : (compressionHalfSize n : ℝ) ≤ (3 / 25 : ℝ) * n := by
have heq : mixerSize n = 2 * compressionHalfSize n := by
rw [compressionHalfSize_eq]
unfold mixerSize
omega
rw [heq, Nat.cast_mul, Nat.cast_ofNat] at hb
linarith
have hpow := Real.rpow_le_rpow_of_exponent_le (by norm_num : (1 : ℝ) ≤ 2) hhalfR
rw [Real.rpow_natCast] at hpow
exact_mod_cast hpow.trans hlow
have hcap : 2 ^ compressionCapExponent n ≤ compressionDictionaryCapacity n := by
have ha := compression_cap_rate (by omega : 40 ≤ n)
have hrate : (compressionCapExponent n : ℝ) ≤ (3 / 25 : ℝ) * n := by linarith
have hpow := Real.rpow_le_rpow_of_exponent_le (by norm_num : (1 : ℝ) ≤ 2) hrate
rw [Real.rpow_natCast] at hpow
exact_mod_cast hpow.trans hlow
unfold storageCells
nlinarith only [hs, ht, hhalf, hcap, hB]
end CompressionData
end LowSpaceSubsetSum
end
end OAI
|