1

Semantics Q1 2007

SEMANTICS (Q1,’07)Week 3

Jacob AndersenPhD student

andersen@daimi.au.dk

2

Semantics Q1 2007

Remember to sign up or check that you have been signed up for the exam !!!

Sept. 1 - 15

3

Semantics Q1 2007

Week 3 - Outline• Small-step vs. big-step (a comparison):

• Non-termination, abnormal termination, non-determinism, and parallelism

• Runtime-errors

• Exceptions and Exception Handling

• Type Errors

• Type Checking

• Intermediate Syntax

• Structural Induction

4

Semantics Q1 2007

BIG-STEP vs. SMALL-STEP

5

Semantics Q1 2007

Big-step vs. Small-step:• Small-step while semantics:

• Big-step while semantics:

< while b do c , > SS < c ; while b do c , >[WH1]SS

< while b do c , > SS [WH2]SS

[WH1]BS

[WH2]BS

< while b do c , > BS ”

< while b do c , > BS

< while b do c , ’ > BS ”< c , > BS ’ |_ b B* tt

|_ b B* ff

|_ b B* tt

|_ b B* ff

6

Semantics Q1 2007

Big-step vs. Small-step: Looping• Small-step:

• Big-step:

Looping described as: infinite transition sequence

< while tt do nil , > ?

< while tt do nil , > < nil ; while tt do nil , >

< while tt do nil , > < nil ; while tt do nil , >

…

< while tt do nil , > ?

…

< nil , >

Looping described as: infinite inference tree (actually no inference tree)!

“vertically infinite”

“horizontally infinite”

stuck

7

Semantics Q1 2007

Extension: Abnormal Termination

• Language L:

• Commands (c Com):

• Small-step semantics ?

• Big-step semantics ?

c ::= nil | v := e | c ; c’ | if b then c else c’ | while b do c | abort

no rule

no rule

8

Semantics Q1 2007

Big-step vs. Small-step: Abnormal Termination

• Small-step:

• Big-step:

Stuck conf.'s described as: terminating transition sequence ( looping)

< nil ; abort , > ?

< nil ; abort , > < abort , >

< abort , > ?< nil , >

Stuck configurations described as: no inference tree (as with looping)!

NB: Big-step cannot distinguish looping and abnormal termination!

NB: Small-step can distinguish looping and abnormal termination!

stuck

stuck

9

Semantics Q1 2007

Extension: Non-determinism• Language L:

• Commands (c Com):

• Small-step semantics ?

• Big-step semantics ?

c ::= nil | v := e | c ; c’ | if b then c else c’ | while b do c | c alt c’

<c alt c’,> SS <c,>

<c alt c’,> SS <c’,>

<c alt c’,> BS ’<c,> BS ’

<c alt c’,> BS ’<c’,> BS ’

10

Semantics Q1 2007

Big-step vs. Small-step: Non-determinism

• Small-step:

• Big-step:

Small-step will commit to a choice (right here, right now)

< abort alt nil, >

< abort alt nil , > < abort , >

< nil , >

Big-step will look ahead for “good” choices (here, only 1 inf. tree exists)

NB: Big-step will suppress non-termination (and abnormal termination)!

NB: Small-step will not suppress looping (or abortion);

< abort alt nil , > < nil , >

or

stuck

11

Semantics Q1 2007

Extension: Parallelism• Language L:

• Commands (c Com):

• Small-step semantics ?

• Big-step semantics ?

c ::= nil | v := e | c ; c’ | if b then c else c’ | while b do c | c par c’

with “interleaving semantics”

<c par c’,> SS <c’’ par c’,’><c,> SS <c’’,’>

not possible(with “interleaving semantics”)

<c par c’,> SS <c par c’’,’><c’,> SS <c’’,’>

12

Semantics Q1 2007

Big-step vs. Small-step: Parallelism• Small-step:

• Big-step:

Small-step can evaluate one step of c0, then c1, then c0, …

< c0 par c1 , > ”

< c0 , > ’

Big-step will have to (chose) evaluate either c0 (or c1) completely first

NB: Big-step cannot express (interleaving) parallelism!

NB: Small-step can easily express (interleaving) parallelism!

< c0 par c1 , >

< c0 par c1’ , ’>

< c0’ par c1’ , ”>

< c1 , ’ > ”

13

Semantics Q1 2007

The transitive closure *

• Recall the small-step semantics for L:

• And imagine the corresponding big-step semantics:

• such that:• Note: can be done for L, but in general only is possible.

• A * is also a big-step evaluation in “disguise”.

C := (Com Store) StoreC C C

