lean/OAI/Combinatorics/IndependentSets/Reduction/TargetRead.lean

import Mathlib
import OAI.Combinatorics.IndependentSets.Machines.ExprTables

namespace OAI

noncomputable section

namespace LargeIndependentSets.TargetRead
open IndependentSetsGames.Foundations IndependentSetsGames.Foundations.Complexity
open IndependentSetsCut.CounterMachine
open Target PCP Hastad.SourceContexts Hastad.SourceGame
open scoped Classical BigOperators

lemma encodeWords_eq (xs : List ℕ) : encodeWords xs=Expr.unaryWords xs := by
  induction xs with
  | nil => rfl
  | cons x xs ih => simp [encodeWords,encodeWord,Expr.unaryWords,ih]

lemma read (F : Target.Formula) (w : ℕ) :
    Expr.wordValue (Complexity.formulaBits F) w=((formulaWords F)[w]?).getD 0 := by
  rw [Complexity.formulaBits,encodeWords_eq,Expr.wordValue_encoded]

lemma block_get {α β : Type} (d : β) (f : α → List β) (k : ℕ) (hl : ∀ x, (f x).length=k)
    (xs : List α) (c : Fin xs.length) (j : ℕ) (hj : j<k) :
    ((xs.flatMap f)[k*c.val+j]?).getD d=((f xs[c])[j]?).getD d := by
  induction xs with
  | nil => exact Fin.elim0 c
  | cons x xs ih =>
    rcases c with ⟨c,hc⟩
    cases c with
    | zero =>
      simp only [List.flatMap_cons,Nat.mul_zero,Nat.zero_add]
      rw [List.getElem?_append_left (by simpa [hl] using hj)]
      rfl
    | succ c =>
      have hc' : c<xs.length := by simpa using hc
      simp only [List.flatMap_cons,Nat.mul_succ]
      rw [List.getElem?_append_right (by rw [hl]; omega),hl]
      have he : k*c+k+j-k=k*c+j := by omega
      rw [he]
      exact ih ⟨c,hc'⟩

lemma read_vars (F : Target.Formula) : Expr.wordValue (Complexity.formulaBits F) 0=F.«variables» := by
  rw [read]; simp [formulaWords]
lemma read_clauses (F : Target.Formula) : Expr.wordValue (Complexity.formulaBits F) 1=F.clauses.length := by
  rw [read]; simp [formulaWords]

lemma read_clause (F : Target.Formula) (c : Fin F.clauses.length) (j : Fin 6) :
    Expr.wordValue (Complexity.formulaBits F) (2+6*c.val+j.val)=
      ((clauseWords (clauseAt F c))[j.val]?).getD 0 := by
  rw [read,formulaWords,List.getElem?_append_right (by simp; omega)]
  simp only [List.length_cons,List.length_nil]
  rw [show 2+6*c.val+j.val-2=6*c.val+j.val by omega]
  exact block_get 0 clauseWords 6 clauseWords_length F.clauses c j.val j.isLt

lemma read_name (F : Target.Formula) (c : Fin F.clauses.length) (s : Slot) :
    Expr.wordValue (Complexity.formulaBits F) (2+6*c.val+2*(RawInitialTables.slotOrder s).val)=
      (nameAt (clauseAt F c) s).val := by
  have h := read_clause F c ⟨2*(RawInitialTables.slotOrder s).val,by have := (RawInitialTables.slotOrder s).isLt; omega⟩
  cases s <;> simpa [RawInitialTables.slotOrder,clauseWords,literalWords,nameAt] using h

def signAt {n : ℕ} (cl : Target.Clause n) : Slot → Bool
  | .first => cl[0].positive
  | .second => cl[1].positive
  | .third => cl[2].positive

lemma read_sign (F : Target.Formula) (c : Fin F.clauses.length) (s : Slot) :
    Expr.wordValue (Complexity.formulaBits F) (2+6*c.val+(2*(RawInitialTables.slotOrder s).val+1))=
      (if signAt (clauseAt F c) s then 1 else 0) := by
  have h := read_clause F c ⟨2*(RawInitialTables.slotOrder s).val+1,by have := (RawInitialTables.slotOrder s).isLt; omega⟩
  cases s <;> convert h using 1 <;> simp [RawInitialTables.slotOrder,clauseWords,literalWords,signAt] <;> rfl

def varsExpr : Expr := Expr.word (.const 0)
def clausesExpr : Expr := Expr.word (.const 1)
def nameExpr (c : Expr) (s : Slot) : Expr :=
  Expr.word (.add (.add (.const 2) (.mul (.const 6) c)) (.const (2*(RawInitialTables.slotOrder s).val)))
