Simply Typed Lambda-Calculi (II)

Transcription

1 THEORY AND PRACTICE OF FUNCTIONAL PROGRAMMING Simply Typed Lambda-Calculi (II) Dr. ZHANG Yu Institute of Software, Chinese Academy of Sciences Fall term, 2011 GUCAS, Beijing

2 Introduction PCF Programming Computable Functions, mainly designed for program analysis and reasoning, rather than practical use. Syntax and type system Reduction and operational semantics Expressive power Theory and Practice of Functional Programming 2 / 22

3 Base types Unit type: unit, which contains a single element. Natural numbers: Constants (values): 0,1,2,... Arithmetic operations: e 1 +e 2,e 1 e 2,... Γ e 1 : Nat Γ e 2 : Nat op {+,,,/,...} Booleans: Γ e 1 op e 2 : Nat Boolean constants (values): true, false. Equality test (of natural numbers): e 1? = e 2. Conditional: if e then e 1 else e 2. Γ e 1 : Nat Γ e 2 : Nat Γ e : Bool Γ e 1 : τ Γ e 2 : τ Γ e 1? = e 2 : Bool Γ if e then e 1 else e 2 : τ Theory and Practice of Functional Programming 3 / 22

4 More types Product types: τ 1 τ 2 Γ e 1 : τ 1 Γ e 2 : τ 2 Γ e 1,e 2 : τ 1 τ 2 Γ e : τ 1 τ 2 Γ proj i e : τ i Sum types: τ 1 +τ 2 A value of τ 1 +τ 2 can be a value of either τ 1 or τ 2, distinguished by tags (inj 1,inj 2 ). We use case to retrieve the value (removing tags). Γ e : τ i Γ inj i e : τ 1 +τ 2 Γ,x i : τ 1 e i : τ(i = 1,2) Γ e : τ 1 +τ 2 Γ case e of inj 1 x 1 in e 1 ;inj 2 x 2 in e 2 : τ Boolean type can be defined using unit and sum: Bool def = unit+unit. true def = inj 1, false def = inj 2 if e then e 1 else e 2 def = case e of inj 1 in e 1 ;inj 2 in e 2 Theory and Practice of Functional Programming 4 / 22

5 Functions and recursions Function type τ τ Γ,x : τ e : τ Γ λx : τ.e : τ τ Γ e 1 : τ τ Γ e 1 e 2 : τ Γ e 2 : τ PCF introduces explicitly an operator for fix-point: fix τ. If F is a function of type τ τ, then the fix-point of F is the value x : τ such that F(x) = x, written as fix τ F. A recursive definition f : τ = e (with f occurs freely in e) indeed defines a fix-point of λf : τ.e. Example: factorization can be defined recursively: f = λx : Nat.if x? = 0 then 1 else x f(x 1) With fix-point operator in PCF, we shall write the definition as fact def = fix Nat Nat (λf.λx.if x? = 0 then 1 else x f(x 1)) Theory and Practice of Functional Programming 5 / 22

6 Syntax of PCF Types: τ 1,τ 2,... ::= Nat Bool τ 1 τ 2 τ 1 +τ 2 τ 1 τ 2 Expressions (terms): e 1,e 2,... ::= x variables 0,1,2,... natural numbers e 1 op e 2 arithmetic operations true false booleans e? 1 = e 2 equality test if e then e 1 else e 2 conditional e 1,e 2 pairing proj 1 e proj 2 e projections inj 1 e inj 2 e injections case e of inj 1 x 1 in e 1 ; case distinction inj 2 x 2 in e 2 λx : τ.e e 1 e 2 functions and applications fix τ recursion (fix point) Theory and Practice of Functional Programming 6 / 22

