lean/OAI/Combinatorics/IndependentSets/Reduction/FrameNonempty.lean

import Mathlib
import OAI.Combinatorics.IndependentSets.PCP.LabelCoverData
import OAI.Combinatorics.IndependentSets.Fourier.Game
import OAI.Combinatorics.IndependentSets.Fourier.Gap
import OAI.Combinatorics.IndependentSets.Reduction.Parameters
import OAI.Combinatorics.IndependentSets.Reduction.OccurrenceTuple
import OAI.Combinatorics.IndependentSets.Encoding.TargetFormula

namespace OAI

namespace LargeIndependentSets
namespace Normalization

lemma frame_nonempty (b : List Bool) : 1 ≤ (frame b).length := by
  cases b <;> simp [frame]

lemma clauseBits_positive (C : List Literal) : 1 ≤ (clauseBits C).length := by
  have h := frame_nonempty C.length.bits
  simp only [clauseBits,List.length_append,nameBits]
  omega

lemma clauses_le_input (F : Formula) : F.clauses.length ≤ (formulaBits F).length := by
  have hl : ∀ cs : List (List Literal), cs.length ≤ (cs.flatMap clauseBits).length := by
    intro cs
    induction cs with
    | nil => simp
    | cons c cs ih =>
      have hc := clauseBits_positive c
      simp only [List.length_cons,List.flatMap_cons,List.length_append]
      omega
  have h := hl F.clauses
  simp only [formulaBits,List.length_append]
  omega

lemma names_bound (F : Formula) : (names F).length ≤ 3*F.clauses.length := by
  simp only [names,List.length_map]
  have h : ∀ cs : List (List Literal), (∀ c ∈ cs, c.length ≤ 3) →
      cs.flatten.length ≤ 3*cs.length := by
    intro cs hw
    induction cs with
    | nil => simp
    | cons c cs ih =>
      have hc := hw c (by simp)
      have ht := ih (fun c hc => hw c (by simp [hc]))
      simp only [List.flatten_cons,List.length_append,List.length_cons]
      omega
  exact h F.clauses F.width

lemma normalize_variables (F : Formula) :
    (normalize F).«variables» ≤ 3*F.clauses.length+1 := by
  by_cases h : [] ∈ F.clauses
  · simp [normalize,h,contradiction]
  · simpa only [normalize,ite_eq_right h] using Nat.add_le_add_right (names_bound F) 1

lemma normalize_clauses (F : Formula) :
    (normalize F).clauses.length ≤ F.clauses.length+2 := by
  by_cases h : [] ∈ F.clauses
  · have he : normalize F = contradiction := ite_eq_left h
    have hh := congrArg (fun G : TargetFormula => G.clauses.length) he
    change (normalize F).clauses.length = 2 at hh
    rw [hh]
    omega
  · have he : normalize F = ⟨(names F).length+1,F.clauses.map (clause F)⟩ := ite_eq_right h
    have hh := congrArg (fun G : TargetFormula => G.clauses.length) he
    simp only [List.length_map] at hh
    rw [hh]
    omega

lemma normalize_bits (F : Formula) :
    (IndependentSetsGames.Foundations.Complexity.formulaBits (normalize F)).length ≤
      100*((formulaBits F).length+1)^2 := by
  have hc := clauses_le_input F
  have hv := normalize_variables F
  have hm := normalize_clauses F
  have hb := IndependentSetsGames.Foundations.Complexity.formulaBits_length_le (normalize F)
  have hv' : (normalize F).«variables» ≤ 3*(formulaBits F).length+1 := by omega
  have hm' : (normalize F).clauses.length ≤ (formulaBits F).length+2 := by omega
  have hprod := Nat.mul_le_mul hm' (Nat.mul_le_mul_left 3 (Nat.add_le_add_right hv' 2))
  nlinarith [Nat.zero_le (formulaBits F).length]

end Normalization
end LargeIndependentSets

namespace LargeIndependentSets.LCInput
open IndependentSetsGames.Foundations
open Target PCP Hastad.SourceContexts Hastad.SourceGame Games
open scoped BigOperators Classical
noncomputable section

def fallback {n : ℕ} (cl : Target.Clause n) : ClauseAnswer :=
  honestAnswer cl (fun v => if v = cl[0].variableIndex then cl[0].positive else false)

lemma fallback_satisfies {n : ℕ} (cl : Target.Clause n) : localSatisfies cl (fallback cl) = true := by
  simp only [fallback, honest_satisfies, Target.Clause.eval, Target.Literal.eval]
  cases cl[0].positive <;> simp

lemma honest_consistent {n : ℕ} (cl : Target.Clause n) (a : Fin n → Bool) :
    localConsistent cl (honestAnswer cl a) = true := by
  rw [localConsistent_eq_true_iff]
  intro s s' h
  simpa only [honest_answerAt] using congrArg a h

lemma fallback_consistent {n : ℕ} (cl : Target.Clause n) : localConsistent cl (fallback cl) = true :=
  honest_consistent cl _

def repair {n : ℕ} (cl : Target.Clause n) (j : ClauseAnswer) : ClauseAnswer :=
  if localSatisfies cl j = true ∧ localConsistent cl j = true then j else fallback cl

lemma repair_spec {n : ℕ} (cl : Target.Clause n) (j : ClauseAnswer) :
    localSatisfies cl (repair cl j) = true ∧ localConsistent cl (repair cl j) = true := by
  unfold repair
  split
  · assumption
  · exact ⟨fallback_satisfies cl, fallback_consistent cl⟩

lemma repair_honest {n : ℕ} (cl : Target.Clause n) (a : Fin n → Bool) (ha : cl.eval a = true) :
    repair cl (honestAnswer cl a) = honestAnswer cl a := by
  simp [repair, honest_satisfies, ha, honest_consistent]