TC := Store C

…

C (Com Store) Store

C = C ∩ ((Com Store) Store )*

14

Semantics Q1 2007

RUNTIME-ERRORS

15

Semantics Q1 2007

SOS for division• SOS for division:

•

•

•

• Division by 0 ?

[DIV1]

< e0 / e1 , > < e0’ / e1 , ’ >< e0 , > < e0’ , ’ >

[DIV2]

[DIV3]< n0 / n1 , > < m , >

m = n0 / n1

< n0 / e1 , > < n0 / e1’ , ’ >< e1 , > < e1’ , ’ >

< 3 / x , [x=0] > < 3 / 0 , [x=0] > stuck

n1 0

16

Semantics Q1 2007

Recall: Terminal Trans. Sys.• A Terminal Transition System is a structure:

is the set of configurations is the transition relation

• T is a set of final configurations

– …satisfying:– i.e. “all configurations in ‘T’ really are terminal”.

– …but not the “converse”:

– However, in practice achieved through runtime-errors!

, , T

T : ’ : ’

T : ’ : ’

17

Semantics Q1 2007

So what about “Division by Zero”

• We would like:

– Add configuration:– …and rule:

•

• …but now what about:

< 3 / 0 , > runtime-error

[DIV4]< n0 / n1 , > runtime-error

n1 = 0

L := Exp Store {runtime-error}

< (3 / 0) + 2 , > stuck?!?

18

Semantics Q1 2007

Add runtime-errors for [add]/[sub]/..

• Propagation of runtime-errors:•

•

•

•

[SUM3]

< e0 + e1 , > runtime-error

< e0 , > runtime-error

[SUM4]

< n0 + e1 , > runtime-error

< e1 , > runtime-error

[SUB3]

< e0 - e1 , > runtime-error

< e0 , > runtime-error

[SUB4]

< n0 - e1 , > runtime-error

< e1 , > runtime-error

19

Semantics Q1 2007

Propagation…• Even for Boolean Expressions:

•

•

• And Commands:•

•

[SEQ3]C

< c0 ; c1 , > C runtime-error

< c0 , > C runtime-error

…

< ~ b , > B runtime-error

< b , > B runtime-error[NOT2]B

…

20

Semantics Q1 2007

All this just for Division by Zero?• Yes

• Note: the same thing happens in prog. lang.’s• Can be done more elegantly (albeit, not in this course)

• Same thing for (depending on lang.):• Arithmetic overflow• Square root of a negative number• Overstepping array bounds• Reading uninitialized variable• Dereferencing null-pointers• Dynamic type failure (in dynamically typed lang.s)• …

21

Semantics Q1 2007

EXCEPTIONS AND

EXCEPTION HANDLING

22

Semantics Q1 2007

Exception Handling• Suppose we want to recover from div-by-zero

– Turn it into an exception (instead):

– And add exception handler construct:• Commands (c Com):

– For simplicity, let’s assume x is always dbzexception

< 3 / 0 , > < dbzexception , >

c ::= nil | v := e | c ; c’ | if b then c else c’ | while b do c try c catch x recover c’

23

Semantics Q1 2007

SOS for try-catch-recover• SOS for “try-catch-recover”:

[TRY1]< c0 , > < c0’ , ’ >

[TRY2]

[TRY3]< c0 , > < x , ’ >

< try c0 catch x recover c1, > < try c0’ catch x recover c1 , ’ >

< try c0 catch x recover c1 , > < c1 , ’ >

< c0 , > ’

< try c0 catch x recover c1 , > ’

Recall that x is always dbzexception

24

Semantics Q1 2007

TYPE ERRORS

25

Semantics Q1 2007

Consider Variant of L; L’• Basic Syntactic Sets:

• Operators–

• Derived Syntactic Sets:• (Mixed) Expressions (e Exp):

–

• Commands (c Com):–

e ::= n | t | v | e o e’ | ~ e

c ::= nil | v := e | c ; c’ | if e then c else c’ | while e do c

o { +, -, , /, =, or } Store = Var Z

Assume variables canonly hold integers:

26

Semantics Q1 2007

Tons of Problems...(?)• Now what about expressions like…:

• • • • • • …

• Well, we could make them runtime-errors• or we could have "fake, almost-like-booleans" (as C)• However, compile-time errors (much better) !!!

2 + tt

~ 42

if 5 then c0 else c1

while 87 do c

x := tt ?

27

Semantics Q1 2007

Runtime- vs. compile-time errors

• Runtime-error (aka. dynamic error):

• i.e., maybe intercepted when the program is run !

