CMSC 631, Fall 2006
Homework 2
Due Wednesday, Sept. 27, in class
1. For the language of commands that we saw in class (Figure 2), show derivations that establish the
following as legal evaluations:
(a) ((1 ∗2) + (3 ∗x), s)→∗(8, s) and likewise ((1 ∗2) + (3 ∗x), s)⇓(8, s) where s(x) = 2.
(b) (x:= 1; while xdo (x:= x+ (−1)), s)→∗s0where s0=s[x7→ 0] and likewise for ⇓.
(Recall that →is the small-step relation, ⇓is the big-step relation. Also, the syntax s[x7→ i] defines
a new map s0such that s0(x) = iand s0(y) = s(y) for all y6=x.)
2. For the language of arithmetic expressions that we discussed in class (Figure 1), prove that for all eand
swhere dom(s)⊇vars (e), either eis an integer ior else there exists an e0such that (e,s)→(e0, s).
We define vars(e) as follows:
vars(x) = {x}
vars(i) = ∅
vars(e1+e2) = vars (e1)∪vars(e2)
vars(e1∗e2) = vars(e1)∪vars (e2)
You should prove this by induction on the height of the derivation (e, s)→(e0, s).
3. Suppose we modify the language of commands and expressions in two ways. First, we add a new
class of boolean expressions and modify the conditional operators if and while to use boolean guards.
Second, we add lists of integers as a legal data structure in our language, along with a pattern matching
operation for accessing the elements of a list. The new language is shown in Figure 3. Define small
and big-step semantics for this new language. Here are a few more details about the language:
Boolean expressions These are largely straightforward; you should follow the same ideas as arith-
metic expressions in defining their semantics. (Note that ∨is boolean “or”, ∧is boolean “and”, and
! is boolean “not”.) You should assume that two expressions are equal if they are syntactically the
same. That is, v1=v2if v1has exactly the same syntactic structure as v2. Note that you only define
equality in terms of values, which are either integers ior integer lists l. In all cases, expressions will
evaluate to values.
Lists A list lis a series of comma-separated integers, concluded by a nil. For example, (1,nil ) is a
list, and (1,(2,(3,nil))) is a list. We’ve extended expressions ewith the empty list nil, and the form
e1, e2which will evaluate to a list assuming that e1evaluates to an integer and e2evaluates to a list.
To access the elements of a list, we use the case expression to do pattern matching. In the command
case eof nil ⇒c1or (x:: y)⇒c2, if eevaluates to nil, then the whole command reduces to c1. If e
evaluates to some list (i, l), then the whole thing evaluates to c2, and in the current store is modified
to map xto iand yto l.
