DECOMPOSITION BASED APPROACH FOR THE SYNTHESIS OF THRESHOLD LOGIC CIRCUITS

Priority Claim [0001] This application claims the benefit of U.S. Provisional Patent

Application serial number 61/106,789, filed October 20, 2008, the disclosure of which is hereby incorporated herein by reference in its entirety and is made part of this specification.

Government Funding

[0002] This invention was made with government support under grant numbers 015516-001 and 019772-001 , awarded by the NSF. The United States Government may have certain rights in this invention.

Field of the Disclosure

[0003] The present disclosure relates to automated circuit synthesis. In particular, the present disclosure relates to the synthesis of threshold logic circuits by decomposing Boolean functions.

Background

[0004] Threshold logic (TL) has long been known as an alternative way to compute Boolean functions. Much of the earlier work on TL dates back to the 1960s, which focused primarily on exploring the theoretical aspects of TL, with little attention being paid to the synthesis and optimization of large, multi-level TL circuits. The lack of efficient implementations of TL gates, when compared to static fully Complementary Metal Oxide Semiconductor (CMOS) transistor networks and the rapid development of synthesis and optimization tools for Boolean logic design, led to a loss of interest in developing a similar infrastructure for designing TL circuits. The situation is now changing in favor of TL

[0005] The scaling of Metal Oxide Semiconductor Field Effect Transistors (MOSFETs) that has been taking place for over three decades is expected to continue for at least another decade, after which a point will be reached where transitioning to non-CMOS technologies will be necessary. Research is currently in progress to find the best alternative to CMOS. A few examples of post-CMOS devices are resonant tunneling diodes (RTDs), single electron transistors (SETs), quantum cellular automata (QCA), and carbon nano-tube FETs (CNT-FETs). A common and important characteristic of these devices is that they can be used to realize TL efficiently. Efficient CMOS implementations of threshold gates are also currently available. Consequently, there has been a resurgence of interest in TL and synthesis and verification methods that are applicable to large, multilevel threshold circuits.

[0006] The traditional approach for the synthesis of multilevel threshold logic circuits is based on determining if a Boolean function is threshold by verifying satisfiability of a large number of integer linear inequalities. However, such an approach is only practical for functions with a few inputs. Thus, there is a need for a method for synthesizing multilevel threshold circuits that eliminates the use of integer linear programming (ILP) formulation to determine if a Boolean function is threshold and to evaluate the weights and threshold in case the function is a threshold function.

Summary

[0007] The present disclosure addresses the need for a method that synthesizes multilevel threshold circuits without using integer linear programming (ILP) to determine if a Boolean function is threshold and to evaluate the weights and threshold of threshold functions. An embodiment of the present disclosure receives a Boolean function as an input and outputs a network of threshold elements to synthesize an optimized threshold logic circuit that corresponds with the inputted Boolean function. In particular, the embodiment receives a Boolean function and converts the Boolean function into a novel cofactor tree data structure that represents the Boolean function. The cofactor tree data structure

includes parent nodes, child nodes, leaf nodes, and a root node. This representation is a generic abstraction of cofactoring and includes many popular graphical representations of cofactoring like the Boolean Decision Diagram (BDD) and its variants. In this disclosure a novel graphical representation is introduced (called the min-max literal factor tree) and the invention is illustrated using the same. However this does not limit the scope of the invention, and the same technique proposed here can be applied to any cofactoring representation with or without changes to the procedure discussed here. The leaf nodes may be, but are not required to be, a zero or one node. All leaf nodes of the cofactor tree data structure are threshold functions.

[0008] According to Shannon's Decomposition theory, the inputted Boolean function can be cofactored into positive and negative cofactors that constitute the inputted Boolean function. These positive and negative cofactors are Boolean sub functions that can also be cofactored into positive and negative cofactors that make up the nodes of the cofactor tree data structure. Cofactors making up the cofactor tree data structure are tested to determine whether or not they are a threshold functions. Each node in the cofactor tree data structure is checked if its function can be implemented in a single threshold gate. This can be done by the proposed invention when both the function cofactors are known to be threshold. An efficient way of accomplishing this includes (but is not limited to) recursively processing each node or considering each node in the bottom up fashion. If a tested cofactor is a threshold function, the process is repeated on its parent node. However, if the tested cofactor is not a threshold function, the tested cofactor is decomposed into positive and negative cofactors. The cofactor tree data structure is also restructured to account for these new cofactors. Either of the positive or negative cofactors is outputted as an element of the threshold circuit being synthesized.

