Operational Semantics

(1)

Delia KESNER IRIF, CNRS et Universit ´e Paris kesner@irif.fr www.irif.fr/˜kesner

Operational Semantics

(2)

Defining an Operational Semantics

Granurality

Small-step semantics, big-step semantics

Order of evaluation: call-by-name, call-by-value, call-by-need, perpetual strategy Abstract machines

(3)

Big-step Semantics

Consider a very elemental calculator handling expressions belonging to the following grammare::=n|x|e+e.

Each rulecompletelyevaluates an expression under asubstitutionto a”value”.

hn, σi ⇓n hx, σi ⇓σ(x) ha1, σi ⇓n1 ha2, σi ⇓n2 nis ”n1plusn2”

ha1+a2, σi ⇓n

(4)

Properties

Abstract

Allows to avoid details

No specification of evaluation order (e.g.(1+3)+(5−3)) No specification of control of errors

No specification of interleaving

(5)

Small-step Semantics

Evaluation of an expression under a substitution is given by a sequence ofstate changes which terminates when the state cannot be reduced further.

ha1, σi{ha⁰₁, σ⁰i ha1+a2, σi{ha⁰₁+a2, σ⁰i

ha2, σi{ha⁰₂, σ⁰i hn1+a2, σi{hn1+a⁰₂, σ⁰i

hx, σi{hσ(x), σi

nis ”n1plusn2” hn1+n2, σi{hn, σi

(6)

Properties

Less abstract

Specification of order of evaluation Control of errors: n2,0

n1/n2{n ^{, where}nis ”n1divided byn2”.

Interleaving: hc1, σi{hc⁰₁, σ⁰i hc1||c2, σi{hc⁰₁||c2, σ⁰i

(7)

From Small-step to Multi-step Semantics

The multi-step semantics is given by the relationt{^∗t⁰which is the reflexive and transitive closure oft{t⁰.

(P1) t{^∗tfor everyt (P2) t{t⁰impliest{^∗t⁰

(P3) t{^∗t⁰andt⁰{^∗t⁰⁰impliest{^∗t⁰⁰

(8)

Properties of the small and big step semantics

The relation{is deterministic.

The relation⇓is deterministic.

t⇓vifft{^∗v, wherevis a ”value”.

(9)

Big-step versus small-step semantics

In small-step semantics evaluation stops at errors. In big-step semantics errors occur deeply inside derivation trees.

The order of evaluation isexplicitin small-step semantics butimplicitin big-step semantics.

Big-step semantics is more abstract, but less precise.

Small-step semantics allows to make difference between non-termination and

”getting stuck”.

(10)

A functional langage

t,u::= x (variable) |

c (constant) |

ht,ui (pair) |

t u (application) |

λx.t (abstraction) |

letx=tinu (let)

Some constant function symbols:fst,snd,ifthenelse,+,∗. . . Some constants:true,false,0,1,2,3, . . .

Thus e.g.iftthenuelsevcan be defined asifthenelseht,hu,vii. Aprogramis a closed expression belonging to the previous grammar.

(11)

Call-by-value lambda-calculus (big-step semantics)

(CBV Normal Forms)V,W::=c| hV,Vi |λx.t

Meaningless expressions such as(h1,1i3)or(true3)arenotconsidered as CBV Normal Forms.

Vis a CBV Normal Form V ⇓_v V

t1⇓_vV1 t2⇓_vV2

ht1,t2i ⇓_vhV1,V2i

u⇓_vV r{x/V} ⇓_vW letx=uinr⇓_vW t⇓_vλx.r u⇓_vW r{x/W} ⇓_vV

t u⇓_vV t⇓_vfst u⇓_vhV1,V2i

t u⇓_vV1

t⇓_vsnd u⇓_vhV1,V2i t u⇓_vV2

t⇓_vifthenelse u⇓_vhtrue,hV1,V2ii tu⇓_vV1

t⇓_vifthenelse u⇓_vhfalse,hV1,V2ii tu⇓_vV2

(12)

Particular case: closed pure lambda-terms

(CBV Normal Forms)V::=λx.t

V ⇓_v V

t⇓_vλx.r u⇓_vW r{x/W} ⇓vV t u⇓_vV

(13)

An example

t0=λf.λx.hx,f xiandt1=λy.y.

t₀t₁⇓_vλx.hx,t₁xi 1⇓_v1 h1,t₁1i⇓_vh1,1i t₀t₁1⇓_vh1,1i

t₀ ⇓_v λf.λx.hx,f xi t₁ ⇓_v λy.y λx.hx,f xi{f/t1} ⇓_vλx.hx,t₁xi t₀t₁⇓_vλx.hx,t1xi

1⇓_v1 t1 ⇓_vλy.y 1⇓_v1 y{y/1} ⇓_v1 t₁1⇓_v1

h1,t₁1i ⇓vh1,1i

(14)

Call-by-value lambda calculus (small-step semantics)

t{vt⁰ ht,ui{vht⁰,ui

u{vu⁰ hV,ui{vhV,u⁰i u{vu⁰

letx=uinr{vletx=u⁰inr letx=Vinr{vr{x/V} t{vt⁰

t u{vt⁰u

u{vu⁰ V u{vV u⁰

(λx.t)V{vt{x\V}

fsthV1,V2i{vV1 sndhV1,V2i{vV2

ifthenelsehtrue,hV1,V2ii{vV1 ifthenelsehfalse,hV1,V2ii{vV2

(15)

The same example

t0=λf.λx.hx,f xiandt1=λy.y.

t0t11 {v

(λx.hx,t1 xi) 1 {v

h1,t11i {v

h1,1i

(16)

Call-by-name lambda-calculus (big-step semantics)

(CBN Normal Forms)P::=c| ht,ui |λx.t Pis a CBN normal-form

P ⇓_n P

r{x/u} ⇓nP letx=uinr⇓_nP t⇓_nλx.r r{x/u} ⇓nP

t u⇓_n P t⇓_nfst u⇓_nht1,t2i t1⇓_nP

tu⇓_nP

t⇓_nsnd u⇓_nht1,t2i t2⇓_nP tu⇓_nP

t⇓_nifthenelse u⇓_nhu1,u2i u1⇓_ntrue u2⇓_nhm1,m2i m1⇓_nP tu⇓_n P

t⇓_nifthenelse u⇓_nhu1,u2i u1⇓_nfalse u2⇓_nhm1,m2i m2⇓_nP tu⇓_n P

(17)

Particular case: closed pure lambda-terms

(CBN Normal Forms)P::=λx.t

P ⇓_n P

t⇓_nλx.r r{x/u} ⇓nP t u⇓_n P

(18)

Call-by-name lambda calculus (small-step semantics)

letx=tinr{nr{x/t} t{nt⁰

t u{nt⁰u (λx.t)u{nt{x\u} t{nt⁰

fstt{nfstt⁰ fstht,ui{nt t{nt⁰

sndt{nsndt⁰ sndht,ui{nu

(19)

t{nt⁰

ifthenelset{nifthenelset⁰

t{nt⁰

ifthenelseht,ui{nifthenelseht⁰,ui t∈ {true,false} u{nu⁰

ifthenelseht,ui{nifthenelseht,u⁰i t{nt⁰

ifthenelsehtrue,ht,uii{nifthenelsehtrue,ht⁰,uii u{nu⁰

ifthenelsehfalse,ht,uii{nifthenelsehfalse,ht,u⁰ii

(20)

Coherence of results

Ift⇓_vu, thenuis a CBV normal-form.

Ift⇓_nu, thenuis a CBN normal-form.

(21)

Deterministic properties

Ift⇓_vVandt⇓_vV⁰, thenV=V⁰. Ift⇓_nPandt⇓_nP⁰, thenP=P⁰. Ift{vuandt{vu⁰, thenu=u⁰. Ift{nuandt{nu⁰, thenu=u⁰.

(22)

Relating big and small-steps semantics

Ift⇓_vV, thent{^∗vV. Ift⇓_nP, thent{^∗nP.

Ift{^∗vuanduis a CBV normal-form, thent⇓_vu. Ift{^∗nuanduis a CBN normal-form, thent⇓_nu.

(23)

Call-by-Need

(24)

Lazy Evaluation and Call-by-Need

Lazy evaluation(Wadsworth’71)

Based ondemand-drivencomputation

Implementsmemoization(the first demand-driven function call transforms the argument into avalue)

May manipulate potentiallyinfinite data

The best ofcall-by-nameand the best ofcall-by-value Modeled bycall-by-needcalculi (Ariola-Felleisen).

(25)

Call-by-need different from call-by-name

Call-by-needis different fromcall-by-name: first evaluates arguments (like call-by-value).

Twice(4+3)→cbname (4+3)+(4+3)→cbname 7+(4+3)→cbname 7+7→cbname 14 Twice(4+3)→cbneed Twice7→cbneed 7+7→cbneed 14

whereTwice=λx.x+x.

(26)

Call-by-need different from call-by-value

Call-by-needis different fromcall-by-value: values are only consumed when required (λx.8)(4+3)→_cbvalue (λx.8)7→_cbvalue 8

(λx.8)(4+3)→cbneed 8 In particular

(λx.8)Ω((→cbvalue(( (λx.8)Ω→_cbneed 8

(27)

(Syntactical) call-by-need different from (semantical) neededness

Syntax:

Call-by-need

Evaluation strategy defined syntactically, using a notion ofneed contextandlet-constructors

Semantics:

Neededness

Evaluation strategy defined semantically, using the residual theoryofλ-calculus.

(28)

But....

?

call-by-name call-by-value

call-by-need neededness

full evaluation

(29)

Observational equivalence, formally

LetRbe a reduction relation with an associated notion of result (e.g. value). We write t⇓Rif the termtconverges to some result.

Two termstanduare said to beobservationally equivalentforR, writtent^Ru, if for every contextC,

C[t] ⇓

_R

if and only if C[u] ⇓

_R

.

Terms that cannot be distinguished by any context.

Often used to compare two different implementations or protocols.

Difficult to reason because of the universal quantification of contexts.

(30)

Call-by-need observationally equivalent to call-by-name

Theorem

Given a programt, thecall-by-nameinterpreter ontstops in avalueif and only if the call-by-needinterpreter ontstops in ananswer.

Said differently, Theorem

Giventanduwe have thatt

cbname uif and only ift

cbneed u.

(31)

Call-by-Need

Syntaxuseslet constructors/explicit substitutions letx=uintis writtent[x\u]

Grammar of terms:

t,u::= x (variable) |

t u (application) |

λx.t (abstraction)

t[x\u] (explicit substitutions)

Reduction computesweak head normal formswith let constructors, so that reduction does not take place inside abstractions:

t→ t⁰does not implyλx.t→ λx.t⁰.

Memoization⇒notion ofvalue(terms of the formV::=λx.t).

Demand-driven computations⇒notion ofneed context.

(32)

Defining weak call-by-need

Explicit binding of arguments

( λx. id) (λy.y)

→

let x = (λy.y) in id (also written id[ x \ (λy.y) ] )

First Reduction Rule:

(λ x .t) u 7→ _dB t[ x \ u ]

(33)

Defining weak call-by-need

Explicit binding of arguments again

( λx. id) [y\ Ω ] (λy.y)

→

id[ x \ (λy.y) ] [y\ Ω ]

First (Revised) Reduction Rule:

(λ x .t) [ x

1

\u

1

] . . . [x

n

\u

n

] u 7→

_dB

t[ x \ u ] [x

1

\u

1

] . . . [x

n

\u

n

]

(34)

Defining weak call-by-need

Substituting values when needed

x [ x \λy.y]

(λy.y)[x\λy.y] →

Second Reduction Rule:

N[[ x ]][ x /V ] 7→ _lsv N[[V ]][ x /V ]

In the example N = , but what is N in general??

(35)

Defining weak call-by-need

Substituting values when needed

Left of an application Left of a let Inside a needed let ( x id)[x\(λy.y)] x[y\id][x\(λy.y)] z[z\x][x\λy.y]

(N⁰[[x]]t)[x\V] N⁰[[x]][y\t][x\V] N⁰[[z]][z\M[[x]]][x\V]

Second Reduction Rule:

N[[ x ]][ x /V ] 7→ _lsv N[[V ]][ x /V ]

where (need contexts) M, N :: = | Nt | N[y\t] | N[[z]][z\M]

(36)

Defining weak call-by-need

Sharing while Substituting

x [ x \(λy.y) [z\id] ]

→ x [x\λy.y] [z\id]

(λy.y)[x\(λy.y)] [z\id] →

Second (Revised) Reduction Rule:

N[[ x ]][ x /V [x

1

\u

1

] . . . [x

n

\u

n

] ] 7→

_lsv

N[[V ]][ x /V ] [x

₁

\ u

1

] . . . [x

n

\ u

n

]

(37)

A Call-by-Need Calculus (Small-Step Semantics)

Reduction Rules:

(Distant Beta reduction)

(λx.t) [x1\u1]. . .[xn\un] u 7→dBt[x\u] [x1\u1]. . .[xn\un] (Linear substitution of values)

N[[x]][x/V [x1\u1]. . .[xn\un] ]7→lsvN[[V]][x/V] [x1\u1]. . .[xn\un] Closed byneedcontextsN

Operational Semantics