lean/OAI/Computability/LoopMatching/LoopParser.lean

import OAI.Computability.LoopMatching.CountedParser
import OAI.Computability.LoopMatching.InputDecode

namespace OAI

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

namespace LoopMatching.InputMachine
open BinaryMatching BinaryMatching.StackCode Polynomial

def loopRecord (l : List Bool) : LoopBits × List Bool :=
  let a := Parse.numeral l
  let b := Parse.numeral a.2
  ((a.1,b.1),b.2)

lemma loopRecord_encode (r : LoopRecord) (l : List Bool) :
    loopRecord (encodeLoopRecord r ++ l)=(loopBitsRepr r,l) := by
  unfold loopRecord encodeLoopRecord
  simp only [List.append_assoc,Parse.numeral_encode]
  rfl

@[fun_prop] theorem loopRecord_poly : Poly loopRecord := by unfold loopRecord; fun_prop

lemma loopRecord_size (l : List Bool) : (loopRecord l).2.length≤l.length ∧
    (encode (loopRecord l).1).length≤20*l.length+10 := by
  have h₁ := Parse.numeral_lengths l
  have h₂ := Parse.numeral_lengths (Parse.numeral l).2
  simp only [loopRecord,code_pair_length,cut_code_length]
  omega

def loopStep (z : List Bool × List LoopBits) : List Bool × List LoopBits :=
  if z.1.isEmpty then z else ((loopRecord z.1).2,z.2++[(loopRecord z.1).1])

lemma encodeLoopRecord_ne_nil (r : LoopRecord) : encodeLoopRecord r≠[] := by
  simp [encodeLoopRecord,encodeNat]

lemma loopStep_encode (r : LoopRecord) (l : List Bool) (acc : List LoopBits) :
    loopStep (encodeLoopRecord r ++ l,acc)=(l,acc++[loopBitsRepr r]) := by
  simp [loopStep,List.isEmpty_iff,List.append_eq_nil_iff,
    encodeLoopRecord_ne_nil,loopRecord_encode]

lemma loopStep_records_suffix (rs : List LoopRecord) (suffix : List Bool)
    (acc : List LoopBits) :
    loopStep^[rs.length] (rs.flatMap encodeLoopRecord ++ suffix,acc)=
      (suffix,acc++rs.map loopBitsRepr) := by
  induction rs generalizing acc with
  | nil => simp
  | cons r rs ih =>
    rw [List.length_cons,Function.iterate_succ_apply,List.flatMap_cons,
      List.append_assoc,loopStep_encode,ih]
    simp [List.append_assoc]

lemma loopRecords_length_le_bits (rs : List LoopRecord) :
    rs.length ≤ (rs.flatMap encodeLoopRecord).length := by
  induction rs with
  | nil => simp
  | cons r rs ih =>
    have hr := List.length_pos_iff.mpr (encodeLoopRecord_ne_nil r)
    simp only [List.length_cons,List.flatMap_cons,List.length_append]
    omega

lemma loopStep_size (z : List Bool × List LoopBits) :
    (loopStep z).1.length≤z.1.length ∧
    (encode (loopStep z).2).length≤(encode z.2).length+40*z.1.length+21 := by
  have hr := loopRecord_size z.1
  unfold loopStep
  split_ifs
  · simp; omega
  · simp only [code_append,List.length_append,code_cons,pairBits_length,List.length_nil,code_nil]
    omega

