File size: 3,636 Bytes
e5a97c6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 | 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
|