Patent Publication Number: US-5291612-A

Title: System for evaluating boolean expressions using total differential generating tree structured processing elements controlled by partial subfunction differentials

Description:
BACKGROUND OF THE INVENTION 
     1. Field of the Invention 
     The invention relates to field of logic machines and methods for processing information within logic machines. In particular, the invention relates to electrical circuits and methods of using electrical circuits to evaluate logical relationships. 
     2. Description of the Prior Art 
     Efficient processing of Boolean expressions or complex logical signals has many applications in monitoring and debugging digital processes and hardware computing systems. Some other applications of Boolean evaluation are special purpose database search processors and hardware simulators for discrete systems. 
     The high-level monitoring activity involves the evaluation of Boolean functions based on the real-time behavior of the system being observed. Depending on the purpose of monitoring, different Boolean expressions are evaluated at different time intervals. The problem is how to develop an approach to evaluate an arbitrary Boolean expression in real-time. Some solutions to this monitoring problem include using a fixed set of Boolean expressions (fixed hardware tools), the manual rewiring of the monitor circuit (wired program tools), and the use of a high speed programmable monitor circuit (stored program tools). Stored program tools are the most flexible and satisfactory, but they impose a high cost on the monitor circuit because it must operate at a much faster rate than that of the system being observed. 
     One possibility of implementing a dynamically reconfigurable circuit that is able to evaluate any Boolean function of two variables is to use three, 2-input multiplexers. A 2-input multiplexer, is symbolically modeled by a Boolean function, M(a,b,s), which has two data inputs a and b, and one control signal s. It evaluates the function: 
     
         M(a,b,s)=as+bs. 
    
     Depending on the value of control signal s, input variable a or input variable b is chosen as the output of M. The function, M(a,b,s) can then be used to model an arbitrary logic circuit. For example, let F(x,y) be a Boolean function of two variables. Its value can be defined by: 
     
         F(0,0)=f.sub.0, 
    
     
         F(0,1)=f.sub.1, 
    
     
         F(1,0)=f.sub.2, 
    
     
         F(1,1)=f.sub.3. 
    
     It can be shown then that a function, F(x,y), is described by a Boolean expression: 
     
         F(x,y)=xyf.sub.0 +xyf.sub.1 +xyf.sub.2 +xyf.sub.3          ( 1) 
    
     Function F(x,y) in Equation (1) can be implemented by three, 2-input multiplexers as follows: 
     
         F(x,y)=M(M(f.sub.0,f.sub.2,x),M(f.sub.1,f.sub.3,x),y). 
    
     There are sixteen possible Boolean functions of the two variables which are listed in Table 1 below. In traditional Boolean function processing methods, all sixteen cases are represented by four bits of F(x,y), i.e., f0, f1, f2 and f3. Processing in a tree structure therefore becomes complex when implemented in custom hardware and very time and resource consumptive when implemented in a general purpose computer. In complex Boolean functions the processing time can seriously lag real time needs for the processed result unless the computing circuit is very large and very fast. 
     What is needed is an apparatus and methodology which will allow any kind of complex Boolean expression to be processed in a real time basis in small computer systems. 
     BRIEF SUMMARY OF THE INVENTION 
     The invention is an apparatus for processing a complex Boolean function comprised of a plurality of Boolean subfunctions. The apparatus comprises a host computer for generating a plurality of partial derivatives corresponding to each of the plurality of subfunctions. A tree structure circuit receives a plurality of signals corresponding to independent inputs and generates total differentials of each of the subfunctions and ultimately of the complex Boolean function. The host computer receives the total differential of the complex Boolean function and generates a signal corresponding to the value of the complex Boolean function corresponding to the plurality of inputs coupled to the tree structure circuit. A controller circuit couples the host computer to the tree structure circuit for communicating at least the plurality of partial derivatives from the host computer to the tree structure circuit. As a result, the complex Boolean function is evaluated at high speed and minimal use of memory. 
     In one embodiment the tree structure circuit comprises a plurality of identical processing circuit organized and coupled with one another in a tree structure. The tree structure is a full binary tree structure. Each of the processing circuit has only two inputs. 
     The processing circuit is a logic circuit having inputs x and y. The host computer generates signals corresponding to the partial derivatives, F x , F y , and F xy  of the subfunction corresponding to the processing circuit. The signals corresponding to the partial derivatives F x , F y  and F xy  are coupled to the processing circuit and logically combined therein to generate a total differential of the subfunction corresponding to the processing circuit. 
     The processing circuit combines the inputs x and y with the signals corresponding to the partial derivatives F x , F y  and F xy  as modeled by the equation: 
     
         dF=F.sub.x dx⊕F.sub.y dy⊕F.sub.xy dx dy, 
    
     where F is the subfunction corresponding to the processing circuit. 
     In another embodiment the processing circuit combines the inputs x and y with the signals corresponding to the partial derivatives F x , F y  and F xy  as modeled by the equation: 
     
         dF=F.sub.x dx dy+F.sub.y dx dy+(F.sub.x ⊕F.sub.y ⊕F.sub.xy)dx dy, 
    
     where F is the subfunction corresponding to the processing circuit. 
     In still another embodiment the processing circuit combines the inputs x and y with the signals corresponding to the partial derivatives F x , F y  and F xy  as modeled by the equation: ##EQU1## where F is the subfunction corresponding to the processing circuit. 
     In one embodiment the processing circuit comprises a plurality of switch circuits having an input for receiving a signal corresponding to the partial derivatives of the corresponding subfunction the complex Boolean function. Two control gates are controlled by one of the differentials dx and dy of the inputs x and y. The plurality of switches are combined to generate a total derivative of the subfunction. The plurality of switches are combined to model the equation: 
     
         dF=S(S(F.sub.y,dx)+S(F.sub.x ⊕F.sub.y ⊕F.sub.xy,dx),dy)+S(S(F.sub.x,dx),dy) 
    
     where S (a, c)=a*c. 
     In still another embodiment the processing circuit comprises three 3-input NOR gates and two inverters combined to logically operate as modeled by equation: ##EQU2## 
     The invention can also be characterized as an apparatus for processing an arbitrary, complex Boolean function comprised of a plurality of subfunctions. The apparatus comprises a circuit for receiving a plurality of inputs, and a circuit for generating a plurality partial derivatives of each of the subfunctions. A circuit generates a plurality total derivatives according to a predetermined rule. A circuit combines the plurality of total derivatives, partial derivatives and inputs in a tree structured organization to generate a total derivative of the Boolean function. A circuit generates that value of the Boolean function for the corresponding plurality of inputs. As a result, the complex Boolean function is evaluated at high speed and minimal use of memory. 
     The circuit for generating a plurality partial derivatives of each of the subfunctions comprises a memory and a processor circuit for retrieving the partial derivatives stored in the memory corresponding to each the subfunction and for storing the retrieved partial derivatives in an array fp and fxy in the memory. 
     The circuit for generating a plurality total derivatives according to a predetermined rule comprises the memory and the processor circuit. The processor circuit generates a total derivative of each the subfunction and for storing the generated total derivative of each the subfunction in an array df in the memory. 
     The circuit for combining the plurality of total derivatives, partial derivatives and inputs comprises the memory and processor circuit and combines the plurality of total derivatives, partial derivatives and inputs in a binary tree of the arrays df, fp and fxy organized in the memory to generate the total derivative of the Boolean function. 
     The array fp and fxy are two separate arrays in the memory. The array fp stores partial derivatives F x  and F y . Array dfxy stores partial derivatives F xy  for each the subfunction. 
     The circuit for generating that value of the Boolean function for the corresponding plurality of inputs comprises a memory and a processor circuit which generates the Boolean function F in the memory and processor circuit as modeled by the equation: 
     
         F(v)=F(0)⊕dF(v) 
    
     where v is a data vector having as its elements the plurality of inputs. 
     The circuit for generating a plurality total derivatives according to a predetermined rule comprises a memory and processor circuit and generates the total derivatives for each subfunction by circuit modeled by equation: 
     
         dF=(dx*F.sub.x)⊕(dy*(F.sub.y ⊕(dx*F.sub.xy))). 
    
     The circuit for combining the plurality of total derivatives, partial derivatives and inputs in a tree structured organization to generate a total derivative of the Boolean function comprises a memory and a processor circuit wherein the tree structured organization is a full binary tree. 
     The memory and full binary tree is organized in the memory from an array df, an array fp, and an array fxy. Array df stores total derivatives of each of the subfunctions corresponding to each node in the tree. Array fp stores partial derivatives F x  and F y  corresponding to each node in the tree. Array fxy stores partial derivatives F xy  corresponding to each node in the tree. 
     The invention is also a method of processing a Boolean function comprised of a plurality of Boolean subfunctions in a memory and processing circuit comprising the step of initializing the memory and processing circuit by evaluating in the processing circuit the Boolean function for all independent variables set to 0 to define an initialized value of the Boolean function. The step of initializing includes the step of determining in the processing circuit partial derivatives for each the subfunction of the Boolean function. The initialized value of the Boolean function and partial derivatives are stored in the memory. The method continues with the step of evaluating in the processing circuit a total derivative of each subfunction. This is accomplished by generating a total derivative of each the subfunctions according to a predetermined method of operating the processing circuit. Each subfunction is related to other ones of the subfunctions by a tree structure to the Boolean function. The step of evaluating includes the step of obtaining in the processing circuit an evaluation of the Boolean function from a total derivative of the Boolean function from the tree by circuit modeled by the equation: 
     
         F(v)=F(0)⊕dF(v) 
    
     where F is the Boolean function, v a vector having a plurality of independent variables as elements, and dF the total derivative of the Boolean function from the tree. 
     In one embodiment the predetermined method of operating the processing circuit to generate a total derivative of each the subfunctions operates the processing circuit so that its operation is modeled by the equation: 
     
         dF=F.sub.x dx⊕F.sub.y dy⊕F.sub.xy dx dy. 
    
     In another embodiment the predetermined method of operating the processing circuit to generate a total derivative of each the subfunctions operates the processing circuit so that its operation is modeled by the equation: 
     
         dF=dx dy F.sub.y +dx dy F.sub.x +dx dy (F.sub.x ⊕F.sub.y ⊕F.sub.xy). 
    
     In still another embodiment the predetermined method of operating the processing circuit to generate a total derivative of each the subfunctions operates the processing circuit so that its operation is modeled by the equation: ##EQU3## 
     In still another embodiment the predetermined method of operating the processing circuit to generate a total derivative of each the subfunctions operates the processing circuit so that its operation is modeled by the equation 
     
         dF=(dx*F.sub.x)⊕(dy*(F.sub.y ⊕(dx*F.sub.xy))) 
    
     The step of evaluating is repeated for each new set of independent variables for which the Boolean function is evaluated. 
     The step of generating a total derivative of each the subfunctions according to a predetermined method of operating the processing circuit comprises the step operating a plurality of separate processing subcircuits. The plurality of subcircuits are organized into a tree circuit. 
     The step of generating a total derivative of each the subfunctions according to a predetermined method of operating the processing circuit comprises the step operating a central processing circuits and memory where a plurality of arrays are defined in the memory for storing independent variables, total derivatives of each of the subfunctions, and partial derivatives of each of the subfunctions. The plurality of subcircuits are organized into a tree circuit. The central processing circuit operates upon the arrays to relate elements of the arrays in a tree relationship using the predetermined method for relating each element in that one of the arrays for storing total derivatives to other elements in the one array. 
    
    
     The invention and its various embodiments are better visualized by now turning to the following drawings where like elements are referenced by like numerals. 
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIG. 1 is a symbolic depiction of the methodology of the invention as practiced at a single node. 
     FIG. 2 is a symbolic depiction of the methodology of the invention as practiced within a portion of a tree network which is used for an arbitrarily complex Boolean function. 
     FIG. 3 is a tree structure for implementing the processing of the Boolean example shown in equation 7. 
     FIG. 4 is a diagrammatic depiction of a processing element used at a node in a tree structure according to the invention. 
     FIG. 5 is a diagrammatic depiction of an arbitrarily large tree structure for processing complex Boolean functions according to the invention. 
     FIG. 6 is a block diagram of the combination of a host computer and a tree structure in which the invention may be implemented in a first class of embodiments. 
     FIG. 7 is a schematic of a CMOS switch used in a first embodiment of the processing elements. 
     FIG. 8 is a schematic of the first embodiment of one of the processing elements in which the switch of FIG. 7 is used. 
     FIG. 9 is a schematic of a second embodiment of one of the processing elements. 
     FIG. 10 is a diagram showing the form of an array for the arrays df, dfp and dfxy. 
     FIG. 11 is a flow diagram of the methodology where the total derivatives are generated in a general purpose computer. 
     FIG. 12 is a flow diagram of the INITIALIZE routine of FIG. 11. 
     FIG. 13 is a flow diagram of the EVALUATE routine of FIG. 11. 
     FIG. 14 is a block diagram of a circuit for performing the methodology shown in the flow diagrams of FIGS. 11-13. 
    
    
     The invention can better be understood by now turning to the following detailed description. 
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS 
     Arbitrary and complex Boolean functions can be evaluated at high speed and with a minimal amount of memory by evaluating the total derivatives of the subfunctions out of which any given Boolean function is built. The Boolean function is then generated from its total derivative. The total derivative of any binary or two input Boolean function is defined by a method dependent only on the inputs and the partial derivatives of the subfunction. By combining the subfunctions in a binary tree, a Boolean function of any complexity can be built up. By using a full binary tree structure in a processing circuit or memory organization, the method is generalized to accommodate all possible Boolean functions. A processing element may be devised to generate the total derivative of each subfunction in a tree circuit of such processing elements, or arrays may be defined in a general purpose computer and elements in the array generated according to a processing methodology which assumes a tree relationship between elements in the array. 
     The invention is based on the total differential of a Boolean function. As will be described below this enables fast processing of Boolean functions in a small, general purpose computer under software control. An efficient process is described that implements the methodology with bit-level parallelism. Numerous sample process runs summarized in Table 3 below show that, compared to conventional techniques, an order of magnitude of performance improvement and an order of magnitude of memory space reduction is realized. 
     
                       TABLE 1                                                     
