import OAI.NumberTheory.TwoPoint.Circuits.CircuitBooleanOps
import OAI.NumberTheory.TwoPoint.Circuits.CircuitGateApproximation

namespace OAI

/-! The single-hit test used by the random polynomial is itself a small
constant-depth circuit on the original child outputs. -/

namespace TwoPointCorrelations

open Finset
open scoped Classical

namespace AC0Circuit

noncomputable def certificateDisjunction {ι : Type*} [Fintype ι] {n : ℕ}
    (c : ι → AC0Circuit n) : AC0Circuit n :=
  (conjunction (fun i => (c i).negate)).negate

lemma certificateDisjunction_eval {ι : Type*} [Fintype ι] {n : ℕ}
    (c : ι → AC0Circuit n) (x : BooleanCube n) :
    (certificateDisjunction c).eval x = true ↔ ∃ i, (c i).eval x = true := by
  rw [certificateDisjunction, negate_eval]
  simp only [ne_eq, conjunction_eval, negate_eval, not_forall, not_not]

lemma certificateDisjunction_depth {ι : Type*} [Fintype ι] {n d : ℕ}
    (c : ι → AC0Circuit n) (hc : ∀ i, (c i).depth ≤ d) :
    (certificateDisjunction c).depth ≤ d + 1 := by
  simp only [certificateDisjunction, negate_depth]
  exact conjunction_depth _ (fun i => by simpa only [negate_depth] using hc i)

lemma certificateDisjunction_size {ι : Type*} [Fintype ι] {n : ℕ}
    (c : ι → AC0Circuit n) : (certificateDisjunction c).size = 1 + ∑ i, (c i).size := by
  simp only [certificateDisjunction, negate_size, conjunction_size]

noncomputable def uniqueFalseTerm {n k : ℕ} (c : Fin k → AC0Circuit n)
    (S : Finset (Fin k)) (i : S) : AC0Circuit n :=
  conjunction (fun j : S => if j = i then (c j).negate else c j)

lemma uniqueFalseTerm_eval {n k : ℕ} (c : Fin k → AC0Circuit n)
    (S : Finset (Fin k)) (i : S) (x : BooleanCube n) :
    (uniqueFalseTerm c S i).eval x = true ↔
      (c i).eval x = false ∧ ∀ j : S, j ≠ i → (c j).eval x = true := by
  rw [uniqueFalseTerm, conjunction_eval]
  constructor
  · intro h
    refine ⟨?_, fun j hj => ?_⟩
    · have hi := h i
      apply Bool.eq_false_iff.mpr
      simpa only [ite_true, negate_eval] using hi
    · simpa only [ite_eq_right hj] using h j
  · rintro ⟨hi, h⟩ j
    by_cases hj : j = i
    · subst j
      rw [ite_eq_left rfl, negate_eval, hi]
      decide
    · simpa only [ite_eq_right hj] using h j hj

noncomputable def uniqueFalseCircuit {n k : ℕ} (c : Fin k → AC0Circuit n)
    (S : Finset (Fin k)) : AC0Circuit n :=
  certificateDisjunction (fun i : S => uniqueFalseTerm c S i)

lemma uniqueFalseCircuit_eval {n k : ℕ} (c : Fin k → AC0Circuit n)
    (S : Finset (Fin k)) (x : BooleanCube n) :
    (uniqueFalseCircuit c S).eval x = true ↔
      ∃ i : S, (c i).eval x = false ∧ ∀ j : S, j ≠ i → (c j).eval x = true := by
  simp only [uniqueFalseCircuit, certificateDisjunction_eval, uniqueFalseTerm_eval]

lemma uniqueFalseTerm_depth {n k d : ℕ} (c : Fin k → AC0Circuit n)
    (hc : ∀ i, (c i).depth ≤ d) (S : Finset (Fin k)) (i : S) :
    (uniqueFalseTerm c S i).depth ≤ d + 1 := by
  apply conjunction_depth
  intro j
  split_ifs <;> simpa only [negate_depth] using hc j

lemma uniqueFalseCircuit_depth {n k d : ℕ} (c : Fin k → AC0Circuit n)
    (hc : ∀ i, (c i).depth ≤ d) (S : Finset (Fin k)) :
    (uniqueFalseCircuit c S).depth ≤ d + 2 := by
  exact certificateDisjunction_depth _ (uniqueFalseTerm_depth c hc S)

lemma uniqueFalseTerm_size {n k : ℕ} (c : Fin k → AC0Circuit n)
    (S : Finset (Fin k)) (i : S) :
    (uniqueFalseTerm c S i).size = 1 + ∑ j : S, (c j).size := by
  rw [uniqueFalseTerm, conjunction_size]
  congr 1
  apply sum_congr rfl
  intro j _
  split_ifs <;> simp only [negate_size]

lemma uniqueFalseCircuit_size {n k : ℕ} (c : Fin k → AC0Circuit n)
    (S : Finset (Fin k)) :
    (uniqueFalseCircuit c S).size = 1 + S.card * (1 + ∑ j : S, (c j).size) := by
  simp only [uniqueFalseCircuit, certificateDisjunction_size, uniqueFalseTerm_size, sum_const,
    card_univ, Fintype.card_coe, nsmul_eq_mul, Nat.cast_id]

lemma uniqueFalseCircuit_size_le {n k : ℕ} (c : Fin k → AC0Circuit n)
    (S : Finset (Fin k)) :
    (uniqueFalseCircuit c S).size ≤ 1 + k * (1 + ∑ j, (c j).size) := by
  rw [uniqueFalseCircuit_size]
  have hcard : S.card ≤ k := (card_le_card (subset_univ S)).trans_eq (card_fin k)
  have hsum : ∑ j : S, (c j).size ≤ ∑ j, (c j).size := by
    calc
      _ = ∑ j ∈ S, (c j).size := sum_coe_sort S (fun j => (c j).size)
      _ ≤ _ := sum_le_sum_of_subset_of_nonneg (subset_univ S) (fun _ _ _ => Nat.zero_le _)
  exact Nat.add_le_add_left (Nat.mul_le_mul hcard (Nat.add_le_add_left hsum 1)) 1

end AC0Circuit

end TwoPointCorrelations

end OAI