def signExpr (c : Expr) (s : Slot) : Expr :=
  Expr.word (.add (.add (.const 2) (.mul (.const 6) c)) (.const (2*(RawInitialTables.slotOrder s).val+1)))

@[simp] lemma varsExpr_eval (F : Target.Formula) (a : ℕ → ℕ) :
    varsExpr.eval (Complexity.formulaBits F) a=F.«variables» := by simp [varsExpr,Expr.eval,read_vars]
@[simp] lemma clausesExpr_eval (F : Target.Formula) (a : ℕ → ℕ) :
    clausesExpr.eval (Complexity.formulaBits F) a=F.clauses.length := by simp [clausesExpr,Expr.eval,read_clauses]
lemma nameExpr_eval (F : Target.Formula) (c : Expr) (a : ℕ → ℕ) (i : Fin F.clauses.length)
    (hi : c.eval (Complexity.formulaBits F) a=i.val) (s : Slot) :
    (nameExpr c s).eval (Complexity.formulaBits F) a=(nameAt (clauseAt F i) s).val := by
  simp only [nameExpr,Expr.word_eval,Expr.eval,hi,read_name]
lemma signExpr_eval (F : Target.Formula) (c : Expr) (a : ℕ → ℕ) (i : Fin F.clauses.length)
    (hi : c.eval (Complexity.formulaBits F) a=i.val) (s : Slot) :
    (signExpr c s).eval (Complexity.formulaBits F) a=if signAt (clauseAt F i) s then 1 else 0 := by
  simp only [signExpr,Expr.word_eval,Expr.eval,hi,read_sign]

end LargeIndependentSets.TargetRead
namespace LargeIndependentSets.TargetRepair
open IndependentSetsGames.Foundations IndependentSetsGames.Foundations.Complexity
open IndependentSetsCut.CounterMachine
open Target PCP Hastad.SourceContexts Hastad.SourceGame
open TargetRead
open scoped Classical BigOperators

def bit (b : Bool) : ℕ := if b then 1 else 0
@[simp] lemma bit_eq (b c : Bool) : bit b=bit c ↔ b=c := by cases b <;> cases c <;> decide
lemma bit_decide (p : Prop) [Decidable p] : bit (decide p)=(if p then 1 else 0) := by
  by_cases h : p <;> simp [bit,h]
@[simp] lemma bit_ne_zero (b : Bool) : bit b≠0 ↔ b=true := by cases b <;> decide

abbrev Shape := (Slot → Bool) × (Slot → Slot → Bool)
def shape {n : ℕ} (cl : Target.Clause n) : Shape :=
  (signAt cl,fun s t => decide (nameAt cl s=nameAt cl t))
def shapeSat (sh : Shape) (j : ClauseAnswer) : Bool :=
  (literalValue (sh.1 .first) j.first || literalValue (sh.1 .second) j.second) ||
    literalValue (sh.1 .third) j.third
def shapeCons (sh : Shape) (j : ClauseAnswer) : Bool :=
  decide (∀ s t, sh.2 s t=true → answerAt j s=answerAt j t)
def repairedBit (sh : Shape) (j : ClauseAnswer) (s : Slot) : Bool :=
  if shapeSat sh j=true ∧ shapeCons sh j=true then answerAt j s
  else if sh.2 s .first then sh.1 .first else false

lemma shapeSat_exact {n : ℕ} (cl : Target.Clause n) (j : ClauseAnswer) :
    shapeSat (shape cl) j=localSatisfies cl j := rfl
lemma shapeCons_exact {n : ℕ} (cl : Target.Clause n) (j : ClauseAnswer) :
    shapeCons (shape cl) j=localConsistent cl j := by
  simp only [shapeCons,shape,localConsistent,decide_eq_true_eq]
lemma repairedBit_exact {n : ℕ} (cl : Target.Clause n) (j : ClauseAnswer) (s : Slot) :
    repairedBit (shape cl) j s=answerAt (LCInput.repair cl j) s := by
  simp only [repairedBit,shapeSat_exact,shapeCons_exact,LCInput.repair]
  by_cases h : localSatisfies cl j=true ∧ localConsistent cl j=true
  · simp only [ite_eq_left h]
  · simp only [ite_eq_right h]
    rw [LCInput.fallback,honest_answerAt]
    change (if decide (nameAt cl s=cl[0].variableIndex) then cl[0].positive else false)=_
    by_cases hn : nameAt cl s=cl[0].variableIndex
    · rw [ite_eq_left (by simpa only [decide_eq_true_eq] using hn),ite_eq_left hn]
    · rw [ite_eq_right (by simpa only [decide_eq_true_eq] using hn),ite_eq_right hn]