[0009] A process of repeated cofactoring with threshold function testing and threshold circuit synthesis continues on the nodes of the cofactor tree data structure until the root node of the cofactor tree data structure is eventually processed. The threshold gate outputted by this process and the

interconnections among them (which together make up the threshold circuit that implements the inputted Boolean circuit) constitutes the final output of the invention.

[0010] Those skilled in the art will appreciate the scope of the present invention and realize additional aspects thereof after reading the following detailed description of the invention in association with the accompanying drawing figures.

Brief Description of the Drawing Figures [0011] The accompanying drawing figures incorporated in and forming a part of this specification illustrate several aspects of the invention, and together with the description serve to explain the principles of the invention.

[0012] Figure 1 is a diagram of an example threshold logic gate.

[0013] Figure 2 is a truth table that shows the weighted sums and values of output for different combinations of inputs.

[0014] Figure 3 depicts a high-level generalization of a threshold logic (TL) circuit synthesizer that incorporates a decomposition based approach for the synthesis of threshold logic circuits according to an embodiment of the present disclosure. [0015] Figure 4 is a block diagram of a computer system for executing the TL circuit synthesizer.

[0016] Figure 5 is a diagram of a Min-Max Literal (MML) factor tree structure according to the present disclosure.

[0017] Figure 6 is a diagram of an example MML factor tree for a given Boolean function.

[0018] Figure 7 depicts the steps involved in threshold function identification.

[0019] Figure 8A shows the weight assignments for an OR node.

[0020] Figure 8B shows the weight assignments for an AND node.

[0021] Figure 8C shows the weight assignments for a constant one node. [0022] Figure 8D shows the weight assignments for a constant zero node.

[0023] Figure 9 shows a MML factor tree of a function having leaves that are trivial threshold functions.

[0024] Figure 10 illustrates two different restructuring rules that depend on child node elimination. [0025] Figure 1 1 A depicts nodes for a function that is a not a threshold function.

[0026] Figure 1 1 B depicts a threshold circuit synthesized by repeatedly applying the present decomposition method to the function represented in Figure 1 1 A. [0027] Figure 12 depicts a threshold circuit synthesis flow.

[0028] Figure 13 is a bar graph showing a comparison of an average number of gates in TL circuits versus the number of Boolean gates with regard to the present decomposition and synthesis method and a reference synthesis method.

Detailed Description

[0029] The embodiments set forth below represent the necessary information to enable those skilled in the art to practice the invention and illustrate the best mode of practicing the invention. Upon reading the following description in light of the accompanying drawing figures, those skilled in the art will understand the concepts of the invention and will recognize applications of these concepts not particularly addressed herein. It should be understood that these concepts and applications fall within the scope of the disclosure and the accompanying claims. [0030] Before delving into the details of the present invention, some definitions of terms are provided to aid in understanding of the following disclosure. A threshold gate has one or more binary inputs, x-i, X ₂ , ...., X _n , and a single binary output. The gate is characterized by a set of weights, W = W ₁ , W ₂ , ..., w _n , where w, is the weight associated with input x,, and a threshold T. The output of a threshold gate is defined as follows:

se

A Boolean function is called a threshold function if it can be implemented by a single threshold gate. Since the threshold gate realizing a function f is completely characterized by the set of weights W and the threshold T, the threshold gate is represented by f = [W; T] = [W ₁₅ W ₂ , . . . ,w _n ; T]. [0031] Figure 1 shows an example of a threshold gate 10 having an output 12 that is governed by a function Z= X Y' ≡ [X= 1 , Y= -1 ; T= 1 ]. An input 14 for a variable X has an applied weight 16, which in this case is a one. Another input 18 for a variable Y has an applied weight 20, which in this example is a negative one. A threshold 22, which in this case has a value of one is tested against the weighted values of the variables X and Y. Figure 2 is a truth table that shows the weighted sums and values of Z for the output 12 for combinations of X and Y inputs.

