| import OAI.Computability.LoopMatching.Model |
| import OAI.Computability.MatchingCount.BinaryParser |
|
|
| namespace OAI |
|
|
| /-! Polynomial-time approximation of weighted matchings with singleton loops. -/ |
|
|
| namespace LoopMatching.InputMachine |
| open BinaryMatching BinaryMatching.StackCode Polynomial |
|
|
| def countedRecords (k : ℕ) (l : List Bool) : List Bool × List Parse.RecordBits := |
| Parse.recordStep^[k] (l,[]) |
|
|
| lemma recordStep_records_suffix (rs : List BinaryMatching.Record) |
| (suffix : List Bool) (acc : List Parse.RecordBits) : |
| Parse.recordStep^[rs.length] (rs.flatMap encodeRecord ++ suffix,acc) = |
| (suffix,acc ++ rs.map Parse.recordRepr) := 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,Parse.recordStep_encode,ih] |
| simp [List.append_assoc] |
|
|
| lemma countedRecords_encoded (rs : List BinaryMatching.Record) (suffix : List Bool) : |
| countedRecords rs.length (rs.flatMap encodeRecord ++ suffix) = |
| (suffix,rs.map Parse.recordRepr) := by |
| simpa only [countedRecords,List.nil_append] using |
| recordStep_records_suffix rs suffix [] |
|
|
| @[fun_prop] theorem countedRecords_poly : |
| Poly (fun z : ℕ × List Bool => countedRecords z.1 z.2) := by |
| have hs : Poly Parse.recordStep := by unfold Parse.recordStep; fun_prop |
| have hi := Poly.boundedIterate Parse.recordStep hs (100*(X+1)^2) (by |
| intro z j hj |
| obtain ⟨h₁,h₂⟩ := Parse.recordStep_iterate_size j z.2 |
| have he : (encode (Parse.recordStep^[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.comp _ (fun z : ℕ × List Bool => (z.1,(z.2,([]:List Parse.RecordBits)))) |
| hi (by fun_prop) |
|
|
| def ordinaryPrefix (l : List Bool) : List Bool × (List Bool × List Parse.RecordBits) := |
| let n := Parse.numeral l |
| let r := Parse.numeral n.2 |
| (n.1,countedRecords (Parse.boundedValue l.length r.1) r.2) |
|
|
| @[fun_prop] theorem ordinaryPrefix_poly : Poly ordinaryPrefix := by |
| unfold ordinaryPrefix |
| fun_prop |
|
|
| lemma ordinaryPrefix_encoded (G : LoopMatching.Input) : |
| ordinaryPrefix (LoopMatching.encodeInput G) = |
| (G.n.bits,(encodeNat G.loops.length ++ G.loops.flatMap encodeLoopRecord, |
| G.ordinary.records.map Parse.recordRepr)) := by |
| have hr := Parse.records_length_le_bits G.ordinary.records |
| have hbound : G.ordinary.records.length ≤ (LoopMatching.encodeInput G).length := by |
| simp only [LoopMatching.encodeInput,BinaryMatching.encodeInput,List.length_append] |
| omega |
| unfold ordinaryPrefix LoopMatching.encodeInput BinaryMatching.encodeInput |
| simp only [List.append_assoc,Parse.numeral_encode,Parse.boundedValue_bits] |
| simp only [LoopMatching.encodeInput,BinaryMatching.encodeInput,List.append_assoc] at hbound |
| rw [min_eq_right hbound,countedRecords_encoded] |
|
|
| end LoopMatching.InputMachine |
|
|
| end OAI |
|
|