______________________________________                                    
Partial derivatives Fx, Fy and Fxy                                        
for all Boolean Functions of Two Variables                                
F         F.sub.x       F.sub.y                                           
                              F.sub.xy                                    
______________________________________                                    
0         0             0     0                                           
xy        y             x     1                                           
x- y      - y           x     1                                           
x         1             0     0                                           
- xy      y             - x   1                                           
y         0             1     0                                           
x ⊕ y 1             1     0                                           
x + y     - y           - x   1                                           
- x - y   - y           - x   1                                           
x ≡ y                                                               
          1             1     0                                           
- y       0             1     0                                           
x + - y   y             - x   1                                           
- x       1             0     0                                           
- x + y   - y           x     1                                           
- x + - y y             x     1                                           
1         0             0     0                                           
______________________________________                                    
 
    
     The invention is also implemented in a tree network structure with identical processing elements, each performing the total differential of a Boolean function. Two efficient hardware architectures for the processing elements are illustrated that permit cost-effective and real-time applications. The present invention is capable of processing an arbitrary Boolean function of any given depth, i.e. regardless of how many steps are required to break the function down to the single input variables. The disclosed network has the ability to process any Boolean function by dynamically reconfiguring its processing element&#39;s functionality. According to the invention an arbitrary Boolean function of two variables can be specified by only three bits, instead of the four bits required in the traditional approach. As will be seen this significantly reduces the hardware costs and increases the speed of processing. 
     First, a brief outline of Boolean calculus will be helpful in understanding how the concept is implemented in a machine and in a machine process. The total differential has been developed as a part of classical Boolean differential calculus. This calculus has been applied in various areas of circuit design, such as in hazard or fault detection, Boolean function decomposition, and circuit synthesis. 
     In traditional methods, Boolean functions are directly processed based on the function values themselves. According to the invention the total differentials of Boolean functions are used instead of using function values. The total differential, dF, of a Boolean function F is defined as the difference in the function value due to the difference in input values. For a Boolean function F(x,y) of two variables, x and y, for example, the total differential is defined in terms of the differences in input, dx and dy, as: 
     
         dF=F.sub.x dx⊕F.sub.y dy⊕F.sub.xy dx dy,           (2) 
    
     where F x , F y  and F xy  are the partial derivatives of F with respect to x, y and xy respectively. The symbol ⊕ represents an exclusive-or operation. 
     The partial derivative of F with respect to z, where z can be either x or y, is defined as: 
     
         F.sub.z =F(x,y;z=1)⊕F(x,y;z=0). 
    
     Function F z  is obtained by the exclusive-or operation between two functions. The two functions are formed from F by setting z once to 0 and once to 1 in F(x,y). For example, F x  and F y  for the OR function, i.e., a+b, are calculated in the following way: 
     
         F.sub.x =(x+y)⊕(x+y)=y⊕1=y                         (3) 
    
     
         F.sub.y =(x+y)⊕(x+y)=x⊕1=x                         (4). 
    
     The value of F xy  is obtained from F by taking a partial derivative of F x  with respect to y. Values of partial derivatives F x , F y  and F xy  for all possible Boolean functions of two variables are calculated in the same way and the results are shown in Table 1 above. 
     Consider now a conceptual model of how an arbitrary Boolean function can be processed in a tree structure. Let F(x,y) be an arbitrary Boolean function of two variables and let x and y be dependent variables, i.e., x=G(x1, x 2 ) and y=H(y 1 , y 2 ). The total differentials of x and y, namely dG and dH, can be supplied as inputs to evaluate the total differential dF as symbolically depicted in FIG. 1 and specifically as set forth below. 
     
         dF(G(x.sub.1, x.sub.2),H(y.sub.1, y.sub.2))=F.sub.x dG(x.sub.1,x.sub.2)⊕F.sub.y dH(y.sub.1,y.sub.2)⊕F.sub.xy dG(x.sub.1,x.sub.2)dH(y.sub.1,y.sub.2)                    (5) 
    
     It follows from Equation (5) that the function values of G(x 1 , x 2 ) and H(y 1 , y 2 ) are not needed to calculate dF. The values of total differentials dG and dH are sufficient to evaluate dF. Therefore to process a Boolean function, we can use total differentials instead of the values of the functions themselves. Since total differentials in Equation (5) represent the total differentials between input and output, they can be combined in a tree network structure to process arbitrary complex Boolean functions as diagrammatically shown in FIG. 2. Equation (5) is performed at each node in this tree network. 
     Besides total differentials dF, dG and dH, Equation (5) includes values of partial derivatives F x , F y  and F xy . In general, these partial derivatives are not constant, and their values will depend on inputs to the function. The following two stage process uses the values of F x , F y  and F xy  which can be treated as constants. The two stages in the processing of a Boolean function F are: (1) initialization and (2) evaluation. 
     During the initialization stage, the function is processed with all the independent variables set to 0. The result is an initial value, denoted as F(0). Next, the partial derivatives are calculated for all subfunctions in the function F. Partial derivatives of a subfunction are obtained from inputs to the subfunction, according to Table 1 above. The values of inputs are calculated during the generation of F(0). The initialization stage thus determines the initial value F(0) and partial derivatives for all subfunctions. 
     During the evaluation stage, the total differential dF(v) for an input vector, v, which is simply a n-tuple of input variables, is calculated from the total differentials of subfunctions using Equation (2). The calculation is performed in a bottom-up fashion, starting with independent variables. Because the initial value F(0) is calculated with independent variables set at 0, the total differential dx of an independent variable x is equal to its value, i.e., x=dx. After the total differential dF(v) is calculated, the final function value F(v) can be obtained by an exclusive-or between F(0), the initial value of function F, and dF(v), the total differential of function F for input vector v. 
     
         F(v)=F(0)⊕dF(v)                                        (6) 
    
     After initialization stage, the evaluation stage of the method can be repeated for an arbitrary number of inputs. The three partial derivatives for each subfunction in the function F, i.e., Fx, Fy and Fxy remain constant during the evaluation stage. They serve as the three parameters in Equation (2) that specify the functionality of a Boolean function being processed. Any one of the sixteen Boolean functions can be specified by these three values. 
     With the above concepts in mind, consider now how the process will be implemented in a tree structure. As an example, let E be the following Boolean function with eight input variables: 
     
         E(x,y,z,t,u,v,w,s)=(x y+z t)⊕((u.tbd.v) (w+s)).        (7) 
    
     Any other function could have been chosen equally as well to concretely illustrate the concept in modeled form and no significance should be attached to the specific form of E. 
     As stated above the methodology is performed in two stages, the initialization stage and the evaluation stage. During the initialization stage, initial value E(0,0,0,0,0,0,0,0) and partial derivatives for all subfunctions are calculated. The evaluation stage processes E for a specific input word. 
     The first step of the initialization stage is to break E down into its subfunctions, i.e., sets of Boolean functions of two variables. Function E can be easily represented as a tree structure as shown in FIG. 3. 
     
         E(G, H)=G⊕H 
    
     
         G(I, J)=I+J 
    
     
         H(K, L)=KL 
    
     
         I(x, y)=xy 
    
     
         J(z, t)=zt 
    
     
         K(u, v)=u.tbd.v 
    
     
         L(w, s)=w+s 
    
     During the second step we compute the function values with their independent variables being 0: 
     
         I(0,0)=1, 
    
     
         J(0,0)=0, 
    
     
         K(0,0)=1, 
    
     
         L(0,0)=1, 
    
     
         G(I,J)=0, 
    
     
         H(K,L)=1, 
    
     
         E(G,H)=1. 
    
     This step produces the initial value E(0,0,0,0,0,0,0,0). 
     In the third step the partial derivatives for each Boolean function are computed from the values of its inputs, according to Table 1. The detailed calculations for G x , G y  and G xy  are: 
     
         G(I,J)=I+J=IJ 
    
     
         G.sub.x =y=G.sub.I =J=1 
    
     
         G.sub.y =X=G.sub.J =I=0 
    
     
         G.sub.xy =G.sub.IJ =1 
    
     Similarly, we compute partial derivatives for functions E, H, L, K, J and I. Partial derivatives for all functions in Boolean function E are shown in Table 2. This concludes the initialization stage. 
     
                       TABLE 2                                                     