[0032] Threshold functions are a subset of unate functions. Since simple primitive gates such as OR, AND, NOR, and NAND are threshold, one can view a multi-level logic network composed of such gates as a special case of a threshold circuit. However, the advantage of using threshold logic is that much more complex functions can be implemented in a single threshold gate. Hence a multi-level threshold network may be viewed as a generalization of a traditional Boolean logic circuit using much more complex primitives. Such a generalization can lead to significant reduction in gate count and, in many cases, circuit depth. Moreover, significant reductions in gate count and circuit depth translates into significant reductions in required circuit area, circuit power consumption, and circuit signal delays. For example, a function such as ab(c+d)+cd(a+b) can be implemented by a single threshold gate. Traditionally, five Boolean AND/OR gates in three levels would be needed to implement the function ab(c+d)+cd(a+b). Since not all Boolean functions are threshold, an arbitrary Boolean function needs to be implemented as a multi-level threshold network. [0033] Determining whether or not a given Boolean function is threshold is an important problem to solve for synthesis, verification, and optimization of threshold logic networks. Another important problem to solve is to decompose a Boolean function into sub-functions that are threshold, i.e. to determine the parts

of the Boolean function that are threshold. After a function has been identified as threshold, it is necessary to assign weights and a threshold for the gate. Currently, the task of identifying threshold functions and assigning weights is done using an Integer Linear Programming (ILP) formulation. [0034] An embodiment of the present disclosure is an efficient (i.e., non-ILP) method that addresses the above problems. The disclosed method generally involves identifying functions or sub-functions that are threshold, and assigning weights and thresholds. Only recently has there been a significant effort in the area of threshold synthesis. Most of these prior art methods use the ILP formulation to determine whether or not a function is a threshold function and weight-threshold assignment. Moreover, most prior art methods use a pre- synthesized Boolean circuit and local merging of Boolean gates to obtain a threshold circuit. Thus the quality of result depends on the circuit representation used as an input. [0035] Figure 3 depicts a high-level generalization of a decomposition based approach for the synthesis of threshold logic circuits according to an embodiment of the present disclosure. As shown in Figure 3, a threshold logic (TL) circuit synthesizer 24 converts a Boolean function 26 into a network of threshold elements that can be implemented as a threshold circuit 28 using various physical implementations (such as Resonant Tunneling Diodes (RTDs), Single Electron Transistors (SETs), Carbon nano-tube Field Effect Transistors (FETs), etc.).

[0036] The TL circuit synthesizer 24 initially receives and cofactors the Boolean function 26 into a cofactor tree data structure 30 which is a data structure that includes leaf nodes 34. The leaf nodes 34 can be Boolean AND, Boolean OR, or a single literal or a constant one or zero if the factor tree is a Min- Max Literal Factor Tree. The leaf nodes are constant one and zero nodes in case of a BDD. The representation can be changed and the method will work for all representations of function cofactoring. The TL circuit synthesizer 24 accepts the Boolean function 26 as input in various forms such as a truth table and factored form, etc. The various input forms are all inter-convertible by way of

public domain and commercial tools such as, but not limited to the Berkeley-SIS tool and the Synopsis Design Compiler®.

[0037] The cofactor tree data structure 30 is generated by cofactoring the Boolean function 26 into constituent positive and negative cofactors. The cofactor tree data structure 30 completely specifies the Boolean function 26 in accordance with the Shannon Decomposition Method, which states that F=x.F _x +x'.F _X '. In this way, the Boolean function 26 represented by F is defined by the positive cofactor F _x and the negative cofactor F _x . Cofactoring continues to yield constituent positive and negative cofactors for each positive and the negative cofactor. Cofactoring is repeated until a leaf node is encountered within the cofactor data tree structure 30. This leaf node is dependent on a cofactor tree representation chosen.