lemma indicator_ne (p : Prop) [Decidable p] : (if p then (1:ℕ) else 0)≠0 ↔ p := by
  by_cases h : p <;> simp [h]

def shapeTest (c : Expr) (sh : Shape) : Expr :=
  .mul
    (Expr.listAll (List.finRange 3) fun i =>
      Expr.equal (signExpr c (RawInitialTables.slotOrder.symm i))
        (.const (bit (sh.1 (RawInitialTables.slotOrder.symm i)))))
    (Expr.listAll (List.finRange 3) fun i =>
      Expr.listAll (List.finRange 3) fun j =>
        Expr.equal
          (Expr.equal (nameExpr c (RawInitialTables.slotOrder.symm i))
            (nameExpr c (RawInitialTables.slotOrder.symm j)))
          (.const (bit (sh.2 (RawInitialTables.slotOrder.symm i) (RawInitialTables.slotOrder.symm j)))))

lemma shapeTest_nonzero (F : Target.Formula) (c : Expr) (a : ℕ → ℕ) (i : Fin F.clauses.length)
    (hi : c.eval (Complexity.formulaBits F) a=i.val) (sh : Shape) :
    (shapeTest c sh).eval (Complexity.formulaBits F) a≠0 ↔ sh=shape (clauseAt F i) := by
  have hs (s : Slot) := signExpr_eval F c a i hi s
  have hn (s : Slot) := nameExpr_eval F c a i hi s
  simp only [shapeTest,Expr.eval,Expr.listAll_eval,Expr.equal_eval,hs,hn,List.mem_finRange,
    forall_true_left,Nat.mul_ne_zero_iff,indicator_ne,Fin.val_inj]
  simp only [← bit_decide,bit_eq,Bool.decide_coe]
  constructor
  · rintro ⟨hs,hn⟩
    apply Prod.ext
    · funext s
      change sh.1 s=signAt (clauseAt F i) s
      simpa using (hs (RawInitialTables.slotOrder s)).symm
    · funext s t
      simpa [shape] using (hn (RawInitialTables.slotOrder s) (RawInitialTables.slotOrder t)).symm
  · rintro rfl
    exact ⟨fun _ => rfl,fun _ _ => rfl⟩

def shapeExpr (c : Expr) : Expr :=
  Expr.pick (fun sh : Shape => (Fintype.equivFin Shape sh).val) (shapeTest c)
lemma shapeExpr_eval (F : Target.Formula) (c : Expr) (a : ℕ → ℕ) (i : Fin F.clauses.length)
    (hi : c.eval (Complexity.formulaBits F) a=i.val) :
    (shapeExpr c).eval (Complexity.formulaBits F) a=(Fintype.equivFin Shape (shape (clauseAt F i))).val := by
  apply Expr.pick_eval
  exact shapeTest_nonzero F c a i hi

def repairExpr (c : Expr) (j : ClauseAnswer) (s : Slot) : Expr :=
  Expr.staticLookup (fun sh : Shape => bit (repairedBit sh j s)) (shapeExpr c)
lemma repairExpr_eval (F : Target.Formula) (c : Expr) (a : ℕ → ℕ) (i : Fin F.clauses.length)
    (hi : c.eval (Complexity.formulaBits F) a=i.val) (j : ClauseAnswer) (s : Slot) :
    (repairExpr c j s).eval (Complexity.formulaBits F) a=bit (answerAt (LCInput.repair (clauseAt F i) j) s) := by
  rw [repairExpr,Expr.staticLookup_eval _ _ _ _ _ (shapeExpr_eval F c a i hi),repairedBit_exact]

def selectSlot (x : Expr) (f : Slot → Expr) : Expr :=
  Expr.listSum (List.finRange 3) fun i =>
    .mul (Expr.equal x (.const i.val)) (f (RawInitialTables.slotOrder.symm i))
lemma selectSlot_eval (x : Expr) (f : Slot → Expr) (str : List Bool) (a : ℕ → ℕ) (s : Slot)
    (hs : x.eval str a=(RawInitialTables.slotOrder s).val) :
    (selectSlot x f).eval str a=(f s).eval str a := by
  simp only [selectSlot,Expr.listSum_eval,Expr.eval,Expr.equal_eval,hs,ite_mul,one_mul,zero_mul]
  rw [← List.ofFn_eq_map,List.sum_ofFn]
  simp [Fin.val_inj]

end LargeIndependentSets.TargetRepair

end

end OAI