• Compile-time error (aka. static error):

• i.e., always intercepted when program is compiled !

int n; .. x = n / 0; // runtime-error (exception)

int n; .. if (n) x = 42; // compile-time error

[Java]

[Java]

28

Semantics Q1 2007

Dynamically vs. Statically Typed Lang.’s

• Dynamically Typed Language:

• i.e., error found only when the program is run (maybe)

• Statically Typed Language:

• i.e., error found when the program is compiled

$beer = true; // dynamically typed vars .. $x = $beer - 42; // runtime-error

boolean b = true; // statically typed vars .. x = b - 42; // compile-time error

[Basic]

[Java]

29

Semantics Q1 2007

However, …• Not all runtime-errors can be “turned into” compile-time

errors:

• Consider division-by-zero (in Java):– runtime-error here e’ evaluates to 0

• We would really like:» runtime-error compile-time error

• However, we cannot do (compile-time) “static analysis”;» Since the error depends on the runtime value of e’,

we can only evaluate e’ in a particular store,

e / e’

30

Semantics Q1 2007

What about Type Errors• Again, we would really like:

• runtime error compile-time type error

• However:

• If we could invent some stronger requirement:• runtime error => compile-time type error

– Then (by contraposition; i.e. ):• no compile-time type error => no runtime error

if (e) b := 7;else b := tt;b := ~ b; // potential runtime-error

The (potential) error dependson the runtime value of e

P => Q ~Q => ~P

31

Semantics Q1 2007

Type Declarations(!)• Add type declarations (bool, int, …)

• And make sure they are respected (everywhere in the program)

• However, now we need to do (static) type checking [in 4 slides…]

bool b; // type declaration (b always bool)if (e) b := 7; // static type errorelse b := tt; // okayb := ~ b; // okay

32

Semantics Q1 2007

Approximative Solution• Potential error…

• …maybe it never happens(!?):

• The Type Checking Approximation:

if (ff) b := 7;else b := tt;b := ~ b; // never an error!!!

never error maybe error

Type safe!

.?

. .never error maybe error

undecidable

type-checking: safe (over-)approximation

above program

Quality of a type-system ~ size of “slack” (wrongfully rejected programs)

33

Semantics Q1 2007

TYPE CHECKING

34

Semantics Q1 2007

Recall L’• Basic Syntactic Sets:

• Operators–

• Derived Syntactic Sets:• (Mixed) Expressions (e Exp):

–

• Commands (c Com):–

e ::= n | t | v | e o e’ | ~ e

c ::= nil | v := e | c ; c’ | if e then c else c’ | while e do c

o { +, -, , /, =, or } Store = Var Z

Assume variables canonly hold integers:

35

Semantics Q1 2007

Introducing Types• Define a set of types:

Types = { int, bool }

• Define (static) type relation:• |_ Exp x Types

• We shall write instead of» Meaning: “the expression 42 has type int”

• We would like:»

»

» whereas for any Types

|_ 42 : int (42,int) ‘|_’

|_ 3+5 : int

|_ 3=5 : bool

|_ 7+tt :

36

Semantics Q1 2007

Basic Syn. Sets (Inherently Typed)

• Expressions:

• Numbers:• for any n

• Truthvalues:• for any t

• Variables:• for any v (assumption: vars only hold ints)

|_ n : int

|_ t : bool

e ::= n | t | v | e e’ | ~ e

|_ v : int

Store = Var Z

Assume variables canonly hold integers:

37

Semantics Q1 2007

• Expressions:

• Negation:• (i.e., only defined if )

• Binary Operators:•

– Where:– i.e. a partial function

Composite Definitionse ::= n | t | v | e e’ | ~ e

|_ e : bool|_ ~e : bool

|_ e0 : 0 |_ e1 : 1

|_ e0 e1 : 2

|_ e : bool

|_ ~e : bool

2 = type(0, 1)

type : Types x Types Types

type+ := [int,int | int]

type= := [int,int | bool]

typeor := [bool,bool | bool]

{ +, -, , /, =, or }

Examples:

38

Semantics Q1 2007

Type Checking Example• Type check:

• How?

~ (ff or ((1 + 2) = 3)))

39

Semantics Q1 2007

Commands: Well-formedness• Commands:

• Define (static) well-formedness relation:• |_wfc Com

• We shall write instead of» Meaning: “c is well-formed (i.e., has no type errors)”

• We would like:» » » whereas

nil | v := e | c ; c’ | if e then c else c’ | while e do c

|_wfc c c ‘|_wfc’

|_wfc x := (1+2)

