| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Machines.TreeSum |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.TreeTyped |
| variable {A B A' B' : Type} [Codec A] [Codec B] [Codec A'] [Codec B'] |
| def Realizer.reencode {f : A→B} (F : Realizer f) (i : A'→A) (g : A'→B') |
| (hi : ∀ a,encode (i a)=encode a) (hg : ∀ a,encode (g a)=encode (f (i a))) : Realizer g where |
| program := F.program |
| cost a := F.cost (i a) |
| correct := by |
| intro a s |
| have h:=F.correct (i a) s |
| rw [hi a,←hg a] at h |
| exact h |
| lemma polynomial_reencode {f : A→B} (F : Realizer f) (i : A'→A) (g : A'→B') |
| (hi : ∀ a,encode (i a)=encode a) (hg : ∀ a,encode (g a)=encode (f (i a))) |
| (hF : PolynomialTime F) : PolynomialTime (F.reencode i g hi hg) := by |
| obtain ⟨p,hp⟩:=hF |
| refine ⟨p,fun a=>?_⟩ |
| have h:=hp (i a) |
| simpa only [Realizer.reencode,weight,hi a,←hg a] using h |
| end MatchingFPRAS.TreeTyped |
|
|
| namespace MatchingFPRAS.LiteralCodec |
| open TreeTyped TreeData TreeFunction |
|
|
| def parts (a : Symbol) : List Bool×List Bool := |
| (List.replicate a.val false,List.replicate (7-a.val) false) |
| instance : Codec Symbol := ⟨fun a=>TreeTyped.encode (parts a)⟩ |
| lemma encode_parts (a : Symbol) : TreeTyped.encode (parts a)=TreeTyped.encode a := rfl |
| lemma weight_false_list (n : ℕ) : weight (List.replicate n false)=2*n+1 := by |
| induction n with |
| | zero => rfl |
| | succ n ih => rw [List.replicate_succ,weight_cons,ih]; change 1+1+(2*n+1)=_; omega |
| lemma weight_symbol (a : Symbol) : weight a=17 := by |
| change weight (parts a)=17 |
| simp only [parts,weight_prod,weight_false_list] |
| have ha:=a.isLt |
| omega |
| lemma weight_word (as : List Symbol) : weight as=18*as.length+1 := by |
| induction as with |
| | nil => rfl |
| | cons a as ih => rw [weight_cons,weight_symbol,ih,List.length_cons]; omega |
|
|
| def valRealizer : Realizer (Fin.val : Symbol→ℕ) := |
| (composition first listLength).reencode parts Fin.val encode_parts (fun a=>by simp [parts]) |
| lemma polynomial_val : PolynomialTime valRealizer := |
| polynomial_reencode _ _ _ _ _ (polynomial_composition polynomial_first polynomial_listLength) |
|
|
| def fromBit (b : Bool) : Symbol := if b then 2 else 1 |
| def fromBitRealizer : Realizer fromBit := choose identity (constant 2) (constant 1) |
| lemma polynomial_fromBit : PolynomialTime fromBitRealizer := |
| polynomial_choose polynomial_identity (polynomial_constant _) (polynomial_constant _) |
| def natWord (n : ℕ) : List Symbol := (n.bits.map fromBit)++[3] |
| def natWordRealizer : Realizer natWord := |
| (composition (pair (composition toBits (map fromBitRealizer)) (constant [3])) append).congr (fun _=>rfl) |
| lemma polynomial_natWord : PolynomialTime natWordRealizer := by |
| unfold natWordRealizer |
| apply polynomial_congr |
| have := polynomial_fromBit |
| have := polynomial_toBits |
| have := polynomial_map polynomial_fromBit |
| tree_cost |
| lemma natWord_eq (n : ℕ) : natWord n=encodeNat n := rfl |
|
|
| def ratWord (x : TreeFraction.Fraction) : List Symbol := 4::natWord x.1++natWord x.2 |
| def ratWordRealizer : Realizer ratWord := |
| (composition (pair (constant 4) (composition (pair (composition first natWordRealizer) |
| (composition second natWordRealizer)) append)) listCons).congr (fun _=>rfl) |
| lemma polynomial_ratWord : PolynomialTime ratWordRealizer := by |
| unfold ratWordRealizer |
| apply polynomial_congr |
| have := polynomial_natWord |
| tree_cost |
| lemma ratWord_repr (q : ℚ) (hq : 0≤q) : ratWord (TreeFraction.repr q)=encodeRat q := by |
| have hn : ¬q.num<0 := not_lt.mpr (Rat.num_nonneg.mpr hq) |
| simp only [ratWord,TreeFraction.repr,natWord_eq,encodeRat,encodeInt,ite_eq_right hn,List.singleton_append] |
| end MatchingFPRAS.LiteralCodec |
|
|
| end OAI |
|
|
