| import OAI.NumberTheory.TwoPoint.Circuits.CircuitEncoding |
| import OAI.NumberTheory.TwoPoint.Bounds.ScalarComparison |
| import Mathlib.Data.Nat.Choose.Bounds |
|
|
| namespace OAI |
|
|
| /-! Exact active-prime states give small scalar expansions after the |
| degree truncation. All absent prime tests remain in each conjunction. -/ |
|
|
| namespace TwoPointCorrelations |
|
|
| open Finset |
| open scoped Classical |
|
|
| def activeState {n : ℕ} (x : BooleanCube n) : Finset (Fin n) := |
| univ.filter (fun i => x i = true) |
|
|
| def boundedActiveStates (n M : ℕ) : Finset (Finset (Fin n)) := |
| univ.powerset.filter (fun S => S.card ≤ M) |
|
|
| lemma mem_boundedActiveStates {n M : ℕ} {S : Finset (Fin n)} : |
| S ∈ boundedActiveStates n M ↔ S.card ≤ M := by |
| simp only [boundedActiveStates, mem_filter, mem_powerset, subset_univ, true_and] |
|
|
| lemma boundedActiveStates_card (n M : ℕ) : |
| (boundedActiveStates n M).card ≤ (M + 1) * (n + 1) ^ M := by |
| have he : boundedActiveStates n M = |
| (range (M + 1)).biUnion (fun r => univ.powersetCard r) := by |
| ext S |
| simp only [mem_boundedActiveStates, mem_biUnion, mem_range, mem_powersetCard, |
| subset_univ, true_and] |
| constructor |
| · intro hS |
| exact ⟨S.card, by omega, rfl⟩ |
| · rintro ⟨r, hr, he⟩ |
| omega |
| rw [he] |
| apply (card_biUnion_le).trans |
| calc |
| (∑ r ∈ range (M + 1), (univ.powersetCard r : Finset (Finset (Fin n))).card) = |
| ∑ r ∈ range (M + 1), n.choose r := by |
| simp only [card_powersetCard, card_univ, Fintype.card_fin] |
| _ ≤ ∑ _r ∈ range (M + 1), (n + 1) ^ M := by |
| apply sum_le_sum |
| intro r hr |
| exact (Nat.choose_le_pow n r).trans |
| ((Nat.pow_le_pow_left (Nat.le_succ n) r).trans |
| (Nat.pow_le_pow_right (by omega) (by simp only [mem_range] at hr; omega))) |
| _ = _ := by simp |
|
|
| def activeStateCircuit {n : ℕ} (S : Finset (Fin n)) : AC0Circuit n := |
| .andGate (fun i : Fin n => .literal i (decide (i ∈ S))) |
|
|
| lemma activeStateCircuit_eval {n : ℕ} (S : Finset (Fin n)) (x : BooleanCube n) : |
| (activeStateCircuit S).eval x = true ↔ activeState x = S := by |
| simp only [activeStateCircuit, AC0Circuit.eval, decide_eq_true_eq] |
| constructor |
| · intro h |
| ext i |
| have hi := h i |
| by_cases hs : i ∈ S <;> cases hx : x i <;> |
| simp_all [activeState] |
| · intro h i |
| have hi : x i = true ↔ i ∈ S := by |
| rw [← h] |
| simp only [activeState, mem_filter, mem_univ, true_and] |
| by_cases hs : i ∈ S <;> cases hx : x i <;> |
| simp_all [activeState] |
|
|
| lemma activeStateCircuit_depth {n : ℕ} (S : Finset (Fin n)) : |
| (activeStateCircuit S).depth ≤ 1 := by |
| simp [activeStateCircuit, AC0Circuit.depth] |
|
|
| lemma activeStateCircuit_size {n : ℕ} (S : Finset (Fin n)) : |
| (activeStateCircuit S).size = 1 + n := by |
| simp [activeStateCircuit, AC0Circuit.size] |
|
|
| theorem activeState_scalar_expansion {n : ℕ} (M : ℕ) |
| (f : Finset (Fin n) → ℝ) (x : BooleanCube n) : |
| (if (activeState x).card ≤ M then f (activeState x) else 0) = |
| ∑ S ∈ boundedActiveStates n M, f S * (activeStateCircuit S).indicator x := by |
| simp only [AC0Circuit.indicator] |
| have hval (S : Finset (Fin n)) : |
| (if (activeStateCircuit S).eval x = true then (1 : ℝ) else 0) = |
| if activeState x = S then 1 else 0 := by |
| simp only [activeStateCircuit_eval] |
| simp only [hval, mul_ite, mul_one, mul_zero] |
| by_cases hx : (activeState x).card ≤ M |
| · rw [ite_eq_left hx, sum_eq_single_of_mem (activeState x) (mem_boundedActiveStates.mpr hx)] |
| · simp |
| · intro S _ hS |
| exact ite_eq_right (Ne.symm hS) |
| · rw [ite_eq_right hx] |
| symm |
| apply sum_eq_zero |
| intro S hS |
| apply ite_eq_right |
| intro he |
| exact hx (he.symm ▸ mem_boundedActiveStates.mp hS) |
|
|
| lemma activeState_coefficient_mass {n M : ℕ} (f : Finset (Fin n) → ℝ) (C : ℝ) |
| (hf : ∀ S ∈ boundedActiveStates n M, |f S| ≤ C) : |
| ∑ S ∈ boundedActiveStates n M, |f S| ≤ ((M + 1) * (n + 1) ^ M : ℕ) * C := by |
| by_cases hC : 0 ≤ C |
| · calc |
| _ ≤ ∑ _S ∈ boundedActiveStates n M, C := sum_le_sum hf |
| _ = ((boundedActiveStates n M).card : ℝ) * C := by simp |
| _ ≤ _ := mul_le_mul_of_nonneg_right (by exact_mod_cast boundedActiveStates_card n M) hC |
| · have hz : ∅ ∈ boundedActiveStates n M := mem_boundedActiveStates.mpr (by simp) |
| exact False.elim (hC ((abs_nonneg (f ∅)).trans (hf ∅ hz))) |
|
|
| theorem activeState_average_comparison {n : ℕ} {α β : Type*} [Fintype α] [Fintype β] |
| (M : ℕ) (f : Finset (Fin n) → ℝ) (x : α → BooleanCube n) (y : β → BooleanCube n) |
| (C ε : ℝ) (hε : 0 ≤ ε) |
| (hf : ∀ S ∈ boundedActiveStates n M, |f S| ≤ C) |
| (hcompare : ∀ S ∈ boundedActiveStates n M, |
| |uniformAverage (fun a => (activeStateCircuit S).indicator (x a)) - |
| uniformAverage (fun b => (activeStateCircuit S).indicator (y b))| ≤ ε) : |
| |uniformAverage (fun a => if (activeState (x a)).card ≤ M then f (activeState (x a)) else 0) - |
| uniformAverage (fun b => if (activeState (y b)).card ≤ M then f (activeState (y b)) else 0)| ≤ |
| (((M + 1) * (n + 1) ^ M : ℕ) : ℝ) * C * ε := by |
| let S := boundedActiveStates n M |
| have hrep (z : BooleanCube n) : |
| (if (activeState z).card ≤ M then f (activeState z) else 0) = |
| ∑ t : S, f t.val * (activeStateCircuit t.val).indicator z := by |
| rw [activeState_scalar_expansion] |
| exact (sum_coe_sort S (fun t => f t * (activeStateCircuit t).indicator z)).symm |
| simp_rw [hrep] |
| have hb := scalar_average_comparison_uniform |
| (fun (t : S) a => (activeStateCircuit t.val).indicator (x a)) |
| (fun (t : S) b => (activeStateCircuit t.val).indicator (y b)) |
| (fun t : S => f t.val) ε (fun t => hcompare t.val t.property) |
| apply hb.trans |
| apply mul_le_mul_of_nonneg_right _ hε |
| change (∑ t : boundedActiveStates n M, |f t.val|) ≤ _ |
| calc |
| _ = ∑ t ∈ boundedActiveStates n M, |f t| := |
| sum_coe_sort (boundedActiveStates n M) (fun t => |f t|) |
| _ ≤ _ := activeState_coefficient_mass f C hf |
|
|
| end TwoPointCorrelations |
|
|
| end OAI |
|
|
