| import OAI.Combinatorics.GotsmanLinial.Statement |
| import OAI.Combinatorics.GotsmanLinial.BlockCoupling |
| import OAI.Combinatorics.GotsmanLinial.Commutator |
| import OAI.Combinatorics.GotsmanLinial.CubeOperators |
| import OAI.Combinatorics.GotsmanLinial.EdgeRecovery |
| import OAI.Combinatorics.GotsmanLinial.GradingShift |
| import OAI.Combinatorics.GotsmanLinial.BlockVanishing |
| import Mathlib.Tactic.Ring |
|
|
| namespace OAI |
|
|
| /-! |
| # Assembly of the Gotsman |
|
|
| The first lemmas are explicitly conditional assembly bridges. The final |
| theorems discharge their matrix and counting hypotheses using the concrete |
| weighted Boolean-cube grading and a sign-preserving constant perturbation. |
| -/ |
|
|
| namespace LeanBlast.GotsmanLinial |
|
|
| open scoped BigOperators |
|
|
| / |
| normalizing by the number of cube vertices. This is only a scalar bridge. -/ |
| theorem normalized_edge_bound {N C T a : ℝ} (hN : 0 < N) |
| (hedge : C ≤ 2 * T) (henergy : T ≤ 4 * a * N) : |
| C / N ≤ 8 * a := by |
| apply (div_le_iff₀ hN).mpr |
| calc |
| C ≤ 2 * T := hedge |
| _ ≤ 2 * (4 * a * N) := mul_le_mul_of_nonneg_left henergy (by norm_num) |
| _ = 8 * a * N := by ring |
|
|
| / |
| energy estimate into the desired sensitivity inequality. The counting and energy premises are explicit. -/ |
| theorem sensitivity_bound_of_counting_energy {n d : ℕ} |
| (f : Cube n → ℝ) (C T : ℝ) |
| (hcount : averageSensitivity f = C / (2 : ℝ) ^ n) |
| (hedge : C ≤ 2 * T) |
| (henergy : T ≤ 4 * ((d : ℝ) * Real.sqrt (n : ℝ)) * (2 : ℝ) ^ n) : |
| averageSensitivity f ≤ 8 * (d : ℝ) * Real.sqrt (n : ℝ) := by |
| rw [hcount] |
| simpa only [mul_assoc] using |
| normalized_edge_bound (pow_pos (by norm_num : (0 : ℝ) < 2) n) hedge henergy |
|
|
| / |
| binomial multiplicities, coordinate tridiagonality, and low-block vanishing. -/ |
| theorem sensitivity_bound_of_cube_grading {n d : ℕ} |
| (f : Cube n → ℝ) (hf : ∀ x, f x = 1 ∨ f x = -1) |
| (P : Fin (n + 1) → Matrix (Cube n) (Cube n) ℂ) |
| (hP : OrthogonalProjectionFamily P) |
| (htrace : ∀ k, (Matrix.trace (P k)).re = (n.choose k.val : ℝ)) |
| (htri : ∀ i : Fin n, BlockTridiagonal P (coordinateSignMatrix i)) |
| (hvanish : ∀ r s : Fin (n + 1), r.val + s.val < n - d → |
| P s * signMatrix (fun x => fullParity x * f x) * P r = 0) : |
| averageSensitivity f ≤ 8 * (d : ℝ) * Real.sqrt (n : ℝ) := by |
| classical |
| let h : Cube n → ℝ := fun x => fullParity x * f x |
| let H : Matrix (Cube n) (Cube n) ℂ := signMatrix h |
| let M : Matrix (Cube n) (Cube n) ℂ := centeredGrading P |
| have hh (x : Cube n) : h x = 1 ∨ h x = -1 := parity_twist_cases hf x |
| have htotal : hsNormSq M = (n : ℝ) * (2 : ℝ) ^ n / 4 := by |
| change hsNormSq (centeredGrading P) = _ |
| rw [hsNormSq_centeredGrading_trace hP] |
| simp_rw [htrace] |
| simpa only [mul_comm] using sum_choose_centered_sq n |
| have hcoordinate (i : Fin n) : |
| hsNormSq (M * coordinateSignMatrix i - coordinateSignMatrix i * M) ≤ (2 : ℝ) ^ n := by |
| simpa only [M, card_cube, Nat.cast_pow, Nat.cast_ofNat] using |
| hsNormSq_centeredGrading_commutator_le_card hP (coordinateSignMatrix i) |
| (htri i) (coordinateSignMatrix_unitary i) |
| have hdistance : |
| (∑ x : Cube n, ∑ y : Cube n, (hammingDist x y : ℝ) * ‖M x y‖ ^ 2) ≤ hsNormSq M := by |
| rw [htotal] |
| exact distance_energy_le_of_coordinate_commutator_bound M hcoordinate |
| have hcap (x y : Cube n) (hxy : x ≠ y) : ‖M x y‖ ^ 2 ≤ (1 : ℝ) / 4 := by |
| apply off_diagonal_sq_norm_le_quarter_of_commutator_bound M _ x y hxy |
| intro i a b |
| exact sq_norm_centeredGrading_commutator_entry_le_one hP (coordinateSignMatrix i) |
| (htri i) (coordinateSignMatrix_unitary i) a b |
| have hedge : ((orderedConstantEdges h).card : ℝ) ≤ |
| 2 * hsNormSq (M * H + H * M) := edge_recovery M h hh htotal hdistance hcap |
| have henergy : hsNormSq (M * H + H * M) ≤ |
| 4 * (d : ℝ) * Real.sqrt (n : ℝ) * (2 : ℝ) ^ n := |
| hsNormSq_centeredGrading_anticommutator_le_of_trace n d P hP H |
| (signMatrix_conjTranspose_mul h hh) (signMatrix_mul_conjTranspose h hh) htrace hvanish |
| apply sensitivity_bound_of_counting_energy f ((orderedConstantEdges h).card : ℝ) |
| (hsNormSq (M * H + H * M)) (averageSensitivity_eq_parity_edges hf) hedge |
| simpa only [mul_assoc] using henergy |
|
|
| / |
| family and both block-vanishing properties are constructed from its absolute |
| value, rather than retained as hypotheses. -/ |
| theorem polynomialThreshold_averageSensitivity_le_of_nonzero {n d : ℕ} |
| (p : MvPolynomial (Fin n) ℝ) (hp : IsMultilinear p) (hd : p.totalDegree ≤ d) |
| (hnz : ∀ x : Cube n, polynomialValue p x ≠ 0) : |
| averageSensitivity (polynomialThreshold p) ≤ 8 * (d : ℝ) * Real.sqrt (n : ℝ) := by |
| let w : Cube n → ℝ := fun x => |polynomialValue p x| |
| have hw (x : Cube n) : 0 < w x := abs_pos.mpr (hnz x) |
| apply sensitivity_bound_of_cube_grading (polynomialThreshold p) |
| (fun x => thresholdSign_cases (polynomialValue p x)) |
| (weightedProjectionMatrix w hw) |
| (weightedProjectionMatrix_family w hw) |
| (weightedProjectionMatrix_trace_re w hw) |
| · intro i |
| exact weightedProjectionMatrix_tridiagonal w hw i |
| · intro r s hrs |
| exact weightedProjectionMatrix_block_eq_zero_of_polynomial_degree p hp hd hnz r s hrs |
|
|
| / |
| sensitivity at most `8*d*sqrt(n)`, including cube zeros under `sign(0)=1`. |
| The argument in fact covers all natural `n` and `d`. -/ |
| theorem polynomialThreshold_averageSensitivity_le {n d : ℕ} |
| (p : MvPolynomial (Fin n) ℝ) (hp : IsMultilinear p) (hd : p.totalDegree ≤ d) : |
| averageSensitivity (polynomialThreshold p) ≤ 8 * (d : ℝ) * Real.sqrt (n : ℝ) := by |
| obtain ⟨q, hq, hqd, hqnz, hqf⟩ := exists_nonzero_polynomial_same_threshold hp hd |
| rw [← hqf] |
| exact polynomialThreshold_averageSensitivity_le_of_nonzero q hq hqd hqnz |
|
|
| / |
| construction hypotheses. -/ |
| theorem gotsmanLinialStatement : GotsmanLinialStatement := by |
| intro n d _ _ _ p hp hd |
| exact polynomialThreshold_averageSensitivity_le p hp hd |
|
|
| end LeanBlast.GotsmanLinial |
|
|
| end OAI |
|
|
