| import OAI.Computability.DepthThree.HardSliceMoment |
| import OAI.Computability.DepthThree.SparseCorrelation |
| import OAI.Computability.DepthThree.HashProbability |
| import OAI.Computability.DepthThree.AlgebraQuotient |
| import Mathlib.Tactic.Positivity |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| open scoped BigOperators Classical |
|
|
| namespace DepthThreeLowerBound |
|
|
| def hardSliceSparseConstant (b : ℕ) (hb : 1 ≤ b) : ℕ := |
| Classical.choose (exists_sparse_correlation_constant.{0} b hb) |
|
|
| theorem hardSliceSparseConstant_pos (b : ℕ) (hb : 1 ≤ b) : |
| 0 < hardSliceSparseConstant b hb := |
| (Classical.choose_spec (exists_sparse_correlation_constant.{0} b hb)).1 |
|
|
| theorem hardSliceSparseConstant_spec (b : ℕ) (hb : 1 ≤ b) |
| (V : Type) [Fintype V] [DecidableEq V] (G : Cube V → ℝ) |
| (htests : ∀ H : CNF V, H.Normalized → H.WidthAtMost b → |
| H.length ≤ hardSliceSparseConstant b hb * Fintype.card V → |
| |finiteAvg (fun x => G x * indicator (H.eval x))| ≤ |
| (2 : ℝ) ^ (-(Fintype.card V : ℝ) / 4)) : |
| corr b G ≤ (2 : ℝ) ^ (-(Fintype.card V : ℝ) / 8) := |
| (Classical.choose_spec (exists_sparse_correlation_constant.{0} b hb)).2 V G htests |
|
|
| theorem sparseMomentBound_nonneg (m b L h : ℕ) (δ : ℝ) : |
| 0 ≤ sparseMomentBound m b L h δ := by |
| unfold sparseMomentBound |
| apply mul_nonneg (Nat.cast_nonneg _) |
| apply div_nonneg |
| · positivity |
| · rw [pow_mul] |
| exact pow_nonneg (sq_nonneg (δ * ((2 ^ m : ℕ) : ℝ))) h |
|
|
| theorem coefficient_corr_failure_le {F V : Type} [Field F] |
| [Module BinaryAlgebra.F2 F] [Fintype F] [Fintype V] |
| (ell : F →ₗ[BinaryAlgebra.F2] BinaryAlgebra.F2) (hOne : ell 1 = 1) |
| (a : Cube V → F) (ha : Function.Injective a) |
| (b : ℕ) (hb : 1 ≤ b) (h : ℕ) (hh : 0 < h) : |
| finiteProb (fun β : Fin (2 * h) → F => |
| ¬ corr b (fun x => sign (Interpolation.acceptEval ell (2 * h) a β x)) ≤ |
| (2 : ℝ) ^ (-(Fintype.card V : ℝ) / 8)) ≤ |
| sparseMomentBound (Fintype.card V) b |
| (hardSliceSparseConstant b hb * Fintype.card V) h |
| ((2 : ℝ) ^ (-(Fintype.card V : ℝ) / 4)) := by |
| apply le_trans _ (coefficient_sparse_cnfs_gt_le ell hOne a ha b |
| (hardSliceSparseConstant b hb * Fintype.card V) h hh |
| ((2 : ℝ) ^ (-(Fintype.card V : ℝ) / 4)) (Real.rpow_pos_of_pos (by norm_num) _)) |
| apply finiteProb_mono |
| intro β hβ |
| by_contra hnone |
| apply hβ |
| apply hardSliceSparseConstant_spec b hb V |
| intro H _ hw hlen |
| by_contra hfail |
| exact hnone ⟨H, hw, hlen, lt_of_not_ge hfail⟩ |
|
|
| theorem hash_coefficient_corr_failure_le {F V U : Type} [Field F] |
| [Module BinaryAlgebra.F2 F] [Fintype F] [Fintype V] |
| [Fintype U] [Nonempty U] |
| (ell : F →ₗ[BinaryAlgebra.F2] BinaryAlgebra.F2) (hOne : ell 1 = 1) |
| (a : U → Cube V → F) (b : ℕ) (hb : 1 ≤ b) (h : ℕ) (hh : 0 < h) : |
| finiteProb (fun ω : U × (Fin (2 * h) → F) => |
| ¬ corr b (fun x => sign (Interpolation.acceptEval ell (2 * h) (a ω.1) ω.2 x)) ≤ |
| (2 : ℝ) ^ (-(Fintype.card V : ℝ) / 8)) ≤ |
| finiteProb (fun u => ¬ Function.Injective (a u)) + |
| sparseMomentBound (Fintype.card V) b |
| (hardSliceSparseConstant b hb * Fintype.card V) h |
| ((2 : ℝ) ^ (-(Fintype.card V : ℝ) / 4)) := by |
| let B := sparseMomentBound (Fintype.card V) b |
| (hardSliceSparseConstant b hb * Fintype.card V) h |
| ((2 : ℝ) ^ (-(Fintype.card V : ℝ) / 4)) |
| have hB : 0 ≤ B := sparseMomentBound_nonneg _ _ _ _ _ |
| change finiteAvg _ ≤ finiteProb _ + B |
| rw [finiteAvg_product] |
| calc |
| _ ≤ finiteAvg (fun u : U => (if ¬ Function.Injective (a u) then 1 else 0) + B) := by |
| apply finiteAvg_mono |
| intro u |
| by_cases hu : Function.Injective (a u) |
| · simpa only [finiteProb, B, hu, not_true_eq_false, ite_false, zero_add] using |
| coefficient_corr_failure_le ell hOne (a u) hu b hb h hh |
| · have hone := finiteProb_le_one (fun β : Fin (2 * h) → F => |
| ¬ corr b (fun x => sign (Interpolation.acceptEval ell (2 * h) (a u) β x)) ≤ |
| (2 : ℝ) ^ (-(Fintype.card V : ℝ) / 8)) |
| simpa only [finiteProb, hu, not_false_eq_true, ite_true] using |
| hone.trans (le_add_of_nonneg_right hB) |
| _ = finiteProb (fun u => ¬ Function.Injective (a u)) + B := by |
| rw [finiteAvg_add, finiteAvg_const] |
| apply congrArg (fun z : ℝ => z + B) |
| apply finiteAvg_congr |
| intro u |
| exact (ite_eq_ite _ _ _).mpr trivial |
|
|
| def encodedHash {d r : ℕ} (p : Fin r → Bool) |
| (u : Fin (d + r - 1) → Bool) (x : Cube (Fin d)) : BinaryAlgebra.BitQuotient p := |
| BinaryAlgebra.encode (fun i => BinaryAlgebra.bitValue (p i)) |
| (fun i => BinaryAlgebra.bitValue (BinaryHash.hashBool u x i)) |
|
|
| theorem encodedHash_fill_injective {d r : ℕ} (p : Fin r → Bool) |
| (u : Fin (d + r - 1) → Bool) (σ : Restriction (Fin d)) |
| (hu : Function.Injective (fun z : Cube (Live σ) => BinaryHash.hashBool u (fill σ z))) : |
| Function.Injective (fun z : Cube (Live σ) => encodedHash p u (fill σ z)) := by |
| intro x y hxy |
| apply hu |
| apply (BinaryAlgebra.bitsEquivF2 (Fin r)).injective |
| exact BinaryAlgebra.encode_injective _ hxy |
|
|
| def hashAcceptance {d r : ℕ} (p : Fin r → Bool) |
| [Fact (Irreducible (BinaryAlgebra.inputPolynomialBits p))] |
| (t : ℕ) (u : Fin (d + r - 1) → Bool) |
| (β : Fin t → BinaryAlgebra.BitQuotient p) : Cube (Fin d) → Bool := |
| Interpolation.acceptEval |
| (BinaryAlgebra.degreeZero (BinaryAlgebra.inputPolynomialBits_monic p)) t |
| (encodedHash p u) β |
|
|
| theorem actual_hash_coefficient_failure_le {d r : ℕ} (p : Fin r → Bool) |
| [Fact (Irreducible (BinaryAlgebra.inputPolynomialBits p))] |
| (hr : 0 < r) (σ : Restriction (Fin d)) |
| (b : ℕ) (hb : 1 ≤ b) (h : ℕ) (hh : 0 < h) : |
| finiteProb (fun ω : (Fin (d + r - 1) → Bool) × |
| (Fin (2 * h) → BinaryAlgebra.BitQuotient p) => |
| ¬ corr b (fun z => sign (hashAcceptance p (2 * h) ω.1 ω.2 (fill σ z))) ≤ |
| (2 : ℝ) ^ (-(Fintype.card (Live σ) : ℝ) / 8)) ≤ |
| (2 : ℝ) ^ Fintype.card (Live σ) / (2 : ℝ) ^ r + |
| sparseMomentBound (Fintype.card (Live σ)) b |
| (hardSliceSparseConstant b hb * Fintype.card (Live σ)) h |
| ((2 : ℝ) ^ (-(Fintype.card (Live σ) : ℝ) / 4)) := by |
| let : Field (BinaryAlgebra.BitQuotient p) := |
| AdjoinRoot.instField (f := BinaryAlgebra.inputPolynomialBits p) |
| let : Module BinaryAlgebra.F2 (BinaryAlgebra.BitQuotient p) := |
| inferInstanceAs (Module BinaryAlgebra.F2 |
| (AdjoinRoot (BinaryAlgebra.inputPolynomialBits p))) |
| have hOne : BinaryAlgebra.degreeZero (BinaryAlgebra.inputPolynomialBits_monic p) |
| (1 : BinaryAlgebra.BitQuotient p) = 1 := |
| BinaryAlgebra.degreeZero_one _ (by simpa using hr) |
| have hhash : finiteProb (fun u : Fin (d + r - 1) → Bool => |
| ¬ Function.Injective (fun z : Cube (Live σ) => encodedHash p u (fill σ z))) ≤ |
| (2 : ℝ) ^ Fintype.card (Live σ) / (2 : ℝ) ^ r := by |
| apply le_trans _ (BinaryHash.hashBool_restriction_failure_le_pow (r := r) σ) |
| apply finiteProb_mono |
| intro u hu hinj |
| exact hu (encodedHash_fill_injective p u σ hinj) |
| exact (hash_coefficient_corr_failure_le (F := BinaryAlgebra.BitQuotient p) |
| (V := Live σ) (U := Fin (d + r - 1) → Bool) |
| (BinaryAlgebra.degreeZero (BinaryAlgebra.inputPolynomialBits_monic p)) hOne |
| (fun u z => encodedHash p u (fill σ z)) b hb h hh).trans |
| (add_le_add_left hhash _) |
|
|
| end DepthThreeLowerBound |
|
|
| end |
|
|
| end OAI |
|
|
