File size: 7,453 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 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 | import Mathlib
import OAI.Combinatorics.MatchingCount.Machines.TreeListMore
import OAI.Combinatorics.MatchingCount.Tapes.Parse
namespace OAI
namespace MatchingFPRAS.LiteralInput
open TreeTyped TreeFunction Polynomial LiteralParse
abbrev PairState := (Bool×ℕ)×List (ℕ×ℕ)
def pairStep (x : ℕ×PairState) : PairState :=
if x.2.1.1 then ((false,0),(x.1,x.2.1.2)::x.2.2) else ((true,x.1),x.2.2)
def pairStepRealizer : Realizer pairStep :=
(choose second.fst.fst
(pair (constant (false,0)) (composition (pair (pair first second.fst.snd) second.snd) listCons))
(pair (pair (constant true) first) second.snd)).congr (by
intro x;simp only [Function.comp_apply,pairStep])
lemma polynomial_pairStep : PolynomialTime pairStepRealizer := by
unfold pairStepRealizer
apply polynomial_congr
dsimp only [Realizer.fst,Realizer.snd]
tree_cost
lemma pairStep_weight (n : ℕ) (s : PairState) : weight (pairStep (n,s)) ≤ weight s+weight n+4 := by
rcases s with ⟨⟨b,m⟩,es⟩
cases b
· change weight ((true,n),es) ≤ weight ((false,m),es)+weight n+4
simp only [weight_prod]
change 1+(1+3+weight n)+weight es ≤ 1+(1+1+weight m)+weight es+weight n+4
omega
· change weight ((false,0),(n,m)::es) ≤ weight ((true,m),es)+weight n+4
simp only [weight_prod,weight_cons]
change 1+(1+1+1)+(1+(1+weight n+weight m)+weight es) ≤
1+(1+3+weight m)+weight es+weight n+4
omega
lemma pairFold_weight (ns : List ℕ) (s : PairState) :
weight (ns.foldl (fun s n=>pairStep (n,s)) s) ≤ weight s+5*weight ns := by
induction ns generalizing s with
| nil => simp
| cons n ns ih =>
have h := ih (pairStep (n,s))
have h' := pairStep_weight n s
simp only [List.foldl_cons,weight_cons]
omega
lemma polynomial_pairFold : PolynomialTime (fold pairStepRealizer) := by
apply polynomial_fold polynomial_pairStep (6*X)
intro as s pre post he
have h := pairFold_weight pre s
have hw : weight pre ≤ weight as := by
have ha := weight_append pre post
have hp := weight_pos post
rw [he]
omega
simp only [Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X,weight_prod]
omega
def pairs (ns : List ℕ) : List (ℕ×ℕ) := (ns.foldl (fun s n=>pairStep (n,s)) ((false,0),[])).2
def pairsRealizer : Realizer pairs :=
(composition
(composition (pair identity (constant (((false,0),[]) : PairState))) (fold pairStepRealizer)) second).congr (fun _=>rfl)
lemma polynomial_pairs : PolynomialTime pairsRealizer :=
polynomial_congr _ (polynomial_composition (polynomial_composition (polynomial_pair polynomial_identity (polynomial_constant _))
polynomial_pairFold) polynomial_second)
lemma pair_pair (i j : ℕ) (es : List (ℕ×ℕ)) :
pairStep (i,pairStep (j,((false,0),es)))=((false,0),(i,j)::es) := rfl
lemma pairs_reverse (es : List (ℕ×ℕ)) (acc : List (ℕ×ℕ)) :
((es.flatMap (fun e=>[e.1,e.2])).reverse.foldl (fun s n=>pairStep (n,s)) ((false,0),acc))=
((false,0),es++acc) := by
induction es generalizing acc with
| nil => rfl
| cons e es ih =>
simp only [List.flatMap_cons,List.reverse_append,List.reverse_cons,List.reverse_nil,
List.nil_append,List.singleton_append,List.foldl_append,ih,List.foldl_cons,List.foldl_nil,pair_pair]
rfl
abbrev Parsed := ℕ×(List (ℕ×ℕ)×(TreeFraction.Fraction×TreeFraction.Fraction))
def ratTail (ns : List ℕ) : TreeFraction.Fraction×TreeFraction.Fraction :=
((ns.tail.tail.tail.headD 0,ns.tail.tail.headD 0),(ns.tail.headD 0,ns.headD 0))
def ratTailRealizer : Realizer ratTail :=
pair (pair (composition (composition (composition tail tail) tail) (head 0))
(composition (composition tail tail) (head 0)))
(pair (composition tail (head 0)) (head 0))
lemma polynomial_ratTail : PolynomialTime ratTailRealizer := by
unfold ratTailRealizer
exact TreeTyped.polynomial_pair
(TreeTyped.polynomial_pair
(polynomial_composition (polynomial_composition (polynomial_composition polynomial_tail polynomial_tail)
polynomial_tail) (polynomial_head _))
(polynomial_composition (polynomial_composition polynomial_tail polynomial_tail) (polynomial_head _)))
(TreeTyped.polynomial_pair (polynomial_composition polynomial_tail (polynomial_head _)) (polynomial_head _))
def fromNumbers (ns : List ℕ) : Parsed :=
(ns.headD 0,(pairs ns.tail.tail.reverse.tail.tail.tail.tail,ratTail ns.tail.tail.reverse))
def reversedTailRealizer : Realizer (fun ns : List ℕ=>ns.tail.tail.reverse) :=
composition (composition tail tail) reverse
def fromNumbersRealizer : Realizer fromNumbers :=
(pair (head 0) (pair
(composition (composition (composition (composition (composition reversedTailRealizer tail) tail) tail) tail) pairsRealizer)
(composition reversedTailRealizer ratTailRealizer))).congr (fun _=>rfl)
lemma polynomial_reversedTail : PolynomialTime reversedTailRealizer :=
polynomial_composition (polynomial_composition polynomial_tail polynomial_tail) polynomial_reverse
lemma polynomial_fromNumbers : PolynomialTime fromNumbersRealizer := by
unfold fromNumbersRealizer
apply polynomial_congr
apply polynomial_pair (polynomial_head _)
apply polynomial_pair
· exact polynomial_composition (polynomial_composition (polynomial_composition
(polynomial_composition (polynomial_composition polynomial_reversedTail polynomial_tail) polynomial_tail)
polynomial_tail) polynomial_tail) polynomial_pairs
· exact polynomial_composition polynomial_reversedTail polynomial_ratTail
def parseInput (as : List Symbol) : Parsed := fromNumbers (LiteralParse.parse as)
def parseInputRealizer : Realizer parseInput := composition LiteralParse.parseRealizer fromNumbersRealizer
lemma polynomial_parseInput : PolynomialTime parseInputRealizer :=
polynomial_composition LiteralParse.polynomial_parse polynomial_fromNumbers
def edgeNumbers (G : GraphInput) : List (ℕ×ℕ) :=
((G.edges.map toLex.toEmbedding).sort (·≤·)).map (fun e=>((ofLex e).1.val,(ofLex e).2.val))
lemma edges_fold (es : List (ℕ×ℕ)) (ns : List ℕ) :
(es.flatMap (fun e=>encodeNat e.1++encodeNat e.2)).foldr (fun a ns=>numStep (a,ns)) ns=
es.flatMap (fun e=>[e.1,e.2])++ns := by
induction es with
| nil => rfl
| cons e es ih =>
simp only [List.flatMap_cons,List.foldr_append,ih,encodeNat_fold]
rfl
lemma parse_source (G : GraphInput) (ε δ : ℚ) : LiteralParse.parse (encodeInput G ε δ)=
G.n::G.edges.card::(edgeNumbers G).flatMap (fun e=>[e.1,e.2])++[ε.num.natAbs,ε.den,δ.num.natAbs,δ.den] := by
unfold encodeInput LiteralParse.parse
simp only [List.foldr_append,encodeNat_fold,encodeRat_fold]
rw [show (((G.edges.map toLex.toEmbedding).sort (·≤·)).flatMap fun e=>encodeNat (ofLex e).1.val++encodeNat (ofLex e).2.val)=
(edgeNumbers G).flatMap (fun e=>encodeNat e.1++encodeNat e.2) by simp only [edgeNumbers,List.flatMap_map]]
rw [edges_fold]
rfl
lemma parseInput_source (G : GraphInput) (ε δ : ℚ) :
parseInput (encodeInput G ε δ)=(G.n,(edgeNumbers G,(TreeFraction.repr ε,TreeFraction.repr δ))) := by
rw [parseInput,parse_source]
unfold fromNumbers
simp only [List.cons_append,List.headD_cons,List.tail_cons,
List.reverse_append,List.reverse_cons,List.reverse_nil,List.nil_append]
unfold ratTail
simp only [List.headD_cons,List.tail_cons]
unfold pairs
rw [pairs_reverse]
simp only [List.append_nil]
rfl
end MatchingFPRAS.LiteralInput
end OAI
|