import Mathlib

namespace OAI

   
                                                                         
                                                                

                                                                          
                                                                         
                                                                        
                                                                      
  
namespace MinUncutGames.BinaryFormula

structure Literal where
  name : Nat
  positive : Bool
  deriving DecidableEq

def Literal.eval (literal : Literal) (assignment : Nat → Bool) : Bool :=
  if literal.positive then assignment literal.name else !(assignment literal.name)

abbrev Clause := Vector Literal 3

def Clause.eval (clause : Clause) (assignment : Nat → Bool) : Bool :=
  (clause[0].eval assignment || clause[1].eval assignment) || clause[2].eval assignment

structure Formula where
  clauses : List Clause

def Formula.Satisfiable (F : Formula) : Prop :=
  ∃ assignment : Nat → Bool, ∀ clause ∈ F.clauses, clause.eval assignment = true

end MinUncutGames.BinaryFormula

namespace MinUncutGames.BinaryEncoding
open BinaryFormula

def frame : List Bool → List Bool
  | [] => [false]
  | b :: bits => true :: b :: frame bits

def nameBits (name : Nat) : List Bool := frame name.bits

def literalBits (literal : Literal) : List Bool :=
  literal.positive :: nameBits literal.name

def clauseBits (clause : Clause) : List Bool :=
  literalBits clause[0] ++ literalBits clause[1] ++ literalBits clause[2]

def clausesBits : List Clause → List Bool
  | [] => [false]
  | clause :: clauses => true :: (clauseBits clause ++ clausesBits clauses)

def formulaBits (formula : Formula) : List Bool := clausesBits formula.clauses

end MinUncutGames.BinaryEncoding

namespace MinUncut
open MinUncutGames.BinaryFormula MinUncutGames.BinaryEncoding

                                                                        
                                                                           
structure Output where
  vertices : ℕ
  adjacent : Fin vertices → Fin vertices → Bool
  symmetric : ∀ u v, adjacent u v = adjacent v u
  loopless : ∀ u, adjacent u u = false
  threshold : ℕ
  threshold_pos : 1 ≤ threshold

                                                                              
                                                           
def Output.uncut (G : Output) (cut : Fin G.vertices → Bool) : ℕ :=
  (Finset.univ.filter fun uv : Fin G.vertices × Fin G.vertices =>
    uv.1 < uv.2 ∧ G.adjacent uv.1 uv.2 = true ∧ cut uv.1 = cut uv.2).card

                                                                             
                                     
noncomputable def Output.opt (G : Output) : ℕ :=
  (Finset.univ.image G.uncut).min' (by
    exact Finset.image_nonempty.mpr Finset.univ_nonempty)

                                                                        
                                                                           
def Output.bits (G : Output) : List Bool :=
  nameBits G.vertices ++
    ((List.finRange G.vertices).flatMap fun u =>
      (List.finRange G.vertices).map fun v => G.adjacent u v) ++
    nameBits G.threshold

                                                                               
                                                             
def inputBits (input : ℕ × Formula) : List Bool :=
  nameBits input.1 ++ formulaBits input.2

                                                                            
                                                                         
                                                                       
                                                                 
structure Reduction where
  reduce : ℕ → Formula → Output
  machine : Turing.TM2Computable inputBits Output.bits (fun p => reduce p.1 p.2)
  finiteAlphabet : ∀ k : machine.tm.K, Finite (machine.tm.Γ k)
  time : ℕ → Polynomial ℕ
  runtime : ∀ K φ,
    Turing.TM2OutputsInTime machine.tm
      ((inputBits (K, φ)).map machine.inputAlphabet.symm)
      (some (((reduce K φ).bits).map machine.outputAlphabet.symm))
      ((time K).eval (formulaBits φ).length)
  size : ℕ → Polynomial ℕ
  output_size : ∀ K φ,
    (reduce K φ).vertices + (reduce K φ).bits.length ≤
      (size K).eval (formulaBits φ).length
  yes : ∀ K, 2 ≤ K → ∀ φ, φ.Satisfiable →
    (reduce K φ).opt ≤ (reduce K φ).threshold
  no : ∀ K, 2 ≤ K → ∀ φ, ¬ φ.Satisfiable →
    K * (reduce K φ).threshold < (reduce K φ).opt

end MinUncut

end OAI