def repaired (F : Target.Formula) {u : ℕ} (c : ClauseContext F u) (j : J u) : J u :=
  fun t => repair (clauseAt F (c t)) (j t)

def labelCover (F : Target.Formula) (u : ℕ) :
    LabelCoverData (ClauseContext F u) (VariableContext F u) (J u) (I u)
      (Fin u → RandomEvent F) where
  left e := fun t => (e t).1
  right e := (repeatedVisible F u e).1
  project e j := pi F (fun t => (e t).1) (repeatedVisible F u e).1
    (repaired F (fun t => (e t).1) j)

lemma complete (F : Target.Formula) (u : ℕ) (hs : F.Satisfiable) :
    ∃ ℓ ρ, (labelCover F u).Satisfied ℓ ρ := by
  obtain ⟨a,ha⟩ := hs
  refine ⟨fun c => honestJ F c a, fun v => honestI F v a, ?_⟩
  intro e
  change pi F _ _ (repaired F _ (honestJ F _ a)) = _
  have he : repaired F (fun t => (e t).1) (honestJ F (fun t => (e t).1) a) =
      honestJ F (fun t => (e t).1) a := by
    funext t
    exact repair_honest _ a (ha _ (List.getElem_mem _))
  dsimp only [labelCover]
  rw [he]
  exact pi_honest F _ _ a (fun t => ⟨(e t).2,rfl⟩)

lemma repaired_accepts_iff (F : Target.Formula) (hne : F.clauses ≠ []) (u : ℕ)
    (c : ClauseContext F u) (v : VariableContext F u) (j : J u) (i : I u) :
    ((baseGame F hne).repetition u).accepts v c i (repaired F c j) = true ↔
      pi F c v (repaired F c j) = i := by
  rw [Game.repetition_accepts_iff]
  constructor
  · intro h
    funext t
    exact ((baseAccepts_eq_true_iff F _ _ _ _).mp (h t)).2.2
  · intro h t
    apply (baseAccepts_eq_true_iff F _ _ _ _).mpr
    exact ⟨(repair_spec _ _).1,(repair_spec _ _).2,congrFun h t⟩

lemma probability_expectation {Ω : Type*} [Fintype Ω] (μ : FiniteDistribution Ω)
    (event : Ω → Bool) : μ.probability event = μ.expectation (fun x => if event x then 1 else 0) := by
  unfold FiniteDistribution.probability FiniteDistribution.expectation
  simp only [mul_ite, mul_one, mul_zero]

lemma success_eq (F : Target.Formula) (hne : F.clauses ≠ []) (u : ℕ)
    (l : ClauseContext F u → J u) (r : VariableContext F u → I u) :
    ((baseGame F hne).repetition u).success (r, fun c => repaired F c (l c)) =
      𝔼 e : Fin u → RandomEvent F,
      if (labelCover F u).project e (l ((labelCover F u).left e)) = r ((labelCover F u).right e)
      then (1:ℝ) else 0 := by
  rw [Game.success, probability_expectation, repeated_expectation]
  apply Finset.expect_congr rfl
  intro e _
  congr 1
  exact propext (repaired_accepts_iff F hne u _ _ _ _)

lemma sound_of_value (F : Target.Formula) (hne : F.clauses ≠ []) (u : ℕ) {σ : ℝ}
    (hs : ((baseGame F hne).repetition u).value ≤ σ) : (labelCover F u).Sound σ := by
  let : Nonempty (RandomEvent F) := event_nonempty F hne
  intro l r
  have h := (Game.success_le_value ((baseGame F hne).repetition u)
    (r, fun c => repaired F c (l c))).trans hs
  rw [success_eq] at h
  simp only [Finset.expect_eq_sum_div_card, Finset.sum_boole, Finset.card_univ] at h
  have hh := (div_le_iff₀ (Nat.cast_pos.mpr (Fintype.card_pos (α := Fin u → RandomEvent F)))).mp h
  convert hh using 1
  congr 2
  ext constraint
  simp

theorem uniform_repetition {η σ : ℚ} (hη : 0 < η) (hη1 : η ≤ 1) (hσ : 0 < σ) :
    ∃ u : ℕ, 0 < u ∧ ∀ F : Target.Formula, Hastad.SourceGap.ClauseGap F η →
      (labelCover F u).Sound (σ:ℝ) := by
  have hg : 0 < η / 3 := by positivity
  have hg1 : η / 3 ≤ 1 := by linarith
  obtain ⟨u,hu,hpow⟩ := IndependentSetsGames.Soundness.RepetitionUpper.exists_power_lt
    (IndependentSetsGames.Integration.SourceParameters.rate (η/3)) σ
    (IndependentSetsGames.Integration.SourceParameters.rate_bounds hg hg1).1.le
    (IndependentSetsGames.Integration.SourceParameters.rate_bounds hg hg1).2 hσ
  refine ⟨u,hu,?_⟩
  intro F hgap
  apply sound_of_value F hgap.1 u
  have hb : (baseGame F hgap.1).value ≤ 1 - ((η/3:ℚ):ℝ) := by
    simpa only [Rat.cast_div,Rat.cast_ofNat] using base_value_le_of_clause_gap F hgap.1 (η:ℝ) hgap.2
  have hr := IndependentSetsGames.Integration.SourceParameters.game_repetition_rate
    (baseGame F hgap.1) hg hg1 (by simp) hb u
  have hp : (IndependentSetsGames.Integration.SourceParameters.rate (η/3):ℝ)^u ≤ σ := by
    exact_mod_cast hpow.le
  exact hr.trans hp

end
end LargeIndependentSets.LCInput

end OAI