1Semantik och programteori

Tillämpning av denotationssemantik

Semantiken hos ett större imperativt språk

Semantik för kontextuella begränsningar

Resonera om program

2Semantik och programteori

Semantiska domäner Specificera semantiska domäner lämpliga för språket vi

vill definiera. Det behövs en domän för att modellera varje typ av värde i språket. Till dessa definieras hjälpfunktioner för att modellera operationer på dessa värden.

I språket behövs: Primitiva typer: Sammansatta typer Första klassens värden Andra värden Omgivningen Minne Variabler

3Semantik och programteori

Typer Primitiva typer:

Truth-Value, Integers, Character Sammansatta typer

Record-Value and Array-Value. Första klassens värden

Value = disjunkt union av Truth-Value, Integer,Character, Record-Value och Array-Value.

Andra värden Variable, Procedure, and Function

4Semantik och programteori

Strukturer Omgivningen

Bindable = disjunkt union av Value, Variable, Procedure, Function och Allocator

Minne (Store) Storable = disjunkt union av

Truth-Value, Integer, Character och Text. Variabler

Record-Variable Array-Variable Variable = disjunkt union av

Location , Record-Variable och Array-Variable.

5Semantik och programteori

Kontenta

Ett bra val av domäner och hjälp funktioner tenderar till att göra de semantiska funktionerna relativt kortfattade och enkla att förstå.

6Semantik och programteori

Semantiska funktions För varje frasklass i programspråket väljer vi en

domän för denotationen för fraser i den klassen och specificerar en semantisk funktion som mappar dessa fraser till deras denotation.

Kommandon Environ Store Store.

Uttryck Environ Store Value Store.

Deklarationer Environ Store Environ Store.

7Semantik och programteori

Uttryck som kommandoblockevaluate : Expression (Environ Store Value Store)

evaluate [begin C; return E end] env sto =let sto' = execute C env sto inevaluate E env sto'

