Pola: a language for PTIME Programming. Mike Burrell, Robin Cockett, Brian Redmond LCC 2009

Transcription

1 Pola: a language for PTIME Programming Mike Burrell, Robin Cockett, Brian Redmond LCC 2009

2 Pola overview Allows for general inductive data types And coinductive as well! Breaks variables into two separate worlds Player Affine Opponent Drives recursion

3 Inductive world Allow constructing typical inductive data types data Nat c = Zero : c Succ : c c data List(a) c = Nil : c Cons : a, c c E.g., [a, b] = Cons(a, Cons(b, Nil)) data Tree(a) c = Leaf : a c Node : c, c c Function application, but no recursion!

4 iszero :: Nat Bool; iszero = x.case x of { Zero.True; Succ( ).False }; isempty :: List(a) Bool; isempty = lst.case lst of { Nil.True; Cons(, ).False }; isempty([2, 3]) False

5 Safe recursion The fold construct introduces a safe recursive function What s being folded over must be in the opponent world Everything else in the fold must be in the player world x must be of a universal type add :: Nat Nat Nat; add = x y.fold f(x, y) as { Zero.n; y)) } in f(x, y ); mul :: Nat, Nat Nat; mul = x, y.fold f(x) as { Zero.Zero; f(m)) } in f(x, y );

6 Opponent and player world f = a.fold f(a, b) as { No restrictions in the opponent world.... f(m, b)) } in f(a, Zero);

7 Opponent and player world f = a.fold f(a) as {... } in f(a ); f = a.fold f(a) as {... } in f(a ); f = a.fold f(a) as {... } in f(succ(zero));

8 No exponential mul :: Nat, Nat Nat; exp = x, y.fold f(x) as { Zero.Succ(Zero); f(m)) } in f(x, y );

9 No exponential mul :: Nat, Nat Nat; exp = x, y.fold f(x) as { Zero.Succ(Zero); f(m)) } in f(x, y );

10 Opponent/player round-up Generally no restrictions in the opponent world, but... The opponent context must stay constant within a safe recursion! The player world is restrictive No duplicating! Variables can t be brought to the opponent world

11 Γ,x: X x : X id o Γ,y : Y y : Y id p Γ t : Y Γ,x: X t : Y weak o Γ t : Y Γ,y : Y t : Y weak p Γ t : X Γ,x: X t : Y Γ t [t/x] :Y cut o Γ 1 t : Y Γ 2,y : Y t : Y Γ 1, 2 t [t/y] :Y cut p Γ t : Y Γ, () : 1 t : Y Γ t : Y Γ, () : 1 t : Y Γ () : 1 Γ,x 1 : X 1,x 2 : X 2 t : Y Γ, (x 1,x 2 ):X 1 X 2 t : Y Γ,y 1 : Y 1,y 2 : Y 2 t : Y Γ, (y 1,y 2 ):Y 1 Y 2 t : Y Γ 1 t 1 : Y 1 Γ 2 t 2 : Y 2 Γ 1, 2 (t 1,t 2 ):Y 1 Y 2 Table 1. The basic logic of safety.

12 player types A, a new player type D(A) is added, together with rules for its constructors C i (see table 2). An inductive data type is introduced into the basic Γ t : F i (D(A),A) Γ C i (t) :D(A) cons i {Γ y i : F i (D(A),A), t i : Y } i=1,...,k 8 9 >< C 1 (y 1 ).t 1 >= Γ y : D(A), case y of. >: >; : Y C k (y k ).t k case 8 < Γ,z : D(A) w : Γ, C f : C, Ẽ Y. : y i : F i (D(A),A) y i : F i (C, A), w : Ẽ t i : Y 9 = ; i=1,...,k 8 >< C 1 (y 9 1@y 1 ).t 1 >= Ẽ fold f(z, w) as. >: >; in f(z, w ):Y C k (y k@y k ).t k Table 2. Judgements for fixed points and safe inductive folding. logic of safety with a specification of the form: data D(A) C = {C i : F i (C, A) C} i=1,...,k

13 Peeks Why can t we duplicate in the player world? We could duplicate recursive calls! Definitely not polynomial anymore! What if we don t want to use a value, just peek at it?

14 iszero = x.case x of { Zero.True; Succ(-).False }; callfifnotzero = x.case x of { Zero.Zero; Succ(-).f(x) };

15 iszero = x.case x of { Zero.True; Succ(-).False }; callfifnotzero = x.case x of { Zero.Zero; Succ(-).f(x) }; callfifnotzero = x.case x of { Zero.Zero; Succ(x ).f(succ(x )) };