|_wfc if ~(1=2) then nil else y := 3

|_wfc if 5 then c else c’

40

Semantics Q1 2007

WFC: Nil, Ass., and Seq.• Commands:

• Nil:•

• Assignment:•

• Sequence:•

nil | v := e | c ; c’ | if e then c else c’ | while e do c

|_wfc nil

|_ e : int

|_wfc v := e

|_wfc c0 ; c1

|_wfc c0 |_wfc c1

41

Semantics Q1 2007

WFC: if-then-else and while-do.

• Commands:

• if-then-else:•

• while-do:•

nil | v := e | c ; c’ | if e then c else c’ | while e do c

|_wfc if e then c0 else c1

|_wfc c0 |_wfc c1|_ e : bool

|_wfc while e do c

|_wfc c|_ e : bool

42

Semantics Q1 2007

Type Checking Examples (wfc)• Type check:

• How?

x := 1 ; y:= 2

while ~ff do nil

if tt then nil else x := tt

43

Semantics Q1 2007

INTERMEDIATE SYNTAX

44

Semantics Q1 2007

“Intermediate Syntax”• Sometimes “intermediate syntax” must be introduced in

order to describe a small-step computation.• E.g. (taken from the upcoming hand-in):

» small-step semantics ??

You can think of F as a boolean expression with possible side-effects (hence evaluated in small steps).

» Introducing new C construct:

• As always: “intermediate syntax” should not be thought of as concrete (ambiguity problems).

» Abstract syntax: Adding a new node type to (intermediate only) ASTs

C ::= (do F od) | …

C ::= (do F od) | (do F rem F’ od) | …

Evaluate F in small-steps as usual.

While remembering the original F.

45

Semantics Q1 2007

STRUCTURAL INDUCTION

46

Semantics Q1 2007

Principle of Mathematical Induction

• Let P be a predicate (i.e. a boolean function):• then we have that:

• Intuitive: ?

P: N { true, false }

nN : P(n)

P(0)

induction stepbase case

Principle of mathematical induction:

P(n) P(n+1)

P(3)

P(0) P(0) => P(1) P(1) => P(2) P(2) => P(3)

47

Semantics Q1 2007

Example Induction Proof• Example: Prove

• I.e.• Base case (i.e. prove P(0)):

• Induction step (i.e. prove P(n) => P(n+1)):– Assume the induction hypothesis (I.H.)

(i.e. assume P(n)):

– Now prove P(n+1):

P(n) [ 20 + 21 + … + 2n = 2n+1 – 1 ]

P(0) [ 20 = 20+1 – 1 ]

[ 20 + 21 + … + 2n = 2n+1 – 1 ]

[ 20 + 21 + … + 2n+1 = 2(n+1)+1 – 1 ]

20 + 21 + … + 2n + 2n+1 (20 + 21 + … + 2n) + 2n+1=

(2n+1 – 1) + 2n+1 == 2*2n+1 – 1 = 2(n+1)+1 – 1 I.H.

nN : ∑2i = 2n+1 – 1i=0

n

48

Semantics Q1 2007

Structural Induction (for Exp)• Given:

• Arithmetic Expressions (e Exp)– e ::= n | v | e0+e1

e Exp : P(e)

P(n)

composite (inductive) casebase cases

Principle of structural induction:

P(e0) P(e1) P(e0+e1) P(v) and

49

Semantics Q1 2007

Intuition: Induction vs. Str’ Induction

• Induction:• Holds for ?

• Structural Induction:• Holds for ?

P(0) P(0) => P(1) P(1) => P(2) P(2) => P(3)

P(3)

P(7+(x+y))

P(7)

P(x) P(y)

P(x+y)

P(7+(x+y))

50

Semantics Q1 2007

Structural Induction (for BExp)• Boolean Expressions (b BExp):

–

• Live exercise… :)• [Think 3 mins; then interactively on the whiteboard]

b ::= t | b or b’ | ~ b

51

Semantics Q1 2007

Structural Induction Examples• Given:

• Arithmetic Expressions (e Exp)–

• Property A:• Evaluation of arithmetic expressions (using a small-

step operational semantics) is deterministic

• Property B:• Evaluation of arithmetic expressions (using a small-

step operational semantics) always terminates

e ::= n | v | e0+e1

52

Semantics Q1 2007

"Three minutes paper"• Please spend three minutes writing down the

most important things that you have learned today (now).

After 1 dayAfter 1 week

After 3 weeksAfter 2 weeks

Right away

53

Semantics Q1 2007

Next week: Def's, static vs. dynamic

semantics

Any Questions?