File size: 5,881 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.BudgetedPreparedCompressionPass
import OAI.Combinatorics.LowSpaceSubsetSum.Search.BudgetedResidueLoop
namespace OAI
/-! # Executed compression residue scan with one shared budget
Each residue constructs its four live readers from the shared arrays. A
completed pass releases those readers before the next residue is started.
-/
namespace LowSpaceSubsetSum.BudgetedCompressionSchedule
open BudgetedSeparatorFlow
open BudgetedSeparatorCall (Outcome)
open PreparedCompressionPass (Arrays)
open scoped BigOperators
variable {n : ℕ}
def bucket (I : Instance n) (C B : ℕ) (A : Arrays) (P : ℕ) (hP : 0 < P)
(z budget : ℕ) : Outcome Bool :=
if z < P then
BudgetedPreparedCompressionPass.run I C B A P I.target z (by exact_mod_cast hP) budget
else BudgetedSeparatorFlow.pure false budget
def bill (I : Instance n) (C B : ℕ) (A : Arrays) (P : ℕ) (hP : 0 < P) (z : ℕ) : ℕ :=
if z < P then
BudgetedPreparedCompressionPass.allowance I C B A P I.target z (by exact_mod_cast hP)
else 0
def run (I : Instance n) (C B : ℕ) (A : Arrays) (P : ℕ) (hP : 0 < P) (budget : ℕ) :=
BudgetedResidueLoop.run (bucket I C B A P hP) 0 P budget
def allowance (I : Instance n) (C B : ℕ) (A : Arrays) (P : ℕ) (hP : 0 < P) :=
BudgetedResidueLoop.allowance (bill I C B A P hP) 0 P
theorem complete (I : Instance n) (C B : ℕ) (A : Arrays) (P : ℕ) (hP : 0 < P)
(hn : 10000 ≤ n) (budget : ℕ) (hb : allowance I C B A P hP ≤ budget) :
∃ v rest, (run I C B A P hP budget).1 = some (v, rest) := by
apply BudgetedResidueLoop.complete _ (bill I C B A P hP) _ _ 0 P budget 0 hb
· intro z b hz
by_cases hp : z < P
· simp only [bill, hp, ↓reduceIte] at hz
simpa only [bucket, hp, ↓reduceIte] using
BudgetedPreparedCompressionPass.complete I C B A P I.target z _ hn b hz
· exact ⟨false, b, by simp only [bucket, hp, ↓reduceIte, BudgetedSeparatorFlow.pure]⟩
· intro z b v rest hz
by_cases hp : z < P
· simp only [bucket, hp, ↓reduceIte] at hz
simpa only [bill, hp, ↓reduceIte] using
BudgetedPreparedCompressionPass.remaining I C B A P I.target z _ hn b v rest hz
· simp only [bucket, hp, ↓reduceIte, BudgetedSeparatorFlow.pure] at hz
cases hz
simp only [bill, hp, ↓reduceIte, Nat.add_zero, le_refl]
private theorem range_sum_fin (f : ℕ → ℕ) (count : ℕ) :
((List.range count).map f).sum = ∑ i : Fin count, f i.val := by
induction count with
| zero => simp
| succ count ih =>
rw [List.sum_range_succ, Fin.sum_univ_castSucc]
simpa only [Fin.val_castSucc, Fin.val_last] using congrArg (· + f count) ih
theorem allowance_eq (I : Instance n) (C B : ℕ) (A : Arrays) (P : ℕ) (hP : 0 < P) :
allowance I C B A P hP = 4 * (P + 1) +
∑ z : Fin P, BudgetedPreparedCompressionPass.allowance I C B A P I.target z.val
(by exact_mod_cast hP) := by
simp only [allowance, BudgetedResidueLoop.allowance_eq, Nat.zero_add, range_sum_fin]
congr 1
apply Finset.sum_congr rfl
intro z _
simp only [bill, z.isLt, ↓reduceIte]
end LowSpaceSubsetSum.BudgetedCompressionSchedule
namespace LowSpaceSubsetSum.CompressionData
open BudgetedSeparatorFlow
variable {n : ℕ} (D : CompressionData n)
theorem preparedSchedule_reference (B : ℕ) (e : Equiv.Perm (Fin n))
(q : CompressionSetup.PrimeSpace n) (z count : ℕ) :
BudgetedResidueLoop.reference
(fun z => if h : z < q.val then D.residuePass B e q ⟨z, h⟩ else false) z count =
CompressionSetup.residueLoop
(fun z => if h : z < q.val then D.residuePass B e q ⟨z, h⟩ else false) count z := by
induction count generalizing z with
| zero => rfl
| succ count ih =>
simp only [BudgetedResidueLoop.reference, CompressionSetup.residueLoop, ih]
theorem preparedSchedule_value (B : ℕ) (e : Equiv.Perm (Fin n))
(q : CompressionSetup.PrimeSpace n) (he : D.compactTests e = true)
(budget : ℕ) (v : Bool) (rest : ℕ)
(h : (BudgetedCompressionSchedule.run D.input (compressionDictionaryCapacity n) B
(PreparedCompressionPass.source D e) q.val (primeRange_prime q.property).pos budget).1 =
some (v, rest)) : v = D.compressionTrial B e q := by
have hv := BudgetedResidueLoop.value
(BudgetedCompressionSchedule.bucket D.input (compressionDictionaryCapacity n) B
(PreparedCompressionPass.source D e) q.val (primeRange_prime q.property).pos)
(fun z => if h : z < q.val then D.residuePass B e q ⟨z, h⟩ else false)
(by
intro z b v rest hz
by_cases hp : z < q.val
· simp only [BudgetedCompressionSchedule.bucket, hp, ↓reduceIte] at hz
simpa only [hp, ↓reduceDIte] using
(BudgetedPreparedCompressionPass.source_value D B e q ⟨z, hp⟩ he b v rest hz).1
· simp only [BudgetedCompressionSchedule.bucket, hp, ↓reduceIte,
BudgetedSeparatorFlow.pure] at hz
cases hz
simp only [hp, ↓reduceDIte]) 0 q.val budget 0 v rest h
exact hv.trans (D.preparedSchedule_reference B e q 0 q.val)
theorem preparedSchedule_account (e : Equiv.Perm (Fin n))
(q : CompressionSetup.PrimeSpace n) (he : D.compactTests e = true)
(hn : 10000 ≤ n) (budget : ℕ) :
Account budget (BudgetedCompressionSchedule.run D.input (compressionDictionaryCapacity n)
(representationBufferCapacity n) (PreparedCompressionPass.source D e) q.val
(primeRange_prime q.property).pos budget) := by
apply BudgetedResidueLoop.account
intro z b
by_cases hp : z < q.val
· simp only [BudgetedCompressionSchedule.bucket, hp, ↓reduceIte]
exact BudgetedPreparedCompressionPass.source_account D e q ⟨z, hp⟩ he b hn
· simp only [BudgetedCompressionSchedule.bucket, hp, ↓reduceIte]
exact pure_account false b
end LowSpaceSubsetSum.CompressionData
end OAI
|