7 PCF typing rules x : τ Γ Γ x : τ n = 0,1,2,... Γ n : Nat Γ e 1 : Nat Γ e 2 : Nat op {+,,,/} Γ e 1 op e 2 : Nat Γ true : Bool Γ false : Bool Γ e 1 : Nat Γ e 2 : Nat Γ e 1? = e 2 : Bool Γ e : Bool Γ e 1 : τ Γ e 2 : τ Γ if e then e 1 else e 2 : τ Γ e 1 : τ 1 Γ e 2 : τ 2 Γ e 1,e 2 : τ 1 τ 2 Γ e : τ 1 τ 2 Γ e : τ 1 τ 2 Γ e : τ 1 Γ e : τ 2 Γ proj 1 e : τ 1 Γ proj 2 e : τ 2 Γ inj 1 e : τ 1 +τ 2 Γ,x 1 : τ 1 e 1 : τ Γ,x 2 : τ 2 e 2 : τ Γ e : τ 1 +τ 2 Γ case e of inj 1 x 1 in e 1 ;inj 2 x 2 in e 2 : τ Γ inj 2 e : τ 1 +τ 2 Γ,x : τ e : τ Γ λx : τ.e : τ τ Γ e 1 : τ τ Γ e 1 e 2 : τ Γ e 2 : τ Γ e : τ τ Γ fix τ e : τ Theory and Practice of Functional Programming 7 / 22

8 Type checking A procedure of checking the validity of a type assertion, by typing rules and induction on expression structure. Example: fix Nat Nat λf : Nat Nat.λx : Nat.if x? = 0 then 1 else x f(x 1) Γ x : Nat Γ 1 : Nat Γ f : Nat Nat Γ x 1 : Nat Γ x : Nat Γ 0 : Nat Γ x : Nat Γ f(x 1) : Nat Γ x? = 0 : Bool Γ 1 : Nat Γ x f(x 1) : Nat f : Nat Nat,x : Nat if x? = 0 then 1 else x f(x 1) : Nat Nat f : Nat Nat λx : Nat.if x? = 0 then 1 else x f(x 1) : Nat λf : Nat Nat.λx : Nat.if x? = 0 then 1 else x f(x 1) : (Nat Nat) (Nat Nat) fix Nat Nat λf : Nat Nat.λx : Nat.if x? = 0 then 1 else x f(x 1) : Nat Nat Theory and Practice of Functional Programming 8 / 22

9 PCF reduction β-reduction: (λx : τ.e)e e[e /x]. Other reductions: 2+3 5, 12? = 23 false,... if true then e 1 else e 2 e 1, if false then e 1 else e 2 e 2 proj 1 e 1,e 2 e 1, proj 2 e 1,e 2 e 2 case inj 1 e of inj 1 x 1 in e 1 ;inj 2 x 2 in e 2 e 1 [e/x 1 ] case inj 2 e of inj 1 x 1 in e 1 ;inj 2 x 2 in e 2 e 2 [e/x 2 ] Reduction of fix-pointer: PCF reductions may not terminate: fix τ λf : τ τ.f(fix τ f) fix λx.x (λf.fix f(fix f))(λx.x) (λx.x)(fix λx.x) fix λx.x Theory and Practice of Functional Programming 9 / 22

10 PCF reduction Example: fact def = fix Nat Nat (λf.λx.if x? = 0 then 1 else x f(x 1)) fact (n+1) = fix Nat Nat (λf.λx.if x? = 0 then 1 else x f(x 1))(n+1) (λg.g(fix Nat Nat g))(λf.λx.if x? = 0 then 1 else x f(x 1))(n+1) Fact(fix Nat Nat Fact) (n+1) (where Fact = λf.λx.if x? = 0 then 1 else x f(x 1)) = (λf.λx.if x? = 0 then 1 else x f(x 1))fact (n+1) (λx.if x? = 0 then 1 else x fact(x 1))(n+1) if n+1? = 0 then 1 else (n+1) fact(n+1 1) if false then 1 else (n+1) fact(n+1 1) (n+1) fact(n+1 1) A syntactic abbreviation for recursion letrec fact=λx : Nat.if x? = 0 then 1 else x fact(x 1) in fact (n+1) Theory and Practice of Functional Programming 10 / 22

11 PCF reduction Multi-step reduction : the reflexive (w.r.t. α-equivalence) and transitive closure of. e e if e = α e or e e & e e PCF reductions are non-deterministic ,5 6 59,5 6 59, , ,30 59,30 PCF reduction system is confluent it satisfies Church-Rosser property. No PCF term can have more than one normal form. Inconsistent reduction system with fixe e(fixe) and η-reduction. λx.fix x η fix λx.fix x fix λx.x(fix x) fix λx.x(x(fix x))... Theory and Practice of Functional Programming 11 / 22