______________________________________                                    
Partial Derivatives of the function of Equation 7                         
F        F.sub.x       F.sub.y                                            
                             F.sub.xy                                     
______________________________________                                    
E        1             1     0                                            
G        1             0     1                                            
H        1             1     1                                            
I        0             0     1                                            
J        0             1     1                                            
K        1             1     0                                            
L        1             0     1                                            
______________________________________                                    
 
    
     Once partial derivatives are calculated, they do not change while the value of E is being processed for different input values. 
     The total differential of independent variables is equal to their value, i.e., x=dx, y=dy, . . . , and s=ds. The total differentials for functions I, J, K, L, G, H and E are: 
     
         dI=I.sub.x x⊕I.sub.y y⊕I.sub.xy x y=0*1⊕0*0⊕1*1*0=0 
    
     
         dJ=J.sub.x z⊕J.sub.y t⊕J.sub.xy z t=0*1⊕1*0⊕1*1*0=0 
    
     
         dK=K.sub.x u⊕K.sub.y v⊕K.sub.xy u v=1*1⊕1*0⊕0*1*0=1 
    
     
         dL=L.sub.x w⊕L.sub.y s⊕L.sub.xy w s=1*1⊕0*0⊕1*1*0=1 
    
     
         dG=G.sub.x dI⊕G.sub.y dJ⊕G.sub.xy dI dJ=1*0⊕0*0⊕1*0*0=0 
    
     
         dH=H.sub.x dK⊕H.sub.y dL⊕H.sub.xy dK dL=1*1⊕1*1⊕1*1*1=1 
    
     
         dE=E.sub.x dG⊕E.sub.y dH⊕E.sub.xy dG dH=1*0⊕1*1⊕0*0*1=1 
    
     Since the total differential dE(1,0,1,0,1,0,1,0) is defined as the difference between E(1,0,1,0,1,0,1,0) and E(0,0,0,0,0,0,0,0), the value of E(1,0,1,0,1,0,1,0) is obtained by an additional exclusive-or of both: 
     
         E(1,0,1,0,1,0,1,0)=E(0,0,0,0,0,0,0,0)⊕dE(1,0,1,0,1,0,1,0)=1⊕1=0 
    
     The total differential of a Boolean function of two variables, as represented in Equation (2), is the operation performed in a node in the tree network. Consider now a processing element for a node in the tree network, how the network based on such processing elements is constructed, and how the entire network is interfaced with a host computer. 
     The processing element (PE) carries out the computation of the total differential in Equation (2). There are six signals input to every processing element as diagrammatically depicted in FIG. 4: 
     two inputs, dx and dy; 
     one output, dF; and 
     three control signals, F x , F y  and F xy . 
     The outputs of two processing elements can be used as a pair of inputs to another processing element at a higher level in the tree network. As diagrammatically depicted in FIG. 5 an arbitrarily large tree network of processing elements is constructed to process arbitrarily complex Boolean functions. Inputs of the first processing elements at the bottom-most level of the tree are used to supply values of independent variables. Output from the topmost processing element provides the total differential of the entire Boolean function. All the processing elements on the same level of the tree can be evaluated in parallel. 
     Processing of Boolean functions is performed in two stages. A host computer 10 including a memory 11 illustrated in FIG. 6 performs the initialization stage. The tree network 14 of processing elements performs the evaluation stage. The tree network 14 and the host computer 10 are interfaced through either a simple special-purpose hardware chip, or a commercial interfacing chip 12 (e.g., an interface controller) which is coupled to host computer 10 through bus 13. The data/control or communication between Interface controller 12 and tree structure 14 is conducted by conventional handshake control. 
     In case of using a special-purpose interface controller, this controller can be easily designed and implemented using a finite state machine (FSM). This interface controller can be implemented as a part of the tree network. A FSM controller 12 is connected to both host computer 10 and tree network 14 through the system control bus 15 as shown in FIG. 6. 
     As discussed below there are eight control signals, four inputs into FSM controller 12 and four outputs of controller 12, which form the conventional handshake control between the host computer (i.e., host) and the tree network (i.e., tree). The basic control scheme consists of the following four steps: 
     1) When host computer 10 finishes the first stage initialization, it sends a signal, INVOKE-TREE (i.e., a logic &#34;high&#34;) to FSM controller 12. FSM controller 12 correspondingly sends a TREE-INITIALIZATION signal (a logic &#34;high&#34;) to tree network 14 to initialize the network for computation. 
     2) When tree network 14 is ready (e.g., it finishes the last computation and is ready to accept data for a new computation), tree network 14 sends back a signal, TREE-READY (i.e., a logic &#34;high&#34;) to FSM controller 12. FSM controller 12 thus sends host computer 10 a signal, READY (a logic &#34;high&#34;) to inform host computer 10 to release the initialization stage results to tree network 14. 
     3) When the tree network finishes its computation, it sends a signal, TREE-WORK FINISHED (i.e., a logic &#34;high&#34;) to FSM controller 12. FSM controller 12 then sends a signal, FINISHED (a logic &#34;high&#34;) to host computer 10 to inform host computer 10 to be ready to accept the final results from tree network 14. 
     4) When host computer 10 receives a FINISHED signal, it will prepare itself to accept the results. If it is ready, it issues signal SEND RESULTS (i.e., a logic &#34;high&#34;) to FSM controller 12. FSM controller 12 then informs tree network 14 to release the final computing results back to host computer 10 through system data bus 13. 
     In a first embodiment illustrated in FIG. 8 the processing element uses five switches and two inverters which contain a total of 14 transistors. Equation (2) for the total differential includes two instances of exclusive-or operation. Since the implementation of exclusive-or operation in CMOS is relatively expensive, the model of Equation (2) is transformed in the illustrated embodiment into a logically equivalent form: 
     
         dF=dx dyF.sub.y +dx dyF.sub.x +dx dy(F.sub.x ⊕F.sub.y ⊕F.sub.xy)(8) 
    
     This Equation (8) leads to an efficient implementation with less expensive logic switches. The two transistor switch 20, S(a,c) of FIG. 7 performs a function modeled by: 
     
         S(a,c)=ac. 
    
     This function is implemented in two transistors 16 and 18 as shown in FIG. 7. The general equation (8) is then implemented with five switches 20 as: 
     
         dF=S(S(F.sub.y, dx)+S(F.sub.x ⊕F.sub.y ⊕F.sub.xy, dx), dy)+S(S(F.sub.x, dx), dy) 
    
     as shown in FIG. 8. Two additional inverters are required to calculate dx and dy. The value F x  ⊕F y  ⊕F xy  is a constant for a given Boolean function. It is precalculated by host computer 10. In Equation (2), one of the control signals is F xy . In this new formulation, the original control signal, F xy , is replaced by F x  ⊕F y  ⊕F xy . 
     In a second embodiment illustrated in FIG. 9 the processing element uses three, 3-input NOR gates and two inverters, which contain a total of 22 transistors. In this case, the general equation for the total differential is transformed to: ##EQU4## The values of F x , F y , and F x  ⊕F y  ⊕F xy  are supplied as control signals by the host computer 10 instead of being control signals in the original process, based on Fx, Fy and Fxy. A circuit in CMOS that implements Equation (9) is shown in FIG. 9 and is exactly modeled by equation 9 as three circuit blocks corresponding to the three quantities which are combined by the OR function. 
     The above implementations minimize the number of inputs and outputs. Different variations are possible, such as reducing the number of transistors at the expense of more I/O signals, or reducing the computing time at the expense of more I/O signals and more transistors. Each of these possible variations must be expressly understood as included within the scope of the invention. 
     The implementation of the process in a general purpose computer under software control is described below. Equation (1) for the total differential can be directly expressed in a programming language that supports parallel bit-wise Boolean operations. That is, a word may be acted upon as a unit, each bit of which corresponds to a different set of input values. Using the symbol * to represent Boolean AND operation and the symbol + to represent Boolean exclusive-or operation, Equation (1) is expressed as: 
     
         dF=(dx*F.sub.x)⊕(dy*(F.sub.y ⊕(dx*F.sub.xy)))      (10) 
    
     The values of F x , F y  and F xy  are precalculated for each Boolean function of two input variables during the initialization stage. According to the invention the processing of a Boolean function of two variables involves the following: 
     five operands: dx, dy, F x , F y  and F xy  ; 
     three Boolean AND operations; 
     two Boolean exclusive-or operations; and 
     the result dF. 
     Assume for example that a computer word is 32 bits in length. Traditionally, an entire computer word is used to process one Boolean function. For example, the expression in Equation (10) produces only one result. Normally, a computer does bit-wise AND and bit-wise exclusive-or operations on the word (e.g., 32 bits) in one instruction. In our implementation, we take advantage of this machine feature to increase execution speed and reduce memory space. 
     Using traditional techniques, the code to calculate dF in Equation (10) produces one result. In contrast in the invention all the bits of an entire word are used to simultaneously process 32 Boolean functions. If the ith bit in the operands is initialized to represent the ith Boolean function, then the ith bit of dF will be the result of the ith total differential Boolean function. All 32 Boolean functions in one word are completely independent. Gain in execution speed and memory reduction are proportional to the length of a computer word. In general, on an N-bit computer, N Boolean functions can be processed simultaneously with the same memory requirement and in the same execution time interval as in the traditional techniques. 
     Arbitrarily large Boolean functions are processed by feeding the output of one stage to the input of the next stage. Any Boolean function can be represented by a binary tree data structure as described in connection with FIG. 3. Each node in a binary tree is connected to at most two children or lower level nodes. A binary tree of depth k is called a full binary tree if it has 2 K  -1 nodes. For example, the tree in FIG. 3 is a full binary tree of depth four and it contains 15 nodes. 
     In the following discussion, assume that all 32 Boolean functions to be evaluated are represented as full binary trees of the same depth. A binary tree that is not full can always be transformed to a full binary tree. This can be done by attaching redundant nodes to make the tree full. These redundant nodes do not affect the result of the original Boolean function. They are used only for passing along input values without modification. The 32 Boolean functions, represented as 32 full binary trees of the same depth, are grouped and processed simultaneously. This offers maximum efficiency in the process. Less efficiency may occur when trees are not full. 
     A binary tree can be stored in a memory structure or organization called a heap. A heap is a tree data structure represented by an array. The nth element of an array a is denoted as a[n]. In a heap, element a[j] has two children, elements a[2j] and a[2j+1]. The highest level of a heap has index, j=1. See the heap with depth 4 shown in FIG. 10. 
     Three heaps are needed to process arbitrary Boolean functions. The heaps are denoted as array df, array fp and array fxy, where N is the number of input variables; df is the array of total differentials dx, dy, dF; fp is the array of the partial differentials F x  and F y ,; and fxy is the array of the partial differentials F xy . 
     For Boolean functions with N inputs, the total differentials, i.e., dF, dx and dy in Equation (1), are represented by heap df with 2*N-1 array elements. This includes the ultimate result dF at df[1], the intermediate or lower level dF&#39;s from the lower nodes and the N input variables. The elements df[N] to df[2*N-1] of the heap df contain the values of independent input variables. Intermediate total differentials are stored in elements df[2] to df[N-1. The element df[1] contains the final total differential for each of the Boolean functions in the 32 bit word. 
     The values of partial derivatives F x  and F y  for all subfunctions are stored in the heap fp which has 2*N-1 array elements. The values of a partial derivative F xy  for all subfunctions are represented by the heap fxy with N-1 elements. 
     Each array element requires 32 bits since it is assumed in the illustrated embodiment that parallel bit processing is being practiced to simultaneously evaluate 32 Boolean functions. To evaluate a total differential dF for a Boolean function that is designated in the ith bit of the jth element in df[j], j=1,2, . . . , N-1, the values in Equation (10) are placed according to the invention as follows: 
     
         dx is placed in the ith bit of df[2*j]; 
    
     
         dy is placed in the ith bit of df[2*j+1]; 
    
     
         F.sub.x is placed in the ith bit of fp[2*j]; 
    
     
         F.sub.y is placed in the ith bit of fp[2*j+1]; 
    
     
         F.sub.xy is placed in the ith bit of fxy[j]; and 
    
     
         the result is placed in the ith bit of df[j]. 
    
     FIG. 11 is the flow chart of a methodology to process any Boolean function using these memory array assignments. The methodology depicted is performed in the circuit of FIG. 14 which is a general purpose computer circuit wherein the memory has been organized according to the invention. The computer circuit comprises a conventional central processing unit (CPU) 42 coupled by means of bus 48 to a conventional input/output device or devices 46 and to a memory 44 having the arrays described below defined therein. 
     In FIG. 11 two main subroutines, INITIALIZE and EVALUATE, perform initialization stage and evaluation stage processes as described above. The subroutines, INITIALIZE, initializes all three heaps, df, fp and fxy. The value of the 32 Boolean functions with all their independent inputs being 0 are put in the 32 bits of element df[1] at step 22. The value of df[1] is stored in the variable, TD, at step 24. After the initialization stage, the functions are processed for each new set of inputs. The subroutine NEWINPUT sets all 32 bits of the elements df[N] through df[2*N-1] to the new values of the inputs at step 26. The core of the process is the subroutine EVALUATE at step 28 which stores the total differential results in the 32 bits of element df[1]. Because the result represents a difference from initial values, see Equation (5), an exclusive-or operation is performed on the corresponding 32 bits in TD in step 30 and the corresponding 32 bits in df[1]. The final results are stored in 32 bits of the variable, RESULT which is the value of the 32 Boolean functions corresponding to the input values assumed. Each bit in the variable, RESULT, is a value of one Boolean function for the given set of input variables. After initialization, the evaluation stage can be repeated for an arbitrary number of times to process Boolean functions for different inputs. 
     The subroutine, INITIALIZE, is diagrammatically depicted in the flowchart of FIG. 12. The subroutine generates the value of all Boolean functions being processed when all of the inputs are set equal to 0, and initializes heaps fp and fxy. The subroutine, COMPUTE, at step 32 processes all Boolean functions with their independent variables being set equal 0. This can be done by any conventional method. The subroutine, COMPUTE, at step 32 stores the 32 final values of the Boolean expressions in 32 bits of element df[1] and in the process of evaluating df[1] for the initial 0 inputs, stores the initialized values of the subfunctions or lower level values of the binary tree in elements df[2] to df[N-1]. These intermediate results or subfunctions will be overwritten in heap df at step 28. The inputs, being 0 in this case, are stored in elements df[N] through df[2*N-1]. These initialized input values will also be overwritten in step 26. 
     The subroutine SET at step 34 in FIG. 12 initializes heaps fp and fxy by storing F x , F y  and F xy  of Equation (10), corresponding to the subfunctions of heap df and the partial derivatives in Table 1. 
     The subroutine, EVALUATE, calculates dF for the elements df[N-1] to df[1] by applying Equation (10), as described in FIG. 13. For example, the indices x and y are initialized at steps 36 and 38. The heap elements df[j] are calculated from Equation (10) using the then stored contents of heaps df, fp and fxy corresponding to the input variables, F x , F y , and F xy  as discussed above until df[N-1] through df[1] have been computed. 
     An optimization technique could be applied for Boolean functions that contain a large number of subfunctions. Since the total differential represents the change in the function value, further function processing can be stopped if this change is 0. For example, if both operands df[x] and df[y] in FIG. 13 are 0, then the result df[f] in FIG. 13 will also be 0. The calculation can be terminated, as soon as all unprocessed inputs become 0. This earlier termination of further redundant processing, as soon as both input total differentials of a Boolean function are 0, can save a great deal of computing time. 
     In the illustrated embodiment, the methodology has been run on a machine that has a 32-bit 25 Mhz Motorola 68030 Microprocessor. The machine performance is estimated at about 3.5 MIPS (million instructions per second). 
     
                                           TABLE 3                                 
__________________________________________________________________________
Performance Measurements on a Machine with a 25 Mhz                       
Motorola 68030 Microprocessor; all data are the average                   
of five runs (Time Units: seconds).                                       
Number of                                                                 
      Number of                                                           
            Number of                                                     
                  Number of                                               
                        Number of Times the Same                          
Boolean                                                                   
      Input Different                                                     
                  Input Function Was Evaluated                            
Functions                                                                 
      Variables                                                           
            Functions                                                     
                  Vectors                                                 
                        0  10  20 30  MBOPS                               
__________________________________________________________________________
32      8   32    1024  5.7                                               
                           12.92                                          
                               20.05                                      
                                  27.42                                   
                                      10.14                               
32     64   16    256   6.65                                              
                           14.91                                          
                               23.03                                      
                                  31.39                                   
                                      9.98                                
32     512   8    64    11.77                                             
                           20.23                                          
                               28.93                                      
                                  37.19                                   
                                      9.88                                
32    4096   4    16    32.72                                             
                           41.45                                          
                               49.87                                      
                                  57.95                                   
                                      9.97                                
__________________________________________________________________________
 
    
     Sample program runs and measurements have been performed on a large number of random Boolean functions of various sizes. The results are shown in Table 3. Column 1 shows that the number of Boolean Functions which was the number of top level or highest complexity Boolean functions in the run. Since each word in a machine in our example contains 32 bits, 32 Boolean functions were processed in all cases. 
     Column 2 shows the number of input variables in each top level Boolean function. Since top level Boolean functions are represented by the full binary trees, a top level Boolean function with N inputs has N-1 Boolean subfunctions. 
     Column 3 shows how many different random Boolean functions were generated. 
     Column 4 shows the number of randomly generated input vectors applied to each Boolean function. The total number of Boolean functions of all levels of complexity processed in each row in Table 3 can be calculated as the product of the number of Boolean functions times the number of input variables-1 times the number of different functions times the number of input vectors. The total number of functions processed per second is shown in column 6. 
     Column 5 shows the number of times the same function was processed, i.e., 0, 10, 20 and 30, i.e. the number of times that function processing was repeated. They are in multiples of ten. This repetition was necessary to increase the measurement accuracy since one execution takes only a small time period. Values under these four subcolumns are the measurement results in seconds. They were averaged over five runs. The column with 0 repetitions or processing shows the time spent on the initialization stage and on the generation of random functions and random input values. 
     Column 6 shows the millions of Boolean function operations per second, MBOPS, which was measured. The values for MBOPS are calculated as the total number of Boolean functions times 30, the maximum number of repeated processing, divided by the time to perform 30 processing. For example, the MBOPS value in the first row is calculated as: 32×(8-1)×1024×32×30/(27.42-5.7)sec -1  =10.14 MBOPS. 
     This rate is an order of magnitude faster than previously used Boolean evaluation processes. A similar examination of the required memory usage also shows a decrease of an order of magnitude in the memory required to perform the processing. 
     Many alterations and modifications can be made by those having ordinary skill in the art without departing from the spirit and scope of the invention. For example, several examples of implementing the methodology based on the definition of the total derivative have been described. However, these illustrated embodiments do not exhaust all the possible ways in which the same basic methodology may be implemented either in custom hardware or in a general purpose computer. Therefore, it must be understood that the illustrated embodiments are set forth only for the purposes of example and clarity of illustration and do not limit the invention defined in the following claims, which include all equivalents and means for performing substantially the same function to get the same result even in a substantially different way.