| import OAI.Computability.DepthThree.LanguageParameterBounds |
| import OAI.Computability.DepthThree.SparseTailBounds |
| import OAI.Computability.DepthThree.HardSliceMoment |
| import OAI.Computability.DepthThree.HardSliceProbability |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| open Filter |
| open scoped Topology |
|
|
| namespace DepthThreeLowerBound |
|
|
| theorem sparseMomentBound_at_quarter (m b L h : ℕ) : |
| sparseMomentBound m b L h ((2 : ℝ) ^ (-(m : ℝ) / 4)) = |
| (Fintype.card (SparseTestCode (Fin m) b L) : ℝ) * |
| ((2 * h : ℕ) : ℝ) ^ (2 * h) * |
| (2 : ℝ) ^ (-((m : ℝ) * ((2 * h : ℕ) : ℝ)) / 4) := by |
| have hbase : ((2 ^ m : ℕ) : ℝ) = (2 : ℝ) ^ (m : ℝ) := by simp |
| have hratio : ((2 ^ m : ℕ) : ℝ) ^ h / |
| (((2 : ℝ) ^ (-(m : ℝ) / 4)) * ((2 ^ m : ℕ) : ℝ)) ^ (2 * h) = |
| (2 : ℝ) ^ (-((m : ℝ) * ((2 * h : ℕ) : ℝ)) / 4) := by |
| rw [hbase, ← Real.rpow_add (by norm_num : (0 : ℝ) < 2), |
| ← Real.rpow_mul_natCast (by norm_num : (0 : ℝ) ≤ 2), |
| ← Real.rpow_mul_natCast (by norm_num : (0 : ℝ) ≤ 2), |
| ← Real.rpow_sub (by norm_num : (0 : ℝ) < 2)] |
| congr 1 |
| push_cast |
| ring |
| have hcard : (Fintype.card (SparseTestCode (Fin m) b L) : ℝ) = |
| ((((2 * m + 1) ^ b + 1) ^ L : ℕ) : ℝ) := by |
| simp only [SparseTestCode.card_eq, Fintype.card_fin] |
| unfold sparseMomentBound |
| rw [← hcard, mul_div_assoc, hratio] |
| ring |
|
|
| theorem sparseMomentBound_quarter_le (m b M h : ℕ) (hm : 0 < m) (hh : 0 < h) |
| (hcond : (M : ℝ) * |
| (1 + (b : ℝ) * (Real.log (2 * (m : ℝ) + 1) / Real.log 2)) / |
| ((2 * h : ℕ) : ℝ) + (Real.log ((2 * h : ℕ) : ℝ) / Real.log 2) / |
| (m : ℝ) ≤ 1 / 8) : |
| sparseMomentBound m b (M * m) h ((2 : ℝ) ^ (-(m : ℝ) / 4)) ≤ |
| (2 : ℝ) ^ (-((m : ℝ) * ((2 * h : ℕ) : ℝ)) / 8) := by |
| rw [sparseMomentBound_at_quarter] |
| simpa only [Fintype.card_fin] using |
| sparse_moment_union_le (V := Fin m) b M (2 * h) |
| (by simpa only [Fintype.card_fin] using hm) |
| (Nat.mul_pos (by decide) hh) |
| (by simpa only [Fintype.card_fin] using hcond) |
|
|
| theorem exists_hashDimension_dominates (B : ℝ) : |
| ∃ D : ℕ, 1 ≤ D ∧ ∀ d : ℕ, D ≤ d → |
| (33 / 16 : ℝ) * (B * Real.sqrt (d : ℝ)) ≤ (hashDimension d : ℝ) := by |
| have hg : ∀ᶠ x : ℝ in atTop, (33 / 16 : ℝ) * B ≤ x ^ (1 / 6 : ℝ) := |
| (tendsto_rpow_atTop (by norm_num : (0 : ℝ) < 1 / 6)).eventually |
| (eventually_ge_atTop ((33 / 16 : ℝ) * B)) |
| obtain ⟨R, hR⟩ := eventually_atTop.mp hg |
| obtain ⟨D, hD⟩ := exists_nat_ge (max 1 R) |
| have hDone : (1 : ℝ) ≤ (D : ℝ) := (le_max_left 1 R).trans hD |
| refine ⟨D, by exact_mod_cast hDone, ?_⟩ |
| intro d hd |
| have hDd : (D : ℝ) ≤ (d : ℝ) := by exact_mod_cast hd |
| have hdpos : (0 : ℝ) < d := lt_of_lt_of_le zero_lt_one (hDone.trans hDd) |
| have hpower := hR (d : ℝ) ((le_max_right 1 R).trans (hD.trans hDd)) |
| calc |
| _ = ((33 / 16 : ℝ) * B) * Real.sqrt (d : ℝ) := by ring |
| _ ≤ (d : ℝ) ^ (1 / 6 : ℝ) * Real.sqrt (d : ℝ) := |
| mul_le_mul_of_nonneg_right hpower (Real.sqrt_nonneg _) |
| _ = (d : ℝ) ^ (2 / 3 : ℝ) := by |
| rw [Real.sqrt_eq_rpow, ← Real.rpow_add hdpos] |
| norm_num |
| _ ≤ (hashDimension d : ℝ) := hashDimension_rpow_lower d |
|
|
| theorem hard_slice_error_bound_eventually (b M : ℕ) (B : ℝ) (hB : 0 < B) : |
| ∃ D : ℕ, 4096 ≤ D ∧ ∀ d : ℕ, D ≤ d → ∀ m h : ℕ, |
| B * Real.sqrt (d : ℝ) / 2 ≤ (m : ℝ) → |
| (m : ℝ) ≤ 2 * (B * Real.sqrt (d : ℝ)) → |
| 2 * h = independenceOrder d → |
| (2 : ℝ) ^ ((m : ℝ) - (hashDimension d : ℝ)) + |
| sparseMomentBound m b (M * m) h ((2 : ℝ) ^ (-(m : ℝ) / 4)) ≤ |
| 2 * (2 : ℝ) ^ (-(B * Real.sqrt (d : ℝ)) / 16) := by |
| obtain ⟨Ds, hDs, hSparse⟩ := uniform_sparse_condition (b : ℝ) (M : ℝ) B |
| (Nat.cast_nonneg _) (Nat.cast_nonneg _) hB |
| obtain ⟨Dr, hDr, hHash⟩ := exists_hashDimension_dominates B |
| refine ⟨max 4096 (max Ds Dr), le_max_left _ _, ?_⟩ |
| intro d hd m h hmlo hmhi heven |
| have hd4096 : 4096 ≤ d := (le_max_left _ _).trans hd |
| have hds : Ds ≤ d := (le_max_left Ds Dr).trans ((le_max_right _ _).trans hd) |
| have hdr : Dr ≤ d := (le_max_right Ds Dr).trans ((le_max_right _ _).trans hd) |
| have hdpos : (0 : ℝ) < d := by exact_mod_cast (by omega : 0 < d) |
| have hμ : 0 < B * Real.sqrt (d : ℝ) := mul_pos hB (Real.sqrt_pos.2 hdpos) |
| have hmpos : 0 < m := by |
| have hmp : (0 : ℝ) < m := lt_of_lt_of_le (by linarith : 0 < B * Real.sqrt (d : ℝ) / 2) hmlo |
| exact_mod_cast hmp |
| have ht2 : 2 ≤ independenceOrder d := (independenceOrder_two_le_iff d).2 (by omega) |
| have htone : (1 : ℝ) ≤ (independenceOrder d : ℝ) := by |
| exact_mod_cast (by omega : 1 ≤ independenceOrder d) |
| have hh : 0 < h := by omega |
| have hcond := hSparse (d : ℝ) (by exact_mod_cast hds) |
| (m : ℝ) (independenceOrder d : ℝ) hmlo |
| (by nlinarith [hmhi]) (half_rpow_le_independenceOrder d hd4096) |
| (independenceOrder_rpow_le d) htone |
| have hsparse : sparseMomentBound m b (M * m) h ((2 : ℝ) ^ (-(m : ℝ) / 4)) ≤ |
| (2 : ℝ) ^ (-((m : ℝ) * (independenceOrder d : ℝ)) / 8) := by |
| simpa only [heven] using sparseMomentBound_quarter_le m b M h hmpos hh |
| (by simpa only [heven] using hcond) |
| have htails := hard_slice_tail_bounds (B * Real.sqrt (d : ℝ)) (m : ℝ) |
| (hashDimension d : ℝ) (independenceOrder d : ℝ) hμ.le hmlo hmhi (hHash d hdr) htone |
| calc |
| _ ≤ (2 : ℝ) ^ ((m : ℝ) - (hashDimension d : ℝ)) + |
| (2 : ℝ) ^ (-((m : ℝ) * (independenceOrder d : ℝ)) / 8) := |
| add_le_add_right hsparse _ |
| _ ≤ (2 : ℝ) ^ (-(B * Real.sqrt (d : ℝ)) / 16) + |
| (2 : ℝ) ^ (-(B * Real.sqrt (d : ℝ)) / 16) := add_le_add htails.1 htails.2 |
| _ = _ := by ring |
|
|
| theorem hash_collision_ratio_eq (m r : ℕ) : |
| (2 : ℝ) ^ m / (2 : ℝ) ^ r = (2 : ℝ) ^ ((m : ℝ) - (r : ℝ)) := by |
| simpa only [Real.rpow_natCast] using |
| (Real.rpow_sub (by norm_num : (0 : ℝ) < 2) (m : ℝ) (r : ℝ)).symm |
|
|
| theorem actual_hard_slice_error_bound_eventually (b : ℕ) (hb : 1 ≤ b) |
| (B : ℝ) (hB : 0 < B) : |
| ∃ D : ℕ, 4096 ≤ D ∧ ∀ d : ℕ, D ≤ d → ∀ m h : ℕ, |
| B * Real.sqrt (d : ℝ) / 2 ≤ (m : ℝ) → |
| (m : ℝ) ≤ 2 * (B * Real.sqrt (d : ℝ)) → |
| 2 * h = independenceOrder d → |
| (2 : ℝ) ^ m / (2 : ℝ) ^ hashDimension d + |
| sparseMomentBound m b (hardSliceSparseConstant b hb * m) h |
| ((2 : ℝ) ^ (-(m : ℝ) / 4)) ≤ |
| 2 * (2 : ℝ) ^ (-(B * Real.sqrt (d : ℝ)) / 16) := by |
| obtain ⟨D, hD, hbound⟩ := |
| hard_slice_error_bound_eventually b (hardSliceSparseConstant b hb) B hB |
| refine ⟨D, hD, ?_⟩ |
| intro d hd m h hmlo hmhi heven |
| rw [hash_collision_ratio_eq] |
| exact hbound d hd m h hmlo hmhi heven |
|
|
| end DepthThreeLowerBound |
|
|
| end |
|
|
| end OAI |
|
|
