IMP: a simple imperative language

We shall now consider a more realistic programming language, one where
we can assign values to variables and execute control constructs such
as "if" and "while". The syntax for this simple imperative language,
called IMP, is as follows:

expressions            e in Expr = Aexp union Bexp
arithmetic expressions a in Aexp a ::= x | n | a1 + a2
boolean expressions    b in Bexp b ::= true | false | a1 < a2

commands	       c in Com  c ::= skip | x := a | c1 ; c2
				     | if b then c1 else c2
				     | while b do c

We'll first give a small-step operational model for IMP.  The
configurations in this language are of the form <c,s>, <b,s>, and
<a,s>, where s is a store. And the final configurations are <skip,s>,
<true,s>, <false, s>, and <n,s>.  We need to define the one-step
evaluation relations for commands and expressions: <c,s> -> <c',s'>,
<b,s> -> <b',s'>, <a,s> -> <a',s'>.

The evaluation rules for arithmetic and boolean expressions are
similar to the ones we've seen before. For commands, the rules are:

     <e,s> -> <e',s>          
  ---------------------    ---------------------
  <x:=e,s> -> <x:=e',s>    <x:=n,s> -> s[x -> n]


     <c1,s> -> <c1',s'>
  -----------------------  -------------------
  <c1;c2,s> -> <c1';c2,s>  <skip;c,s> -> <c,s>


For if commands, we gradually reduce the test until we get either true
or false; then, we execute the appropriate branch:

                      <b,s> -> <b',s>
  -------------------------------------------------------
  <if b then c1 else c2, s> -> <if b' then c1 else c2, s>

  --------------------------------------
  <if true then c1 else c2, s> -> <c1,s>

  --------------------------------------
  <if false then c1 else c2, s> -> <c2,s>


For while loops, the above strategy doesn't work (why?). Instead, we
can use the following rule:

  -----------------------------------------------------------------
  <while b do c, s> -> <if (b) then (c; while b do c) else skip, s>


We can now take a concrete program and see how it executes under the
above rules. Consider we start with state s = {x=0} and we execute the
program:
   
   x := 3; while (x < 4) do x := x + 5

The execution works as follows:

<x := 3; while (x < 4) do x := x + 5, s> ->
-> <skip; while (x < 4) do x := x + 5, s'>     (where s'=s[x->3])
-> <while (x < 4) do x := x + 5, s'> 
-> <if (x < 4) then (x := x + 5; W) else skip, s'>
-> <if (3 < 4) then (x := x + 5; W) else skip, s'>
-> <if true then (x := x + 5; W) else skip, s'>
-> <x := x + 5; while (x < 4) do x := x + 5, s'>
-> <x := 3 + 5; while (x < 4) do x := x + 5, s'>
-> <x := 8; while (x < 4) do x := x + 5, s'>
-> <while (x < 4) do x := x + 5, s''> (where s'' = s'[x->8])
-> <if (x < 4) then (x := x + 5; W) else skip, s''>
-> <if (8 < 4) then (x := x + 5; W) else skip, s''>
-> <if false then (x := x + 5; W) else skip, s''>
-> <skip, s''>

(where W is an abbreviation for the while loop "while (x < 4) do x :=
x + 5").