Two Level Minimization

Review of logic minimization
Definitions
Heuristic two-level minimization
Espresso algorithm
Homework
Espresso phases
Advanced Digital Logic Design – EECS 303 Tautology checking
There be Dragons here

http://ziyang.eecs.northwestern.edu/eecs303/
Teacher: Robert Dick

Office: L477 Tech Today’s material might at first appear difficult
Email: dickrp@northwestern.edu
Phone: 847–467–2298 Perhaps even a bit dry
. . . but follow closely
Trust me, if you really get it, there is great depth and beauty here
3 Robert Dick Advanced Digital Logic Design
Review of logic minimization Review of logic minimization

Definitions Definitions
Heuristic two-level minimization Heuristic two-level minimization
Espresso algorithm Espresso algorithm
Homework Homework
Espresso phases Espresso phases
Tautology checking Tautology checking
Two-level logic minimization Optimal two-level logic synthesis is N P-complete
Goal: two-level logic realizations with fewest gates and fewest number Upper bound on number of prime implicants grows 3n/n where n is the
of gate inputs number of inputs
Algebraic Given > 16 inputs, can be intractable
Karnaugh map However, there have been advances in complete solvers for many
Quine–McCluskey functions
Optimal solutions are possible for some large functions
Espresso heuristic
5 Robert Dick Advanced Digital Logic Design 6 Robert Dick Advanced Digital Logic Design

Homework Homework
Logic minimization methods Espresso two-level logic minimization heuristic
For difficult and large functions, solve by heuristic search Generate only a subset of prime implicants
Multi-level logic minimization is also best solved by search Carefully select prime implicants in this subset covering on-set
The general search problem can be introduced via two-level Guaranteed to be correct
minimization May not be minimal
Examine simplified version of the algorithms in Espresso
Usually high-quality in practice

Homework Homework
Espresso Boolean space
Start with a potentially optimal algorithm 0 b 1

Add numerous techniques for constraining the search space
1 If g and h are two Boolean
Use efficient move order to allow pruning
functions s.t. the on-set of g is a
Disable backtracking to arrive at a heuristic solver
a subset of the on-set of h then
h covers g or. . .
Widely used in industry 0 ...g ⊆ h
Still has room for improvement 1
E.g., early recursion termination c
0
Homework Homework
Redundancy in Boolean space Espresso moves
f (a, b , c ) ab
00 01 11 10
0 1 0 1
If a formula contains AB and B , AB ⊆ B ⇒ AB is redundant c
Sometimes redundancy is difficult to observe 1 1 1 1 1
If f = BC + AB + AC , then AB is redundant
Add a literal to a cube (reduce)

Remove a literal from a cube (expansion)
Remove redundant cubes (irredundant cover)

Homework Homework
Espresso moves Irredundant functions need not be minimal
f (a, b , c ) ab f (a, b , c ) ab
00 01 11 10 00 01 11 10
0 1 0 1 0 0 0 0 1
c c
1 1 1 1 1 1 1 1 0 1
B C + A C + AB C
Reduce: AB C + A C + AB C
Sometimes necessary to increase cost to escape local minima
Expand: AB + A C + AB C
Add a literal to a cube (reduction)
Irredundant cover: AB + A C
To later allow expansion in another dimension

Homework Homework
Repeat the following

1 Reduce sometimes necessary to contain cubes within others
Another cover with fewer terms or fewer literals might exist Repeat sequence Reduce, Expand, Irredundant Cover to find
Shrink prime implicants to allow expansion in another variable alternative prime implicants
2 An Irredundant Cover is extracted from the expanded
primes Keep doing this as long as new covers improve on last solution
Similar goals to the Quine-McCluskey prime implicant chart A number of optimizations are tried, e.g., identify and remove
Good performance requires a few tricks
essential primes early in the process
3 Expand implicants to their maximum size
Implicants covered by an expanded implicant are removed from
further consideration
Quality of result depends on order of implicant expansion
Heuristic methods used to determine order

Homework Homework
Espresso pseudocode Espresso example

