| import OAI.NumberTheory.TwoPoint.Circuits.CircuitDecisionRestriction |
| import OAI.NumberTheory.TwoPoint.Circuits.CircuitSwitchingLemma |
|
|
| namespace OAI |
|
|
| /-! Switching a gate whose inputs already have shallow decision trees. |
| The number of clauses is irrelevant to the switching estimate. -/ |
|
|
| namespace TwoPointCorrelations |
|
|
| open Finset |
| open scoped Classical |
|
|
| noncomputable def decisionTreeDisjunction {n k : ℕ} (T : Fin k → BooleanDecisionTree n) : |
| List (CubeTerm n) := |
| (univ : Finset (Fin k)).toList.flatMap (fun i => (T i).toDNF) |
|
|
| theorem decisionTreeDisjunction_eval {n k : ℕ} (T : Fin k → BooleanDecisionTree n) |
| (x : BooleanCube n) : |
| dnfEval (decisionTreeDisjunction T) x = decide (∃ i, (T i).eval x = true) := by |
| apply Bool.eq_iff_iff.mpr |
| simp only [dnfEval_eq_true, decisionTreeDisjunction, List.mem_flatMap, |
| Finset.mem_toList, mem_univ, true_and, decide_eq_true_eq] |
| constructor |
| · rintro ⟨C, ⟨i, hC⟩, he⟩ |
| exact ⟨i, (T i).toDNF_eval x ▸ (dnfEval_eq_true _ _).mpr ⟨C, hC, he⟩⟩ |
| · rintro ⟨i, hi⟩ |
| have hh : dnfEval (T i).toDNF x = true := by rwa [(T i).toDNF_eval] |
| obtain ⟨C, hC, he⟩ := (dnfEval_eq_true _ _).mp hh |
| exact ⟨C, ⟨i, hC⟩, he⟩ |
|
|
| theorem decisionTreeDisjunction_width {n k r : ℕ} (T : Fin k → BooleanDecisionTree n) |
| (hT : ∀ i, (T i).depth ≤ r) : |
| ∀ C ∈ decisionTreeDisjunction T, C.support.card ≤ r := by |
| intro C hC |
| obtain ⟨i, _, hi⟩ := List.mem_flatMap.mp hC |
| exact ((T i).toDNF_width C hi).trans (hT i) |
|
|
| theorem disjunction_restriction_switching {n k r : ℕ} (f : Fin k → BooleanCube n → Bool) |
| (hf : ∀ i, HasSmallDecisionTree (f i) r) |
| (p : ℝ) (hp : 0 ≤ p) (hp1 : p < 1) |
| (hq : ((3 * (2 * r + 3) ^ 2 : ℕ) : ℝ) * (2 * p / (1 - p)) ≤ 1 / 2) : |
| (restrictionLaw n p hp hp1.le).probability (fun ρ => |
| ¬ HasSmallDecisionTree (fun x => decide (∃ i, f i (ρ.apply x) = true)) r) ≤ |
| 2 * (((3 * (2 * r + 3) ^ 2 : ℕ) : ℝ) * (2 * p / (1 - p))) ^ (r + 1) := by |
| choose T hT he using hf |
| have hF := decisionTreeDisjunction_width T hT |
| have hh := dnf_restriction_has_shallow_tree (decisionTreeDisjunction T) hF p hp hp1 hq r |
| apply (FiniteLaw.probability_mono _ ?_).trans hh |
| intro ρ hρ hgood |
| apply hρ |
| obtain ⟨S, hS, hs⟩ := hgood |
| refine ⟨S, hS, ?_⟩ |
| intro x |
| rw [hs, decisionTreeDisjunction_eval] |
| simp only [he] |
|
|
| theorem conjunction_restriction_switching {n k r : ℕ} (f : Fin k → BooleanCube n → Bool) |
| (hf : ∀ i, HasSmallDecisionTree (f i) r) |
| (p : ℝ) (hp : 0 ≤ p) (hp1 : p < 1) |
| (hq : ((3 * (2 * r + 3) ^ 2 : ℕ) : ℝ) * (2 * p / (1 - p)) ≤ 1 / 2) : |
| (restrictionLaw n p hp hp1.le).probability (fun ρ => |
| ¬ HasSmallDecisionTree (fun x => decide (∀ i, f i (ρ.apply x) = true)) r) ≤ |
| 2 * (((3 * (2 * r + 3) ^ 2 : ℕ) : ℝ) * (2 * p / (1 - p))) ^ (r + 1) := by |
| have hh := disjunction_restriction_switching (fun i x => Bool.not (f i x)) |
| (fun i => (hf i).negate) p hp hp1 hq |
| apply (FiniteLaw.probability_mono _ ?_).trans hh |
| intro ρ hρ hgood |
| apply hρ |
| have heq : (fun x => Bool.not (decide (∃ i, Bool.not (f i (ρ.apply x)) = true))) = |
| (fun x => decide (∀ i, f i (ρ.apply x) = true)) := by |
| funext x |
| by_cases hall : ∀ i, f i (ρ.apply x) = true |
| · simp [hall] |
| · obtain ⟨i, hi⟩ := not_forall.mp hall |
| have hn : ∃ i, Bool.not (f i (ρ.apply x)) = true := by |
| refine ⟨i, ?_⟩ |
| cases h : f i (ρ.apply x) <;> simp_all |
| simp only [hn, decide_true, Bool.not_true, hall, decide_false] |
| have hneg := hgood.negate |
| exact Eq.mp (congrArg (fun f => HasSmallDecisionTree f r) heq) hneg |
|
|
| end TwoPointCorrelations |
|
|
| end OAI |
|
|
