Operational Semantics Mooly Sagiv Reference: Semantics with Applications Chapter 2 H. Nielson and F. Nielson 1

Syntax vs. Semantics u The pattern of formation of sentences or phrases in a language u Examples –Regular expressions –Context free grammars u The study or science of meaning in language u Examples –Interpreter –Compiler –Better mechanisms will be given today

Outline u Why formal semantics? u Possible formal semantics u A Simple programming language While u Natural Operational Semantics for While u Structural Operational Semantics for While u Equivalence Result u Extensions to While –Abort –Non determinism –Parallel constructs –Blocks and procedures

Benefits of Formal Semantics u Programming language design –hard- to-define= hard-to-implement=hard-to-use u Programming language implementation u Programming language understanding u Program correctness u Program equivalence u Compiler Correctness u Automatic generation of interpreter u But probably not –Automatic compiler generation

Alternative Formal Semantics u Operational Semantics –The meaning of the program is described “operationally” –Natural Operational Semantics –Structural Operational Semantics u Denotational Semantics –The meaning of the program is an input/output relation –Mathematically challenging but complicated u Axiomatic Semantics –The meaning of the program are observed properties

int fact(int x) { int z, y; z = 1; y= x while (y>0) { z = z * y ; y = y – 1; } return z } [x  3] [x  3, z , y  ] [x  3, z  1, y  ] [x  3, z  1, y  3] [x  3, z  3, y  3] [x  3, z  3, y  2]

int fact(int x) { int z, y; z = 1; y= x while (y>0) { z = z * y ; y = y – 1; } return z } [x  3, z  3, y  2] [x  3, z  6, y  2] [x  3, z  6, y  1] [x  3, z  3, y  2]

int fact(int x) { int z, y; z = 1; y= x while (y>0) { z = z * y ; y = y – 1; } return z } [x  3, z  6, y  1] [x  3, z  6, y  0] [x  3, z  6, y  1]

int fact(int x) { int z, y; z = 1; y= x while (y>0) { z = z * y ; y = y – 1; } return z } [x  3, z  6, y  0]

int fact(int x) { int z, y; z = 1; y= x; while (y>0) { z = z * y ; y = y – 1; } return 6 } [x  3, z  6, y  0]

f= x. if x = 0 then 1 else x * f(x -1) Denotational Semantics int fact(int x) { int z, y; z = 1; y= x ; while (y>0) { z = z * y ; y = y – 1; } return z; }

{x=n} int fact(int x) { int z, y; z = 1; {x=n  z=1} y= x {x=n  z=1  y=n} while {x=n  y  0  z=n! / y!} (y>0) { {x=n  y >0  z=n! / y!} z = z * y ; {x=n  y>0  z=n!/(y-1)!} y = y – 1; {x=n  y  0  z=n!/y!} } return z} {x=n  z=n!} Axiomatic Semantics

Operational Semantics Natural Semantics 13

Operational Semantics of Arithmetic Expressions Exp  | number | Exp PLUS Exp | Exp MINUS Exp | Exp MUL Exp | UMINUS Exp A  : Exp  Z A  n  = val(n) A  e 1 PLUS e 2  =A  e 1  + A  e 2  A  e 1 MINUS e 2  = A  e 1  - A  e 2  A  e 1 MUL e 2  = A  e 1  * A  e 2  A  UMINUS e  = A  e 

Handling Variables Exp  | number | variable | Exp PLUS Exp | Exp MINUS Exp | Exp MUL Exp | UMINUS Exp u Need the notions of states u States State = Var  Z u Lookup in a state s: s x u Update of a state s: s [ x  5]

Example State Manipulations u [x  1, y  7, z  16] y = u [x  1, y  7, z  16] t = u [x  1, y  7, z  16][x  5] = u [x  1, y  7, z  16][x  5] x = u [x  1, y  7, z  16][x  5] y =

Semantics of arithmetic expressions u Assume that arithmetic expressions are side-effect free u A  Aexp  : State  Z u Defined by induction on the syntax tree –A  n  s = n –A  x  s = s x –A  e 1 PLUS e 2  s = A  e 1  s + A  e 2  s –A  e 1 MUL e 2  s = A  e 1  s * A  e 2  s –A  UMINUS e  s = -A  e  s u Compositional u Properties can be proved by structural induction

Semantics of Boolean expressions u Assume that Boolean expressions are side-effect free u B  Bexp  : State  T u Defined by induction on the syntax tree –B  true  s = tt –B  false  s = ff –B  e 1 = e 2  s = –B  e 1  e 2  s = –B  e 1  e 2  s = tt if A  e 1  s = A  e 2  s ff if A  e 1  s  A  e 2  s tt if B  e 1  s = tt and B  e 2  =tt ff if B  e 1  s=ff or B  e 2  s=ff

The While Programming Language u Abstract syntax S::= x := a | skip | S 1 ; S 2 | if b then S 1 else S 2 | while b do S u Use parenthesizes for precedence u Informal Semantics –skip behaves like no-operation –Import meaning of arithmetic and Boolean operations

Example While Program y := 1; while  (x=1) do ( y := y * x; x := x - 1 )

General Notations u Syntactic categories –Var the set of program variables –Aexp the set of arithmetic expressions –Bexp the set of Boolean expressions –Stm set of program statements u Semantic categories –Natural values N={0, 1, 2, …} –Truth values T={ff, tt} –States State = Var  N –Lookup in a state s: s x –Update of a state s: s [ x  5]

Natural Operational Semantics u Describe the “overall” effect of program constructs u Ignores non terminating computations

Natural Semantics u Notations – - the program statement S is executed on input state s –s representing a terminal (final) state u For every statement S, write meaning rules  o “If the statement S is executed on an input state i, it terminates and yields an output state o” u The meaning of a program P on an input state s is the set of outputs states o such that  o u The meaning of compound statements is defined using the meaning immediate constituent statements

