Reachability Analysis using AIGs: The Unknown Component Problem

1. Reachability Analysis using AIGs (instead of BDDs?) 290N: The Unknown Component Problem Lecture 23

2. Outline • AND-INV graphs (AIGs) • Non-canonicity • Structural hashing • Applications • Reachability analysis (implementation using AIGs) • Image computation • Boolean operations • Structural fixed point • Discussion (advantages and disadvantages compared to BDDs) • Delayed Boolean operations • Need efficient logic synthesis for highly redundant AIGs • Developing a hybrid approach (combining AIGs and BDDs) • Collapsing • Sliding boundary • Other methods?

3. And/Inverter Graphs (AIGs) • Example • Non-canonicity • Structural hashing • Typical applications

4. Example F(a,b,c,d) = ab + d(ac’+bc) d a 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

5. Structural Hashing • No structural hashing • Always add a new AND-node • One-level structural hashing • 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)

6. 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

7. Reachability Analysis using AIGs • Computation using AIGs • Reachability pseudo-code • Using AIGs for reachability • Example • Structural fixed point • Consequences

8. Using AIGs for Computation • Boolean operations • Express an operation in terms of ANDs and INVs • Cofactoring • Propagate a constant • Quantification • Propagate two constants and OR the results • Variable replacement • Reconstruct a graph in terms of different variables

9. 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 );

10. Using AIGs for Reachability • General idea • Take any BDD-based computation and perform it using AIGs, instead of BDDs • Consequences • 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

11. Example: s27, initial state

12. Example: s27, transition relation

13. Example: s27, quantified relation

14. Example: s27, reached 1

15. Example: s27, reached 2

16. Example: s27, reached 1

17. 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

18. Reduction Procedures To Try • Key insight • AIGs record delayed BDD computations! • BDD-based partial collapsing • Using a shifting BDD/AIG boundary

19. 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 reachesthe structural fixed point after n or n+1 iterations.

20. 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, thefixed point is reached after n+1 iterations.

21. Lemma • Lemma. If Front is Constant-0 Boolean function but notConstant-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.

22. 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 );

23. Proof Illustration csP(cs,ns) P(cs,ns) = Relation(cs,ns) & Front(cs) Quantification  Front Relation P P P P cs 00 ns 01 10 11 cs ns ns ns ns

24. Discussion • It would be nice if AIGs could beat BDDs for reachable state computation • In practice, this did not happen (so far)

25. 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

26. 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