[0038] A threshold determining function 36 determines if the Boolean function 26 is threshold when the cofactors F _x and F/ of the Boolean function 26 are known to be threshold. Since cofactors of the leaf nodes 34 are always threshold, all the leaf nodes 34 of the cofactor tree data structure 30 are threshold. In this way, the threshold determining function 36 can determine if the function of any node in the cofactor tree data structure 30 is threshold, when its cofactors are known to be threshold. [0039] If the threshold determining function 36 determines that a cofactor of the Boolean function 26 is threshold, the process continues with its parent node. In contrast, if a cofactor of the Boolean function is determined to be non- threshold, the cofactor is sent to a decomposition function 38. The threshold cofactor (i.e., the TL part), either the F _x cofactor or the F _x * is sent to be added as part of threshold circuit 28. The remainder function (i.e., the one remaining after either cofactor is removed), is sent to the threshold determining function 36 again. All cofactors associated with nodes of the cofactor tree data structure 30 are processed in the same manner until a root node 40 of the cofactor tree data structure 30 is eventually processed. [0040] Figure 4 is a block diagram of a computer system 42 for executing the TL circuit synthesizer 24 (Figure 3). The computer system 42 includes a user

interface 44 for receiving the Boolean function 26 (Figure 3) and for displaying or printing the synthesized threshold circuit 28 (Figure 3). A memory 46 is for storing the cofactor tree data structure 30 (Figure 3) along with software code comprising the TL circuit synthesizer 24. A processor 48 is for executing the software code comprising the TL circuit synthesizer 24. An optional network interface 50 is useable to transmit data such as the synthesized threshold circuit 28 and the Boolean function 26 over a network such as the Internet. [0041] In order to disclose further details of the present disclosure, additional definitions are provided. A positive threshold function is one in which all the variable weights in a weight-threshold assignment are positive. A positive threshold function also a positive unate function. For example F = a+bc ≡ [w(a) = 2, w(b) = 1 , w(c) = 1 ; T = 2] is a positive threshold function. Note that F = a+bc ≡ [w(a) = 2, w(b) = 1 , w(c) = 1 ; T = 2] is also a positive unate function. [0042] The set of all variables on which a function depends is called the support set of the function. The support set of function F is denoted by Supp(F). For example, F = a + c, Supp(F) = {a, c}.

[0043] A variable d is said to be a "don't care" variable of a function F if and only if F(d=0) = F(d=1 ). Don't care variables do not belong to the support set of a function. [0044] A sum of products (SOP) formula is a complete sum (i.e., a sum of all prime implicants and only prime implicants) if and only if:

1 ) no term includes any other term; and

2) the consensus of any two terms of the formula either does not exist or is contained in some other term. [0045] The complete sum of function F is denoted by CS[F). For example, the complete sum of ab' + ab + c is CS(F) = a + c.

[0046] Ordering: For a function F if F _{x=1 iy=0} 2 F _x=o ,y=i, it is denoted as x y y. x

^ y is defined similarly. If F _{x=1 >y=0} 3 F _x=0 , _y =i, it is denoted as x >- y. x -< y is defined similarly. For a pair of variables x and y, if x y y and x ± y, it is denoted as x ~ y.

[0047] For a threshold function, W _x > w _y implies x y y, and W _x = w _y implies x « y. It is also known that for a threshold function F, Supp(F) can be totally pseudo- ordered using the ^-relation.

[0048] Factorization of a Boolean function represented in SOP form is done to reduce the number of literals and thereby obtain more compact representations. For the purposes of this disclosure, an SOP is a set of cubes, wherein a cube is the AND of a set of literals.

