import OAI.Computability.LoopMatching.LoopParser
import OAI.Computability.LoopMatching.RawAccumulator
import OAI.Computability.LoopMatching.BitNormalize
import OAI.Computability.LoopMatching.Approximation

namespace OAI

/-! Polynomial-time approximation of weighted matchings with singleton loops. -/

namespace LoopMatching.MachineMain
open BinaryMatching.StackCode

def packBits (l : List Bool) : List Bool :=
  let b := BitNormalize.normalize l
  List.replicate b.length false ++ true :: b

@[fun_prop] theorem packBits_poly : Poly packBits := by
  unfold packBits
  fun_prop

lemma packBits_value (l : List Bool) :
    packBits l = BinaryMatching.encodeNat (BitAdd.value l) := by
  simp only [packBits,BitNormalize.normalize_eq_bits,BinaryMatching.encodeNat]

lemma packBits_length (l : List Bool) :
    (packBits l).length = 2*(BitNormalize.normalize l).length+1 := by
  simp only [packBits,List.length_append,List.length_replicate,List.length_cons]
  omega

def serialize (p : List Bool × List Bool) : List Bool := packBits p.1 ++ packBits p.2

@[fun_prop] theorem serialize_poly : Poly serialize := by
  unfold serialize
  fun_prop

lemma serialize_values (p : List Bool × List Bool) :
    serialize p = encodeOutput (BitAdd.value p.1,BitAdd.value p.2) := by
  simp only [serialize,packBits_value,encodeOutput]

lemma serialize_rawAccumulator (G : Input) :
    serialize (RawAccumulator.rawAccumulator (InputMachine.repr G)) =
      encodeOutput (Approximation.output G) := by
  obtain ⟨hq,hd⟩ := RawAccumulator.rawAccumulator_repr G
  rw [serialize_values,hq,hd]
  rfl

def rawPair (l : List Bool) : List Bool × List Bool :=
  (InputMachine.prepare l).elim ([],[true]) RawAccumulator.rawAccumulator

@[fun_prop] theorem rawPair_poly : Poly rawPair := by
  exact Poly.comp _ InputMachine.prepare
    (Poly.optionElim ([],[true]) RawAccumulator.rawAccumulator
      RawAccumulator.rawAccumulator_poly) InputMachine.prepare_poly

def runInput (l : List Bool) : List Bool := serialize (rawPair l)

@[fun_prop] theorem runInput_poly : Poly runInput := by
  unfold runInput
  fun_prop

def A (G : Input) : ℕ × ℕ :=
  if 2*G.ordinary.records.length+G.loops.length<G.n then (0,1)
  else Approximation.output G

lemma runInput_encoded (G : Input) : runInput (encodeInput G)=encodeOutput (A G) := by
  unfold runInput rawPair
  rw [InputMachine.prepare_encoded]
  unfold A
  by_cases h : 2*G.ordinary.records.length+G.loops.length<G.n
  · simp only [ite_eq_left h]
    change serialize ([],[true]) = encodeOutput (0,1)
    rw [serialize_values]
    rfl
  · simp only [ite_eq_right h]
    exact serialize_rawAccumulator G

def bitAlgorithm (b : Bits) : Bits := ⟨runInput b.data⟩

theorem bitAlgorithm_poly : Poly bitAlgorithm := by
  change Poly (fun b : Bits => Bits.mk (runInput b.data))
  exact Poly.comp Bits.mk (fun b : Bits => runInput b.data) Poly.bitsEncode
    (Poly.comp runInput Bits.data runInput_poly Poly.bitsDecode)

noncomputable def binaryRoutine : Routine Bits.data Bits.data bitAlgorithm :=
  bitAlgorithm_poly.routine

lemma bitAlgorithm_encoded (G : Input) :
    (bitAlgorithm ⟨encodeInput G⟩).data=encodeOutput (A G) :=
  runInput_encoded G

noncomputable def countingRoutine : Routine encodeInput encodeOutput A :=
  binaryRoutine.reindex encodeInput encodeOutput A (fun G => Bits.mk (encodeInput G))
    (fun _ => rfl) bitAlgorithm_encoded

theorem computational_endpoint :
    ∃ machine : Turing.TM2ComputableInPolyTime encodeInput encodeOutput A,
      (∀ k, Finite (machine.tm.Γ k)) ∧
      (∃ P : Polynomial ℕ, ∀ G,
        (encodeOutput (A G)).length ≤ P.eval (encodeInput G).length) := by
  refine ⟨countingRoutine.machine,countingRoutine.machine_alphabets_finite,?_⟩
  refine ⟨Polynomial.X+countingRoutine.time,?_⟩
  intro G
  simpa only [Polynomial.eval_add,Polynomial.eval_X] using countingRoutine.length_bound G

end LoopMatching.MachineMain

end OAI