290N: The Unknown Component
Problem
Lecture 23
Reachability Analysis using AIGs
(instead of BDDs?)
Outline

AND-INV graphs (AIGs)




Reachability analysis (implementation using AIGs)




Image computation
Boolean operations
Structural fixed point
Discussion (advantages and disadvantages compared to BDDs)



Non-canonicity
Structural hashing
Applications
Delayed Boolean operations
Need efficient logic synthesis for highly redundant AIGs
Developing a hybrid approach (combining AIGs and BDDs)



Collapsing
Sliding boundary
Other methods?
And/Inverter Graphs (AIGs)
 Example
 Non-canonicity
 Structural
hashing
 Typical applications
Example
cd
ab
00
01
11
10
cd
ab
00
01
11
10
00
01
11
10
0
0
0
0
0
0
1
0
1
1
1
1
0
1
0
0
00
01
11
10
0
0
0
0
0
0
1
0
1
1
1
1
0
1
0
0
F(a,b,c,d) = ab + d(ac’+bc)
a
d
b
a
c’ b
c
F(a,b,c,d) = ac’(b’d’)’ + c(a’d’)’
= ac’(b+d) + bc(a+d)
a
c’
b
d
b
c a
d
Structural Hashing

No structural hashing


One-level structural hashing


Always add a new AND-node
When a new AND-node is to be added, check a
hash table for an existence of a node with the same
pair of inputs; if it exists, return it; otherwise, create
a new node
Two-level structural hashing

When a new AND-node is to be added, consider its
predecessors, and hash the three AND-gates into a
canonical form (two-level canonicity)
Applications of AIGs
 A data
structure for circuit-based SAT
 A data structure for EC and BMC
 A alternative representation of functionality
of a node in the Boolean network
 A uniform representation for both


algebraic factored forms, and
the result of Boolean decomposition
Reachability Analysis using AIGs
 Computation
using AIGs
 Reachability pseudo-code
 Using AIGs for reachability
 Example
 Structural fixed point
 Consequences
Using AIGs for Computation

Boolean operations


Cofactoring


Propagate a constant
Quantification


Express an operation in terms of ANDs and INVs
Propagate two constants and OR the results
Variable replacement

Reconstruct a graph in terms of different variables
Reachable State Computation
Relation(cs,ns) = i k [ nsk  NSk( i, cs ) ];
Reached(cs) = 0;
Front(cs) = InitState(cs);
do
{
Reached = Reached + Front;
Next(cs) = cs [ Relation(cs,ns) & Front(cs) ] ns  cs;
Front = Next & Reached;
}
while ( Front  0 );
Using AIGs for Reachability

General idea


Consequences



Take any BDD-based computation and perform it
using AIGs, instead of BDDs
Prevents unexpected “BDD blow-ups”
Instead, creates AIGs monotonically growing from
one iteration to another
Requires efficient reduction procedures

A good test for logic synthesis algorithms and tools
Example: s27, initial state
Example: s27, transition relation
Example: s27, quantified relation
Example: s27, reached 1
Example: s27, reached 2
Example: s27, reached 1
Reduction Procedures Tried





Merging functionally-equivalent nodes
(up to complementation)
AIG rewriting using pre-computed table
Applying optimization scripts in SIS/MVSIS
BDD-based collapsing
BDD-based partial collapsing
Reduction Procedures To Try

Key insight


AIGs record delayed BDD computations!
BDD-based partial collapsing
 Using a shifting BDD/AIG boundary
Structural Fixed Point

Definition. The functional fixed point is reached
when in the above computation
Front = Constant-0 Boolean function
 Definition. The structural fixed point is reached
when in the above computation
Front = Constant-0 AIG
 Theorem. Suppose BDD-based reachable state
computation reaches the functional fixed point
after n iterations. Then, a similar AIG-based
computation reaches the structural fixed point
after n or n+1 iterations.
Proof

After n iterations, Next contains only visited
states and Front is Constant 0 Boolean function.
 If Front is also Constant 0 AIG, the structural
fixed point is reached after n iterations.
 If Front is not Constant-0 AIG, then we show
that, after the next image computation, Next
becomes Constant-0 AIG (see Lemma). In this
case, the fixed point is reached after n+1
iterations.
Lemma

Lemma. If Front is Constant-0 Boolean function
but not Constant-0 AIG, the result of image
computation is always Constant-0 AIG.
Proof:
 Each cofactor of Product w.r.t. the cs variables is
Constant 0 AIG.
 Quantification is performed by ORing all of the
cofactors of Product w.r.t. the cs variables.
 ORing any number of Constant 0 AIGs gives
Constant 0 AIG. Q.E.D.
Reachable State Computation
Relation(cs,ns) = i k [ nsk  NSk( i, cs ) ];
Reached(cs) = 0;
Front(cs) = InitState(cs);
do
{
Reached = Reached + Front;
Next(cs) = cs [ Relation(cs,ns) & Front(cs) ] ns  cs;
Front = Next & Reached;
}
while ( Front  0 );
Proof Illustration
cs P(cs,ns)
P(cs,ns) = Relation(cs,ns) & Front(cs)
Quantification

Front
Relation
cs
ns
cs
P
P
P
P
ns 00
ns 01
ns 10
ns 11
Discussion

It would be nice if AIGs could beat BDDs for
reachable state computation
 In practice, this did not happen (so far)
Towards a Hybrid Approach

Perhaps AIGs alone cannot beat BDDs
 A hybrid approach should exploit respective
strengths of these data structures



BDDs: canonicity, non-redundancy
AIGs: no blow-up, structural fixed point
The sliding boundary idea
 AIGs represent delayed BDD computation
Conclusion





Reviewed AIG data structure
Presented AIG-based computation
Proved an existence of structural fixed point in
the AIG-based reachable state computation
Reported on preliminary experimental results
Outlined future research