12 PCF values and canonical form PCF values are closed expressions that cannot be reduced any more. PCF values are in canonical forms: Boolean values: true, false. Natural number values: 0,1,2,... Product values: e 1,e 2. Injective values: inj 1 e,inj 2 e. Function values: λx.e. Every closed normal PCF expression must be in the canonical form. Proof. By induction on the structure of PCF expressions. Theory and Practice of Functional Programming 12 / 22

13 Reduction strategy Restrict the reduction system so that reductions are deterministic and consistent with the original system. Different reduction strategies (λx : τ.e 1 )e 2 e 1 [e 2 /x] (λx : τ.e 1 )e 2 (λx : τ.e 1 )e 2 (λx : τ.e 1 )e 2 (λx : τ.e 1 )e 2 Lazy evaluation, a.k.a, call-by-name Function optimization Eager evaluation, a.k.a, call-by-value Theory and Practice of Functional Programming 13 / 22

14 A reduction system with lazy evaluation If the top-level term is a redex, it will be reduced first: if e e, then e lazy e. lazy e 1 e 1 e 1 lazy e 1 e 2 e 1e 2 lazy e 1 op {+,,,/,? =} e 1 op e 2 lazy e 1 +e 2 e lazy e n {0,1,2,...} op {+,,,/,? =} n op e lazy n+e e lazy e if e then e 1 else e 2 lazy if e then e 1 else e 2 e lazy e proj i e lazy proj i e e lazy e case e of inj 1 x 1 in e 1 ;inj 2 x 2 in e 2 lazy case e of... Consistency with the PCF reduction system: if e lazy e, then e e Incompleteness: lazy normal form is not necessarily PCF-normal form. Theory and Practice of Functional Programming 14 / 22

