| import OAI.Computability.DepthThree.HardSliceExistence |
| import OAI.Computability.DepthThree.HardSliceParameters |
| import OAI.Computability.DepthThree.FinalParameterBounds |
| import OAI.Computability.DepthThree.IrreducibleEncoding |
| import OAI.Computability.DepthThree.LanguageSlice |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| open scoped BigOperators Classical |
|
|
| namespace DepthThreeLowerBound |
|
|
| theorem exists_good_language_slice_eventually (b : ℕ) (hb : 1 ≤ b) |
| (B : ℝ) (hB : 0 < B) : |
| ∃ N : ℕ, 20480 ≤ N ∧ ∀ n : ℕ, N ≤ n → |
| ∃ α : Fin n → Sum (Fin (dataDimension n)) Bool, |
| restrictionAvg (liveProbability B (dataDimension n)) (fun σ => |
| if ¬ goodRestriction (liveProbability B (dataDimension n)) |
| ((2 : ℝ) ^ (-(B * Real.sqrt (dataDimension n : ℝ)) / 16)) b |
| (fun x => language (List.ofFn (GateInput.assignment α x))) σ |
| then 1 else 0) ≤ |
| 4 * (2 : ℝ) ^ (-(B * Real.sqrt (dataDimension n : ℝ)) / 16) := by |
| obtain ⟨De, hDe, herr⟩ := actual_hard_slice_error_bound_eventually b hb B hB |
| obtain ⟨Dp, hDp, hprob⟩ := exists_liveProbability_threshold B hB |
| let D := max De Dp |
| refine ⟨5 * D, ?_, ?_⟩ |
| · have hbig : 4096 ≤ D := hDe.trans (le_max_left _ _) |
| omega |
| intro n hn |
| let d := dataDimension n |
| have hDd : D ≤ d := by |
| dsimp [d, dataDimension] |
| omega |
| have hde : De ≤ d := (le_max_left _ _).trans hDd |
| have hdp : Dp ≤ d := (le_max_right _ _).trans hDd |
| have hd4096 : 4096 ≤ d := hDe.trans hde |
| have hdpos : 0 < d := by omega |
| have hr : 0 < hashDimension d := hashDimension_pos hdpos |
| have ht2 : 2 ≤ independenceOrder d := (independenceOrder_two_le_iff d).mpr (by omega) |
| obtain ⟨h, hh⟩ := independenceOrder_even d |
| have heven : 2 * h = independenceOrder d := by omega |
| have hhpos : 0 < h := by omega |
| obtain ⟨hq0, hqhalf⟩ := hprob d hdp |
| have hq1 : liveProbability B d ≤ 1 := by linarith |
| obtain ⟨p, hp⟩ := exists_irreducible_inputPolynomialBits (hashDimension d) hr |
| let : Fact (Irreducible (BinaryAlgebra.inputPolynomialBits p)) := ⟨hp⟩ |
| have hbound (m : ℕ) |
| (hmlo : (liveProbability B d * d) / 2 ≤ (m : ℝ)) |
| (hmhi : (m : ℝ) ≤ 2 * (liveProbability B d * d)) : |
| (2 : ℝ) ^ m / (2 : ℝ) ^ hashDimension d + |
| sparseMomentBound m b (hardSliceSparseConstant b hb * m) h |
| ((2 : ℝ) ^ (-(m : ℝ) / 4)) ≤ |
| 2 * (2 : ℝ) ^ (-(liveProbability B d * d) / 16) := by |
| rw [liveProbability_mul_dimension B d hdpos] at hmlo hmhi ⊢ |
| exact herr d hde m h hmlo hmhi heven |
| have hex : ∃ (u : Fin (d + hashDimension d - 1) → Bool) |
| (β : Fin (independenceOrder d) → BinaryAlgebra.BitQuotient p), |
| restrictionAvg (liveProbability B d) (fun σ => |
| if ¬ goodRestriction (liveProbability B d) |
| ((2 : ℝ) ^ (-(B * Real.sqrt (d : ℝ)) / 16)) b |
| (hashAcceptance p (independenceOrder d) u β) σ then 1 else 0) ≤ |
| 4 * (2 : ℝ) ^ (-(B * Real.sqrt (d : ℝ)) / 16) := by |
| rw [← heven] |
| simpa only [liveProbability_mul_dimension B d hdpos] using |
| exists_good_hash_coefficients p hr hb hhpos (liveProbability B d) hq0.le hq1 hbound |
| obtain ⟨u, β, hβ⟩ := hex |
| let c := coefficientInputBits p β |
| let α : Fin n → Sum (Fin (dataDimension n)) Bool := canonicalSlice n u p c |
| have hfit : blockLen d ≤ n := |
| (blockLen_le_five_mul d hd4096).trans (five_mul_dataDimension_le n) |
| have heval : (fun x => language (List.ofFn (GateInput.assignment α x))) = |
| hashAcceptance p (independenceOrder d) u β := by |
| funext x |
| rw [language_canonicalSlice_acceptEval n u p c x hdpos ht2 hfit] |
| change hashAcceptance p (independenceOrder d) u |
| (fun j => BinaryAlgebra.encode (fun i => BinaryAlgebra.bitValue (p i)) |
| (fun i => BinaryAlgebra.bitValue (coefficientInputBits p β j i))) x = _ |
| rw [hashAcceptance_coefficientInputBits] |
| refine ⟨α, ?_⟩ |
| rw [heval] |
| exact hβ |
|
|
| end DepthThreeLowerBound |
|
|
| end |
|
|
| end OAI |
|
|
