import Mathlib
import OAI.Combinatorics.IndependentSets.Reduction.Mixed
import OAI.Combinatorics.IndependentSets.Reduction.EnumerationSimple

namespace OAI

namespace LargeIndependentSets
open IndependentSetsGames.Foundations
open PCP Hastad.SourceContexts Hastad.SourceGame

namespace ExplicitEnum

def mapEquiv {A B : Type} (e : ExplicitEnum A) (f : A ≃ B) : ExplicitEnum B where
  values := e.values.map f
  nodup := e.nodup.map f.injective
  covers b := List.mem_map.mpr ⟨f.symm b,e.covers _,f.apply_symm_apply b⟩

def bool : ExplicitEnum Bool := ⟨[false,true],by decide,by intro b; cases b <;> simp⟩

def clauseAnswer : ExplicitEnum ClauseAnswer := mapEquiv (fin 8) clauseAnswerFinEquiv.symm

def slot : ExplicitEnum Slot := ⟨[.first,.second,.third],by decide,by intro s; cases s <;> simp⟩

def leftAnswer (u : ℕ) : ExplicitEnum (J u) := pi (fin u) (fun _ => clauseAnswer)
def rightAnswer (u : ℕ) : ExplicitEnum (I u) := pi (fin u) (fun _ => bool)
def clauses (F : Target.Formula) (u : ℕ) : ExplicitEnum (ClauseContext F u) :=
  pi (fin u) (fun _ => fin F.clauses.length)
def variablesEnum (F : Target.Formula) (u : ℕ) : ExplicitEnum (VariableContext F u) :=
  pi (fin u) (fun _ => fin F.variables)
def events (F : Target.Formula) (u : ℕ) : ExplicitEnum (Fin u → RandomEvent F) :=
  pi (fin u) (fun _ => prod (fin F.clauses.length) slot)

end ExplicitEnum

namespace NamedReduction
attribute [-instance] mixedTupleComputableFintype mixedTupleDecidableEq

noncomputable def staticCopies (p : SamplerParameters) (u : ℕ) :
    ExplicitEnum (p.Vertices (J u) (I u) Unit) := by
  classical
  exact ⟨Finset.univ.toList,Finset.nodup_toList _,fun x => Finset.mem_toList.mpr (Finset.mem_univ x)⟩

attribute [instance 1100] mixedTupleComputableFintype
attribute [instance] mixedTupleDecidableEq

instance cubeDecidableEq : (k : ℕ) → DecidableEq (BooleanJunta.Cube k)
  | 0 => inferInstanceAs (DecidableEq Unit)
  | k+1 => by
    letI := cubeDecidableEq k
    exact inferInstanceAs (DecidableEq (Bool × BooleanJunta.Cube k))

def vertexDecidable (p : SamplerParameters) (u : ℕ) (F : Target.Formula) :
    DecidableEq (p.Vertices (J u) (I u) (Fin u → RandomEvent F)) := by
  letI outcomeEq : DecidableEq (SamplerOutcome (J u) (I u) p.n p.s p.m p.k) := by
    unfold SamplerOutcome
    infer_instance
  delta SamplerParameters.Vertices RationalLaw.Vertices RationalLaw.Expanded
  exact @instDecidableEqProd _ _ (inferInstanceAs (DecidableEq (Fin p.n → Fin u → RandomEvent F)))
    (fun x y => decidable_of_iff (x.1=y.1 ∧ x.2.val=y.2.val) (by
      constructor
      · rintro ⟨h,hv⟩
        rcases x with ⟨a,i⟩
        rcases y with ⟨b,j⟩
        dsimp at h hv
        subst b
        have hi : i=j := Fin.ext hv
        subst j
        rfl
      · intro h; subst y; exact ⟨rfl,rfl⟩))