16 Peeking peek is semantically the same as a case Typing is different Only anonymous patterns Player variables in callfifnotzero = x. peek x of { Zero.Zero; Succ( ).f(x) }; subject can be reused

17 Coinductive world data c Prod(a, b) = P1 : c a P2 : c b E.g., P1( ( P1 : 3 ; P2 : hello ) ) 3 data c Fn(a, b) = Eval : c, a b E.g., Eval( ( Eval : x. Succ(x) ), 3) 4

18 map :: Fn(a, b), List(a) List(b); map = f, l.fold g(l) as { Nil.Nil; Cons(x, xs).cons(eval(f, x), g(xs)) } in g(l ); map( ( Eval : x.succ(x) ), [3, 4]) [4, 5]

19 Safe recursion data c InfList(a) = Head : c a Tail : c c; naturalnumbers :: InfList(Nat); naturalnumbers =.unfold g(x) as ( Head : x; Tail : g(succ(x)) ) in g(zero); Head(Tail(Tail(naturalNumbers))) 2

20 data c InfTree = Left : c c Right : c c; infinitetree :: InfTree; infinitetree =.unfold g() as ( Left : g(); Right : g() ) in g();

21 data c InfTree = Left : c c Right : c c; infinitetree :: InfTree; infinitetree =.unfold g() as ( Left : g(); Right : g() ) in g(); fold f(x, t) as { Zero.t; Right(t)) } in f(n, infinitetree);

22 12 Γ t : D(A/B) A i Γ D i (t) :G i (D(A/B),B) dest i {Γ,a i : A i t i : G i (D(A/B),B)} i=1...k 0 1 D 1 : a 1.t 1 B D k : a k.t k C A : D(A/B) record Γ ỹ : Γ, C g : Ẽ C 8 < : Ẽ unfold g(ỹ) as. a i : A i, ỹ : Ẽ t i : G i (C, B) 0 1 D 1 : a 1.t 1 D k : a k.t k 9 = ; i=1,...,k C A in g(ỹ ):D(A/B) Table 4. Judgements for destruction, records and safe coinductive unfolding. to a corresponding destructor, together with a value for the variable a i, that computation proceeds by evaluating the appropriate term t i. Example Pola programs using coinductive types are given in figure 4. The type of the function pmap is A B,L(A) L(B) and it simply applies the player function f to every element of the list. This shows that the list function is

23 Polynomial completeness The power of Pola exacts equals PTIME Pola can compute any PTIME algorithm We can compute a fixed polynomial from the size of the input One level of safe recursion per degree of the polynomial Use that to drive the recursion simulating a Turing machine

24 Polynomial completeness Any Pola program is in PTIME Everything in the player world is constant time A single fold is linear in the size of its input Nested folds are polynomial in the size of their input fold f(x) of { Nil.Zero; Cons(y, g(z) of { Nil.Zero; Cons(, ).Zero in g(ys ) in f(x )

25 Polynomials can be assigned to terms inductively by the following rules. In fact, the derivation of the polynomial associated to a term mimics the derivation of the term by the proof rules. x = x (opponent variable) y = 0 (player variable) (t 1,t 2 ) = t 1 + t 2 t[t /x] = t [ t /x] (opponent cut) t[t /y] = t + t (player cut) () =0 C(t) = t +1 case y of {C i (y i).t i } = max i t i [y/y i ] peek y of {C i ( ).t i } = max i t i fold f(z, w) as { } in f(z, w ) = f(z, w ) f(z, w) = z case z of {C i (y i).t i } unfold g(ỹ) as ( ) in g(ỹ ) =0 ( ) = 0 (record) D(t, t ) = {t} + t + t (destruction) where { } is identical to except that: {unfold g(ỹ) as (D 1 : a 1.t 1 ; ; D k : a k.t k ) in g(ỹ )} = max t i i {(D 1 : a 1.t 1 ; ; D k : a k.t k )} = max t i i {D(t, t )} = {t} where has the same inductive definition as except that f(z, w) =0 for each recursive call to f. One can show by induction on the proof rules that if x 1 : X 1,..., x n : X n y 1 : Y 1,..., y m : Y m t : Y is derivable then t is a polynomial in x 1,..., x n. One can then show that whenever t evaluates to e, e t + y y m For example, addition on unary numbers is defined in Pola by x : Nat y :

26 Pola wrap-up Unifies work of Hofmann, Bellantoni and Cook, etc. Aims to be general, practical PTIME language Inductive data types, coinductive data types Peeking at values Implementation nearing stability

27 Thank you.