evaluate [E1 + E2] env sto =let (int1, sto') = evaluate E1 env sto inlet (int2, sto'') = evaluate E2 env sto' in(sum (int1, int2), sto'')

evaluate [N] env sto =(valuation N, sto)

execute [I := E] env sto =let (val, sto') = evaluate E env sto inlet variable loc = find (env, I) in

update (sto', loc, val)

8Semantik och programteori

Denotation för uttryck, kommandon och deklarationer.

Frasklass Domän för denotation

Pure functional language:Expression Environ ValueDeclaration Environ Environ

Imperative language without side effects:Expression Environ Store ValueCommand Environ Store StoreDeclaration Environ Store Environ Store

Imperative language with side effects:Expression Environ Store Value StoreCommand Environ Store StoreDeclaration Environ Store Environ Store

9Semantik och programteori

Abstraktioner Abstraktionsdomäner i språk med statiska bindningar.

Typ av Denotation för Abstraktionsdomänabstraktion abstraktionskropp

Pure functional language:Function Environ Value Argument* Value

Imperative language without side effects:Function Environ Store Value Argument* Store ValueProcedure Environ Store Store Argument* Store Store

Imperative language with side effects:Function Environ Argument*

Store Value Store Store Value StoreProcedure Environ Store Store Argument* Store Store

10Semantik och programteori

Program och input–outputrun : Program (Input Output)

program(input n :Integer,output p :Integer) ~p := 1;while n > 0 do

begin p := 2 * p; n := n - 1 end

Program ::=program(

input Identifier : Type-Denoter,

output Identifier : Type-Denoter ) ~

Command

11Semantik och programteori

Semantiska funktionerrun : Program (Value Value)run [program ( input I1 : T1 ,

output I2 : T2 ) ~ C] in-val =let sto = empty-store inlet (sto1, in-var) = allocate-variable T1 empty-environ sto inlet (sto2, out-var) = allocate-variable T2 empty-environ sto1 inlet sto3 = update-variable (sto2, in-var, in-val) inlet env = overlay (bind (I1, variable in-var),

bind (I2, variable out-var)) inlet sto4 = execute C env sto3 infetch-variable (sto4, out-var)

12Semantik och programteori

ExempelC1 = p := 1

C2 = p := 2 * p

C3 = n := n - 1

C4 = while n > 0 do begin C2 ; C3 end

C5 = C1 ; C4

run [program(input n :Integer,output p :Integer) ~ C5] v =

let sto = empty-store inlet (sto1, in-var) = allocate-variable Integer empty-environ sto inlet (sto2, out-var) = allocate-variable Integer empty-environ sto1 inlet sto3 = update-variable (sto2, in-var, v) inlet e0 = overlay ( bind (n, variable in-var),

bind (p , variable out-var)) inlet sto4 = execute C5 e0 sto3 infetch-variable (sto4, out-var)

13Semantik och programteori

Exempelrun [program(input n :Integer,output p :Integer) ~ C5] v =

let s0 = empty-store inlet (s1, in-var) = allocate-variable Integer empty-environ s0 inlet (s2, out-var) = allocate-variable Integer empty-environ s1 inlet s3 = update-variable (s2, in-var , v) inlet e0 = overlay ( bind (n, variable in-var),

bind (p , variable out-var)) inlet s4 = execute C5 e0 s3 infetch-variable (s4, out-var)

14Semantik och programteori

Exempelrun [program(input n :Integer,output p :Integer) ~ C5] v =

let s0 = empty-store inlet (s1, in-var) = let (sto,l0) = allocate s0 in (sto,primitiv-variable l0) inlet (s2, out-var) = allocate-variable Integer empty-environ s1 inlet s3 = update-variable (s2, in-var , v) inlet e0 = overlay ( bind (n, variable in-var),

bind (p , variable out-var)) inlet s4 = execute C5 e0 s3 infetch-variable (s4, out-var)

15Semantik och programteori

Exempelrun [program(input n :Integer,output p :Integer) ~ C5] v =

let s0 = empty-store inlet (sto, l0) = allocate s0 in let (s1, in-var) = (sto,primitiv-variable l0) inlet (s2, out-var) = allocate-variable Integer empty-environ s1 in let s3 = update-variable (s2, in-var , v) inlet e0 = overlay ( bind (n, variable in-var),

bind (p , variable out-var)) inlet s4 = execute C5 e0 s3 infetch-variable (s4, out-var)

16Semantik och programteori

Exempelrun [program(input n :Integer,output p :Integer) ~ C5] v =

let s0 = empty-store inlet (s1, l0) = allocate s0 in let in-var = primitiv-variable l0 inlet (s2, out-var) = allocate-variable Integer empty-environ s1 in let s3 = update-variable (s2, in-var , v) inlet e0 = overlay ( bind (n, variable in-var),

bind (p , variable out-var)) inlet s4 = execute C5 e0 s3 infetch-variable (s4, out-var)

17Semantik och programteori

Exempelrun [program(input n :Integer,output p :Integer) ~ C5] v =

let s0 = empty-store inlet (s1, l0) = allocate s0 in let in-var = primitiv-variable l0 inlet (s2, l1) = allocate s1 in let out-var = primitiv-variable l1 in let s3 = update-variable (s2, in-var , v) inlet e0 = overlay ( bind (n, variable in-var),

bind (p , variable out-var)) inlet s4 = execute C5 e0 s3 infetch-variable (sto4, out-var)

18Semantik och programteori

Exempelrun [program(input n :Integer,output p :Integer) ~ C5] v =

let s0 = empty-store inlet (s1, l0) = allocate s0 in let (s2, l1) = allocate s1 in let out-var = primitiv-variable l1 in let s3 = update-variable (s2, primitiv-variable l0 , v) inlet e0 = overlay ( bind (n, variable (primitiv-variable l0)),

bind (p , variable out-var)) inlet s4 = execute C5 e0 s3 infetch-variable (s4, out-var)

19Semantik och programteori

Exempelrun [program(input n :Integer,output p :Integer) ~ C5] v =

let s0 = empty-store inlet (s1, l0) = allocate s0 in let (s2, l1) = allocate s1 in let s3 = update-variable (s2, primitiv-variable l0 , v) inlet e0 = overlay ( bind (n, variable (primitiv-variable l0)),

bind (p , variable (primitiv-variable l1))) inlet s4 = execute C5 e0 s3 infetch-variable (s4, primitiv-variable l1)

20Semantik och programteori

Exempelrun [program(input n :Integer,output p :Integer) ~ C5] v =

let s0 = empty-store inlet (s1, l0) = allocate s0 in let (s2, l1) = allocate s1 in let s3 = update (s2, l0 , v) inlet e0 = overlay ( bind (n, variable (primitiv-variable l0)),

bind (p , variable (primitiv-variable l1))) inlet s4 = execute C5 e0 s3 infetch-variable (s4, primitiv-variable l1)

21Semantik och programteori

Exempelrun [program(input n :Integer,output p :Integer) ~ C5] v =

let (s1, l0) = allocate empty-store in let (s2, l1) = allocate s1 in let s3 = update (s2, l0 , v) inlet e0 = overlay ( bind (n, variable (primitiv-variable l0)),

bind (p , variable (primitiv-variable l1))) inlet s4 = execute C5 e0 s3 infetch-variable (s4, primitiv-variable l1)

22Semantik och programteori

Exempelrun [program(input n :Integer,output p :Integer) ~ C5] v =

let (s1, l0) = allocate empty-store in let (s2, l1) = allocate s1 in let s3 = update (s2, l0 , v) inlet e0 = overlay ( bind (n, variable (primitiv-variable l0)),

bind (p , variable (primitiv-variable l1))) inlet s4 = execute C5 e0 sto3 infetch (s4, l1)

23Semantik och programteori

Exempelexecute C5 e0 s3 =

execute [C1; C4] e0 s3

24Semantik och programteori

Exempelexecute C5 e0 s3 =

execute [p := 1; C4] e0 s3

25Semantik och programteori

Exempelexecute C5 e0 s3 =

execute C4 e0 (execute p := 1 e0 s3)

26Semantik och programteori

Exempelexecute C5 e0 s3 =

execute C4 e0 ( let val = evaluate 1 e0 s3 inlet variable var = identify p e0 inupdate-variable(s3, var,val))

27Semantik och programteori

Exempelexecute C5 e0 s3 =

execute C4 e0 ( let val = integer (valuation 1 ) inlet variable var = identify p e0 inupdate-variable(s3, var,val))

28Semantik och programteori

Exempelexecute C5 e0 s3 =

execute C4 e0 ( let val = integer 1 inlet variable var = identify p e0 inupdate-variable(s3, var,val))

29Semantik och programteori

Exempelexecute C5 e0 s3 =

execute C4 e0 ( let variable var = identify p e0 inupdate-variable(s3, var, integer 1))

identify p e0 =

find (e0 ,p) =

find (overlay ( bind (n, variable (primitiv-variable l0)),bind (p , variable (primitiv-variable l1))), p) =

find (bind (p , variable (primitiv-variable l1)), p) =

variable (primitiv-variable l1))

30Semantik och programteori

Exempelexecute C5 e0 s3 =

execute C4 e0 ( let variable var = variable (primitiv-variable l1) inupdate-variable(s3, var, integer 1))

31Semantik och programteori

Exempelexecute C5 e0 s3 =

execute C4 e0 ( update-variable(s3, primitiv-variable l1 , integer 1))

32Semantik och programteori

Exempelexecute C5 e0 s3 =

execute C4 e0 (update(s3, l1 , integer 1))

33Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 , integer 1) in execute C4 e0 s31

34Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 , integer 1) in