noncomputable def formula (H : RoundTables.BaseTable) (p : SamplerParameters)
    (u q : ℕ) (hq : 0<q) (F : Formula) : Graph := by
  let G := SemanticReduction.gapFormula H F
  letI := vertexDecidable p u G
  exact p.namedOutput q hq (LCInput.labelCover G u)
    (ExplicitEnum.clauses G u) (ExplicitEnum.variablesEnum G u)
    (ExplicitEnum.leftAnswer u) (ExplicitEnum.rightAnswer u)
    (ExplicitEnum.events G u) (staticCopies p u)

attribute [-instance] mixedTupleComputableFintype mixedTupleDecidableEq
noncomputable def formula_renaming (H : RoundTables.BaseTable) (p : SamplerParameters)
    (u q : ℕ) (hq : 0<q) (F : Formula) :
    Graph.Renaming (formula H p u q hq F) (SemanticReduction.reduce H p u q hq F) := by
  let G := SemanticReduction.gapFormula H F
  letI := vertexDecidable p u G
  exact p.namedOutput_renaming q hq (LCInput.labelCover G u)
    (ExplicitEnum.clauses G u) (ExplicitEnum.variablesEnum G u)
    (ExplicitEnum.leftAnswer u) (ExplicitEnum.rightAnswer u)
    (ExplicitEnum.events G u) (staticCopies p u)
attribute [instance 1100] mixedTupleComputableFintype
attribute [instance] mixedTupleDecidableEq

lemma bits_length_of_vertices (G H : Graph) (h : G.vertices=H.vertices) :
    (graphBits G).length = (graphBits H).length := by
  have hh (G : Graph) : (graphBits G).length = (nameBits G.vertices).length + G.vertices^2 := by
    unfold graphBits
    rw [List.length_append]
    congr 1
    have hx (xs : List (Fin G.vertices)) :
        (xs.flatMap (fun i => (List.finRange G.vertices).map (G.adj i))).length =
          xs.length * G.vertices := by
      induction xs with
      | nil => simp
      | cons i xs ih => simp only [List.flatMap_cons,List.length_append,List.length_map,
          List.length_finRange,List.length_cons,ih]; ring
    simpa only [List.length_finRange, pow_two] using hx (List.finRange G.vertices)
  rw [hh,hh,h]

noncomputable def total (H : RoundTables.BaseTable) (p : SamplerParameters)
    (u q : ℕ) (hq : 0<q) (b : List Bool) : Graph :=
  formula H p u q hq (BinaryParser.decode b)

theorem total_named_semantic_reduction {δ : ℚ} (hδ : 0<δ) :
    ∃ H : RoundTables.BaseTable, ∃ p : SamplerParameters, ∃ u q : ℕ, ∃ hq : 0<q,
    (∀ b, (graphBits (total H p u q hq b)).length ≤
      (SemanticReduction.totalPolynomial p u q).eval b.length) ∧
    (∀ F : Formula, F.Satisfiable → (total H p u q hq (formulaBits F)).ThreeColorable) ∧
    (∀ F : Formula, ¬F.Satisfiable →
      ((total H p u q hq (formulaBits F)).independenceNumber : ℚ) <
        δ*(total H p u q hq (formulaBits F)).vertices) := by
  obtain ⟨H,p,u,q,hq,hyes,hno⟩ := semantic_reduction hδ
  refine ⟨H,p,u,q,hq,?_,?_,?_⟩
  · intro b
    have e := formula_renaming H p u q hq (BinaryParser.decode b)
    have hl := bits_length_of_vertices _ _ e.vertices_eq
    change (graphBits (formula H p u q hq (BinaryParser.decode b))).length ≤ _
    rw [hl]
    exact SemanticReduction.total_output_bound H p u q hq b
  · intro F hF
    simpa only [total,BinaryParser.decode_encoded] using
      (formula_renaming H p u q hq F).symm.colorable (hyes F hF)
  · intro F hF
    have e := formula_renaming H p u q hq F
    have hv := e.vertices_eq
    have ha := e.alpha_eq
    simpa only [total,BinaryParser.decode_encoded,ha,hv] using hno F hF

end NamedReduction
end LargeIndependentSets

end OAI