[0049] Algebraic factorization is the algebraic division of a Boolean function. If D is the divisor used to factor function F, then F = Q. D + R, where Q and R are the quotient and remainder obtained by the algebraic division of F by D. Q and R may be further factored to obtain a more compact factored form. Many different factoring techniques have been developed. The main difference between these different techniques is the way in which the divisors are chosen. One factoring technique called the best literal factorization uses a literal for the divisor that occurs in the greatest number of cubes. For example, for F = ab + ac + de = a(b + c) + de, a is the best literal as it occurs in two cubes, which is more than the number of cubes in which any other literal occurs. Here Q = b + c, D = a, R = de, and F = Q.D + R. [0050] Figure 5 is a diagram illustrating a novel factorization method according to the present disclosure. The factorization represented in Figure 5 is referred to herein as the Min-Max Literal (MML) factorization and is well suited for the factorization implemented by the TL circuit synthesizer 24 (Figure 3). As shown in Figure 5, the left edge of a node is labeled using the MML chosen to be the divisor of the function of the node. A left child node represents the quotient obtained by algebraic division and a right child node represents the remainder. [0051] MML factorization is very similar to the best literal factorization in that a single literal is used as a divisor, but MML factorization has novelty in the technique used to choose the divisor D. For instance, let C _j represent the set of all cubes in an SOP that contain j literals. The MML is a literal that occurs in the greatest number of cubes in C _k , where k is the size of the smallest cube. For example, in ab + ce + ad + bed, a is the MML as it occurs more often in C ₂ = {ab,

ce, ad}, than any other literal. In case of a tie, the literals that occur in an equal number of cubes in Ck are then compared to each other using the occurrences of these literals in C _k+1 and so on, until the tie is resolved. For example, in abc + ad + ae + de, again a is the MML. Even though a, d and e all occur in two cubes in C ₂ = {ad, ae, de}, the tie is broken using C ₃ = {abc}, since a occurs in one cube of C ₃ , whereas d and e are not present in any cube in C ₃ . In case the tie is not broken even after comparing the variable occurrences in Ci , where I is the size of the largest cube, the tie is broken arbitrarily. In ab + ac + be, a, b or c can be chosen as the MML, as they all occur in an equal number of cubes in C ₂ and the largest cube size is two.

[0052] After repeatedly factoring a SOP using the MML factorization, the factored form may be represented using a factor tree such as cofactor tree data structure 30 (Figure 3). Figure 6 depicts an example of a MML factor tree for a function G = a+bc+bd+be+cd+ce = a+b(c+d+e)+c(d+e). [0053] Turning back to Figure 3, the parts of the Boolean function 26 that are threshold are determined by the threshold determining function 36. An MML factor tree, such as the cofactor tree data structure 30 is constructed from the Boolean function 26, which can be in an SOP form. To make the factor tree more compact, the SOP form of the Boolean function 26 is minimal with respect to single cube containment. Although MML factorization is not necessary to obtain the cofactor tree data structure 30, it has some convenient features. For a threshold function, the MML represents the variable with the highest weight. All literals of the SOP form are assumed to be positive without loss of generality. Therefore a and a' are considered to be two separate literals. All weights that are assigned during the decomposition procedure are thus positive. The exact weights can be easily obtained by the use of Lemma 6 (see below). For example, if the decomposition procedure yields the following weight-threshold assignment: [w(a') = 2, w(b) = 1 , w(c) = 1 ; T = 3], then by Lemma 6, this is equivalent to [w(a) = -2, w(b) = 1 , w(c) = 1 ; T = 1 ]. It is important to note that the cofactor tree data structure 30 is a general abstraction for concrete data structures used by existing circuit synthesis tools. A Boolean Decision Diagram

(BDD) (one manifestation of the cofactor tree data structure 30) is one of the most popular graphical representations of cofactoring used by existing circuit synthesis and analysis tools. In a preferred embodiment, the disclosed MML factor tree has many convenient features when implemented as the cofactor tree data structure 30.

