| import OAI.NumberTheory.TwoPoint.Circuits.CircuitComparison |
| import OAI.NumberTheory.TwoPoint.Circuits.BitEncoding |
|
|
| namespace OAI |
|
|
| /-! |
| # Truth-table encoding and substitution for residue circuits |
|
|
| Any decoded residue equality is a Boolean function of its block of bits. |
| Its explicit disjunctive normal form has depth at most two and size at most |
| `1 + 2^B (1+B)`. Substituting such forms into the actual circuit syntax |
| increases depth by at most two and multiplies size by this bound. |
| -/ |
|
|
| namespace TwoPointCorrelations.AC0Circuit |
|
|
| open Finset |
|
|
| /-- Replace each positive or negative input literal by a circuit. -/ |
| def substitute {n m : ℕ} (σ : Fin n → Bool → AC0Circuit m) : AC0Circuit n → AC0Circuit m |
| | .literal i positive => σ i positive |
| | .andGate children => .andGate (fun i => substitute σ (children i)) |
| | .orGate children => .orGate (fun i => substitute σ (children i)) |
|
|
| lemma substitute_eval {n m : ℕ} (σ : Fin n → Bool → AC0Circuit m) |
| (F : BooleanCube m → BooleanCube n) |
| (hσ : ∀ i positive x, (σ i positive).eval x = if positive then F x i else !(F x i)) |
| (c : AC0Circuit n) (x : BooleanCube m) : (substitute σ c).eval x = c.eval (F x) := by |
| induction c with |
| | literal i positive => exact hσ i positive x |
| | andGate children ih => simp only [substitute, eval, ih] |
| | orGate children ih => simp only [substitute, eval, ih] |
|
|
| lemma substitute_depth {n m d : ℕ} (σ : Fin n → Bool → AC0Circuit m) |
| (hσ : ∀ i positive, (σ i positive).depth ≤ d) (c : AC0Circuit n) : |
| (substitute σ c).depth ≤ c.depth + d := by |
| induction c with |
| | literal i positive => simpa [substitute, depth] using hσ i positive |
| | andGate children ih => |
| simp only [substitute, depth] |
| have hs : (Finset.univ.sup fun i => (substitute σ (children i)).depth) ≤ |
| (Finset.univ.sup fun i => (children i).depth) + d := by |
| apply Finset.sup_le |
| intro i hi |
| exact (ih i).trans (Nat.add_le_add_right (Finset.le_sup (f := fun i => (children i).depth) hi) d) |
| omega |
| | orGate children ih => |
| simp only [substitute, depth] |
| have hs : (Finset.univ.sup fun i => (substitute σ (children i)).depth) ≤ |
| (Finset.univ.sup fun i => (children i).depth) + d := by |
| apply Finset.sup_le |
| intro i hi |
| exact (ih i).trans (Nat.add_le_add_right (Finset.le_sup (f := fun i => (children i).depth) hi) d) |
| omega |
|
|
| lemma substitute_size {n m K : ℕ} (σ : Fin n → Bool → AC0Circuit m) |
| (hK : 1 ≤ K) (hσ : ∀ i positive, (σ i positive).size ≤ K) (c : AC0Circuit n) : |
| (substitute σ c).size ≤ K * c.size := by |
| induction c with |
| | literal i positive => simpa [substitute, size] using hσ i positive |
| | andGate children ih => |
| simp only [substitute, size] |
| calc |
| 1 + ∑ i, (substitute σ (children i)).size ≤ K + ∑ i, K * (children i).size := |
| Nat.add_le_add hK (Finset.sum_le_sum (fun i _ => ih i)) |
| _ = K * (1 + ∑ i, (children i).size) := by rw [← Finset.mul_sum]; ring |
| | orGate children ih => |
| simp only [substitute, size] |
| calc |
| 1 + ∑ i, (substitute σ (children i)).size ≤ K + ∑ i, K * (children i).size := |
| Nat.add_le_add hK (Finset.sum_le_sum (fun i _ => ih i)) |
| _ = K * (1 + ∑ i, (children i).size) := by rw [← Finset.mul_sum]; ring |
|
|
| /-- Conjunction specifying one assignment on a selected block of bits. -/ |
| def assignmentTerm {n B : ℕ} (v : Fin B → Fin n) (z : BooleanCube B) : AC0Circuit n := |
| .andGate (fun i => .literal (v i) (z i)) |
|
|
| /-- The constant false circuit, used for rejected rows of a truth table. -/ |
| def falseCircuit (n : ℕ) : AC0Circuit n := .orGate (fun i : Fin 0 => Fin.elim0 i) |
|
|
| lemma literal_eval_true {n : ℕ} (i : Fin n) (positive : Bool) (x : BooleanCube n) : |
| (.literal i positive : AC0Circuit n).eval x = true ↔ x i = positive := by |
| cases h : x i <;> cases positive <;> simp [eval, h] |
|
|
| lemma assignmentTerm_eval_true {n B : ℕ} (v : Fin B → Fin n) |
| (z : BooleanCube B) (x : BooleanCube n) : |
| (assignmentTerm v z).eval x = true ↔ (fun i => x (v i)) = z := by |
| change (decide (∀ i : Fin B, (.literal (v i) (z i) : AC0Circuit n).eval x = true) = true) ↔ _ |
| constructor |
| · intro h |
| funext i |
| exact (literal_eval_true (v i) (z i) x).mp ((of_decide_eq_true h) i) |
| · intro h |
| apply decide_eq_true |
| intro i |
| exact (literal_eval_true (v i) (z i) x).mpr (congrFun h i) |
|
|
| @[simp] lemma falseCircuit_eval (n : ℕ) (x : BooleanCube n) : |
| (falseCircuit n).eval x = false := by simp [falseCircuit, eval] |
|
|
| /-- Explicit DNF with one possible conjunction for each of the `2^B` rows. -/ |
| noncomputable def truthTable {n B : ℕ} (v : Fin B → Fin n) |
| (F : BooleanCube B → Bool) : AC0Circuit n := |
| .orGate (fun k : Fin (2 ^ B) => |
| if F (binaryCellEquiv B k) then assignmentTerm v (binaryCellEquiv B k) |
| else falseCircuit n) |
|
|
| lemma truthTable_eval {n B : ℕ} (v : Fin B → Fin n) (F : BooleanCube B → Bool) |
| (x : BooleanCube n) : (truthTable v F).eval x = F (fun i => x (v i)) := by |
| apply Bool.eq_iff_iff.mpr |
| simp only [truthTable, eval, decide_eq_true_eq] |
| constructor |
| · rintro ⟨k, hk⟩ |
| split_ifs at hk with hF |
| · have heq := (assignmentTerm_eval_true v (binaryCellEquiv B k) x).mp hk |
| rwa [heq] |
| · simp only [falseCircuit_eval, Bool.false_eq_true] at hk |
| · intro hF |
| refine ⟨(binaryCellEquiv B).symm (fun i => x (v i)), ?_⟩ |
| simp only [Equiv.apply_symm_apply, hF, ite_true] |
| exact (assignmentTerm_eval_true v _ x).mpr rfl |
|
|
| lemma assignmentTerm_depth {n B : ℕ} (v : Fin B → Fin n) (z : BooleanCube B) : |
| (assignmentTerm v z).depth = 1 := by simp [assignmentTerm, depth] |
|
|
| lemma assignmentTerm_size {n B : ℕ} (v : Fin B → Fin n) (z : BooleanCube B) : |
| (assignmentTerm v z).size = 1 + B := by simp [assignmentTerm, size] |
|
|
| lemma truthTable_depth {n B : ℕ} (v : Fin B → Fin n) (F : BooleanCube B → Bool) : |
| (truthTable v F).depth ≤ 2 := by |
| change 1 + (Finset.univ.sup fun k : Fin (2 ^ B) => |
| (if F (binaryCellEquiv B k) then assignmentTerm v (binaryCellEquiv B k) |
| else falseCircuit n).depth) ≤ 2 |
| have hs : (Finset.univ.sup fun k : Fin (2 ^ B) => |
| (if F (binaryCellEquiv B k) then assignmentTerm v (binaryCellEquiv B k) |
| else falseCircuit n).depth) ≤ 1 := by |
| apply Finset.sup_le |
| intro k _ |
| split_ifs <;> simp [assignmentTerm_depth, falseCircuit, depth] |
| omega |
|
|
| lemma truthTable_size {n B : ℕ} (v : Fin B → Fin n) (F : BooleanCube B → Bool) : |
| (truthTable v F).size ≤ 1 + 2 ^ B * (1 + B) := by |
| change 1 + (∑ k : Fin (2 ^ B), |
| (if F (binaryCellEquiv B k) then assignmentTerm v (binaryCellEquiv B k) |
| else falseCircuit n).size) ≤ _ |
| apply Nat.add_le_add_left |
| calc |
| _ ≤ ∑ _k : Fin (2 ^ B), (1 + B) := by |
| apply Finset.sum_le_sum |
| intro k _ |
| split_ifs <;> simp [assignmentTerm_size, falseCircuit, size] |
| _ = 2 ^ B * (1 + B) := by simp |
|
|
| /-- Encode each residue input using a truth table on its own selected bits. -/ |
| noncomputable def encodeInputs {n m B : ℕ} (v : Fin n → Fin B → Fin m) |
| (F : Fin n → BooleanCube B → Bool) (c : AC0Circuit n) : AC0Circuit m := |
| substitute (fun i positive => truthTable (v i) |
| (fun z => if positive then F i z else !(F i z))) c |
|
|
| lemma encodeInputs_eval {n m B : ℕ} (v : Fin n → Fin B → Fin m) |
| (F : Fin n → BooleanCube B → Bool) (c : AC0Circuit n) (x : BooleanCube m) : |
| (encodeInputs v F c).eval x = c.eval (fun i => F i (fun j => x (v i j))) := by |
| apply substitute_eval |
| intro i positive y |
| exact truthTable_eval _ _ y |
|
|
| lemma encodeInputs_depth {n m B : ℕ} (v : Fin n → Fin B → Fin m) |
| (F : Fin n → BooleanCube B → Bool) (c : AC0Circuit n) : |
| (encodeInputs v F c).depth ≤ c.depth + 2 := |
| substitute_depth _ (fun _ _ => truthTable_depth _ _) c |
|
|
| lemma encodeInputs_size {n m B : ℕ} (v : Fin n → Fin B → Fin m) |
| (F : Fin n → BooleanCube B → Bool) (c : AC0Circuit n) : |
| (encodeInputs v F c).size ≤ (1 + 2 ^ B * (1 + B)) * c.size := |
| substitute_size _ (by omega) (fun _ _ => truthTable_size _ _) c |
|
|
| end TwoPointCorrelations.AC0Circuit |
|
|
| end OAI |
|
|
