File size: 3,053 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 | import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionSampleArrays
import OAI.Combinatorics.LowSpaceSubsetSum.Storage.PermutationSamplerCells
namespace OAI
/-! # Live storage for the bounded compression sample
The accepted digits are materialized once. The prime candidate tuple is
retained, but not searched, when the digit sampler fails. Ideal backup
values remain proof data and do not select an execution branch.
-/
noncomputable section
namespace LowSpaceSubsetSum.CompressionSampleCells
variable {n : ℕ}
def run (D : CompressionData n) (hn : 168000000 ≤ n) (s : (D.sampler hn).Seed) :
(Option (Vector (Fin n) n × CompressionSetup.PrimeSpace n) × ℕ) × ℕ :=
let digits := PermutationSamplerCells.run n n s.1
match digits.1.value with
| none => ((none, digits.1.reads+digits.1.tests+1), digits.2+3*n^3+128)
| some d =>
let v := PermutationArray.build n d
let q := SamplerVectorCells.primeSeed
(show 4 ≤ compressionPrimeExponent n by unfold compressionPrimeExponent; omega) n s.2
((q.1.value.map (fun q => (v.1, q)),
digits.1.reads+digits.1.tests+v.2+q.1.reads+q.1.tests+3),
digits.2+PermutationArray.peakCells n+q.2+4*n+64)
theorem value (D : CompressionData n) (hn : 168000000 ≤ n) (s : (D.sampler hn).Seed) :
(run D hn s).1 = CompressionSampleArrays.run D hn s := by
simp only [run, CompressionSampleArrays.run, PermutationSamplerCells.run_value,
SamplerVectorCells.primeSeed_value, CompressionSampleArrays.prime]
split <;> simp_all only
theorem cells (D : CompressionData n) (hn : 168000000 ≤ n) (s : (D.sampler hn).Seed) :
(run D hn s).2 ≤ (n+1)*(3*n^3+256) := by
have hd := PermutationSamplerCells.run_cells n n s.1
have hp := PermutationArray.peakCells_bound n
have hq := SamplerVectorCells.primeSeed_cells
(show 4 ≤ compressionPrimeExponent n by unfold compressionPrimeExponent; omega) n s.2
simp only [run]
split <;> dsimp only <;>
nlinarith only [hd, hp, hq, Nat.zero_le (n^3)]
theorem cells_scale (D : CompressionData n) (hn : 168000000 ≤ n)
(s : (D.sampler hn).Seed) : (run D hn s).2 ≤ inputScale D.input^5 := by
have hu : n+1 ≤ inputScale D.input := by unfold inputScale; omega
have hu0 : 10000 ≤ inputScale D.input := by omega
have hc := Nat.pow_le_pow_left (show n ≤ inputScale D.input by omega) 3
have hu3 : inputScale D.input ≤ inputScale D.input^3 := by
simpa only [pow_one] using pow_le_pow_right' (by omega : 1 ≤ inputScale D.input)
(by decide : 1 ≤ 3)
have ht : 3*n^3+256 ≤ 4*inputScale D.input^3 := by
nlinarith only [hc, hu0, hu3]
have hm := Nat.mul_le_mul hu ht
have hm' : (n+1)*(3*n^3+256) ≤ 4*inputScale D.input^4 := by
convert hm using 1; ring
have hp : 4*inputScale D.input^4 ≤ inputScale D.input^5 := by
calc
_ ≤ inputScale D.input*inputScale D.input^4 := Nat.mul_le_mul_right _ (by omega)
_ = _ := (pow_succ' _ _).symm
exact (cells D hn s).trans (hm'.trans hp)
end LowSpaceSubsetSum.CompressionSampleCells
end
end OAI
|