Document Sample

Semantics And Applications – Class Notes from Lecture 2 Uri Israeli Natalia Cherniavsky Operational Semantics • Natural Semantics – how the overall result of executions are obtained (previous lecture). • Structural Semantics – how the individual steps of the computations take place (current lecture). Properties of natural semantics Semantic Equivalence Two statements are semantically equivalent if the semantics cannot distinguish between them. Formally: Two statements S1 and S2 are semantically equivalent if for all states σ and σ' : <S1, σ> → σ’ if and only if <S2, σ> → σ’. Example: the statement "while b do S" is semantically equivalent to: “if b then (S ; while b do S) else skip”. Proof: See page 26 (chapter 2) in the Nielsen and Nielsen Textbook. More examples: • “skip; com” is semantically equivalent to “com”. • “com; skip” is semantically equivalent to “com”. skip is neutral! • “((com1 ; com2) ; com3)” is semantically equivalent to “(com1 ;( com2 ; com3))” Note: concatenation is associative but not commutative. For example: “x:=3; x:=2” is not semantically equivalent to “x:=2;x:=3”. • “(X := 5; Y := X * 8)” is semantically equivalent to “(X :=5; Y := 40)”. Determinism A natural semantic is deterministic if for all choices of a statement S and states σ, σ', σ'': <S, σ> → σ' and <S, σ> → σ'' implies σ’ = σ''. Theorem: The natural semantics of IMP is deterministic Proof: See page 29 (chapter 2) in the Nielsen and Nielsen Textbook. The Semantic Function Sns The Determinism property leads us to a definition of the semantic function Sns . The meaning of commands can now be summarized as a (partial) function from State to State. We define: Sns: Com → (State y State) This means that for every command S we have a partial function Sns’S÷ ∈{State y State} which is given by: Note that Sns is well defined if and only if the natural semantics is deterministic. The object in the ’ ÷ brackets is a syntactic object (program statement) and the object in the ( ) brackets is a semantic object (state). Examples: • Sns’while true do skip÷ (σ) = undef • Sns’skip÷ (σ) = σ • Sns’X:=1÷ (σ) = σ [1/X] Note that the result is undef when there is no state that can be reached by executing the command. Structural Operational Semantics In Structural Operational Semantics the emphasis is on the individual steps of the execution of the execution. The transition relation has the form: <com, σ> ⇒ γ . The transition expresses the first step of the execution of S from state σ. γ can have two forms: • <com', σ'>, in which case the execution of com from σ is not completed and the remaining computation is expressed by the intermediate configuration <com', σ'>. • σ', in which case execution of com from σ is terminated and the final state is σ'. • We say that <com, σ> is stuck if there is no γ such that <com, σ> ⇒ γ. This means that the computation is not completed yet but there’s no where to move on. For example if there was a runtime error, there won’t be any rules describing that. SOS (IMP) The following two rules are almost the same as in the Natural Semantics since these two statements are fully executed in one step. • <skip, σ> ⇒ σ • <a, σ> → m . <X := a, σ> ⇒ σ[m/X] The following two rules express that to execute com1; com2 in state σ, we first execute com1 on step from σ: • If the execution of com1 has been completed we can start the execution of com2. <com1, σ> ⇒ σ’ . <com1; com2, σ> ⇒ <com2, σ’> • If the execution of com1 has not been completed then we have to complete it before starting the execution of com2. <com1, σ> ⇒ <com1’, σ’> . <com1; com2, σ> ⇒ <com1’; com2, σ’> The following two rules express that to execute a conditional (if-then- else) in state σ, we first perform the test and then select the appropriate branch: • <b, σ> ⇒ true . <if b then com1 else com2, σ> ⇒ <com1, σ> • <b, σ> ⇒ false . <if b then com1 else com2, σ> ⇒ <com2, σ> Finally, we have a rule for “while”. Here, in one step we convert the statement to a semantically equivalent statement (however- more complicated). We unfold one level of the “while”. • <while b do com, σ> ⇒ <if b then (com; while b do com) else skip, σ> Derivation Sequences: ♦ A finite derivation sequence of configurations starting at <S, σ> is γ0, γ1, γ2… γk such that: γ0 = <S, σ> (initial state), γi ⇒ γi+1, and γk is either a finite state or a stuck configuration. A finite derivation sequence means a computation that has terminated. ♦ An infinite derivation sequence of configurations starting at <S, σ> is γ0, γ1, γ2… γk such that: γ0 = <S, σ> (initial state), γi ⇒ γi+1. An infinite derivation sequence means a computation that does not terminate. i ♦ We write γ0 ⇒ γi to indicate that there are i steps in the execution from γ0 to γi. * ♦ We write γ0 ⇒ γi to indicate that there is a finite number of steps in the execution from γ0 to γi. * note that γ0 ⇒i γi and write γ0 ⇒* γi need not be derivation sequences. They will be so iff γi is either a finite state or a stuck configuration. ♦ For each step there is a derivation tree. Example 1: Consider the statement: (z:=x; x:=y); y:=z and let σ0 be a state that maps: σ0(x) = 5, σ0(y) = 7. (Assume that all other variables are mapped to 0). We then have the derivation sequence: <(z:=x; x:=y); y:=z, σ0> ⇒ <x:=y; y:=z, σ0[5/z]> ⇒ <y:=z, (σ0[5/z])[7/x]> ⇒ ((σ0[5/z])[7/x])[5/y] Corresponding to each of these steps we have derivation trees explaining why they take place. For the first step: <(z:=x; x:=y); y:=z, σ0> ⇒ <x:=y; y:=z, σ0[5/z]> the derivation tree is: <z:=x, σ0> ⇒ σ0[5/z] _ <z:=x; x:=y, σ0> ⇒ <x:=y, σ0[5/z]> _ <(z:=x; x:=y); y:=z, σ0> ⇒ <x:=y; y:=z, σ0[5/z]> Example 2: Consider the statement: “y:=1; while ¬(x=1) do y:=y*x; x:=x-1” and let σ be a state that maps: σ(x) = 3. The first step of execution from the configuration <y:=1; while ¬(x=1) do y:=y*x; x:=x-1, σ> will give the configuration <while ¬(x=1) do y:=y*x; x:=x-1, σ[1/y]>. The next step of the execution will rewrite the loop as a conditional so we get: <if ¬(x=1) then ((y:=y*x; x:=x-1); while ¬(x=1) do (y:=y*x; x:=x-1)) else skip, σ[1/y]> The following step will perform the test and yield the configuration <(y:=y*x; x:=x-1); while ¬(x=1) do (y:=y*x; x:=x-1)), σ[1/y]> Next we obtain: <x:=x-1; while ¬(x=1) do (y:=y*x; x:=x-1)), σ[3/y]> The next configuration will be: <while ¬(x=1) do (y:=y*x; x:=x-1)), σ[3/y][2/x]>. Continuing in this way we eventually reach the final state σ[6/y][1/x]. Program Termination Using the concept of derivation sequences we define program termination. We say that the execution of a command "com" on a statement σ : • terminates iff there exists a finite derivation sequence starting with <com, σ> • loops iff there is an infinite derivation sequence starting with <com, σ> There are 2 ways in which a command can terminate: • successfully, if <com, σ> ⇒* σ' for some state σ'. • terminate in a stuck state. Finally, we say that a command "com": • always terminates if it terminates for all states. • always loops if it loops for all states Example: "while true do skip" always loops. Note: in Natural semantics a command always terminates. (Non- terminating computations are not explicitly represented). Properties of structural semantics Like in Natural Semantics, we define properties on Structural Semantics. Semantic Equivalence Two commands "com1" and "com2" are semantically equivalent if: • for all states σ and σ' - <com1, σ> ⇒* σ' iff <com2, σ> ⇒* σ' • there is an infinite derivation sequence starting at <com1, σ> iff there is an infinite derivation sequence starting at <com2, σ> By this definition we ensure that com1 and com2 act identically on all finite and infinite computations. Example We show that com;Skip and com are semantically equivalent: Let σ be some state. There are 2 cases to be taken care of: 1. <S, σ> ⇒* γ where γ is a configuration that is either stuck or terminal. 2. There is an infinite derivation sequence starting from <S, σ> Assume that <S, σ> ⇒* γ (1st case). So: If γ = σ' (meaning that σ' is a terminal state) then there is a finite derivation sequence from <S, σ> that leads to σ': <S, σ> ⇒* σ’. So the same derivation sequence will lead <S; skip, σ> to <skip, σ'> (according to the deterministic property which states that there is exactly one derivation sequence starting at configuration <S, σ>, and also according to the “concatenation” rule). Next, according the “skip” rule we get <skip, σ'> ⇒ σ'. And over all we get: <S; skip, σ> ⇒* <skip, σ'> ⇒ σ'. If γ is a "stuck" configuration then <S; skip, σ> will also lead to a "stuck" configuration because the execution of S in state σ will lead us to it. Now assume that There is an infinite derivation sequence starting from <S, σ> (2nd case). So there is also an infinite derivation sequence from <S; skip, σ>. This is because the execution of S will occur first and lead us to the same infinite derivation sequence. (Again, this is according to the deterministic property). The other direction: Staring from <S; skip, σ> is analogue to what we've shown. This is because skip is a "neutral" command, meaning it does not change the state. So any result we get from <S; skip, σ> is a result only from the execution of S. For example if there is an infinite derivation sequence starting at <S; skip, σ> then we conclude that the same derivation sequence starts at <S, σ>. Because we know that there for any state s, <skip, s> leads to s (terminal!). Determinism We say that a Structural Semantic is deterministic if: <com, σ> ⇒* σ' and <com, σ> ⇒* σ'' implies σ'= σ'' Theorem: SOS(IMP) is deterministic. Proof: by induction on length of derivations sequences. Sequential Composition We say that a Structural Semantic holds the property of Sequentinal composition if for every 2 command "com1" and "com2" and for every sate σ it holds that: If <com1; com2, σ > ⇒k σ’’ then there exists a state σ’ and numbers k1 and k2 such that: • <com1, σ > ⇒k1 σ’ • <com2, σ’> ⇒k2 σ’’ • k = k1 + k 2 Example: <x:=2 ; while x>0 do x:=x-1, σ> ⇒ <while x>0 do x:=x-1, σ[2/x]> ⇒ <if (x>0) then (x:=x-1;while x>0 do x:=x-1) else skip, σ[2/x]> ⇒ <x:=x-1;while x>0 do x:=x-1, σ[2/x]> ⇒ <while x>0 do x:=x-1, σ[1/x]> ⇒ <if (x>0) then (x:=x-1;while x>0 do x:=x-1) else skip, σ[1/x]> ⇒ <x:=x-1;while x>0 do x:=x-1, σ[2/x]> ⇒ <while x>0 do x:=x-1, σ[0/x]> ⇒ <if (x>0) then (x:=x-1;while x>0 do x:=x-1) else skip, σ[0/x]> ⇒ <skip, σ[0/x]> ⇒ σ[0/x]. So we see that <x:=2 ; while x>0 do x:=x-1, σ> ⇒9 σ[0/x]. And there exists a state σ’ = σ[2/x] and numbers k1 = 1, k2 = 8 such that: • <x:=2, σ> ⇒k1=1 σ’ =σ[2/x] • <while x>0 do x:=x-1, σ’> ⇒k2=8 σ[0/x] Theorem: SOS(IMP) has the property of sequential composition. Proof: by induction on length of derivations sequences. The Semantic Function SSOS As in Natural Semantics, we define a semantic function. The meaning of a command com is defined as a partial function from State to State. We define: SSOS: Com → (State y State) SSOS’com÷(σ) = σ’ if <com, σ> ⇒*σ’ and otherwise Ssos ’com÷(σ) is undefined. Theorem: SSOS’IMP÷ = SNS’IMP÷ The proof is done in two stages which are expressed by Lemma 1 and Lemma 2 below: Lemma 1: For every command com of IMP and states σ and σ' we have: <com,σ>→ σ' implies <com,σ> ⇒*σ'. The proof is given by induction on the shape of the derivation tree for <com,σ>→ σ' . Lemma2: For every command com of IMP, states σ and σ' and natural number k we have: <com,σ> ⇒k σ' implies <com,σ>→ σ' . The proof is done by induction on k (By induction on the length of the derivation sequence <com,σ> ⇒k σ'). The proof follows from Lemma 1 and Lemma 2. This result expresses two properties: • If the execution of com from some state terminates in one of the semantics then it also terminates in the other, and the resulting states are equal. • If the execution of com from some states loops in one of the semantics then it will also loop in the other. Extension to IMP In order to illustrate the power and weakness of the 2 approaches to operational semantics (Natural and Structural) we shall consider various extensions to the language IMP. IMP + Abort First we will consider the extension of IMP with the abort command. Abort stops the execution of the program. Meaning, that no command will be executed after an abort command. So a configuration of the form <abort, σ> is stuck. The new syntax of commands is given by: com::= X := a | skip | com1 ; com2 | if b then com1 else com2 | while b do com | abort No new rules are needed in natural and structural operational semantics: In natural semantics we don’t have intermediate configurations. In SOS we will get exactly what we want by not adding any rules. If we reach a point where we have an abort command, then since there are no derivation rules we will enter a stuck configuration and the execution will terminate. Observation 1: From the SOS point of view abort and skip are not semantically equivalent. The reason for this is that the only derivation sequence for skip starting from σ is <skip, σ> ⇒ σ And the only derivation sequence for abort staring from σ is <abort,σ> (empty sequence). Observation 2: From the SOS point of view abort and while true do skip are not semantically equivalent. The reason for this is that <while true do skip, σ> ⇒ <if true then (skip; while true do skip) else skip, σ> ⇒ <skip; while true do skip, σ> ⇒ <while true do skip, σ> ⇒ … is a infinite derivation sequence for while true do skip. And abort has no infinite derivation sequences. Observation 3: From the Natural Semantics point of view abort and while true do skip are semantically equivalent. The reason for this is that in the Natural Semantics we are only concerned with executions that terminate properly. S if we do not have a derivation for <com,σ> → σ' then we cannot tell whether it's because we've entered a stuck configuration or a looping execution. Summary: • In a natural semantics we cannot distinguish between looping and abnormal termination. • In structural semantics looping is reflected by infinite derivation sequences and abnormal termination by finite derivation sequences ending in a stuck state. IMP + No determinism We shall now consider a second extension to IMP which is given by: com::= X := a | skip | com1 ; com2 | if b then com1 else com2 | while b do com | com1 or com2 The idea of or is that in "com1 or com2" we can non-deterministically choose to execute either com1 or com2. Example: the execution of X := 1 or (X :=2 ; X := X+2) could result in a state where x has the value 1, but it could as well result in a state where x has the value 4. We extend the Natural Semantics with the following 2 rules: • <com1, σ> → σ' . <com1 or com2, σ> → σ' • <com2, σ> → σ' . <com1 or com2, σ> → σ' Example: corresponding to the configuration <X := 1 or (X :=2 ; X := X+2), σ> we have derivation trees for: <X := 1 or (X :=2 ; X := X+2), σ> → σ[X x1] as well as <X := 1 or (X :=2 ; X := X+2), σ> → σ[X x4] Note: In the above example, if we replace "X := 1" with "while true do skip" then we will only have one derivation tree: <while true do skip or (X :=2 ; X := X+2), σ> → σ[X x4] this is because we have no derivation for "while true do skip". We extend the Structural Semantics with the following 2 axioms: • <com1 or com2, σ> ⇒ <com1, σ> • <com1 or com2, σ> ⇒ <com2, σ> Example 1: corresponding to the above example, we have 2 derivation sequences: • <X := 1 or (X :=2 ; X := X+2), σ> ⇒* σ[X x1] • <X := 1 or (X :=2 ; X := X+2), σ> ⇒* σ[X x4] Note: In the above example, if we replace "X := 1" with "while true do skip" then we will still have 2 derivation sequences: • <while true do skip or (X :=2 ; X := X+2), σ> ⇒ <while true do skip, σ> ⇒ <while true do skip, σ> ⇒ … • <X := 1 or (X :=2 ; X := X+2), σ> ⇒* σ[X x4] Example 2: the configuration <X := 1 or X := 10; X := X+5 or X := X-5, σ> has 4 different finite derivation sequences: • <X := 1 or X := 10; X := X+5 or X := X-5,σ> ⇒ <X := 1; X := X+5 or X := X-5,σ> ⇒ <X := X+5 or X := X-5,σ[X x1]> ⇒ <X := X+5,σ[X x1]> ⇒ σ[X x6] • <X := 1 or X := 10; X := X+5 or X := X-5,σ> ⇒ <X := 1; X := X+5 or X := X-5,σ> ⇒ <X := X+5 or X := X-5,σ[X x1]> ⇒ <X := X-5,σ[X x1]> ⇒ σ[X x-4] • <X := 1 or X := 10; X := X+5 or X := X-5,σ> ⇒ <X := 10; X := X+5 or X := X-5,σ> ⇒ <X := X+5 or X := X-5,σ[X x10]> ⇒ <X := X+5,σ[X x10]> ⇒ σ[X x15] • <X := 1 or X := 10; X := X+5 or X := X-5,σ> ⇒ <X := 10; X := X+5 or X := X-5,σ> ⇒ <X := X+5 or X := X-5,σ[X x10]> ⇒ <X := X-5,σ[X x10]> ⇒ σ[X x5] Notes: • In SNS non-determinism will suppress looping, if possible. • In SOS non-determinism does not suppress looping. IMP+ Parallelism: Consider an extension with a parallel construct: com::= X := a | skip | com1 ; com2 | if b then com1 else com2 | while b do com| com1 par com2 com1 par com2 means that all the interleaving of com1 or com2 are executed. This means that a statement like X := 1 par (X :=2 ; X := X+2) can give three different results for x: if we first execute x:=1 then we get x=4, if we first execute x:=2;x:= x+2 then we get x=1. finally, we have the possibility of first executing x:=2, then x:=1 and lastly x:=x+2 and then we get x=3. We express this in SOS: • <com1, σ> ⇒ <com1’, σ’> . <com1 par com2, σ> ⇒ <com1’ par com2, σ’> • <com1, σ> ⇒ σ’ . <com1 par com2, σ> ⇒ <com2, σ’> • <com2, σ> ⇒ <com2’, σ’> . <com1 par com2, σ> ⇒ <com1 par com2’, σ’> • <com2, σ> ⇒ σ’ . <com1 par com2, σ> ⇒ <com1, σ’> Example: The configuration <(X := 0; X := X+1) par (X := 3; if X=4 then (while true do skip)),σ> has the following finite derivation sequences: • <(X := 0; X := X+1) par (X := 3; if X=4 then (while true do skip)),σ> ⇒ <(X := 0; X := X+1) par (if X=4 then (while true do skip)),σ[X x3]> ⇒ <(X := X+1) par (if X=4 then (while true do skip)),σ[X x0]> ⇒ <if X=4 then (while true do skip),σ[X x1]> ⇒ σ[X x1] • <(X := 0; X := X+1) par (X := 3; if X=4 then (while true do skip)),σ> ⇒ <(X := 0; X := X+1) par (if X=4 then (while true do skip)),σ[X x3]> ⇒ <(X := X+1) par (if X=4 then (while true do skip)),σ[X x0]> ⇒ <(X := X+1),σ[X x0]> ⇒ σ[X x1]> • <(X := 0; X := X+1) par (X := 3; if X=4 then (while true do skip)),σ> ⇒ <(X := 0; X := X+1) par (if X=4 then (while true do skip)),σ[X x3]> ⇒ <X := 0; X := X+1,σ[X x3]> ⇒ <X := X+1,σ[X x0]> ⇒σ[X x1] • <(X := 0; X := X+1) par (X := 3; if X=4 then (while true do skip)),σ> ⇒ <(X := X+1) par (X := 3; if X=4 then (while true do skip)),σ[X x0]> ⇒ <(X := X+1) par (if X=4 then (while true do skip)),σ[X x3]> ⇒ <X := X+1,σ[X x3]> ⇒σ[X x4] • <(X := 0; X := X+1) par (X := 3; if X=4 then (while true do skip)),σ> ⇒ <(X := X+1) par (X := 3; if X=4 then (while true do skip)),σ[X x0]> ⇒ <(X := 3; if X=4 then (while true do skip),σ[X x1]> ⇒ <if X=4 then (while true do skip),σ[X x3]> ⇒ σ[X x3] And the following infinite derivation sequence: • <(X := 0; X := X+1) par (X := 3; if X=4 then (while true do skip)),σ> ⇒ <(X := X+1) par (X := 3; if X=4 then (while true do skip)),σ[X x0]> ⇒ <(X := X+1) par (if X=4 then (while true do skip)),σ[X x3]> ⇒ <if X=4 then (while true do skip),σ[X x4]> ⇒ <while true do skip,σ[X x4]> ⇒ <if true then (skip; while true do skip) else skip, σ[X x4]> ⇒ <skip; while true do skip, σ[X x4]> ⇒ <while true do skip, σ[X x4]> ⇒ … We might express the extension in natural semantics (NS) in the following way: • <com1, σ> → σ’, <com2, σ’> → σ’’_ <com1 par com2, σ> →σ’’ • <com2, σ> → σ’, <com1, σ’> → σ’’ . <com1 par com2, σ> →σ’’ However, it is easy to see that this will not do because the rules only express that either com1 is executed before com2 or vice versa. This means that we have lost the ability to interleave the execution of two statements. Furthermore, it seems impossible to be able to express this in NS because we consider the execution of a statement as an atomic entity that cannot be split into smaller pieces. Summary: • In the natural semantics immediate constituent is an atomic entity so we cannot express interleaving of computations • In the structural operational semantics we concentrate on small steps so interleaving of computations can be easily expressed. IMP + Local variables: We now extend the language with blocks containing declarations of local variables: com::= X := a | skip | com1 ; com2 | if b then com1 else com2| while b do com| begin Vars com end Vars::= var X := a ; Vars | ε The idea is that the variables declared inside a block begin Vars com end are local to it. We define the set DV(Vars) of variables declared in Vars: DV(ε) = ∅ DV(var x:=a;Vars) = {x}∪DV(Vars) We might express this in Natural Semantics (NS) in the following way: • <Vars, σ> → σ’, <com, σ’> → σ’’_ <begin Vars com end , σ> →σ’’ This is incorrect, because for example, if we have a variable that is redefined in a block then when coming out of the block we need to restore its previous value. The correct rule is: • <Vars, σ> → σ’, <com, σ’> → σ’’ _ <begin Vars com end , σ> →σ’’[σ/DV(Vars)] Where: • <x:=a, σ> → σ’, <Vars, σ’> → σ’’_ <var x:=a;Vars, σ> →σ’’ • <ε, σ> → σ It is somewhat harder to specify the SOS for the extension. One approach is to replace states with a structure that is similar to a runtime stacks used in the implementation of block structured languages. Example: We’ll show how to execute the following statement in Natural Semantics: Begin var x: =1 y: =2; Begin var y: =1 x: = x+y End; y: = y +x +1 End We denote Y: =2; Begin var y: =1 x: = x+y End; y: =y + x +1 by com1. (1) <x:=1, σ> → σ[1/x] , < com1, σ[1/x]> → γ? <begin var x:=1 com1 end, σ>→γ? [σ/DV(Vars)] Where DV(Vars) = {x} here. Our purpose is to find γ?. In order to do that we need to execute com1: Denote Y: =2 by com2, Begin var y: =1 x: = x+y End by com3 and y: = y+ x +1 by com4. Note that com1 = com2; com3; com4. (2) <y:=2, σ[1/x]> → σ[1/x][2/y] , < com3, σ[1/x][2/y]> → γ?1 <com2; com3, σ>→γ?1 (3) <y:=1, σ[1/x][2/y]> → σ[1/x][1/y] , < x: = x+y, σ[1/x][1/y]> →σ[2/x][1/y] <com3, σ>→(σ[2/x][1/y]) [σ[1/x][2/y] / DV(Vars)] Where DV(Vars) = {y} here. So we get that (3) is: <y:=1, σ[1/x][2/y]> → σ[1/x][1/y] , < x: = x+y, σ[1/x][1/y]> →σ[2/x][1/y] <com3, σ>→σ[2/x][2/y] Also now we know that γ?1 = σ[2/x][2/y]. So (2) is now clearer: <y:=2, σ[1/x]> → σ[1/x][2/y] , < com3, σ[1/x][2/y]> → σ[2/x][2/y] <com2; com3, σ>→σ[2/x][2/y] From (2) we get: (4) <com2;com3, σ[1/x]> → σ[2/x][2/y] , <y: = y+ x +1, σ[2/x][2/y]> → σ[2/x][5/y] <com2; com3; com4, σ[1/x]>→ σ[2/x][5/y] So we can see that γ? = σ[2/x][5/y]. So (1) is: <x:=1, σ> → σ[1/x] , < com1, σ[1/x]> → σ[2/x][5/y] <begin var x:=1 com1 end, σ>→(σ[2/x][5/y]) [σ/DV(Vars)] And since DV(Vars) = {x}, assume that x’s value in σ is x0. Then we get: (1) <x:=1, σ> → σ[1/x] , < com1, σ[1/x]> → σ[2/x][5/y] <begin var x:=1 com1 end, σ>→σ[x0/x][5/y] A different construction: This construction was suggested by Tal Lev-Ami. This construction refers to block per variable. com::= X := a | skip | com1 ; com2 | if b then com1 else com2| while b do com| begin var x:=a com end According to this extension, defining a variable “opens” a new block which refers to it. This construction doesn’t need the definition of DV, since we deal with one variable at a time. <Var x: = a, σ> → σ’, <com, σ’> → σ’’ _ <begin Var x:=a com end , σ> →σ’’[σ/x]. Summary • Structural operational semantics allows us to simulate low level computations without getting bugged into too many details • Natural semantics allows to abstract more – Local memory – Non termination

DOCUMENT INFO

Shared By:

Categories:

Tags:
Semantics And Applications � Class Notes from Lecture 2, Program Generation, Walid Taha, Programming languages, International Workshop, computer science, implementation techniques, CALL FOR PAPERS, program committee, Semantic Web

Stats:

views: | 17 |

posted: | 11/1/2008 |

language: | English |

pages: | 15 |

OTHER DOCS BY franklinr

How are you planning on using Docstoc?
BUSINESS
PERSONAL

By registering with docstoc.com you agree to our
privacy policy and
terms of service, and to receive content and offer notifications.

Docstoc is the premier online destination to start and grow small businesses. It hosts the best quality and widest selection of professional documents (over 20 million) and resources including expert videos, articles and productivity tools to make every small business better.

Search or Browse for any specific document or resource you need for your business. Or explore our curated resources for Starting a Business, Growing a Business or for Professional Development.

Feel free to Contact Us with any questions you might have.