Procedure Espresso(F, D, R)
1: /* F is ON set, D is don’t care, R OFF */
f (a, b , c , d ) ab
2: R = Compliment(F+D); /* Compute complement */
00 01 11 10
3: F = Expand(F, R); /* Initial expansion */
4: F = Irredundant(F,D); /* Initial irredundant cover */ 00 1 1 0 0
5: E = Essential(F,D) /* Detecting essential primes */
6: F = F - E; /* Remove essential primes from F */ 01 1 1 1 1
7: D = D + E; /* Add essential primes to D */ cd
8: while Cost(F) keeps decreasing do
9: F = Reduce(F,D); /* Perform reduction, heuristic which cubes */
11 0 0 1 1
10: F = Expand(F,R); /* Perform expansion, heuristic which cubes */
11: F = Irredundant(F,D); /* Perform irredundant cover */ 10 1 1 1 1
12: end while
13: F = F + E;
14: return F; Irredundant but not minimal Reduce Expand Irredundant
19 Robert Dick Advanced Digital Logic Design 20
Cover
Robert Dick Advanced Digital Logic Design
Homework Homework
Espresso input Espresso output

P
f (A, B, C , D) = (4, 5, 6, 8, 9, 10, 13) + d(0, 7, 15)
P
Input Meaning f (A, B, C , D) = (4, 5, 6, 8, 9, 10, 13) + d(0, 7, 15)
.i 4 # inputs
.o 1 # outputs Output Meaning
.ilb a b c d input names .i 4 # inputs
.ob f output name .o 1 # outputs
.p 10 number of product terms .ilb a b c d input names
0100 1 AB C D = 1 .ob f output name
0101 1 AB C D = 1 .p 3 number of product terms
0110 1 AB C D = 1 1-01 1 ACD=1
1000 1 A BCD =1 10-0 1 A BD =1
1001 1 A BCD =1 01– 1 AB = 1
1010 1 A B CD = 1 .e end
1101 1 AB CD=1
0000 - AB C D = X g (A, B, C , D) = AC D + AB D + A B
0111 - AB C D = X
1111 - AB C D=X
.e end

Homework Homework
Two-level heuristic minimization summary Irredundant cover
After expansion, it’s necessary to remove redundant cubes to

Generating all prime implicants can be too expensive reach a local minimum
Make incremental changes: Expand, Reduce, and First, find the relatively essential cubes
Irredundant Cover to improve cover
For each other cube, check to see whether it is covered by
Determining whether incremental change represents same
relatively essential cubes or don’t-cares
function is difficult
Need to use clever algorithms to speed it up If so, it’s totally redundant
If not, it’s partially redundant

Homework Homework
Irredundant cover Irredundant cover
After expansion, it’s necessary to remove redundant cubes to

Relatively essential cubes must be kept reach a local minimum
Totally redundant cubes can clearly be eliminated First, find the relatively essential cubes
A subset of the partially redundant cubes need to be kept For each other cube, check to see whether it is covered by
Formulate as a unate covering problem relatively essential cubes or don’t-cares
We’ll come back to this in a moment If so, it’s totally redundant
If not, it’s partially redundant

Homework Homework
Tautology check for relatively essential cubes Terminology example
c is a 1-cube a b c f
Check to see whether the union of 1-cubes and don’t-care cubes 0 X X 1
minus c, cofactored by c, is a tautology X 0 X 1
X X 1 1
Let A be the set of 1-cubes
1 X 1 1
Let D be the set of don’t-care cubes 1 0 0 X
((A ∪ D) − c)c 6= 1 ⇔ c is relatively essential
That’s it: You can use tautology checking to determine whether Find the relatively essential cubes
a cube is relatively essential Find totally redundant cubes
Of course, an example would make it clearer Find partially redundant cubes
Homework Homework
Detecting relatively essential cubes Recursive pivoting?
Could also recursively pivot on variables if inclusion fails

How to determine whether a cube is fully covered by other 1 and 0XX|1
don’t-care cubes? ↓
00X|1, 01X|1
Could decompose everything to minterm canonical form
↓
Recall that there may be 2n minterms, given n variables 000|1, 001|1, 010|1, 011|1
Decomposition is a bad idea Lets us terminate recursion as soon as cube is covered by single
Exponential other cube, e.g., 01X|X
However, even with pruning, this is still slow in practice
Worst-case time complexity?

Homework Homework
Definition: Cofactor by variable Definition: Cofactor by cube, usage
Given that c is a cube, and literals l1 , l2 , . . . ln ∈ c, cofactoring the

function by the cube is equivalent to sequentially cofactoring by all
cube literals, i.e.,
fx1 = f(1, x2 , . . . , xn )
fc = fl1 ,l2 ,...ln
fx1 = f(0, x2 , . . . , xn )
c ⊆ f ⇐⇒ fc = 1
Note that it’s commutative,
A tautology is a function that is always true
(fx1 )x2 = (fx2 )x1 A cube is less than or equal to a function, i.e., is fully covered by the
function, if and only if the function cofactored by the cube is a
tautology

