File size: 6,675 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 | import OAI.Combinatorics.LowSpaceSubsetSum.Compression.BudgetedCompressionPass
import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionJoinErasure
import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionTrialLedger
import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationTaskSpace
namespace OAI
/-! # The compression residue pass and its original source ledger
The contexts in `passData` specify the shared-array initializer values.
The allowance bounds the two joins, with context construction charged
separately.
-/
namespace LowSpaceSubsetSum.CompressionData
variable {n : ℕ} (D : CompressionData n)
def passData (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n) (z : Fin q.val) :
BudgetedCompressionPass.Data q.val D.input.target z.val :=
⟨⟨D.storedRightArray e q 0, _, D.groupStart e q 0 .direct⟩,
⟨D.storedRightArray e q 1, _, D.groupStart e q 1 (.complementary z.val)⟩,
⟨D.storedRightArray e q 2, _, D.groupStart e q 2 .direct⟩,
⟨D.storedRightArray e q 3, _, D.groupStart e q 3 (.complementary ((D.input.target : ℤ) - z.val))⟩,
D.streamLength e 0, D.streamLength e 1, D.streamLength e 2, D.streamLength e 3⟩
theorem pass_left_value (B : ℕ) (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n)
(z : Fin q.val) :
StreamJoin.mapUser D.eraseCompression
(BudgetedCompressionPass.leftFull D.input (compressionDictionaryCapacity n) B
(D.passData e q z)).1.state =
D.leftJoin B e q z (D.streamLength e 0 + D.streamLength e 1 + 1) :=
D.leftReference_value B e q z _
theorem pass_right_value (B : ℕ) (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n)
(z : Fin q.val) (tree : BinaryTrie.Tree) :
(BudgetedCompressionPass.rightFull D.input B (D.passData e q z) tree).1.state =
D.rightJoin B e q z tree (D.streamLength e 2 + D.streamLength e 3 + 1) :=
D.rightReference_value B e q z tree _
theorem pass_reference (B : ℕ) (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n)
(z : Fin q.val) (he : D.compactTests e = true) :
BudgetedCompressionPass.reference D.input (compressionDictionaryCapacity n) B (D.passData e q z) =
D.residuePass B e q z := by
have hl := congrArg StreamJoin.State.user (D.pass_left_value B e q z)
change (BudgetedCompressionPass.leftFull D.input (compressionDictionaryCapacity n) B
(D.passData e q z)).1.state.user.val.keys = D.actualLeftDictionary B e q z at hl
dsimp only [BudgetedCompressionPass.reference, residuePass]
rw [hl, he, ite_eq_left rfl]
split
· rfl
· exact congrArg StreamJoin.State.user (D.pass_right_value B e q z _)
theorem pass_leftKeys (B : ℕ) (e : Equiv.Perm (Fin n))
(q : CompressionSetup.PrimeSpace n) (z : Fin q.val) :
(BudgetedCompressionPass.leftFull D.input (compressionDictionaryCapacity n) B
(D.passData e q z)).1.state.user.val.keys =
(D.leftJoin B e q z (D.streamLength e 0 + D.streamLength e 1 + 1)).user :=
congrArg StreamJoin.State.user (D.pass_left_value B e q z)
theorem pass_leftBill (B : ℕ) (e : Equiv.Perm (Fin n))
(q : CompressionSetup.PrimeSpace n) (z : Fin q.val) :
BudgetedCompressionPass.leftBill D.input (compressionDictionaryCapacity n) B
(D.passData e q z) = inputScale D.input ^ 5 *
(D.leftJoin B e q z (D.streamLength e 0 + D.streamLength e 1 + 1)).queries +
B * (D.leftJoin B e q z (D.streamLength e 0 + D.streamLength e 1 + 1)).copies + 4 := by
have hq := congrArg StreamJoin.State.queries (D.pass_left_value B e q z)
have hc := congrArg StreamJoin.State.copies (D.pass_left_value B e q z)
dsimp only [StreamJoin.mapUser] at hq hc
dsimp only [BudgetedCompressionPass.leftBill]
rw [hq, hc]
theorem pass_rightBill (B : ℕ) (e : Equiv.Perm (Fin n))
(q : CompressionSetup.PrimeSpace n) (z : Fin q.val) (tree : BinaryTrie.Tree) :
BudgetedCompressionPass.rightBill D.input B (D.passData e q z) tree =
inputScale D.input ^ 5 *
(D.rightJoin B e q z tree (D.streamLength e 2 + D.streamLength e 3 + 1)).queries +
B * (D.rightJoin B e q z tree (D.streamLength e 2 + D.streamLength e 3 + 1)).copies + 4 := by
have hq := congrArg StreamJoin.State.queries (D.pass_right_value B e q z tree)
have hc := congrArg StreamJoin.State.copies (D.pass_right_value B e q z tree)
dsimp only [BudgetedCompressionPass.rightBill]
rw [hq, hc]
theorem pass_allowance (B : ℕ) (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n)
(z : Fin q.val) (he : D.compactTests e = true) :
BudgetedCompressionPass.allowance D.input (compressionDictionaryCapacity n) B (D.passData e q z) ≤
inputScale D.input ^ 5 * (D.residueLedger B e q z).queries +
B * (D.residueLedger B e q z).copies + 16 := by
dsimp only [BudgetedCompressionPass.allowance]
rw [D.pass_leftKeys, D.pass_leftBill]
simp only [residueLedger, he, ↓reduceIte]
split
· dsimp only
omega
· rw [D.pass_rightBill]
simp only [Nat.mul_add]
omega
theorem pass_depth (e : Equiv.Perm (Fin n)) (he : D.compactTests e = true)
(hn : 10000 ≤ n) (i : Fin 4) : Nat.clog 2 (D.storedFirst e i).toArray.size ≤ n := by
apply Nat.clog_le_of_le_pow
simp only [List.size_toArray]
apply (D.storedFirst_length_bound e he i).trans
apply Nat.pow_le_pow_right (by decide)
have hr := compression_cap_rate (by omega : 40 ≤ n)
have hnR : (0 : ℝ) ≤ n := Nat.cast_nonneg _
have hh : (compressionCapExponent n : ℝ) ≤ n := by linarith
exact_mod_cast hh
theorem pass_account (e : Equiv.Perm (Fin n)) (he : D.compactTests e = true)
(q : CompressionSetup.PrimeSpace n) (z : Fin q.val) (budget : ℕ) (hn : 10000 ≤ n) :
BudgetedSeparatorFlow.Account budget
(BudgetedCompressionPass.run D.input (compressionDictionaryCapacity n)
(representationBufferCapacity n) (D.passData e q z) budget) := by
have copy (i : Fin 4) (mode : FilteredStream.Mode) :
10 * 2 ^ (Nat.clog 2 (D.storedFirst e i).toArray.size + 1) ≤ representationBufferCapacity n := by
have h := D.snapshotCells_le_buffer e he (by omega) q i mode (D.groupStart e q i mode)
have ht := Tournament.nodes_exact (D.groupStart e q i mode).tree
have hp : 0 < 2 ^ (Nat.clog 2 (D.storedFirst e i).toArray.size + 1) := by positivity
unfold snapshotCells representationBufferCapacity at *
omega
exact BudgetedCompressionPass.account _ _ _ _ _ hn
(D.pass_depth e he hn 0) (D.pass_depth e he hn 1)
(D.pass_depth e he hn 2) (D.pass_depth e he hn 3)
(copy 1 (.complementary z.val))
(copy 3 (.complementary ((D.input.target : ℤ) - z.val)))
end LowSpaceSubsetSum.CompressionData
end OAI
|