| import OAI.NumberTheory.TwoPoint.Circuits.CircuitGateSwitching |
| import OAI.NumberTheory.TwoPoint.Circuits.CircuitRestrictionComposition |
|
|
| namespace OAI |
|
|
| /-! Iterate switching through arbitrary AND/OR circuits. Each gate pays |
| one switching error, so the total loss is bounded by circuit size. -/ |
|
|
| namespace TwoPointCorrelations |
|
|
| open Finset |
| open scoped Classical |
|
|
| theorem FiniteLaw.average_probability_le_union {α β ι : Type*} |
| [Fintype α] [Fintype β] [Fintype ι] |
| (μ : FiniteLaw α) (ν : FiniteLaw β) (E : α → β → Prop) |
| (bad : ι → α → Prop) (δ : ℝ) (hδ : 0 ≤ δ) |
| (hgood : ∀ x, (∀ i, ¬ bad i x) → ν.probability (E x) ≤ δ) : |
| μ.average (fun x => ν.probability (E x)) ≤ |
| (∑ i, μ.probability (bad i)) + δ := by |
| calc |
| _ ≤ μ.average (fun x => (if ∃ i, bad i x then 1 else 0) + δ) := by |
| apply μ.average_mono |
| intro x |
| by_cases hx : ∃ i, bad i x |
| · simpa only [ite_eq_left hx] using |
| (ν.probability_le_one (E x)).trans (by linarith) |
| · simpa only [ite_eq_right hx, zero_add] using |
| hgood x (fun i hi => hx ⟨i, hi⟩) |
| _ = μ.probability (fun x => ∃ i, bad i x) + δ := by |
| simp only [FiniteLaw.probability, FiniteLaw.average, mul_add, |
| sum_add_distrib, ← sum_mul, μ.total, one_mul] |
| congr 1 |
| apply sum_congr rfl |
| intro x _ |
| by_cases hx : ∃ i, bad i x <;> simp [hx] |
| _ ≤ _ := add_le_add (μ.probability_exists_le bad) le_rfl |
|
|
| namespace AC0Circuit |
|
|
| theorem restriction_shallow {n : ℕ} (p : ℝ) (hp : 0 ≤ p) (hp1 : p < 1) |
| (r : ℕ) (hr : 1 ≤ r) |
| (hq : ((3 * (2 * r + 3) ^ 2 : ℕ) : ℝ) * (2 * p / (1 - p)) ≤ 1 / 2) |
| (d : ℕ) (c : AC0Circuit n) (hc : c.depth ≤ d) : |
| (restrictionLaw n (p ^ d) (pow_nonneg hp _) (pow_le_one₀ hp hp1.le)).probability |
| (fun ρ => ¬ HasSmallDecisionTree (fun x => c.eval (ρ.apply x)) r) ≤ |
| (c.size : ℝ) * |
| (2 * (((3 * (2 * r + 3) ^ 2 : ℕ) : ℝ) * (2 * p / (1 - p))) ^ (r + 1)) := by |
| let δ := 2 * (((3 * (2 * r + 3) ^ 2 : ℕ) : ℝ) * (2 * p / (1 - p))) ^ (r + 1) |
| have hδ : 0 ≤ δ := by dsimp [δ]; positivity |
| induction d generalizing c with |
| | zero => |
| cases c with |
| | literal i b => |
| have he (ρ : PartialAssignment n) : |
| ¬ (¬ HasSmallDecisionTree (fun x => (literal i b).eval (ρ.apply x)) r) := |
| not_not.mpr (literal_hasSmallDecisionTree i b hr ρ) |
| simpa only [FiniteLaw.probability, he, ite_false, FiniteLaw.average_const, |
| size, Nat.cast_one, one_mul] using hδ |
| | andGate children => simp [depth] at hc |
| | orGate children => simp [depth] at hc |
| | succ d ih => |
| let μ := restrictionLaw n (p ^ d) (pow_nonneg hp _) (pow_le_one₀ hp hp1.le) |
| let ν := restrictionLaw n p hp hp1.le |
| have hcompose (E : PartialAssignment n → Prop) : |
| (restrictionLaw n (p ^ (d + 1)) (pow_nonneg hp _) |
| (pow_le_one₀ hp hp1.le)).probability E = |
| μ.average (fun ρ => ν.probability (fun τ => E (composeRestriction ρ τ))) := by |
| unfold FiniteLaw.probability |
| exact (restrictionLaw_compose (p ^ d) p (pow_nonneg hp _) |
| (pow_le_one₀ hp hp1.le) hp hp1.le (fun ρ => if E ρ then 1 else 0)).symm |
| cases c with |
| | literal i b => |
| have he (ρ : PartialAssignment n) : |
| ¬ (¬ HasSmallDecisionTree (fun x => (literal i b).eval (ρ.apply x)) r) := |
| not_not.mpr (literal_hasSmallDecisionTree i b hr ρ) |
| simpa only [FiniteLaw.probability, he, ite_false, FiniteLaw.average_const, |
| size, Nat.cast_one, one_mul] using hδ |
| | andGate children => |
| have hchild (i) : (children i).depth ≤ d := by |
| have hi := Finset.le_sup (f := fun i => (children i).depth) (mem_univ i) |
| simp only [depth] at hc |
| omega |
| rw [hcompose] |
| apply (FiniteLaw.average_probability_le_union μ ν _ |
| (fun i ρ => ¬ HasSmallDecisionTree (fun x => (children i).eval (ρ.apply x)) r) |
| δ hδ ?_).trans |
| · calc |
| _ ≤ (∑ i, ((children i).size : ℝ) * δ) + δ := by |
| exact add_le_add (sum_le_sum (fun i _ => ih (children i) (hchild i))) le_rfl |
| _ = _ := by simp only [size, Nat.cast_add, Nat.cast_one, Nat.cast_sum]; rw [← sum_mul]; ring |
| · intro ρ hρ |
| have hh := conjunction_restriction_switching |
| (fun i x => (children i).eval (ρ.apply x)) (fun i => not_not.mp (hρ i)) |
| p hp hp1 hq |
| simpa only [eval, composeRestriction_apply] using hh |
| | orGate children => |
| have hchild (i) : (children i).depth ≤ d := by |
| have hi := Finset.le_sup (f := fun i => (children i).depth) (mem_univ i) |
| simp only [depth] at hc |
| omega |
| rw [hcompose] |
| apply (FiniteLaw.average_probability_le_union μ ν _ |
| (fun i ρ => ¬ HasSmallDecisionTree (fun x => (children i).eval (ρ.apply x)) r) |
| δ hδ ?_).trans |
| · calc |
| _ ≤ (∑ i, ((children i).size : ℝ) * δ) + δ := by |
| exact add_le_add (sum_le_sum (fun i _ => ih (children i) (hchild i))) le_rfl |
| _ = _ := by simp only [size, Nat.cast_add, Nat.cast_one, Nat.cast_sum]; rw [← sum_mul]; ring |
| · intro ρ hρ |
| have hh := disjunction_restriction_switching |
| (fun i x => (children i).eval (ρ.apply x)) (fun i => not_not.mp (hρ i)) |
| p hp hp1 hq |
| simpa only [eval, composeRestriction_apply] using hh |
|
|
|
|
| end AC0Circuit |
|
|
| end TwoPointCorrelations |
|
|
| end OAI |
|
|