Homework Homework
Problem conversion Conversion benefits
Thus, we have taken the problem

Cofactoring eliminates variables, speeding analysis
Determine whether a cube, c, is covered by a set of 1-cubes, A, or
don’t-care, D, cubes. Tautology is a straight-forward and well-understood problem
However, tautology checking is not easy
and converted it to Could pivot on all variables. . .
. . . but this is too slow
Determine whether a set of 1-cubes, A, and don’t-care cubes, D, Example?
cofactored by cube c is a tautology.

Homework Homework
Unate functions Unate functions
f(x1 , x2 , . . . , xn ) is monotonically increasing in x1 if and only if

0 b 1
∀x2 , . . . , xn : f(0, x2 , . . . , xn ) ≤ f(1, x2 , . . . , xn )
1
f(x1 , x2 , . . . , xn ) is monotonically decreasing in x1 if and only if
∀x2 , . . . , xn : f(0, x2 , . . . , xn ) ≥ f(1, x2 , . . . , xn ) a
A function that is neither monotonically increasing or
monotonically decreasing in x1 is non-monotonic in x1 0
A function that is monotonically increasing or monotonically
decreasing in x1 is unate in x1 0
c
A function that is unate in all its variables is unate 1
Unate
Homework Homework
Unate covers Identifying unate covers is easy
a b c f
0 0 X 1
Unate functions are difficult to identify X 1 1 1
A cover is unate as long as the complemented and X 1 0 1
uncomplimented literals for the same variable do not both appear 0 1 1 X
Identifying unate covers is easy
Scan the columns for the presence of a 0 and 1
Note, some unate functions can have non-unate covers
Unate covers always express a unate function

Homework Homework
Unate cover tautology checking Fast tautology checking using unate covers
Given that C is a cover containing cubes composed of variables

A unate cover is a tautology if and only if it contains a 1, i.e., x1 , x2 , . . . , xn
XXX|1
Tautology(C )
Think of it this way: There is some point or cube in the input
if C is unate then
space of the function at which all cubes intersect
if C contains a 1-row then
Thus, the only way to have a tautology is for one of the cubes to Return true
be a tautology end if
Thus, it’s trivial to check unate covers for tautology else
Search for a tautology cube Return Tautology(Cx1 ) ∧ Tautology(Cx1 )
end if

Homework Homework
Fast tautology checking using unate covers Example of unate cofactoring
What if the cover isn’t unate? a c + bc + a b c

Can still accelerate Cover unate only in a
If cover C is unate in a variable, x1 , then factor out x1 ¡ ¢
a c + bc + a b c a = bc
C = x1 · F1 (x2 , . . . , xn ) + F2 (x2 , . . . , xn ) ¡ ¢
a c + bc + a b c a = c + bc + b c
or
C = x1 · F1 (x2 , . . . , xn ) + F2 (x2 , . . . , xn )
Notice anything nice about this?

Homework Homework
Fast tautology checking using unate covers Example of unate cofactoring
Assume
a c + bc + a b c
C = x1 · F1 (x2 , . . . , xn ) + F2 (x2 , . . . , xn )
Cover unate only in a
Then the Cx1 cofactor is ¡ ¢
F1 (x2 , . . . , xn ) + F2 (x2 , . . . , xn ) a c + bc + a b c a = bc
¡ ¢
and the Cx1 cofactor is a c + bc + a b c a = c + bc + b c
F2 (x2 , . . . , xn ) F1 = c + b c
F2 = bc
Homework Homework
Fast tautology checking using unate covers Tautology checking final version
Given that C is a cover containing cubes composed of variables

x1 , x2 , . . . , xn
Cx1 = F1 (x2 , . . . , xn ) + F2 (x2 , . . . , xn )
Cx1 = F2 (x2 , . . . , xn ) Tautology(C )
if C is unate then
Clearly, if C contains a 1-row then
Cx1 ⊆ Cx1 Return true
end if
Therefore we need only consider Cx1 for tautology checking, else
significantly simplifying the problem, i.e., if Cx1 is a tautology, then Return Tautology(Cx1 )
Cx1 is obviously also a tautology. end if

Homework Homework
Summary: Fast tautology checking More complicated example
a b c f
Identify unate covers
0 X 0 1
No columns with 1s and zeros
1 0 X 1
If unate, scan for an XXX |1 row X 1 1 1
If not unate, cofactor on (preferable) unate variable 1 X 1 1
Only need to consider uncomplemented or uncomplemented X 0 0 1
cofactor 1 0 0 X
Why? F2 ≤ F1 + F2 Relatively essential check for 0X 0|1?
Full check on c.

