import OAI.Computability.LoopMatching.ExpandInput
import OAI.Computability.MatchingCount.BinarySolve

namespace OAI

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

namespace LoopMatching.InputMachine
open BinaryMatching BinaryMatching.StackCode

abbrev LoopData := ℕ × List Bool
abbrev Data := ℕ × (List Raw.InputData.Rec × List LoopData)

def loopRepr (r : LoopRecord) : LoopData := (r.vertex,r.multiplicity.bits)
def repr (G : LoopMatching.Input) : Data :=
  (G.n,(G.ordinary.records.map Raw.InputData.repr,G.loops.map loopRepr))

def crossBlock (n j : ℕ) (r : LoopData) : List Raw.InputData.Rec :=
  (List.range j).map (fun d => (r.1,(n+d,r.2)))

def cross (n j : ℕ) (rs : List LoopData) : List Raw.InputData.Rec :=
  rs.flatMap (crossBlock n j)

def expanded (z : Data) (j : ℕ) : Raw.InputData.Data :=
  (z.1+j,z.2.1 ++ cross z.1 j z.2.2)

@[fun_prop] theorem crossBlock_poly :
    Poly (fun z : (ℕ × ℕ) × LoopData => crossBlock z.1.1 z.1.2 z.2) := by
  exact Poly.mapWith (fun z : (ℕ × ℕ) × LoopData => List.range z.1.2)
    (fun z : ((ℕ × ℕ) × LoopData) × ℕ =>
      (z.1.2.1,(z.1.1.1+z.2,z.1.2.2))) (by fun_prop) (by fun_prop)

@[fun_prop] theorem cross_poly :
    Poly (fun z : (ℕ × ℕ) × List LoopData => cross z.1.1 z.1.2 z.2) := by
  apply Poly.flatMapWith (fun z : (ℕ × ℕ) × List LoopData => z.2)
    (fun z : ((ℕ × ℕ) × List LoopData) × LoopData =>
      crossBlock z.1.1.1 z.1.1.2 z.2) (by fun_prop)
  exact Poly.comp _ (fun z : ((ℕ × ℕ) × List LoopData) × LoopData =>
    (z.1.1,z.2)) crossBlock_poly (by fun_prop)

@[fun_prop] theorem expanded_poly : Poly (fun z : Data × ℕ => expanded z.1 z.2) := by
  have hc : Poly (fun z : Data × ℕ => cross z.1.1 z.2 z.1.2.2) :=
    Poly.comp _ (fun z : Data × ℕ => ((z.1.1,z.2),z.1.2.2)) cross_poly (by fun_prop)
  unfold expanded
  fun_prop

lemma cross_repr (n j : ℕ) (rs : List LoopRecord) :
    cross n j (rs.map loopRepr) = (crossRecords n j rs).map Raw.InputData.repr := by
  induction rs with
  | nil => rfl
  | cons r rs ih =>
    simp only [List.map_cons, cross, List.flatMap_cons, crossRecords, List.map_append]
    rw [← cross, ih]
    simp only [crossBlock, List.map_map]
    rfl

lemma expanded_repr (G : LoopMatching.Input) (j : ℕ) :
    expanded (repr G) j = ((expand G j).n,(expand G j).records.map Raw.InputData.repr) := by
  simp only [expanded, repr, cross_repr, expand, List.map_append]

def call (z : Data) (j : ℕ) : List Bool := Raw.InputData.solve (expanded z j)

@[fun_prop] theorem call_poly : Poly (fun z : Data × ℕ => call z.1 z.2) :=
  Poly.comp Raw.InputData.solve _ Raw.InputData.solve_poly expanded_poly

lemma solve_repr (G : BinaryMatching.Input) :
    Raw.InputData.solve (G.n,G.records.map Raw.InputData.repr) =
      (Raw.InputData.sparseEstimate G).bits := by
  unfold Raw.InputData.solve Raw.InputData.sparseEstimate
  simp only [List.length_map]
  split_ifs
  · rfl
  · exact Raw.InputData.smallSolve_repr G

lemma call_repr (G : LoopMatching.Input) (j : ℕ) :
    call (repr G) j = (Raw.InputData.sparseEstimate (expand G j)).bits := by
  rw [call, expanded_repr, solve_repr]

end LoopMatching.InputMachine

end OAI