execute [while n > 0 do begin C2;C3 end] e0 s31

35Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 , integer 1) in

let execute-while env sto = if evaluate [n > 0] env sto = truth-value true then execute-while env (execute [C2;C3] env sto)

else sto

inexecute-while e0 s31

36Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 , integer 1) in

let execute-while sto = if evaluate [n > 0] e0 sto = truth-value true then execute-while (execute [C2;C3] e0 sto)

else sto

inexecute-while s31

37Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 , integer 1) in

let execute-while sto = if ( let integer int1 = evaluate n e0 sto in

let integer int2 = evaluate 0 e0 sto intruth-value (greater(int1 , int2 )) = truth-value true)

then execute-while (execute [C2;C3] e0 sto)

else sto

inexecute-while s31

38Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 , integer 1) in

let execute-while sto = if ( let integer int1 = coerce(sto,identify n e0) in

let integer int2 = evaluate 0 e0 sto intruth-value (greater(int1 , int2 )) = truth-value true)

then execute-while (execute [C2;C3] e0 sto)

else sto

inexecute-while s31

39Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 , integer 1) in

let execute-while sto = if ( let integer int1 = coerce(sto,find(e0,n)) in

let integer int2 = evaluate 0 e0 sto intruth-value (greater(int1 , int2 )) = truth-value true)

then execute-while (execute [C2;C3] e0 sto)

else sto

inexecute-while s31

40Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 , integer 1) in

let execute-while sto = if ( let integer int1 = coerce(sto, variable (primitiv-variable l0)) in

let integer int2 = evaluate 0 e0 sto intruth-value (greater(int1 , int2 )) = truth-value true)