Homework Homework
Two-level heuristic minimization summary Espresso summary
Reduce: Allows expansion in another direction, get out of local

Generating all prime implicants can be too expensive minima
Make incremental changes: Expand, Reduce, and Expand: Decreases complexity, in practice blocking matrix used for
Irredundant Cover expansion. Search with would also work but would be slower in most
Determining whether incremental change represents same cases.
function is too expensive Irredundant cover: Remove redundant cubes
Use cofactoring to convert it to a tautology check Tautology check used in many places, gave example of use in
Use unateness to make the tautology check fast in most cases Irredundant cover use
We have only scratched the surface!

Homework Homework
CAD Questions
What is the unate covering problem?

Computer–Aided Design (of Integrated Circuits and Systems)
Where have we seen it used?
Also called Electronics Design Automation (EDA)
What can tautology checking be used for?
Without it, computers wouldn’t work
How do we make it fast?
Review of logic minimization
Definitions
Espresso algorithm
Homework Homework
Espresso phases
Tautology checking
Next lecture: Implementation technologies Reading assignment
M. Morris Mano and Charles R. Kime. Logic and Computer

Design Fundamentals. Prentice-Hall, NJ, fourth edition, 2008
PALs, PLAs
Chapter 4
MUX, DEMUX review
M. Morris Mano and Charles R. Kime. Web supplements to Logic
Steering logic and Computer Design Fundamentals. Prentice-Hall, NJ.
http://www.writphotec.com/mano4/Supplements
VLSI Programmable Logic Devices, document 1

Two Level Minimization

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Two Level Minimization

Uploaded by

Copyright:

Available Formats

Review of logic minimization

Advanced Digital Logic Design – EECS 303 Tautology checking

There be Dragons here

Teacher: Robert Dick

3 Robert Dick Advanced Digital Logic Design

Review of logic minimization Review of logic minimization

Two-level logic minimization Optimal two-level logic synthesis is N P-complete

Review of logic minimization Review of logic minimization

Logic minimization methods Espresso two-level logic minimization heuristic

Review of logic minimization Review of logic minimization

Espresso Boolean space

Start with a potentially optimal algorithm 0 b 1

Redundancy in Boolean space Espresso moves

Add a literal to a cube (reduce)

Review of logic minimization Review of logic minimization

Espresso moves Irredundant functions need not be minimal

Review of logic minimization Review of logic minimization

Espresso algorithm Espresso algorithm

Repeat the following

Review of logic minimization Review of logic minimization

Espresso pseudocode Espresso example

Espresso input Espresso output

Review of logic minimization Review of logic minimization

Two-level heuristic minimization summary Irredundant cover

After expansion, it’s necessary to remove redundant cubes to

Review of logic minimization Review of logic minimization

Irredundant cover Irredundant cover

After expansion, it’s necessary to remove redundant cubes to

Review of logic minimization Review of logic minimization

Tautology check for relatively essential cubes Terminology example

Detecting relatively essential cubes Recursive pivoting?

Could also recursively pivot on variables if inclusion fails

Review of logic minimization Review of logic minimization

Definition: Cofactor by variable Definition: Cofactor by cube, usage

Given that c is a cube, and literals l1 , l2 , . . . ln ∈ c, cofactoring the

Review of logic minimization Review of logic minimization

Problem conversion Conversion benefits

Thus, we have taken the problem

Review of logic minimization Review of logic minimization

Unate functions Unate functions

f(x1 , x2 , . . . , xn ) is monotonically increasing in x1 if and only if

Unate covers Identifying unate covers is easy

Review of logic minimization Review of logic minimization

Given that C is a cover containing cubes composed of variables

Review of logic minimization Review of logic minimization

Fast tautology checking using unate covers Example of unate cofactoring

What if the cover isn’t unate? a c + bc + a b c

Review of logic minimization Review of logic minimization

Fast tautology checking using unate covers Example of unate cofactoring

Given that C is a cover containing cubes composed of variables

Review of logic minimization Review of logic minimization

Summary: Fast tautology checking More complicated example

Review of logic minimization Review of logic minimization

Two-level heuristic minimization summary Espresso summary

Reduce: Allows expansion in another direction, get out of local

Review of logic minimization Review of logic minimization

What is the unate covering problem?

Next lecture: Implementation technologies Reading assignment

M. Morris Mano and Charles R. Kime. Logic and Computer

You might also like