[0054] Figure 7 shows a more detailed operations flow for the TL circuit synthesizer 24 (Figure 3). The TL circuit synthesizer 24 traverses the cofactor tree data structure 30 (Figure 3) in a bottom-up fashion (this can also be achieved by a recursive implementation). In this example the cofactor tree data structure 30 is of the preferred MML type. By construction, the leaf nodes, which are AND/OR functions or constants one, or zero of the cofactor tree data structure 30 are threshold. The threshold determining function 36 (Figure 3) determines whether or not a node of the cofactor tree data structure 30 is a threshold function given that its two child nodes are threshold functions. If so, the weights for the threshold functions are determined; otherwise, the Boolean function 26 (Figure 3) is transformed by reorganizing the cofactor tree data structure 30 after decomposing one cofactor of the function (of a node in the cofactor tree data structure 30 that is not threshold) of the Boolean function 26. [0055] In the following example, let F _x and F _x * be the left and right children of a node F, with x being the cofactor literal (i.e., F = x F _x + x' F _/ in case of a positive threshold function F = x F _x + F _x ). Suppose F _x and F _x * are threshold functions. Lemma 5 (see below) states that F is not a threshold function if in a cofactor tree, the support set of one child is not contained in the support set of the other child. Therefore, the threshold determining function 36 (Figure 3) checks for support set containment (step 100). If F is determined not to be threshold, F is restructured (step 102).

[0056] Next, if the conditions of Lemma 5 are satisfied, the conditions of Lemma 4 (see below) are checked (step 104), which state that in a cofactor tree, if there exists a pair of variables in F _x and F _/ that have different ^-ordering, then F is not a threshold function and F is restructured (step 102). However, if the ordering is found not to be contradictory, the variable weights of F _x and F _/ are

compared to test the weights for equivalence (step 206). If the weights are the same, then F will be a threshold function (Lemma 1 ,see below) and weights are assigned (step 108) to the leaf nodes of F (also indicated in Lemma 1 ). In contrast, if the weights are not the same, F may or may not be a threshold function. Therefore an Extended Identification (EX-I) procedure shown in the dashed box of Figure 7 is implemented to determine whether or not F is a threshold function.

[0057] If the weights are not the same, the EX-I procedure checks to determine if the weight of F _x holds (i.e., is valid) for F _x * and vice versa (step 1 10). If so, F is a threshold function and weights are assigned to the corresponding node in the cofactor tree data structure 30 (step 108). However, if the weight of F _x does not hold for F _x * and vice versa, a check is conducted to see if all the nodes in F/ are contained in F _x (if all the nodes in F _x are contained in F _x ) (step 1 12). If all the nodes F _x * are not contained F _x (and vice versa) then F is not threshold and F is restructured (step 102). Otherwise, the conjugate of the weights (which is obtained by adding the individual weights) is checked for validity with regard to both F _x and F _x * (step 1 14). If the conjugate of the weights is valid for both F _x and F _x , then F is threshold and weights are assigned to the node corresponding to F (step 108). Otherwise, F is not threshold and F is restructured (step 102).

[0058] In order to increase the chance of identifying threshold functions, the following rules are used to assign weight to the leaf nodes. Note that all literals are treated as positive literals:

1. The AND, OR, and constants one and zero nodes are assigned the same weights as the weights assigned to a sister node function. Two nodes are sister nodes if and only if they have the same parent.

2. For an OR node, the exact same weights of the sister node are assigned and the threshold is set to be equal to the smallest variable weight. This is a valid weight-threshold assignment for conditions when any of the inputs are a one. Figure 8A shows the weight assignments for an OR node.

3. For an AND node the exact same weights of the sister node are assigned and the threshold is set to be the sum of all weights. The AND function outputs a one only when all of the AND function's inputs are one. Figure 8B shows the weight assignments for an AND node. 4. The weights are similarly made identical to that of the sister node in case of a constant one node. The threshold is set to zero since all weights are > 0 (positive threshold function) and no matter what the state of input variables are, the weighted sum of inputs is always > 0, which is the threshold. Figure 8C shows the weight assignments for a constant one node.

5. The threshold is set to be one greater than the sum of all weights for a constant zero node after setting the same weights as that of the sister node. Figure 8D shows the weight assignments for a constant zero node.

6. If the leaf node is AND/OR and the sister node has not been assigned weights and a threshold, a weight of one is assigned to all inputs. The threshold is set to be one for an OR node and it is set to be the cardinality of the support set in case of an AND node.

[0059] Figure 9 shows an example MML factor tree for the function A(B + C) + BC. The leaves are trivial threshold functions whose weight-threshold pairs can be trivially assigned. Now consider the parent node. Both children satisfy Lemma 5 and 4, and have the same weights. Hence weight-threshold assignment for the parent node can be determined by Lemma 1. [0060] The restructuring of the factor tree is done when the node F is declared to be a non-threshold function, even though its children are threshold. When a node is not threshold but the children of the node are threshold, the MML factor tree is decomposed. The larger of the two child nodes (the one with the bigger support set) is removed (any other criteria can be used for selecting the child to decompose), and the MML factor tree is modified so that more threshold functions may be identified. [0061] Figure 10 illustrates that there are two different restructuring rules depending on which child node is eliminated. Similar rules are used if a BDD is

used as the cofactor tree representation. However, in the rest of the discussion only the MML factor tree representation is considered. The function of the child node with a larger support set is assigned a single literal, in this case X and the tree is reordered. Reordering is straightforward if the left child node is replaced by a literal. Reordering is more involved if the right child node is replaced by a literal. Note that this reordering does not change the function represented by the tree. The procedure only helps to identify sub trees in the MML factor tree that represent threshold functions. [0062] A threshold circuit is a directed graph. The nodes in the graph of Figure 1 1 B represent threshold elements, and the directed edges represent input-output interconnection between different gates. Each threshold element has a weight-threshold assignment that fully characterizes the element. The objective of the synthesis procedure is to generate a threshold circuit that implements the specified function. [0063] The threshold identification methodology developed earlier is an integral part of the synthesis procedure. Note that the identification procedure identifies sub functions that are threshold. If repeated threshold identification coupled with decomposition of the cofactor tree is performed until the root node is declared to be threshold, the result is a network of threshold gates that will implement the required function. For example, consider the function AB + CD. As depicted in Figure 11 A the function AB + CD is a not a threshold function. However, by using the decomposition methodology repeatedly we can obtain the threshold circuit shown in Figure 1 1 B. [0064] Figure 12 illustrates a version of the synthesis flow that could be used to generate threshold circuits that implement multi-output functions. Any other variation of the same may be developed for particular implementations. In the implementation discussed here Berkeley-SIS is used to obtain an optimized circuit graph. Each node in the circuit graph represents a complex Boolean function. For each node, the cofactor tree of the node function is constructed. Decomposition based synthesis is performed to obtain a threshold circuit for the

function of the node. Once a threshold circuit is obtained for all nodes in the circuit graph, the required multi-output threshold circuit has been generated. [0065] In order to compare the circuit synthesizing results of the present embodiment with typical circuit synthesizing results with other approaches, circuits in the Microelectronics Center of North Carolina (MCNC) benchmark suite were synthesized using the algorithm described herein. The results are reported in Table 1 below. Gate count and depth are non-technology-specific metrics for area and delay. These are reported herein as they are reported in previously published work (R. Zhang, P. Gupta, L. Zhong, and N. K. Jha, "Threshold Network Synthesis and Optimization and Its Application to

Nanotechnologies," IEEE Transactions on Computer Aided Design, 2005, which is incorporated herein by reference in its entirety). Thus, this approach is compared against a modern circuit synthesis method. Table 1 lists the gate count and level count for the benchmark circuits when implemented as Boolean circuits and as TL circuits by the method described by Zhang et al., which has a fanin restriction of six inputs. Compared to the method described by Zhang et al., the method of the present invention generates circuits with comparable depth and 27% fewer gates on average and 66% fewer gates at best. This method does not have a restriction on the fanin of gates; however, such a restriction can be imposed if needed.

Table 1 : Comparison with previous state-of-art

[0066] The most important advantage of the presently disclosed method when compared with these two previous approaches is that it gives a combinatorial method and a theoretical underpinning for synthesizing TL circuits as opposed to the heuristic of localized merging of Boolean gates.

[0067] The method in M. Avedillo and J. Quintana, "A Threshold Logic Synthesis Tool for RTD Circuits," Euromicro Symposium on Digital System Design, 2004, generates feed forward TL networks in which there is only one gate in each level. This method is extremely expensive in terms of computation time. It requires more than a minute even for small circuits of only two TL gates. In comparison, the method of the present disclosure takes an average of two seconds to complete execution. Even for circuits that have over six hundred threshold gates it takes no more than six seconds to generate the threshold circuit. [0068] To better compare the results, a histogram may be used, as shown in Figure 13. The horizontal x-axis of the histogram represents the number of gates in the Boolean circuit. The vertical y-axis of the histogram plots the average number of gates in the threshold circuits generated by the two methods to implement the same benchmarks. For example, consider the circuits that needed 200 to 500 gates in the Boolean implementation. Zhang et al.'s method requires an average of 200 gates, whereas the method of the present embodiment requires an average of only 126 gates to implement the same circuits. As shown in Figure 13, the approach described herein needs fewer

gates than the reference approach in every range. The improvement in the gate count is greater for larger circuits.

[0069] In terms of delay, the circuits generated by the method of the present disclosure are on average 1 % worse than the circuits generated by the method proposed by Zhang et al. The focus of this particular implementation of the invention was to reduce the gate count and in this regard the proposed method did better than the previous method for almost all circuits. The invention can be used with suitable changes to obtain different circuits that are better suited for improving different circuit parameters (like delay, power etc.).

Lemmas

[0070] Lemma 1 : If F = x F _x + x' F _x * is a Boolean function, and F _x and F _x * are known to be threshold, with a weight-threshold assignment [W; T (F _x )] and [W;

T(F _x )] (identical input weights) respectively, then F is also a threshold function with w _x = T(F _x ) - T(F _x ) and F ≡ [W u { T(F _x . ) - T(F _x ) }; T(F _x )].

[0071] Lemma 2: In all weight-threshold assignments of a positive threshold function, the don't care variables have weight strictly less than all other non-don't care variables.

[0072] Let F = x F _x + x' F _x . (in case of a MML factor tree F = x F _x + F _x . ) is the, where x is the cofactoring variable. Lemma 3, 4 and 5 discuss some properties of this functional representation of F.

[0073] Lemma 3: There exists a weight-threshold assignment of F _x and F _x - such that both F _x and F _x . have the same variable weights.

[0074] Lemma 4: Both A and B have the same ^-ordering of variables. (NOTE: For a function F if F _{x=1 >y=0} 2 F _x=0 , _y =i, it is denoted as x > y. x =< y is defined similarly. If F _{x=1 y=0} 3 F _x=0,y =i, it is denoted as x >- y. x -< y is defined similarly.

[0075] For a pair of variables x and y, if x > y and x =< y, it is denoted as x ~ y. [0076] Lemma 5: If Supp(F _x ) \ Supp(F _x ) ≠ φ and S upp(F _x ) \ S upp(F _x ) ≠ φ, then F is not a threshold function.

[0077] Lemma 6 If f (X) is a threshold function and has a weight threshold assignment [ Jw ₁ , ^{■ ■ ■} w _a _ ₁ , w _a , w _a+1 , ^{■ ■ ■} , W _n }; T ], then for f (X ; a → a' ), [Jw ₁ , ^{■ ■ ■} w _a -i , - w _a , w _a+1 , ^{■ ■ ■} , w _n }; T - w _a ] is a feasible weight threshold assignment. [0078] As outlined before, scaling is currently the most popular technique used to improve performance metrics of Complementary Metal Oxide Semiconductor (CMOS) circuits. This cannot go on forever, because the properties that are responsible for the functioning of Metal Oxide Semiconductor Field Effect Transistors (MOSFETs) no longer hold in nano dimensions. Recent research into nano devices has shown that nano-devices can be an alternative to CMOS when scaling of CMOS becomes infeasible in the near future. This is motivating the need for stable and mature design automation techniques for threshold logic since it is the design abstraction used for most nano-devices. The present disclosure provides a new decomposition theory that is based on the properties of threshold functions. The present invention can also be applied to design efficient CMOS circuits that are based on threshold logic. The main contributions of this work are a new method of algebraic factorization called the Min-Max factorization, a decomposition theory that uses this new factorization to identify and characterize threshold functions, and a new threshold logic synthesis methodology that uses the decomposition theory. The invention disclosed here can also work with any traditional representations of cofactoring like BDD an its many variants.

[0079] Further described herein is a novel theory for decomposition of Boolean functions into constituent threshold functions. New properties of threshold functions are introduced. Using these properties, a decomposition procedure is developed to identify and assign weights and threshold to a threshold function. A new algebraic factorization for factoring Boolean functions, which can be used in conjunction with the proposed procedure, is presented. A new synthesis procedure is built on top of the decomposition theory. This procedure has sound theoretical basis as opposed to other heuristic node merging algorithms. When compared to the most recent synthesis procedure,

the method outlined herein generates threshold circuits that have an average of 27% fewer gates with comparable circuit depth.

[0080] Those skilled in the art will recognize improvements and modifications to the preferred embodiments of the present invention. All such improvements and modifications are considered within the scope of the concepts disclosed herein and the claims that follow.