15 Lazy and eager evaluation Lazy evaluation may lead to low efficient computation, as it often produces multiple copies of a expression, which will be executed (reduced) for multiple times. In practical FPL with lazy evaluation (e.g., Haskell), duplication is done by setting multiple pointers to a single expression, which is executed only once if necessary. This is call-by-need evaluation. Eager evaluation can lead to non-terminating computations for programs that necessarily terminate with lazy evaluation. (λx : Nat.0)((fixλy : Nat.y)0) lazy 0 (λx : Nat.0)((fixλy : Nat.y)0) eager (λx : Nat.0)(((λy : Nat.y) fixλy : Nat.y 0) eager (λx : Nat.0)((λz : Nat.(fixλy : Nat.y)z)0) eager (λx : Nat.0)((fixλy : Nat.y)0) Theory and Practice of Functional Programming 15 / 22

16 Semantics Roughly speaking, semantics is the meaning of programs. Three styles of semantics Operational semantics: how do programs execute (reduce)? It s about the evaluation or computation procedure of programs. Axiomatic semantics: do programs satisfy a certain property? It s about the reasoning of properties of and relations between programs. Denotational semantics: what do programs represent? It s about the exact (mathematical) object that a program denotes. In this course we only discuss operational semantics. For the other two semantics, please refer to Prof. Liu Xinxin s course on formal semantics of programming languages. Theory and Practice of Functional Programming 16 / 22

17 Operational semantics The PCF reduction system indeed defines an operational semantics of PCF, which we often refer to as small-step semantics. Big-step semantics: e e if e e and (e ). c {true,false,0,1,2,...} c c e 1 n 1 e 2 n 2 n 1 op n 2 = n e 1 op e 2 n e 1 n 1 e 2 n 2 n 1 n 2 e 1? = e 2 false e 1 n e 2 n e 1? = e 2 true e true e 1 v 1 if e then e 1 else e 2 v 1 e false e 2 v 2 if e then e 1 else e 2 v 2 e 1 v 1 e 2 v 2 e 1,e 2 v 1,v 2 e v 1,v 2 proj i e v i e v e inj 1 v 1 e 1 [v 1 /x 1 ] v inj i e inj i v case e of inj 1 x 1 in e 1 ;inj 2 x 2 in e 2 v e inj 2 v 2 e 2 [v 2 /x 2 ] v case e of inj 1 x 1 in e 1 ;inj 2 x 2 in e 2 v e 1 λx.e 1 e 1[e 2 /x] v (Lazy) e 1 e 2 v Theory and Practice of Functional Programming 17 / 22

18 Total recursive functions A class C of numeric functions f : N k N is closed under composition: for every f 1,...,f l : N k N and g : N l N of C, the function h(n 1,...,n k ) = g(f 1 (n 1,...,n k ),...,f l (n 1,...,n k )) is also in C. closed under primitive recursion: for every f : N k N and g : N k+2 N of C, the function h : N k+1 N defined as follows is in C: h(0,n 1,...,n k ) = f(n 1,...,n k ) h(m+1,n 1,...,n k ) = g(m,n 1,...,n k,h(m,n 1,...,n k )) closed under minimization: for every f : N k+1 N of C such that n 1,...,n k, m,f(m,n 1,...,n k ) = 0, the function g(n 1,...,n k ) = min({m f(m,n 1,...,n k ) = 0}) is in C. Total recursive functions are the least class of numeric functions: closed under composition, primitive recursion and minimization; contains projection function proj k i (n 1,...,n k ) = n i, successor function succ(n) = n+1 and constant zero functionzero zero(n) = 0. Theory and Practice of Functional Programming 18 / 22

19 Expressing total recursive functions in PCF A numeric function f : N k N is PCF-definable if there exists a PCF program e of Nat k Nat such that e = f in the set-theoretic model. Every total recursive function is definable in PCF. Proof. It suffices to define a PCF term for every basic function and composition, primitive recursion, minimization. Basic functions: proj k i Composition: def = λx 1. λx k.x i. h def = λx 1. λx k.g(f 1 x 1 x k ) (f l x 1 x k ) Primitive recursion h def = fix λh.λn. if n > 0 then λ x.g(n 1, x,h (n 1, x)) else λ x.f x Minimization: g def = (fix λg.λn.λ x.if f(n, x)? = 0 then n else g (n+1, x))0 Theory and Practice of Functional Programming 19 / 22

20 Partial recursive functions Partial numeric functions f : N k N can be undefined at some points. Closed under composition: for every f 1,...,f l : N k N and g : N l N of C, the composition function is in C: h(n 1,...,n k ) = g(m 1,...,m l ) if m i = f i (n 1,...,n k ) and g(m 1,...,m l ) are defined otherwise closed under primitive recursion: for every f 1,...,f l : N k N and g : N k+2 N of C, the function h : N k+1 N defined as follows is in C: { f(n1,...,n h(0,n 1,...,n k ) = k ) if f(n 1,...,n k ) is defined o.w. g(m,n 1,...,n k,q) if q = h(m,n 1,...,n k ) and h(m+1,n 1,...,n k ) = g(m,n 1,...,n k,q) are defined o.w. closed under minimization: for every f : N k+1 N of C, C contains the function { the least m s.t. f(m,n1,...,n k ) = 0 if such m exist g(n 1,...,n k ) = otherwise Theory and Practice of Functional Programming 20 / 22

21 Expressing partial recursive functions in PCF Partial recursive functions are the least class of partial numeric functions: closed under composition, primitive recursion and minimization; contains projection function proj k i, successor functionsucc and constant zero function zero. Every partial recursive function is definable in PCF. Proof. Representing undefinedness by non-termination in PCF: def = fix λf.f By Church s thesis, all mechanically computable functions on natural numbers are definable in PCF. Theory and Practice of Functional Programming 21 / 22

22 Non-definability of parallel operations The parallel-or operation: true PORe 1 e 2 false no normal form if e 1 true or e 2 true if e 1 false and e 2 false otherwise where e 1,e 2 are closed PCF terms. There is no PCF program that definespor POR. The proof can be found in Chapter 2 of J. Mitchell s book Foundations for Programming Languages, which relies essentially on the sequentiality of PCF reduction system. Theory and Practice of Functional Programming 22 / 22