then execute-while (execute [C2;C3] e0 sto)

else sto

inexecute-while s31

41Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 , integer 1) in

let execute-while sto = if ( let integer int1 = fetch-variable(sto,primitiv-variable l0) in

let integer int2 = evaluate 0 e0 sto intruth-value (greater(int1 , int2 )) = truth-value true)

then execute-while (execute [C2;C3] e0 sto)

else sto

inexecute-while s31

42Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 , integer 1) in

let execute-while sto = if ( let integer int1 = fetch (sto,l0) in

let integer int2 = evaluate 0 e0 sto intruth-value (greater(int1 , int2 )) = truth-value true)

then execute-while (execute [C2;C3] e0 sto)

else sto

inexecute-while s31

43Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 ,integer 1) in

let execute-while sto = if ( let integer int1 = fetch (sto,l0) in

let integer int2 = integer 0 intruth-value (greater(int1 , int2 )) = truth-value true)

then execute-while (execute [C2;C3] e0 sto)

else sto

inexecute-while s31

44Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 ,integer 1) in

let execute-while sto = if ( let integer int1 = fetch (sto,l0) in

truth-value (greater(int1 , 0)) = truth-value true)then execute-while (execute [C2;C3] e0 sto)

else sto

inexecute-while s31

45Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 ,integer 1) in

let execute-while sto = if ( let integer int1 = fetch (sto,l0) in greater(int1 , 0) = true)then execute-while (execute [C2;C3] e0 sto)

else sto

inexecute-while s31

46Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 ,integer 1) in

let execute-while sto = if (let integer int1 = fetch (sto,l0) in greater(int1 , 0))then execute-while (execute [C2;C3] e0 sto)

else sto

inexecute-while s31

47Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 ,integer 1) in

let execute-while sto = let integer int1 = fetch (sto,l0) in if greater(int1 , 0)then execute-while (execute [C2;C3] e0 sto)

else sto

inexecute-while s31

48Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 ,integer 1) in

let execute-while sto = let integer int1 = fetch (sto,l0) in if greater(int1 , 0)then execute-while (execute C3 e0 (execute C2 e0 sto))

else sto

inexecute-while s31

49Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 ,integer 1) in

let execute-while sto = let integer int1 = fetch (sto,l0) in if greater(int1 , 0) then execute-while (execute C3 e0 (execute [p := 2 * p] e0 sto))

else sto

inexecute-while s31

50Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 ,integer 1) in

let execute-while sto = let integer int1 = fetch (sto,l0) in if greater(int1 , 0) then execute-while (execute C3 e0 (

let val = evaluate [2 * p] e0 sto inlet variable var = identify p e0 inupdate-variable (sto,var,val)))

else sto

inexecute-while s31

51Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 ,integer 1) in

let execute-while sto = let integer int1 = fetch (sto,l0) in if greater(int1 , 0) then execute-while (execute C3 e0 (

let integer int2 = fetch (sto, l1 ) inupdate (sto, l1 ,integer(times(2,int2)))))

else sto

inexecute-while s31

52Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 ,integer 1) in

let execute-while sto = let integer int1 = fetch (sto,l0) in if greater(int1 , 0) then let s32 = let integer int2 = fetch (sto, l1 ) in

update (sto, l1 ,integer(times(2,int2))) in execute-while (execute C3 e0 s32)

else sto

inexecute-while s31

53Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 ,integer 1) in

let execute-while sto = let integer int1 = fetch (sto,l0) in if (greater(int1 , 0) = true)then let integer int2 = fetch (sto, l1 ) in

let s32 = update (sto, l1 , integer(times(2,int2))) in execute-while (execute C3 e0 s32)

else sto

inexecute-while s31

54Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 ,integer 1) in

let execute-while sto = let integer int1 = fetch (sto,l0) in if greater(int1 , 0) then let integer int2 = fetch (sto, l1 ) in

let s32 = update (sto, l1 , integer(times(2,int2))) in execute-while (execute [n := n - 1] e0 s32)

else sto

inexecute-while s31

55Semantik och programteori

Exempelexecute C5 e0 s3 =

let s31 = update(s3, l1 ,integer 1) in

let execute-while sto = let integer int1 = fetch (sto,l0) in if greater(int1 , 0) then let integer int2 = fetch (sto, l1 ) in

