| import OAI.NumberTheory.TwoPoint.Circuits.CircuitPartialAssignment |
| import OAI.NumberTheory.TwoPoint.Circuits.CircuitDecisionTree |
|
|
| namespace OAI |
|
|
| /-! The canonical tree queries the unset variables of the first compatible |
| term, then continues through the remaining terms. This concrete tree is the |
| one encoded in the switching argument. -/ |
|
|
| namespace TwoPointCorrelations |
|
|
| open Finset |
| open scoped Classical |
|
|
| namespace BooleanDecisionTree |
|
|
| def queryVariables {n : ℕ} : List (Fin n) → |
| (PartialAssignment n → BooleanDecisionTree n) → PartialAssignment n → BooleanDecisionTree n |
| | [], k, ρ => k ρ |
| | i :: is, k, ρ => .query i |
| (queryVariables is k (Function.update ρ i (some false))) |
| (queryVariables is k (Function.update ρ i (some true))) |
|
|
| lemma queryVariables_eval {n : ℕ} (is : List (Fin n)) |
| (k : PartialAssignment n → BooleanDecisionTree n) (ρ : PartialAssignment n) |
| (x : BooleanCube n) : |
| (queryVariables is k ρ).eval x = (k (ρ.assign is.toFinset x)).eval x := by |
| induction is generalizing ρ with |
| | nil => simp [queryVariables] |
| | cons i is ih => |
| simp only [queryVariables, eval] |
| cases hx : x i <;> simp only [Bool.false_eq_true, ite_false, ite_true] |
| · rw [ih] |
| have ha := PartialAssignment.assign_insert ρ is.toFinset x i |
| rw [hx] at ha |
| simp only [List.toFinset_cons, ha] |
| · rw [ih] |
| have ha := PartialAssignment.assign_insert ρ is.toFinset x i |
| rw [hx] at ha |
| simp only [List.toFinset_cons, ha] |
|
|
| lemma queryVariables_depth_le {n d : ℕ} (is : List (Fin n)) |
| (k : PartialAssignment n → BooleanDecisionTree n) |
| (hk : ∀ ρ, (k ρ).depth ≤ d) (ρ : PartialAssignment n) : |
| (queryVariables is k ρ).depth ≤ is.length + d := by |
| induction is generalizing ρ with |
| | nil => simpa only [queryVariables, List.length_nil, Nat.zero_add] using hk ρ |
| | cons i is ih => |
| change max _ _ + 1 ≤ _ |
| have hl := ih (Function.update ρ i (some false)) |
| have hh := ih (Function.update ρ i (some true)) |
| have hm := max_le hl hh |
| simpa only [List.length_cons, Nat.add_right_comm] using Nat.add_le_add_right hm 1 |
|
|
| end BooleanDecisionTree |
|
|
| def dnfEval {n : ℕ} (F : List (CubeTerm n)) (x : BooleanCube n) : Bool := |
| F.any (fun C => C.eval x) |
|
|
| noncomputable def canonicalDNFTree {n : ℕ} : |
| List (CubeTerm n) → PartialAssignment n → BooleanDecisionTree n |
| | [], _ => .leaf false |
| | C :: F, ρ => |
| if C.Compatible ρ then |
| BooleanDecisionTree.queryVariables ((C.live ρ).sort (· ≤ ·)) |
| (fun τ => if C.Satisfied τ then .leaf true else canonicalDNFTree F τ) ρ |
| else canonicalDNFTree F ρ |
|
|
| theorem canonicalDNFTree_eval {n : ℕ} (F : List (CubeTerm n)) |
| (ρ : PartialAssignment n) (x : BooleanCube n) : |
| (canonicalDNFTree F ρ).eval x = dnfEval F (ρ.apply x) := by |
| induction F generalizing ρ with |
| | nil => simp [canonicalDNFTree, dnfEval, BooleanDecisionTree.eval] |
| | cons C F ih => |
| by_cases hC : C.Compatible ρ |
| · rw [canonicalDNFTree, ite_eq_left hC, BooleanDecisionTree.queryVariables_eval] |
| simp only [Finset.sort_toFinset] |
| have happly := ρ.apply_assign_free (C.live ρ) (C.live_subset_free ρ) x |
| have hs := C.satisfied_assign_live_iff ρ hC x |
| by_cases hsat : C.Satisfied (ρ.assign (C.live ρ) x) |
| · have he := hs.mp hsat |
| simp [hsat, BooleanDecisionTree.eval, dnfEval, he] |
| · have he : C.eval (ρ.apply x) = false := Bool.eq_false_iff.mpr (mt hs.mpr hsat) |
| simp only [hsat, ite_false, ih, happly, dnfEval, List.any_cons, he, |
| Bool.false_or] |
| · have he := C.eval_apply_of_incompatible ρ hC x |
| simp only [canonicalDNFTree, hC, ite_false, ih, dnfEval, List.any_cons, he, |
| Bool.false_or] |
|
|
| end TwoPointCorrelations |
|
|
| end OAI |
|
|