Natural Semantics for While [ass ns ]  s[x  A  a  s] [skip ns ]  s [comp ns ]  s’,  s’’  s’’ [if tt ns ]  s’  s’ if B  b  s=tt [if ff ns ]  s’  s’ if B  b  s=ff axioms rules

Natural Semantics for While (More rules) [while tt ns ]  s’,  s’’  s’’ if B  b  s=tt [while ff ns ]  s if B  b  s=ff

Simple Examples [comp ns ]  s 0,  s 0 [x  1]  s 0 [x  1] u Let s 0 be the state which assigns zero to all program variables u Assignments [ass ns ]  s 0 [x  1] u Skip statement [skip ns ]  s 0 u Composition

Simple Examples (Cont) [if tt ns ]  s 0  s 0 u Let s 0 be the state which assigns zero to all program variables u if-construct

A Derivation Tree u A “proof” that  s’ u The root of tree is  s’ u Leaves are instances of axioms u Internal nodes rules –Immediate children match rule premises u Simple Example  s 0 [x  1]> comp ns  s 0 [x  1]> ass ns  s 0 skip ns

An Example Derivation Tree  s0[x  1][y  2][z  2]  s0[x  1][y  2]  s0[x  1][y  2][z  2]  s0[x  1]  s0[x  1][y  2] comp ns ass ns

Top Down Evaluation of Derivation Trees u Given a program S and an input state s u Find an output state s’ such that  s’ u Start with the root and repeatedly apply rules until the axioms are reached u Inspect different alternatives in order u In While s’ and the derivation tree is unique

Example of Top Down Tree Construction u Input state s such that s x = 2 u Factorial program  > ass ns   > comp ns  > while tt ns while ff ns  > comp ns ass ns s[y  1] s[y  2][x  1] s[y  2] s[y  2][x  1 s[y  2][x  1] s[y  2][x  1 s[y  2][x  1] s[y  2] s[y  2][x  1]

Program Termination u Given a statement S and input s –S terminates on s if there exists a state s’ such that  s’ –S loops on s if there is no state s’ such that  s’ u Given a statement S –S always terminates if for every input state s, S terminates on s –S always loops if for every input state s, S loops on s

Semantic Equivalence u S 1 and S 2 are semantically equivalent if for all s and s’  s’ if and only if  s’ u Simple example “while b do S” is semantically equivalent to: “if b then (S ; while b do S) else skip”

Properties of Natural Semantics u Equivalence of program constructs –“skip ; skip” is semantically equivalent to “skip” –“((S 1 ; S 2 ) ; S 3 )” is semantically equivalent to “(S 1 ;( S 2 ; S 3 ))” –“(x := 5 ; y := x * 8)” is semantically equivalent to “(x :=5; y := 40)” u Deterministic –If  s 1 and  s 2 then s 1 =s 2

Deterministic Semantics for While u If  s 1 and  s 2 then s 1 =s 2 u The proof uses induction on the shape of derivation trees –Prove that the property holds for all simple derivation trees by showing it holds for axioms –Prove that the property holds for all composite trees: »For each rule assume that the property holds for its premises (induction hypothesis) and prove it holds for the conclusion of the rule

The Semantic Function S ns u The meaning of a statement S is defined as a partial function from State to State u S ns : Stm  (State  State) u S ns  S  s = s’ if  s’ and otherwise S ns  S  s is undefined u Examples –S ns  skip  s =s –S ns  x :=1  s = s [x  1] –S ns  while true do skip  s = undefined

Extensions to While u Abort statement (like C exit w/o return value) u Non determinism u Parallelism u Local Variables u Procedures –Static Scope –Dynamic scope

The While Programming Language with Abort u Abstract syntax S::= x := a | skip | S 1 ; S 2 | if b then S 1 else S 2 | while b do S| abort u Abort terminates the execution u No new rules are needed in natural operational semantics u Statements –if x = 0 then abort else y := y / x –skip –abort –while true do skip

Conclusion u The natural semantics cannot distinguish between looping and abnormal termination (unless the states are modified)

The While Programming Language with Non-Determinism u Abstract syntax S::= x := a | skip | S 1 ; S 2 | if b then S 1 else S 2 | while b do S| S 1 or S 2 u Either S 1 or S 2 is executed u Example –x := 1 or (x :=2 ; x := x+2)

[or 1 ns ]  s’  s’ The While Programming Language with Non-Determinism Natural Semantics [or 2 ns ]  s’  s’

The While Programming Language with Non-Determinism Examples u x := 1 or (x :=2 ; x := x+2) u (while true do skip) or (x :=2 ; x := x+2)

Conclusion u In the natural semantics non-determinism will suppress looping if possible (mnemonic)

The While Programming Language with Parallel Constructs u Abstract syntax S::= x := a | skip | S 1 ; S 2 | if b then S 1 else S 2 | while b do S| S 1 par S 2 u All the interleaving of S 1 or S 2 are executed u Example –x := 1 par (x :=2 ; x := x+2)

Conclusion u In the natural semantics immediate constituent is an atomic entity so we cannot express interleaving of computations

The While Programming Language with local variables and procedures u Abstract syntax S::= x := a | skip | S 1 ; S 2 | if b then S 1 else S 2 | while b do S| begin D v D p S end | call p D v ::= var x := a ; D v |  D p ::= proc p is S ; D p | 

Conclusions Local Variables u The natural semantics can “remember” local states

Summary u Operational Semantics is useful for: –Language Designers –Compiler/Interpreter Writer –Programmers u Natural operational semantics is a useful abstraction –Can handle many PL features –No stack/ program counter –Simple –“Mostly” compositional u Other abstractions exist