Model Solutions for HW4

1. 

{Q: m < n ^ b[m:n-1]=B[m:n-1]}
p := m, q:= n
{P: (A i: m <= i < p: b[i] <=x) ^ (A i: q <= i < n: b[i]>x) ^ m<=p<=q<=n ^
perm(b,B)}
{bound t: q-p}
do p<q ^ b[p]<=x -> p:=p+1
   p<q ^ b[q-1]>x -> q:=q-1
   p<q ^ b[p]>x ^ b[q-1]<=x -> p,q,b[p],b[q-1]:=p+1,q-1,b[q-1],b[p]
od

{R: m<=p<=n ^ (A i: m<=i<p: b[i]<=x) ^ (A i: p<=i<n: b[i]>x) ^ perm(b,B)}

2.

{Q: (A i: 0<=i<n: red(b[i]) v white(b[i]) v blue(b[i])) ^ n>=0 ^
b[0:n-1]=B[0:n-1]}
p,q:=0,n
{P1: 0<=p<=q<=n ^ (A i: 0<=i<p: red(b[i])) ^ (A i: q<=i<n: ~red(b[i])) ^
perm(b,B)}
{bound t: q-p}
do p<q ^ red(b[p]) -> p:=p+1
   p<q ^ ~red(b[q-1]) -> q:=q-1
   p<q ^ ~red(b[p]) ^ red(b[q-1]) -> swap(b[p],b[q-1]); p,q:=p+1,q-1
od
{R1: (A i: 0<=i<p: red(b[i])) ^ (A i: p<=i<n: ~red(b[i])) ^ perm(b,B) ^ n>=0}
q,r:=p,n
{P2: 0<=p<=q<=r<=n ^ (A i: 0<=i<p:red(b[i])) ^ (A i: p<=i<n: ~red(b[i])) ^ (A i:
p<=i<q: white(b[i])) ^ (A i: r <=i<n: blue(b[i])) ^ perm(b,B)}
{bound t: r-q}
do q<r ^ white(b[q]) -> q:=q+1
   q<r ^ blue(b[r-1]) -> r:=r-1
   q<r ^ blue(b[q]) ^ white(b[r-1]) -> swap(b[q],b[r-1]); q,r:=q+1,r-1
od
{R: (A i: 0<=i<p: red(b[i])) ^ (A i: p<=i<q: white(b[i])) ^ (A i: q<=i<n:
blue(b[i])) ^ perm(b,B) }

3.

16.5.9 or 16.5.10: These are basically the same problem.  16.5.10 might be
considered slightly tougher by some because it is a generalization of 16.5.9 so
I provide the solution for 16.5.10.  

{Q: x=X ^ X>0 ^ B>1}
k:=0
{P: X>0 ^ B>1 ^ x>=0 ^ X=B^k * x + (Sumover i:0<=i<k: B^i * v[i]) ^ (A i:
0<=i<k: 0<=v[i]<B)}
{bound t: x}
do x != 0 -> x,k,v[k]:=quotient(x,B),k+1,remainder(x,B) od
{R: X = (Sumover i: 0<=i<k: B^i * v[i]) ^ (A i: 0<=i<k: 0<=v[i]<B)}

4. 

Defs. #p will be the number of nodes in tree p
      leaves(p) is given as 0, if p is empty; 1, if p is a leaf; leaves(left(p)) +
      leaves(right(p)), ow.  
      notleaf(p) = #p - leaves(p)
      
Solution: 

{Q: p a tree, S a stack}
leaves, notleaves, S := 0, 0, {p} 
{P: leaves(p) = leaves + (SumOver t in S: leaves(t)) ^ notleaf(p) = notleaves + (SumOver
t in S: notleaf(t))}
{bound t: 2 * (leaves(p)-leaves) + 2 * (notleaf(p)-notleaves) + size(S) }   
do ~empty(S) -> x := top(S); pop(S);
                if empty(x) -> skip
		   ~empty(x) ^ empty(left(x)) ^ empty(right(x)) -> leaves:=leaves+1
		   ~empty(x) ^ (~empty(left(x)) v ~empty(right(x))) ->
		   notleaves:=notleaves + 1; push(left(x)); push(right(x))
		fi
od
{R: leaves(p) = leaves}

If you don't see why the conditions are met, you can come and ask during office hours.

5. 

Defs. #pnodes(p) = the number of pass-thru nodes of tree p
      #fnodes(p) = the number of full internal nodes of tree p
      #leaves(p) = the number of leaves of tree p
      
Solution:      

f,n,l,s := 0,0,0,{p};
{inv P: #leaves(p) = l + (SumOver r in s: #leaves(r)) ^
        #fnodes(p) = f + (SumOver r in s: #fnodes(r)) ^
	#pnodes(p) = n + (SumOver r in s: #pnodes(r)) }
{bound t: 2 * (#leaves(p) - l + #fnodes(p) - f + #pnodes(p) - n) + |s| }
do s != {} -> choose(q,s); s:=s-{q};
              if empty(q) -> skip
	         leaf(q)  -> l:=l+1
		 ~empty(left(q)) ^ ~empty(right(q)) -> f,s:=f+1,s U {left(q),right(q)}
		 ~empty(left(q)) ^ empty(right(q)) -> n,s:=n+1,s U {left(q)}
		 empty(left(q)) ^ ~empty(right(q)) -> n,s:=n+1,s U {right(q)}
	      fi
od
{R: f = #fnodes(p) ^ n=#pnodes(p) ^ l=#leaves(p)}