let s32 = update (sto, l1 , integer(times(2,int2))) in let integer int3 = fetch (s32 , l0 ) in let s33 = update (s32 , l0 , integer(minus(int1,1))) in execute-while s33

else sto

inexecute-while s31

56Semantik och programteori

Exempelrun [program(input n :Integer,output p :Integer) ~ C5] v =

let (s1, l0) = allocate empty-store in let (s2, l1) = allocate s1 in let s3 = update (s2, l0 , v) inlet e0 = overlay ( bind (n, variable (primitiv-variable l0)),

bind (p , variable (primitiv-variable l1))) inlet s4 = execute C5 e0 s3 infetch (s4, l1)

57Semantik och programteori

Exempelrun [program(input n :Integer,output p :Integer) ~ C5] v =

let (s1, l0) = allocate empty-store in let (s2, l1) = allocate s1 in let s3 = update (s2, l0 , v) inlet e0 = overlay ( bind (n, variable (primitiv-variable l0)),

bind (p , variable (primitiv-variable l1))) inlet sto4 = let s31 = update(s3, l1 ,integer 1) in

let execute-while sto = let integer int1 = fetch (sto,l0) in if greater(int1 , 0) then let integer int2 = fetch (sto, l1 ) in

let s32 = update (sto, l1 , integer(times(2,int2)))) in

let integer int3 = fetch (s32 , l0 ) in let s33 = update (s32 , l0 , integer(minus(int1,1)))

in execute-while s33

else sto in execute-while s31

in fetch(sto4, l1)

58Semantik och programteori

Exempelrun [program(input n :Integer,output p :Integer) ~ C5] v =

let (s1, l0) = allocate empty-store in let (s2, l1) = allocate s1 in let s3 = update (s2, l0 , v) inlet e0 = overlay ( bind (n, variable (primitiv-variable l0)),

bind (p , variable (primitiv-variable l1))) inlet s31 = update(s3, l1 ,integer 1) in let execute-while sto =

let integer int1 = fetch (sto,l0) in if greater(int1 , 0) then let integer int2 = fetch (sto, l1 ) in

let s32 = update (sto, l1 , integer(times(2,int2))) in let integer int3 = fetch (s32 , l0 ) in let s33 = update (s32 , l0 , integer(minus(int1,1))) in execute-while s33

else sto in fetch(execute-while s31 , l1)

59Semantik och programteori

Klartrun [program(input n :Integer,output p :Integer) ~ C5] v =

let (s1, l0) = allocate empty-store in let (s2, l1) = allocate s1 in let s3 = update (s2, l0 , v) inlet s31 = update(s3, l1 ,integer 1) in let execute-while sto =

let integer int1 = fetch (sto,l0) in if greater(int1 ,0)then let integer int2 = fetch (sto, l1 ) in

let s32 = update (sto, l1 , integer(times(2,int2))) in let integer int3 = fetch (s32 , l0 ) in let s33 = update (s32 , l0 , integer(minus(int1,1))) in execute-while s33

else sto in fetch(execute-while s31 , l1)

60Semantik och programteori

Utan typtaggarrun [program(input n :Integer,output p :Integer) ~ C5] v =

let (s1, l0) = allocate empty-store in let (s2, l1) = allocate s1 in let s3 = update (s2, l0 , v) inlet s31 = update(s3, l1 ,1) in let execute-while sto =

let int1 = fetch (sto,l0) in if greater(int1 ,0)then let int2 = fetch (sto, l1 ) in

let s32 = update (sto, l1 , times(2,int2)) in let integer int3 = fetch (s32 , l0 ) in let s33 = update (s32 , l0 ,minus(int1,1)) in execute-while s33

else sto in fetch(execute-while s31 , l1)

61Semantik och programteori

Än mer förenklatrun [program(input n :Integer,output p :Integer) ~ C5] v =

let (s1, l0) = allocate empty-store in let (s2, l1) = allocate s1 in let s3 = update (s2, l0 , v) inlet s31 = update(s3, l1 ,1) in let execute-while sto =

if greater(fetch (sto,l0) ,0)then let s32 = update (sto, l1 ,times(2, fetch (sto, l1 ))) in

let s33 = update (s32 , l0 ,minus(fetch (s32 , l0 ),1)) in execute-while s33

else sto in fetch(execute-while s31 , l1)

62Semantik och programteori

Kontextuella restriktioner Av all meningar som genereras av programspråkets

grammatik är endast en del välformade program. De kontextuella restriktionerna är regler som avgör om ett givet program är välformat eller ej. De avgör också om enstaka programfraser är välformade eller ej.

