| import OAI.Combinatorics.LowSpaceSubsetSum.Word.WordSamplingBounds |
| import OAI.Combinatorics.LowSpaceSubsetSum.Search.PreparedAsymptotics |
|
|
| namespace OAI |
|
|
| /-! # Finite random-word addresses fit the fixed machine word -/ |
|
|
| noncomputable section |
| namespace LowSpaceSubsetSum.WordAddressBounds |
|
|
| def roundReads (n : ℕ) : ℕ := n*n^3+n^3+WordRealization.historyReads n |
|
|
| def totalReads {n : ℕ} (I : Instance n) : ℕ := inputScale I^120*roundReads n |
|
|
| theorem round_reads {n : ℕ} (I : Instance n) (hn : 10000 ≤ n) : |
| roundReads n ≤ inputScale I^6*(compressionDictionaryCapacity n+1) := by |
| let u := inputScale I |
| let C := compressionDictionaryCapacity n |
| have hu : 10000 ≤ u := by unfold u inputScale; omega |
| have hnu : n ≤ u := by unfold u inputScale; omega |
| have hp : n*n^3+n^3 ≤ 2*u^4 := by |
| have h1 : n*n^3 ≤ u^4 := by |
| simpa only [←pow_succ'] using Nat.mul_le_mul hnu (Nat.pow_le_pow_left hnu 3) |
| have h2 : n^3 ≤ u^4 := (Nat.pow_le_pow_left hnu 3).trans |
| (Nat.pow_le_pow_right (by omega) (by decide : 3 ≤ 4)) |
| omega |
| have hh := WordSamplingBounds.history_reads I hn |
| change WordRealization.historyReads n ≤ u^5*(C+1) at hh |
| have hs : 2*u^4 ≤ u^5*(C+1) := by |
| have h1 : 2*u^4 ≤ u*u^4 := Nat.mul_le_mul_right _ (by omega) |
| have h2 : u^5 ≤ u^5*(C+1) := Nat.le_mul_of_pos_right _ (by omega) |
| rw [←pow_succ'] at h1 |
| exact h1.trans h2 |
| have hround : roundReads n ≤ 2*(u^5*(C+1)) := by |
| unfold roundReads |
| omega |
| apply hround.trans |
| calc |
| _ ≤ u*(u^5*(C+1)) := Nat.mul_le_mul_right _ (by omega) |
| _ = _ := by rw [←Nat.mul_assoc,←pow_succ'] |
|
|
| theorem total_reads {n : ℕ} (I : Instance n) (hn : 10000 ≤ n) : |
| totalReads I ≤ inputScale I^126*(compressionDictionaryCapacity n+1) := by |
| have h := Nat.mul_le_mul_left (inputScale I^120) (round_reads I hn) |
| simpa only [totalReads,←Nat.mul_assoc,←pow_add] using h |
|
|
| theorem total_limit {n : ℕ} (I : Instance n) (hn : 10000 ≤ n) |
| (hscale : Real.logb 2 (inputScale I : ℝ) ≤ (n : ℝ)/1000000000) : |
| totalReads I < 2^n := by |
| have hu : (0 : ℝ) < inputScale I := by |
| exact_mod_cast (show 0 < inputScale I by unfold inputScale; omega) |
| have hC : (1 : ℝ) ≤ compressionDictionaryCapacity n := by |
| exact_mod_cast (show 1 ≤ compressionDictionaryCapacity n from Nat.one_le_two_pow) |
| have hc := PreparedAsymptotics.capacity_upper n |
| have hsum : (compressionDictionaryCapacity n : ℝ)+1 ≤ |
| (2 : ℝ)^((199/1000 : ℝ)*n+1) := by |
| rw [Real.rpow_add (by norm_num : (0 : ℝ) < 2),Real.rpow_one] |
| linarith only [hC,hc] |
| have hs := mul_le_mul_of_nonneg_left hsum |
| (show 0 ≤ (inputScale I : ℝ)^126 by positivity) |
| have ht := guarded_polynomial_exponential hn hu hscale 126 |
| (a := (199/1000 : ℝ)) (by norm_num) |
| have hb : ((totalReads I : ℕ) : ℝ) ≤ |
| (inputScale I : ℝ)^126*((compressionDictionaryCapacity n : ℝ)+1) := by |
| exact_mod_cast total_reads I hn |
| have hfin := hb.trans_lt (hs.trans_lt ht) |
| exact_mod_cast hfin |
|
|
| theorem total_fits {n : ℕ} (I : Instance n) (hn : 10000 ≤ n) |
| (hscale : Real.logb 2 (inputScale I : ℝ) ≤ (n : ℝ)/1000000000) : |
| totalReads I < 2^wordWidth I := cutoff_fits_word I (total_limit I hn hscale) |
|
|
| end LowSpaceSubsetSum.WordAddressBounds |
|
|
| end |
|
|
| end OAI |
|
|
