File size: 4,667 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 | import OAI.Combinatorics.LowSpaceSubsetSum.Separators.SeparatorParameters
import OAI.Combinatorics.LowSpaceSubsetSum.Counting.CountedBinomial
import OAI.Combinatorics.LowSpaceSubsetSum.Streams.MeasuredLog2
namespace OAI
/-! # Integer execution of the separator sizes and sample counts
A constant-state power loop and binary-log loop compute the prescribed
sample size. Five multiplicative binomial loops and four integer ceiling
divisions compute the actual family-array lengths.
-/
namespace LowSpaceSubsetSum.SeparatorParameterExecution
open scoped BigOperators
def powerLoop : ℕ → ℕ → ℕ → ℕ × ℕ
| 0, value, work => (value, work + 1)
| fuel + 1, value, work => powerLoop fuel (value * 3) (work + 3)
theorem powerLoop_formula (fuel value work : ℕ) :
powerLoop fuel value work = (value * 3 ^ fuel, work + 3 * fuel + 1) := by
induction fuel generalizing value work with
| zero => simp [powerLoop]
| succ fuel ih =>
simp only [powerLoop, ih, pow_succ]
congr 1 <;> ring
theorem three_power_bound (m : ℕ) : 3 ^ m ≤ 2 ^ (2 * m) := by
calc
3 ^ m ≤ 4 ^ m := Nat.pow_le_pow_left (by decide) m
_ = 2 ^ (2 * m) := by rw [pow_mul]; rfl
def logBits (m : ℕ) : ℕ × ℕ :=
let power := powerLoop m 1 0
let bits := MeasuredLog2.run (2 * m) power.1
(bits.1, power.2 + bits.2 + 2)
theorem logBits_value (m : ℕ) : (logBits m).1 = SeparatorParameters.logBits m := by
simp only [logBits, powerLoop_formula, one_mul]
rw [MeasuredLog2.run_value _ _ (three_power_bound m), Nat.log2_eq_log_two]
rfl
theorem logBits_work (m : ℕ) : (logBits m).2 ≤ 9 * m + 4 := by
have h := MeasuredLog2.run_work (2 * m) (3 ^ m)
simp only [logBits, powerLoop_formula, one_mul, zero_add]
omega
def sample (g k : ℕ) : ℕ × ℕ :=
let bits := logBits (4 * g)
((8 * g * g - bits.1 * (g - k)) / (16 * g), bits.2 + 12)
theorem sample_value (g k : ℕ) : (sample g k).1 = SeparatorParameters.sampleSize g k := by
simp only [sample, logBits_value, SeparatorParameters.sampleSize]
theorem sample_work (g k : ℕ) : (sample g k).2 ≤ 36 * g + 16 := by
have h := logBits_work (4 * g)
change _ + 12 ≤ _
omega
def families (g k e : ℕ) : Vector ℕ 4 × ℕ :=
let numerator := CountedBinomial.run g e
let denominators := Vector.ofFn (fun i : Fin 4 =>
CountedBinomial.run (g / 2) (e - balancedBlockCounts 4 k i))
(Vector.ofFn (fun i : Fin 4 => (10 * numerator.value) ⌈/⌉ denominators[i.val].value),
8 * numerator.steps + (∑ i : Fin 4, 8 * denominators[i.val].steps + 6) + 10)
theorem families_value (g k e : ℕ) (i : Fin 4) :
(families g k e).1[i.val] =
(10 * g.choose e) ⌈/⌉ (g / 2).choose (e - balancedBlockCounts 4 k i) := by
simp only [families, Vector.getElem_ofFn, CountedBinomial.run_value]
theorem families_work (g k e : ℕ) : (families g k e).2 ≤ 24 * g + 34 := by
have hn := CountedBinomial.run_steps g e
have hs := Finset.sum_le_sum (fun i (_ : i ∈ (Finset.univ : Finset (Fin 4))) =>
Nat.mul_le_mul_left 8
(CountedBinomial.run_steps (g / 2) (e - balancedBlockCounts 4 k i)))
simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, smul_eq_mul] at hs
have hd : 2 * (g / 2) ≤ g := by omega
change 8 * (CountedBinomial.run g e).steps +
(∑ i : Fin 4, 8 * (CountedBinomial.run (g / 2) (e - balancedBlockCounts 4 k i)).steps + 6) + 10 ≤ _
omega
structure Data where
size : ℕ
counts : Vector ℕ 4
def run (g k : ℕ) : Data × ℕ :=
let e := sample g k
let counts := families g k e.1
(⟨e.1, counts.1⟩, e.2 + counts.2 + 1)
theorem size_value (g k : ℕ) : (run g k).1.size = SeparatorParameters.sampleSize g k :=
sample_value g k
theorem counts_value (g k : ℕ) (i : Fin 4) :
(run g k).1.counts[i.val] = SeparatorParameters.familyCount g k i := by
simp only [run, sample_value, families_value, SeparatorParameters.familyCount]
theorem work (g k : ℕ) : (run g k).2 ≤ 60 * g + 51 := by
have he := sample_work g k
have hc := families_work g k (sample g k).1
change _ + _ + 1 ≤ _
omega
theorem rounded_size (g k : ℕ) (hg : 64 ≤ g) (heven : 2 ∣ g)
(hk : k ≤ g) (hklo : 2 * g ≤ 3 * k) (i : Fin 4) :
(run g k).1.size = (SeparatorParameters.rounded g k hg heven hk hklo).e i :=
size_value g k
theorem rounded_counts (g k : ℕ) (hg : 64 ≤ g) (heven : 2 ∣ g)
(hk : k ≤ g) (hklo : 2 * g ≤ 3 * k) (i : Fin 4) :
(run g k).1.counts[i.val] = (SeparatorParameters.rounded g k hg heven hk hklo).counts i := by
rw [counts_value, SeparatorParameters.familyCount_eq g k hg heven hk hklo]
end LowSpaceSubsetSum.SeparatorParameterExecution
end OAI
|