Factoring and Recognition of Read-Once Functions Using Cographs and Normality

1. Factoring and Recognition of Read-Once Functions Using Cographs and Normality Author: M. C. Golumbic, A. Mintz, U. Rotics Speaker: J. Lee

2. Outline • Introduction • Properties of Read-Once Functions • Proposed Read-Once Algorithm • Conclusions

3. Introduction • A Boolean function is called a read-once function if each variable appears once • f = aq+acp+ace = a(q+c(p+e)) • Read-once function • J. P. Hayes introduced fanout-free functions • AKA non-repeatable tree functions since the parse tree of a read-once formula has no variable repeated

4. Previous Works • J. P. Hayes, “The Fanout Structure of Switching Functions” • Identify and factor fanout-free functions based on adjacency of the function variables • High complexity • J. Peer and R. Pinter, “Minimal decomposition of boolean functions using non-repeating literal trees” • Non-polynomial complexity

5. Outline • Introduction • Properties of Read-Once Functions • Proposed Read-Once Algorithm • Conclusions

6. Unate Function and its Graph • A unate function: each variable appears either in the positive or negative form throughout the formula • We define a graph Γ=(V,E) of a unate function F which is given in an SOP form • V={a1,…,an} : different literals in F • An edge (ai, aj) in E exists  if its literals ai, aj both appear in some product term of F

7. Unate Function and its Graph (cont’d) • Each product term in F induces a clique in Γ • Clique: a complete subgraph a f1=abc c b

8. Unate Function and its Graph (cont’d) • The mapping of F to Γ is not 1-1 a f1=abc f2=ab+bc+ac c b

9. Unate Function and its Graph (cont’d) • The mapping of Γ to FΓis as follows • Find the set of all maximal cliques of the graph Γ • Transform each maximal clique to a cube in FΓ a f1=abc c b

10. Normality • A function F is normal if F = FΓ • Mapping F to a graph Γ and vice versa will yield the original function a f1=abc f1=abc c b

11. Normality (cont’d) • F -> Γ : obvious • Γ -> F : NP-complete • Find all maximal cliques of a graph

12. P4-free Graphs • P4: path graph with 4 vertices • A graph is P4-free if it contains no copy of P4 as an induced subgraph

13. P4-free Graphs (cont’d) • P4-free graphs are also know as cographs • A cograph has a canonical tree representation called the cotree 1 e f 0 0 1 1 g a b g a b c d e f c d

14. Main Theorem for Read-Once Functions • F are read-once functions • F is normal and its graph Γ contains no subgraph isomorphic to P4 • The graphs Γ and Γ* have no edges in common • The union of the graphs Γ and Γ* forms a complete graph

15. Outline • Introduction • Properties of Read-Once Functions • Proposed Read-Once Algorithm • Conclusions

16. Proposed Read-Once Algorithm Is_Read_Once_Function(root) if(!Check_Unate(root)) return(false); Γ=Build_Graph(root); if(!Graph_Partition(Γ, new_root)) return(false); if(!Check_Normality(root, new_root)) return(false);

17. Check Unate • Scan the parsing tree in a BFS order, check that no literal and its negation exist simultaneously f3=acd+aef+ag+bcd+bef+bg + . . . . . . a g b g d d a c a e f b c b e f

18. Build Graph • An N*N matrix M • N: #(literals) • M(i, j)=1 iff the literals i and j share a common implicant f3=acd+aef+ag+bcd+bef+bg e f g a b c d

19. Graph Partition • Determine if the graph Γ is a cograph • 1-node: AND • 0-node: OR 1 0 0 1 1 g a b c d e f

20. Check Normality • Represent each tree by an integer vector and then check for vector equivalence • The goal is to do the comparison with minimum complexity and without collapsing the read-once tree

21. Check Normality (cont’d) • {13,14,49,50,65,66} + {13,49,65,14,50,66} . . . . . . {13} {49} {65} {14} {50} {66} a g b g d d a c a e f b c b e f {1} {4} {8} {1} {16} {32} {1} {64} {2} {4} {8} {2} {16} {32} {2} {64}

22. Check Normality (cont’d) • {13,14,49,50,65,66} . {13,65,49,14,66,50} + + {1,2} {12,64,48} . . {12} {48} g a b {1} {2} {64} c d e f {4} {8} {16} {32}

23. Outline • Introduction • Properties of Read-Once Functions • Proposed Read-Once Algorithm • Conclusions

24. Conclusions • We have presented a very fast algorithm for recognizing and factoring read-once functions • Our method is based on cograph recognition and on normality checking