let const m ~ 10in

‚ let var p : boolin

ƒ p := (m > 0) Omgivningar:

{}‚ {m integer-type}ƒ {m integer-type, p var truth-type}.

63Semantik och programteori

BegränsningarTyp omgivning Dynamisk omgivning { } { }‚ { m integer-type} { m 10}ƒ { m integer-type, { m 10,

p var truth-type} p en variabel innehållande

ett truth-value}

64Semantik och programteori

Denotationssemantik För varje programspråk definierar vi en domän Type, vars

element representerar typer i språket. Låt domänen för typ omgivning vara Type-Environ, med följande hjälp funktioner:

empty-environ : Type-Environbind : Identifier Type Type-Environoverlay : Type-Environ Type-Environ Type-Environfind : Type-Environ Identifier Type

Type-Environ = Identifier (bound Type + unbound)

65Semantik och programteori

För språket IMP: Domän

Type = truth-type + integer-type + var Type + error-type

equivalent : Type Type Truth-Value

equivalent (typ1, typ2) = (typ1 = typ2)

66Semantik och programteori

Semantiska funktionerconstrain : Command (Type-Environ Truth-Value)

typify : Expression (Type-Environ Value-Type)

declare : Declaration (Type-Environ Truth-Value Type-

Environ)

type-denoted-by : Type-Denoter Value-Type

67Semantik och programteori

Constrainconstrain : Command (Type-Environ Truth-Value)constrain [skip] typenv = true

constrain [I := E] typenv =let typ = find (typenv, I) inlet typ' = typify E typenv inequivalent (typ, var typ')

constrain [let D in C] typenv =let (ok, typenv') = declare D typenv inif okthen constrain C (overlay (typenv', typenv))else false

68Semantik och programteori

Constrain Fortsättningconstrain [C1 ; C2] typenv =

constrain C1 typenv constrain C2 typenv

constrain [if E then C1 else C2] typenv =equivalent (typify E typenv, truth-type) constrain C1 typenv constrain C2 typenv

constrain [while E do C] typenv =equivalent (typify E typenv, truth-type) constrain C typenv

69Semantik och programteori

Typifytypify : Expression (Type-Environ Value-Type)typify [N] typenv = integer-type

typify [false] typenv = truth-type

typify [I] typenv =let value-type-of (truth-type) = truth-type

value-type-of (integer-type) = integer-typevalue-type-of (var typ) = typvalue-type-of (error-type) = error-type

invalue-type-of (find (typenv, I))

typify [E1 + E2] typenv =if equivalent (typify E1 typenv, integer-type)

equivalent (typify E2 typenv, integer-type)then integer-typeelse error-type

70Semantik och programteori

Declaredeclare : Declaration ( Type-Environ

Truth-Value Type-Environ)declare [const I ~ E] typenv =

let typ = typify E typenv inif equivalent (typ, error-type)then (false, empty-environ)else (true, bind (I, typ))

declare [var I : T] typenv =let typ = type-denoted-by T in(true, bind (I, var typ))

71Semantik och programteori

Type-denoted-bytype-denoted-by : Type-Denoter Value-Type

type-denoted-by [bool] = truth-type

type-denoted-by [int] = integer-type

72Semantik och programteori

Resonera om program Genom att ge en rent matematisk mening åt varje program,

låter oss denotationssemantiken att etablera semantiska egenskaper hos program med hjälp av matematiskt resonemang.

Framförallt behöver vi ibland bevisa att två kommandon är semantiskt ekvivalenta. I så fall kan vi ersätta det ena kommandot med det andra i programtransformationer. Vi bevisar ekvivalens genom att visa att deras denotation är lika.

73Semantik och programteori

Visa: C ; skip Cexecute [C ; skip] e s

= execute [skip] e (execute C e s)= execute C e s

Därför är execute [C ; skip] = execute C.

74Semantik och programteori

Bevis av Whilewhile E do C

if E then begin C ; while E do C end else skip

execute [begin C end] = execute C

execute[ if E then begin C ; while E do C end else skip] e s

= if evaluate E e s = truth-value truethen execute [begin C ; while E do C end] e selse execute [skip] e s

= if evaluate E e s = truth-value truethen execute [C ; while E do C] e selse s

= if evaluate E e s = truth-value truethen execute [while E do C] e (execute C e s)else s

= execute [while E do C] e s