lemma loopStep_iterate_size (k : ℕ) (z : List Bool × List LoopBits) :
    (loopStep^[k] z).1.length≤z.1.length ∧
    (encode (loopStep^[k] z).2).length≤(encode z.2).length+k*(40*z.1.length+21) := by
  induction k with
  | zero => simp
  | succ k ih =>
    rw [Function.iterate_succ_apply']
    have h := loopStep_size (loopStep^[k] z)
    constructor
    · exact h.1.trans ih.1
    · nlinarith

def countedLoops (k : ℕ) (l : List Bool) : List LoopBits := (loopStep^[k] (l,[])).2

@[fun_prop] theorem countedLoops_poly : Poly (fun z : ℕ × List Bool => countedLoops z.1 z.2) := by
  have hs : Poly loopStep := by unfold loopStep; fun_prop
  have hi := Poly.boundedIterate loopStep hs (100*(X+1)^2) (by
    intro z j hj
    obtain ⟨h₁,h₂⟩ := loopStep_iterate_size j z.2
    have he : (encode (loopStep^[j] z.2)).length ≤
        6*z.2.1.length+(encode z.2.2).length+j*(40*z.2.1.length+21)+1 := by
      simp only [code_pair_length,cut_code_length]
      omega
    have hl : z.2.1.length≤(encode z).length := by
      simp only [code_pair_length,code_nat_length,cut_code_length]; omega
    have hk : j≤(encode z).length := by
      simp only [code_pair_length,code_nat_length]; omega
    have ha : (encode z.2.2).length≤(encode z).length := by
      simp only [code_pair_length]; omega
    have hm := Nat.mul_le_mul hk hl
    simp only [eval_mul,eval_ofNat,eval_pow,eval_add,eval_X,eval_one]
    nlinarith)
  exact Poly.second _ (Poly.comp _
    (fun z : ℕ × List Bool => (z.1,(z.2,([]:List LoopBits)))) hi (by fun_prop))

lemma countedLoops_encoded (rs : List LoopRecord) :
    countedLoops rs.length (rs.flatMap encodeLoopRecord)=rs.map loopBitsRepr := by
  have h := loopStep_records_suffix rs [] []
  simpa only [countedLoops,List.append_nil,List.nil_append] using congrArg Prod.snd h

def loops (l : List Bool) : List LoopBits :=
  let a := Parse.numeral l
  countedLoops (Parse.boundedValue l.length a.1) a.2

@[fun_prop] theorem loops_poly : Poly loops := by unfold loops; fun_prop

lemma loops_encoded (rs : List LoopRecord) :
    loops (encodeNat rs.length ++ rs.flatMap encodeLoopRecord)=rs.map loopBitsRepr := by
  have h := loopRecords_length_le_bits rs
  have hb : rs.length ≤ (encodeNat rs.length ++ rs.flatMap encodeLoopRecord).length := by
    rw [List.length_append]
    omega
  unfold loops
  rw [Parse.numeral_encode]
  dsimp only
  rw [Parse.boundedValue_bits,min_eq_right hb,countedLoops_encoded]

def parse (l : List Bool) : BitsData :=
  let a := ordinaryPrefix l
  (a.1,(a.2.2,loops a.2.1))

@[fun_prop] theorem parse_poly : Poly parse := by unfold parse; fun_prop

lemma parse_encoded (G : LoopMatching.Input) : parse (LoopMatching.encodeInput G)=bitsRepr G := by
  unfold parse
  rw [ordinaryPrefix_encoded]
  dsimp only
  rw [loops_encoded]
  rfl

def prepare (l : List Bool) : Option Data :=
  let z := decode (parse l)
  if 2*z.2.1.length+z.2.2.length<z.1 then none else some z

@[fun_prop] theorem prepare_poly : Poly prepare := by
  have h : Poly (fun l : List Bool =>
      if decide (2*(decode (parse l)).2.1.length+(decode (parse l)).2.2.length <
        (decode (parse l)).1) then (none : Option Data) else some (decode (parse l))) := by
    fun_prop
  exact h.congr (fun l => by simp only [prepare,decide_eq_true_eq])

lemma prepare_encoded (G : LoopMatching.Input) :
    prepare (LoopMatching.encodeInput G)=
      if 2*G.ordinary.records.length+G.loops.length<G.n then none else some (repr G) := by
  unfold prepare
  rw [parse_encoded]
  by_cases h : 2*G.ordinary.records.length+G.loops.length<G.n
  · rw [ite_eq_left h,ite_eq_left ((sparse_guard_repr G).mpr h)]
  · rw [ite_eq_right h,ite_eq_right (by simpa only [sparse_guard_repr] using h),decode_repr G (by omega)]

lemma prepare_encoded_pass (G : LoopMatching.Input)
    (h : G.n ≤ 2*G.ordinary.records.length+G.loops.length) :
    prepare (LoopMatching.encodeInput G)=some (repr G) := by
  rw [prepare_encoded,ite_eq_right (by omega)]

lemma prepare_encoded_reject (G : LoopMatching.Input)
    (h : 2*G.ordinary.records.length+G.loops.length<G.n) :
    prepare (LoopMatching.encodeInput G)=none := by rw [prepare_encoded,ite_eq_left h]

end LoopMatching.InputMachine

end OAI