<PRE>

CS 6831 04f

Notes on Covers

CLOSED COVERS

It often happens that a given sequential machine has no useful closed partitions or partition pairs. This motivates the idea of generalizing the partition concept to something that may be more widely useful. We will only introduce the idea here, to a point where the value may be appreciated and applied, at least in simple cases.

We generalize the idea of the partition as follows:

Definition 1: a
*cover* is a collection of subsets that
includes every state, and such that no subset of the collection is contained in
another member. (We will call the
subsets *blocks*.). So, for a 7-state machine, (125, 345,
167) is a cover. Note that blocks
may overlap. (1234, 34, 567) is *not* a cover because 34 is included in 1234. (123, 345, 6) is *not* a cover because state-7 is missing.

Note that a partition is a special case of a cover.

The following definitions involving covers are analogous to those we have used for partitions.

Definition 2: For a particular machine, a cover q is *closed*, if, for every input I, if a and b are included in a
block of q, then N(a, I), and N(b, I) (i.e., the next-states of a and b under
input I) are also included in some block of q.

Definition 3: if p and q are two covers, then p>q if every block of q is included in a block of p. So, for example, (123, 345, 67) > (12, 23, 345, 6, 7)

Definition 4: Given two covers p and q, pq, the product, or greatest lower bound (glb), of p and q, is the largest cover that is less than both p and q. For example,

(1234, 2345, 167)(14, 2456, 137) = (13, 14, 17, 245, 6)

Definition 5: Given two covers, p and q, p + q, the sum, or least upper bound (lub), of p and q, is the largest cover that is greater than both p and q.

We can compute the lub by forming the collection of all blocks appearing in either p or q or both and then deleting those that are subsets of any of the others. For example,

(12, 34, 567) + (1, 23, 46, 57) = (12, 23, 34, 46, 567)

Example 1 The flow table below has no non-trivial closed partitions.

X

0 1

--------

1 1,0 2,1

2 3,0 2,0

3 1,0 3,0

---------

But (13, 23) is a closed cover. Suppose we assign y1 to this cover, letting y1=0 for the 13-block and 1 for the 23-block. But how can we do this, since 3 is in both blocks!

What we do is let 3 appear *twice* in the flow table, once with y1=0 and once with
y1=1. Or we can consider instead
that two y-states are assigned to row-3.
This gives us the expanded table below. We choose another cover (in this case a partition) (12, 3)
such that (12, 3)(13, 23) = (1, 2, 3) = 0, (Recall that the partition with only 1-member blocks is
called the 0-partition.).
Assigning a second variable y2, corresponding to (12, 3), gives us the
valid state assignment shown below.

X

0 1

-------- y1 y2

1 1,0 2,1 0 0

2 3,0 2,0 1 0

3 1,0 3,0 1 1

3 1,0 3,0 0 1

----------

The Y-matrix is shown below.

Note the don't cares for Y1 when the NS is 3. This reflects the fact that, in state-3, y1 can be either 0 or 1.

X

0 1

-------- y1 y2

1 00 10 0 0

2 -1 10 1 0

3 00 -1 1 1

3 00 -1 0 1

---------Y1Y2

Now we can generate the logic expressions below for the Y's and Z.

Y1 = X, Y2=X'y1y2' + Xy2, Z = Xy1'y2'

Example 2.

(123, 345) is a CLOSED COVER for the machine below.

Expand row 3 to 2 rows, assigning the values y1 =0 for 123 and 1 for 345. So we are setting y1=0 for the first copy of row-3 and 1 for the second. Thus we can think of y1 as a "don't care" for row-3.

Because of the closure property, we know we can find Y1 as a
function only of X and y1, *independent*
of the other, as yet unchosen y-variables. In fact, it is not hard to see that
Y1=X'y1' (Remember that the 3-entries
are don't cares for Y1).

X X

0 1 0 1 y1

----- -----

1 4 2 1 4 2 0

2 5 3 2 5 3 0

3 3 1 3 3 1 0

4 2 1 3 3 1 1

5 1 3 4 2 1 1

----- 5 1 3 1

-----

We could decompose the machine on the basis of the closed cover (123, 345), in which case the flow table for the corresponding sub-machine would be:

X

0 1

-----

(123) 1 2 1

(345) 2 1 1

-----

Finally, altho we will not explore this path, we could generalize the notion of partition pairs to "cover pairs" along the lines of the above discussion.

ŠŠŠŠ.

</PRE>