Author's personal copy
Information Sciences 180 (2010) 288–300
Contents lists available at ScienceDirect
Information Sciences
journal homepage: www.elsevier.com/locate/ins
Solution of systems of Boolean equations via the integer domain
Ahmed H. Abdel-Gawad, Amir F. Atiya *, Nevin M. Darwish
Department of Computer Engineering, Cairo University, Giza, Egypt
a r t i c l e
i n f o
Article history:
Received 2 March 2008
Received in revised form 8 September 2009
Accepted 18 September 2009
Keywords:
System of Boolean equations
Boolean variables
Automatic test-pattern generation
Multivariate polynomials
Fast polynomial multiplication
a b s t r a c t
This paper presents a new method for solving systems of Boolean equations. The method is
based on converting the equations so that we operate in the integer domain. In the integer
domain better and more efficient methodologies for solving equations are available. The
conversion leads us to a system of polynomial equations obeying certain characteristics.
A method is proposed for solving these equations. The most computationally demanding
step is the repeated multiplication of polynomials. We develop a method for this problem
that is significantly faster than the standard approach. We also introduce another variant of
the method, the so-called hybrid approach, that leads to reduced memory requirements.
Theoretical and experimental results indicate the superior performance of the proposed
method and its variant compared to the competing methods. The proposed method is also
validated by applying it to the problem of hardware verification.
Ó 2009 Elsevier Inc. All rights reserved.
1. Introduction
Since many decades during the history of digital science, Boolean variables have been the basic variables of use in the
majority of the computer operations. Many basic problems involving Boolean variables are encountered, and some problems,
in spite of the maturity of the field, do not have satisfactory solution methods. Among these is the problem of solving simultaneous Boolean equations. Existing methods for this NP-complete problem are far from satisfactory and do not improve
much over exhaustive methods. This problem has many applications such as the synthesis, simulation and testing of digital
networks and VLSI systems, output encoding and state assignment of finite state machines [2], timing analysis and delayfault test generation for combinational circuits [8], automatic test-pattern generation [6], and the determination of the initial
state in circuits containing feedback loops. In the field of Cryptography, it has applications in the analysis and breaking of
block ciphers as they can be reduced to the problem of solving a large-scale system of Boolean equations.
In this paper, we propose an efficient method for solving systems of Boolean equations. Rather than confining ourselves to
the Boolean domain, our idea is to convert the problem so that we operate in the integer domain. The integer domain is a
richer domain to work with, as algorithms there are well-developed. Then, we pose the problem as that of solving a set
of simultaneous multivariate polynomial equations; and develop a new fast algorithm for solving such equations.
Several approaches have been proposed in the literature for the problem of solving simultaneous Boolean equations. All
these methods operate in the Boolean domain. The simplest approach, based on Karnaugh maps, performs successive elimination of the variables in the equations [13,14]. This method utilizes ‘‘don’t care” and ‘‘can’t happen” conditions to aid in
obtaining the solution. Another efficient algorithm for variable elimination is through function decomposition of Boolean
functions represented by the so-called binary decision diagrams (BDD’s) [17]. In [10], a pure algebraic method is presented.
In [16,11,15], a new graph-like representation for the Boolean equations is proposed. Furthermore, they propose certain
* Corresponding author.
E-mail addresses: [email protected] (A.H. Abdel-Gawad), [email protected] (A.F. Atiya), [email protected] (N.M. Darwish).
0020-0255/$ - see front matter Ó 2009 Elsevier Inc. All rights reserved.
doi:10.1016/j.ins.2009.09.010
Author's personal copy
A.H. Abdel-Gawad et al. / Information Sciences 180 (2010) 288–300
289
operations that deal with this representation, and lead to a solution for the system of equations. A tabular representation for
sets of Boolean vectors is proposed in [11]. In this approach they propose a separation between overlapping product terms in
the tables in a way to decrease the complexity of the Boolean operations. Subsequently, [16] suggest modifying the tabular
representation to the case of ordered BDD representation. This is performed while still making use of the separation between
the product terms. Separation means removing the redundancies in the Boolean expressions. Redundancies occur in situations when a minterm can be embedded in an expression without altering the values of the expression. The OR operation is a
clear example for this redundancy as y1 þ y2 has the minterm y1 y2 common between each of the two terms. They will then
1 y2 (see [16]). In fact, this redundancy is one of the main aspects differentiating the Boolean domain
be separated to y1 þ y
from the integer (or the real) domain. In [12], a genetic algorithm is proposed for solving systems of Boolean equations. There
are approaches that solve a fragment of systems of Boolean equations like the class of stratified systems of Boolean equations. These are specific fixed-point equations where the variables are interspersed in the equations in a way that simplifies
the computation of the solution [4,5]. Other methods rely on presenting a characteristic set method for solving the Boolean
equations. They rely on a disjoint and monic zero decomposition algorithm for the zero set of a system of Boolean equations.
They give a formula for the number of solutions of the system [1].
The rest of this paper is organized as follows: Section 2 presents the proposed solution of the system of Boolean equations.
It also describes the new algorithm for fast multivariate polynomial multiplication. Section 3 presents another variant of the
algorithm, the so-called hybrid model. Section 4 gives a complexity analysis of the different components of the proposed
solution. In Section 5 simulation results are presented to verify the complexity analysis formulas and to prove the scalability
of this method. Finally, Section 6 gives the conclusion of this work.
2. Solution of systems of Boolean equations
We introduce here few definitions, where we will closely follow the terminology in [16]: let B ¼ f0; 1g. The Boolean product domain Bn is the n-fold product of B. A minterm is an instance of the Boolean space Bn . A variable is a symbol representing
a single coordinate of Bn . A literal is a variable yi or its negation yi .
Assume we have n Boolean equations. Rather than confining ourselves to the Boolean domain, we consider the integer
domain, as it can give new effective methods of solution. Let us call the proposed method the Integer Solution of Boolean
Equations (ISBE). Let xi 2 Z be the integer equivalent of the binary yi . The Boolean operations of AND, OR, and negation
are equivalent to the following in the integer domain:
y 1 y 2 x 1 x2
ðaÞ
y 1 þ y 2 x 1 þ x2 x 1 x 2
y1 1 x1 ðcÞ
ð1Þ
ðbÞ
The transformations in (1), when applied to any Boolean function of any form, will transform the function to the integer
domain. A simplification of the transformation (1)(b) can be obtained for the case when the summands are only Boolean
minterms. There is no need to subtract the multiplication of the two distinct minterms since any two minterms are mutually
exclusive. So the transformation for the OR operation between Boolean minterms is reduced and (1)(b) becomes:
y1 þ y2 x1 þ x2
Using these operations the Boolean equations will be converted to multivariate polynomial equations in the integer domain. We have to add the constraints x2i ¼ xi ; i ¼ 1; . . . ; n. This will guarantee that the solution of the systems of polynomial
equations is either 1 or 0. It is obvious that any x ¼ ðx1 ; x2 ; . . . ; xn Þ is a solution of the polynomial system of equations if and
only if it is a solution of the Boolean system of equations.
Once applying the transformations in (1) and substituting xi for any x2i , the polynomial equations obtained are of the
form:
C i0;1 þ C i1;1 x1 þ . . . þ C i
1;
n
1
xn þ þ C i
n;
x1 x2 . . . xn ¼ 0;
n
n
i ¼ 1; . . . ; n
where C ij;k is the coefficient of the ith equation for the kth term of the jth order.
We propose to solve the above system of equations using the elimination method. The fact that in any step a power of a
variable can be replaced by the variable itself ðxki ¼ xi Þ simplifies significantly the solution method, and makes it possible to
ultimately solve the problem. The steps of the proposed method are the following:
Separate a variable from all equations. Since any single variable has no power greater than one, separating it from the
(e.g.
separate
x1
from
equation
leads
to
xi ðconst: þ terms without xi Þ þ ðconst: þ terms without xi Þ ¼ 0.
x1 x2 þ x1 x2 þ x2 x3 ¼ 0 ! x1 ð1 þ x2 Þ þ ðx2 þ x2 x3 Þ ¼ 0).
Substitute this variable from one equation into the remaining equations. This step involves performing two multivariate
polynomial multiplications per substitution in each equation.
Substitute xi for every x2i . This would limit the number of resulting terms from the multiplication to 2n terms at most. Even
when the multiplicands have each as high as 2n terms there is no increase in the number of terms beyond 2n .
Author's personal copy
290
A.H. Abdel-Gawad et al. / Information Sciences 180 (2010) 288–300
Repeat the above till the system transforms to a triangular form.
Perform back-substitution to find the values of all variables.
Sometimes in the middle of the elimination process the equations become sufficiently reduced that conventional methods
for solving equations can be applied in a straightforward manner. For such a situation, no more elimination is needed. In the
case where there is no solution for the system of equations, there will be no integer solution but a rational one.
Example 1. Given F 1 ðx1 ; x2 ; x3 Þ; F 2 ðx1 ; x2 ; x3 Þ and F 3 ðx1 ; x2 ; x3 Þ, represented in Bn as:
F 1 ¼ x1 x2 þ x1 x2
F 2 ¼ x1 x3 þ x2 x3 þ x1 x2 x3
F 3 ¼ x1 x2 þ x2 x3
Find x1 ; x2 and x3 to satisfy F 1 ¼ 0; F 2 ¼ 1 and F 3 ¼ 1.
Table 1 depicts the complete truth table for F 1 ; F 2 and F 3 , the row that have the desired output is in italics.
Using the proposed technique, the above system of equations is represented in Z n as follows:
F 1 ¼ ð1 x1 Þx2 ð1 x3 Þ þ ð1 x1 Þx2 x3 þ x1 ð1 x2 Þð1 x3 Þ þ x1 ð1 x2 Þx3
F 2 ¼ ð1 x1 Þð1 x2 Þx3 þ ð1 x1 Þx2 x3 þ x1 ð1 x2 Þx3 þ x1 x2 ð1 x3 Þ
F 3 ¼ ð1 x1 Þð1 x2 Þð1 x3 Þ þ ð1 x1 Þð1 x2 Þx3 þ ð1 x1 Þx2 x3 þ x1 x2 x3
Multiplying and combining the coefficients of the system and solving for F 1 ¼ 0; F 2 ¼ 1 and F 3 ¼ 1, the system becomes:
F 1 ¼ x1 þ x2 2x1 x2 ¼ 0
F 2 ¼ x3 þ x1 x2 2x1 x2 x3 ¼ 1
F 3 ¼ 1 x1 x2 þ x1 x2 þ x2 x3 ¼ 1
Separating x1 from the equations:
x1 ð1 2x2 Þ þ x2 ¼ 0
ð2Þ
x1 ðx2 2x2 x3 Þ þ ð1 þ x3 Þ ¼ 0
ð3Þ
x1 ð1 þ x2 Þ þ ðx2 þ x2 x3 Þ ¼ 0
ð4Þ
Substituting for x1 (2) in (3) and (4):
x1 ð1 2x2 Þ þ x2 ¼ 0
ðx2 Þðx2 2x2 x3 Þ þ ð1 2x2 Þð1 þ x3 Þ ¼ 0
ðx2 Þð1 þ x2 Þ þ ð1 2x1 Þðx2 þ x2 x3 Þ ¼ 0
Reducing the equations using the property x2i ¼ xi :
x1 ð1 2x2 Þ þ x2 ¼ 0
x 2 þ x3 1 ¼ 0
x2 x2 x3 ¼ 0
Similarly, separating and substituting x2 to obtain:
x1 ð1 2x2 Þ þ x2 ¼ 0
x 2 þ x3 1 ¼ 0
x3 ¼ 1
By back-substitution, the values of the variables are: x3 ¼ 1; x2 ¼ 0 and x1 ¼ 0.
Table 1
Truth table for example 1.
x1
x2
x3
F1
F2
F3
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
0
1
1
1
1
0
0
0
1
0
1
0
1
1
0
1
1
0
1
0
0
0
1
Author's personal copy
A.H. Abdel-Gawad et al. / Information Sciences 180 (2010) 288–300
291
2.1. Multivariate polynomial multiplication
The computationally dominant step is the multivariate polynomial multiplication. If we were to use the brute force multiplication (element-by-element) then the proposed solution method would be too slow.
We therefore propose a new method for multiplying Boolean-based polynomials which we call the Boolean-based multivariate polynomial multiplication method (BMPM). This method is computationally much faster than the element-by-element approach. It is based on computing certain summations and using them repeatedly to evaluate the multiplication
outcome (thus saving computations that were going to be done recomputing many of the terms). We have not found in
the literature hardly any method for the efficient multiplication of two multivariate polynomials. Most work focused on univariate polynomial multiplication. Before we present the details of the algorithm, we present an example that demonstrates
the steps of the algorithm.
Consider the multiplication of two polynomials of three variables each. The multiplication should result in:
ðC 0;1 þ C 1;1 x1 þ C 1;2 x2 þ C 1;3 x3 þ C 2;1 x1 x2 þ C 2;2 x1 x3 þ C 2;3 x2 x3 þ C 3;1 x1 x2 x3 Þ ðD0;1 þ D1;1 x1 þ D1;2 x2 þ D1;3 x3 þ D2;1 x1 x2
þ D2;2 x1 x3 þ D2;3 x2 x3 þ D3;1 x1 x2 x3 Þ
¼ ðE0;1 þ E1;1 x1 þ E1;2 x2 þ E1;3 x3 þ E2;1 x1 x2 þ E2;2 x1 x3 þ E2;3 x2 x3 þ E3;1 x1 x2 x3 Þ
The final coefficients Ej;k can be summarized in the form:
E0;1 ¼ C 0;1 D0;1
E1;1 ¼ C 0;1 D1;1 þ C 1;1 ðD0;1 þ D1;1 Þ
E1;2 ¼ C 0;1 D1;2 þ C 1;2 ðD0;1 þ D1;2 Þ
E1;3 ¼ C 0;1 D1;3 þ C 1;3 ðD0;1 þ D1;3 Þ
E2;1 ¼ C 0;1 D2;1 þ C 1;1 ðD1;2 þ D2;1 Þ þ C 1;2 ðD1;1 þ D2;1 Þ þ C 2;1 ðD0;1 þ D1;1 þ D1;2 þ D2;1 Þ
E2;2 ¼ C 0;1 D2;2 þ C 1;1 ðD1;3 þ D2;2 Þ þ C 1;3 ðD1;1 þ D2;2 Þ þ C 2;2 ðD0;1 þ D1;1 þ D1;3 þ D2;2 Þ
E2;3 ¼ C 0;1 D2;3 þ C 1;2 ðD1;3 þ D2;3 Þ þ C 1;3 ðD1;2 þ D2;3 Þ þ C 2;3 ðD0;1 þ D1;2 þ D1;3 þ D2;3 Þ
E3;1 ¼ C 0;1 D3;1 þ C 1;1 ðD2;3 þ D3;1 Þ þ C 1;2 ðD2;2 þ D3;1 Þ þ C 1;3 ðD2;1 þ D3;1 Þ þ C 2;1 ðD1;3 þ D2;2 þ D2;3 þ D3;1 Þ
þ C 2;2 ðD1;2 þ D2;1 þ D2;3 þ D3;1 Þ þ C 2;3 ðD1;1 þ D2;1 þ D2;2 þ D3;1 Þ þ C 3;1 ðD0;1 þ D1;1 þ D1;2 þ D1;3
þ D2;1 þ D2;2 þ D2;3 þ D3;1 Þ
which can be reorganized as:
E0;1 ¼ C 0;1 D0;1
E1;1 ¼ ðC 0;1 þ C 1;1 ÞðD0;1 þ D1;1 Þ C 0;1 D0;1
E1;2 ¼ ðC 0;1 þ C 1;2 ÞðD0;1 þ D1;2 Þ C 0;1 D0;1
E1;3 ¼ ðC 0;1 þ C 1;3 ÞðD0;1 þ D1;3 Þ C 0;1 D0;1
E2;1 ¼ ðC 0;1 þ C 1;1 þ C 1;2 þ C 2;1 ÞðD0;1 þ D1;1 þ D1;2 þ D2;1 Þ ðC 0;1 þ C 1;1 ÞðD0;1 þ D1;1 Þ ðC 0;1 þ C 1;2 ÞðD0;1 þ D1;2 Þ þ C 0;1 D0;1
E2;2 ¼ ðC 0;1 þ C 1;1 þ C 1;3 þ C 2;2 ÞðD0;1 þ D1;1 þ D1;3 þ D2;2 Þ ðC 0;1 þ C 1;1 ÞðD0;1 þ D1;1 Þ ðC 0;1 þ C 1;3 ÞðD0;1 þ D1;3 Þ þ C 0;1 D0;1
E2;3 ¼ ðC 0;1 þ C 1;2 þ C 1;3 þ C 2;3 ÞðD0;1 þ D1;2 þ D1;3 þ D2;3 Þ ðC 0;1 þ C 1;1 ÞðD0;1 þ D1;1 Þ ðC 0;1 þ C 1;2 ÞðD0;1 þ D1;2 Þ þ C 0;1 D0;1
E3;1 ¼ ðC 0;1 þ C 1;1 þ C 1;2 þ C 1;3 þ C 2;1 þ C 2;2 þ C 2;3 þ C 3;1 Þ ðD0;1 þ D1;1 þ D1;2 þ D1;3 þ D2;1 þ D2;2 þ D2;3 þ D3;1 Þ
ðC 0;1 þ C 1;1 þ C 1;2 þ C 2;1 ÞðD0;1 þ D1;1 þ D1;2 þ D2;1 Þ ðC 0;1 þ C 1;1 þ C 1;3 þ C 2;2 ÞðD0;1 þ D1;1 þ D1;3 þ D2;2 Þ
ðC 0;1 þ C 1;2 þ C 1;3 þ C 2;3 ÞðD0;1 þ D1;2 þ D1;3 þ D2;3 Þ þ ðC 0;1 þ C 1;1 ÞðD0;1 þ D1;1 Þ þ ðC 0;1 þ C 1;2 ÞðD0;1 þ D1;2 Þ
þ ðC 0;1 þ C 1;3 ÞðD0;1 þ D1;3 Þ C 0;1 D0;1
These computations can be performed in an efficient way by first computing the following intermediate variables:
1 ð1Þ
S1;1 ¼ C 1;1 þ C 0;1
1 ð1Þ
S1;2 ¼ C 1;2 þ C 0;1
1 ð1Þ
S1;3 ¼ C 1;3 þ C 0;1
1 ð1Þ
S2;1 ¼ S2;1 þ S1;1
1 ð1Þ
S2;2 ¼ S2;2 þ S1;1
1 ð1Þ
S2;3 ¼ S2;3 þ S1;2
1 ð1Þ
S3;1 ¼ S3;1 þ S2;2
S2;1 ¼ C 2;1 þ C 1;2
S2;2 ¼ C 2;2 þ C 1;3
S2;3 ¼ C 2;3 þ C 1;3
S3;1 ¼ C 3;1 þ C 2;3
2 ð1Þ
1 ð1Þ
1 ð1Þ
2 ð1Þ
1 ð1Þ
1 ð1Þ
2 ð1Þ
1 ð1Þ
1 ð1Þ
2 ð1Þ
1 ð1Þ
1 ð1Þ
3 ð1Þ
2 ð1Þ
2 ð1Þ
S3;1 ¼ S3;1 þ S2;1
Author's personal copy
292
A.H. Abdel-Gawad et al. / Information Sciences 180 (2010) 288–300
l ð2Þ
Exactly similar computations are performed for the Dj;k variables, leading to the terms Sj;k .
Then we compute the following terms:
M 0;1 ¼ C 0;1 D0;1
1 ð1Þ
1 ð2Þ
1 ð1Þ
1 ð2Þ
1 ð1Þ
1 ð2Þ
M 1;1 ¼ ðC 0;1 þ C 1;1 ÞðD0;1 þ D1;1 Þ ¼ S1;1 S1;1
M 1;2 ¼ ðC 0;1 þ C 1;2 ÞðD0;1 þ D1;2 Þ ¼ S1;2 S1;2
M 1;3 ¼ ðC 0;1 þ C 1;3 ÞðD0;1 þ D1;3 Þ ¼ S1;3 S1;3
2 ð1Þ
2 ð2Þ
2 ð1Þ
2 ð2Þ
2 ð1Þ
2 ð2Þ
M 2;1 ¼ ðC 0;1 þ C 1;1 þ C 1;2 þ C 2;1 ÞðD0;1 þ D1;1 þ D1;2 þ D2;1 Þ ¼ S2;1 S2;1
M 2;2 ¼ ðC 0;1 þ C 1;1 þ C 1;3 þ C 2;2 ÞðD0;1 þ D1;1 þ D1;3 þ D2;2 Þ ¼ S2;2 S2;2
M 2;3 ¼ ðC 0;1 þ C 1;2 þ C 1;3 þ C 2;3 ÞðD0;1 þ D1;2 þ D1;3 þ D2;3 Þ ¼ S2;3 S2;3
M 3;1 ¼ ðC 0;1 þ C 1;1 þ C 1;2 þ C 1;3 þ C 2;1 þ C 2;2 þ C 2;3 þ C 3;1 Þ ðD0;1 þ D1;1 þ D1;2 þ D1;3 þ D2;1 þ D2;2 þ D2;3 þ D3;1 Þ
3 ð1Þ
3 ð2Þ
¼ S3;1 S3;1
j ð3Þ
and we get the final form for the Ej;k ¼ Sj;k variables:
1 ð3Þ
S1;1 ¼ M1;1 M 0;1
1 ð3Þ
S1;2 ¼ M1;2 M 0;1
1 ð3Þ
S1;3 ¼ M1;3 M 0;1
1 ð3Þ
S2;1 ¼ S2;1 S1;1
1 ð3Þ
S2;2 ¼ S2;2 S1;1
1 ð3Þ
S2;3 ¼ S2;3 S1;2
1 ð3Þ
S3;1 ¼ S3;1 S2;2
S2;1 ¼ M2;1 M 1;2
S2;2 ¼ M2;2 M 1;3
S2;3 ¼ M2;3 M 1;3
S3;1 ¼ M3;1 M 2;3
2 ð3Þ
1 ð3Þ
1 ð3Þ
2 ð3Þ
1 ð3Þ
1 ð3Þ
2 ð3Þ
1 ð3Þ
1 ð3Þ
2 ð3Þ
1 ð3Þ
1 ð3Þ
3 ð3Þ
2 ð3Þ
2 ð3Þ
S3;1 ¼ S3;1 S2;1
We now turn to the description of the algorithm in its general form.
2.1.1. Algorithm: polynomial multiplication
The set An;j contains all combinations of j variables out of the pool of n variables. An;j ðkÞ is the kth element of this set.
Example. A4;2 ¼ fab; ac; ad; bc; bd; cdg and A4;2 ð1Þ ¼ ab.
For n variables, the set T j;k;l represents the indices inside An;l of the l-variable terms included in the term An;j ðkÞ.
Consider n ¼ 4 and let us evaluate T 3;1;2 ; A4;2 ¼ fab; ac; ad; bc; bd; cdg, and A4;3 ð1Þ is the first element in A4;3 which is abc.
The elements of A4;2 that are included in A4;3 ð1Þ are ab; ac and bc (the 1st; 2nd and 4th elements of A4;2 ). Hence
T 3;1;2 ¼ f1; 2; 4g.
Concerning the multiplication of two
multivariate polynomials in n variables, the multiplication can be put in the form
C j;k Dj;k ¼ Ej;k ; j ¼ 0; . . . ; n; k ¼ 1; . . . ; nj . This form is summarized as:
M v ;w ¼
"
v
X
X
r¼0 q2T v ;w;r
Ej;k ¼
j
X
v ¼0
X
# "
#
v
X
X
C r;q Dr;q ;
v ¼ 0; . . . ; n;
w ¼ 1; . . . ;
r¼0 q2T v ;w;r
w2T j;k;v
1 ð1Þ
Sj;k ¼ C j;k þ C j1;T j;k;j1 ðjÞ
v ð1Þ
v 1 ð1Þ
¼ Sj;k
v 1 ð1Þ
þ Sj1;T j;k;j1 ðjv þ1Þ
1 ð2Þ
Sj;k ¼ Dj;k þ Dj1;T j;k;j1 ðjÞ
v ð2Þ
Sj;k
v
ð1Þjv M v ;w
but if building on the organized additions for j ¼ 1; . . . ; n; k ¼ 1; . . . ; j and
Sj;k
n
v 1 ð2Þ
¼ Sj;k
v 1 ð2Þ
þ Sj1;T j;k;j1 ðjv þ1Þ
M 0;1 ¼ C 0;1 D0;1
j ð1Þ
j ð2Þ
M j;k ¼ Sj;k Sj;k
v ¼ 2; . . . ; j, the equations can be written as:
Author's personal copy
293
A.H. Abdel-Gawad et al. / Information Sciences 180 (2010) 288–300
1 ð3Þ
¼ M j;k M j1;T j;k;j1 ðjÞ
v ð3Þ
¼ Sj;k
Sj;k
Sj;k
v 1 ð3Þ
v 1 ð3Þ
Sj1;T j;k;j1 ðjv þ1Þ
E0;1 ¼ M0;1
j ð3Þ
Ej;k ¼ Sj;k
It is a bit complicated to calculate T j;k;j1 by tracking down its exact definition, so a new algorithm is proposed to calculate
these indices directly and non-recursively. Table 2 illustrates an example for the pattern of indices of terms composed of six
variables, a; b; . . . ; f (used instead of x1 ; x2 ; . . . ; x6 for compactness). The first part of the table (the part having the letters) lists
all combinations of terms grouped by the number of variables in each term. The second part of the table has for each group of
terms the indices of the combinations forming each term (For example, the term abc has the combinations ab with index 1,
appear in the second group in the second part of the figure. This
ac with index 2 and bc with index 6. These indices
) represents then T 3;1;2 ).
group (i.e.
The generalized form of the indices pattern for T j;k;j1 is in Fig. 2.
Rather than enumerating all the combinations of variables to obtain T j;k;j1 , the patterns of the indices as appearing in
Table 2 can be computed recursively. Fig. 1 shows the pattern of change of the indices from row to the next for the case
Table 2
Indexing pattern example ðn ¼ 5Þ.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
a
b
c
d
e
f
ab
ac
ad
ae
af
bc
bd
be
bf
cd
ce
cf
de
df
ef
abc
abd
abe
abf
acd
ace
acf
ade
adf
aef
bcd
bce
bcf
bde
bdf
bef
cde
cdf
cef
def
abcd
abce
abcf
abde
abdf
abef
acde
acdf
acef
adef
bcde
bcdf
bcef
bdef
cdef
abcde
abcdf
abcef
abdef
acdef
bcdef
1
1
1
1
1
2
2
2
2
3
3
3
4
4
5
2
3
4
5
6
3
4
5
6
4
5
6
5
6
6
1
1
1
1
2
2
2
3
3
4
6
6
6
7
7
8
10
10
11
13
2
3
4
5
3
4
5
4
5
5
7
8
9
8
9
9
11
12
12
14
6
7
8
9
10
11
12
13
14
15
10
11
12
13
14
15
13
14
15
15
1
1
1
2
2
3
5
5
6
8
11
11
12
14
17
Fig. 1. Illustrated indices pattern.
2
3
4
3
4
4
6
7
7
9
12
13
13
15
18
5
6
7
8
9
10
8
9
10
10
14
15
16
16
19
11
12
13
14
15
16
17
18
19
20
17
18
19
20
20
1
1
2
4
7
11
2
3
3
5
8
12
4
5
6
6
9
13
7
8
9
10
10
14
11
12
13
14
15
15
Author's personal copy
294
A.H. Abdel-Gawad et al. / Information Sciences 180 (2010) 288–300
Fig. 2. Generalized indices pattern for T j;k;j1 .
of 4 variables (out of 6), i.e. the second to last group of columns in Table 2. Fig. 2 shows the case of general n and j. We can see
the following characteristics, which we use to generate the T k;k;j1 ’s:
Any column i has groups of consecutive numbers (e.g. column 4 has a group of numbers 11–20). The top most group has
nþij1
nþijk
.
size
. The kth group down has size
i1
i1
Each group in column i encompasses a number of groups of column i 1. The first element of the group in column i equals
1 plus the last element of the encompassed groups of column i 1. Consider for example the group 11 to 20 in column 4.
The number 11 is 1 plus the last element of the encompassed group of column 3 (which are (5,6,7,8,9,10),(8,9,10),(10)).
2.1.2. Some comments and extensions
The proposed method can also handle the case when the number of equations M is different than the number of variables
n. If M > n then we can select any n equations and apply the proposed methodology. After we obtain the solutions, we
substitute these into the remaining M n equations to check whether these solutions would still hold. If M < n then
we apply the proposed methodology to eliminate as many variables as possible. We will get at the end one equations having a smaller number of unknowns (typically n M unknowns). We analyze this equation to obtain its solutions.
If the equations are available in a form other than a sum of minterms, then the proposed method can still be applied efficiently. A separation step (see Section 1) is first needed to convert the equations into sums of mutually exclusive product
terms. Then, the proposed method can proceed as described.
3. The hybrid integer-Boolean solution method
In the ISBE method, all negated variables in the equations are initially replaced with the equivalent integer representation
for them. This step has two drawbacks: increasing the computational time of replacement and increasing the memory holding the expanded equations especially for small N. We propose here a modification to the ISBE to overcome these drawbacks.
In this modified version we replace only the variable that is to be substituted for in the equations. Therefore, the computational time is reduced and the size of the equations will rather decrease. We will call this modified version of the ISBE method the Hybrid method because the method uses both the Boolean and integer representations simultaneously:
Separate a variable from all equations.
Substitute with the integer equivalent for the separated variable.
Substitute this variable from one equation into the remaining equations. This will involve multiplying together Boolean
expressions.
Repeat the above till the system transforms to the triangular form.
Perform back-substitution to find the values of all variables.
3.1. Detailed example
Example 2. Consider F 1 ðx1 ; x2 ; x3 ; x4 Þ; F 2 ðx1 ; x2 ; x3 ; x4 Þ; F 3 ðx1 ; x2 ; x3 ; x4 Þ and F 4 ðx1 ; x2 ; x3 ; x4 Þ, given in separated form as
follows:
F 1 ¼ x1 x2 x3 x4 þ x1 x2 þ x1 x2 x4 þ x1 x2 x3 x4
F 2 ¼ x1 x2 x4 þ x1 x2 x3 þ x2 x3 x4
F 3 ¼ x1 x2 x3 x4 þ x1 x2 x3 þ x1 x2 x3 x4 þ x2 x3
F 4 ¼ x1 x2 þ x1 x2 x3 x4 þ x1 x2 x3 x4 þ x1 x2 x3 x4 þ x1 x2 x3 x4
Find x1 ; x2 ; x3 and x4 to satisfy F 1 ¼ 1; F 2 ¼ 1; F 3 ¼ 1 and F 4 ¼ 1.
Author's personal copy
295
A.H. Abdel-Gawad et al. / Information Sciences 180 (2010) 288–300
Table 3 depicts the truth table for F 1 ; F 2 ; F 3 and F 4 . The rows that correspond to the correct solution are in italics.
x1 and separating x1 from all equations:
Substituting only 1 x1 for x1 ðx2 x4 x2 x3 x4 þ x2 x3 x4 x2 Þ ¼ x2 x3 x4 x2 þ 1
ð5Þ
x1 ðx2 x4 x2 x3 Þ ¼ x2 x4 x2 x3 x4 x2 x3 þ 1
ð6Þ
x1 ðx2 x3 x4 x2 x3 x4 x2 x3 Þ ¼ x2 x3 x2 x3 x4 x2 x3 þ 1
ð7Þ
x1 ðx2 x3 x4 þ x2 x3 x4 x2 x2 x3 x4 x2 x3 x4 Þ ¼ x2 x2 x3 x4 x2 x3 x4 þ 1
ð8Þ
Substituting (5) in (6)–(8), we get:
x1 ðx2 x4 x2 x3 x4 þ x2 x3 x4 x2 Þ ¼ x2 x3 x4 x2 þ 1
ð9Þ
x2 x4 þ x2 x4 þ x2 x3 x4 þ x2 x3 x2 ¼ 0
ð10Þ
x2 x3 x4 þ x2 x3 x4 x2 x4 x2 x3 x4 x2 x3 þ x2 ¼ 0
ð11Þ
x2 x3 x4 þ x2 x3 x4 þ x2 x3 x4 x2 x2 x3 x4 x2 x3 x4 þ x2 ¼ 0
ð12Þ
Substituting only 1 x2 for x2 and separating x2 from (10)–(12):
x1 ðx2 x4 x2 x3 x4 þ x2 x3 x4 x2 Þ ¼ x2 x3 x4 x2 þ 1
ð13Þ
x2 ðx3 x4 þ x3 x4 x4 1Þ ¼ x4 x4
ð14Þ
x2 ð2x3 x4 x3 x4 x3 x4 þ 1Þ ¼ x3 x4 x3 x4 x4
ð15Þ
x2 ð2x3 x4 x3 x4 x3 x4 x3 x4 þ 2Þ ¼ x3 x4 x3 x4 x3 x4 þ 1
ð16Þ
Substituting (14) in (15) and (16):
x1 ðx2 x4 x2 x3 x4 þ x2 x3 x4 x2 Þ ¼ x2 x3 x4 x2 þ 1
ð17Þ
x2 ðx3 x4 þ x3 x4 x4 1Þ ¼ x4 x4
ð18Þ
2x3 x4 þ 2x3 x4 þ x3 2x4 x4 ¼ 0
ð19Þ
x3 x4 þ x3 x4 x3 x4 x4 þ 1 ¼ 0
ð20Þ
Substituting only 1 x3 for x3 and separating x3 from (19) and (20):
x1 ðx2 x4 x2 x3 x4 þ x2 x3 x4 x2 Þ ¼ x2 x3 x4 x2 þ 1
ð21Þ
x2 ðx3 x4 þ x3 x4 x4 1Þ ¼ x4 x4
ð22Þ
x3 ð1Þ ¼ x4
ð23Þ
x3 ð1Þ ¼ x4 1
ð24Þ
Table 3
Truth table for example 2.
x1
x2
x3
x4
F1
F2
F3
F4
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
1
0
0
0
1
1
1
1
1
0
1
0
1
0
0
0
0
1
0
1
1
0
1
1
0
1
0
0
1
0
0
0
1
1
0
0
1
0
1
1
1
1
0
1
0
0
0
0
1
1
1
1
1
0
0
1
0
1
1
0
0
0
0
0
Author's personal copy
296
A.H. Abdel-Gawad et al. / Information Sciences 180 (2010) 288–300
Substituting (23) in (24):
x1 ðx2 x4 x2 x3 x4 þ x2 x3 x4 x2 Þ ¼ x2 x3 x4 x2 þ 1
x2 ðx3 x4 þ x3 x4 x4 1Þ ¼ x4 x4
ð26Þ
x3 ð1Þ ¼ x4
x4 þ x4 ¼ 1
ð28Þ
ð25Þ
ð27Þ
From (28), x4 ¼ 0 or x4 ¼ 1. After performing back-substitution with the two possible solutions we get the final solutions:
0
0
1
0
x4
x3
x2
x1
1
1
1
0
3.2. Multiplication of Boolean expressions
As in the ISBE method, the process of multiplication is also a computational bottleneck for this method. One possible fast
multiplication method of two Boolean expressions is to organize the expressions in a tree form. The tree representation also
allows to easily separate a variable from the expression especially when this variable is the root of the tree. In this tree representation, each node in the tree represents a variable pointing to three possible other nodes. One pointer to the next node
represents the next variable in the chain that has the current variable. Another pointer to the next node represents the next
variable in the chain that has the negation of the current variable. The last pointer to the next node represents the next variable in the chain free from the current variable.
Example. To represent the expression:
x0 x1 x2 þ x0 x1 þ x0 x2 þ x1 x2
It can be reorganized as follows to obtain the tree representation
x0 ðx1 ðx2 ð1Þ þ x1 ð1ÞÞ þ x2 ð1ÞÞ þ x1 ðx2 ð1ÞÞ
Each term is terminated with a special node representing the constant multiplier coefficient.
4. Complexity analysis
4.1. The ISBE method
Let N be the average number of terms per equation. The main and dominant component in the complexity of the elimination process is the multivariate polynomial multiplication. Multivariate polynomial multiplication of N N terms using
the conventional element-by-element method needs the following operations (consider the worst case number of terms
N ¼ 2n ):
22n multiplications and
22n 2n additions, the huge number of additions is due to the summation of many similar terms resulting from the
multiplications.
The new BMPM algorithm for the multiplication of multivariate polynomials reduces the complexity significantly for moderate and large N. The complexity of the BMPM algorithm can be obtained as:
2n multiplications as the upper bound, since for calculating the coefficient of each of the 2n terms, only one multiplication
is required, and
v ð1Þ v ð2Þ
v ð3Þ
additions
as the upper bound for computing all of the three series Sj;k ; Sj;k and Sj;k , each series of them needs
3n 2n1
Pn
n
n1
additions which equals n 2 .
j¼1 j j
The complexity of the whole algorithm is computed as follows. When separating the first variable x1 to x1 ð Þ þ ð Þ, each
bracket can have a maximum of 2n1 terms. When substituting from x1 to the remaining n 1 equations, each equation substitution will lead to two polynomial multiplications (see Example 1 in Section 2). In the second cycle, we are dealing with
n 1 variables x2 ; . . . ; xn and n 1 equations. When we separate x2 from one equation and substitute in the remaining n 2
equations, we need to perform a total of ðn 2Þ 2 polynomial multiplication (each polynomial has at most 2n2 terms). We
keep going on until solving the system of equations. The overall complexity will be the summation of the complexities of
each cycle, as follows ðN ! 2n Þ:
Author's personal copy
A.H. Abdel-Gawad et al. / Information Sciences 180 (2010) 288–300
297
The complexity of multiplications is:
1
X
2 No: of equs: complexity of multi0s in one equ: ¼
l¼n1
1
X
ð2 lÞ 2l ¼ ðn þ 1Þ 2n1 4
l¼n1
The complexity of additions is:
1
X
2 No: of equs: complexity of add0s in one equ: ¼
l¼n1
1
X
ð2 lÞ ð3 l 2l1 Þ ¼ 3 ½n ðn 1Þ 2n2 2
l¼n1
The only drawback that occurs during the elimination process in ISBE is that during the substitution the multiplication of
the multivariate polynomials increases the number of terms. However, as we go further in the elimination process, the number of terms reverses its course and decreases since the number of variables decreases. Concerning the conversion step from
Boolean equations to integer polynomials, it has a negligible complexity compared to the polynomial multiplication step
(not even exponential in n). So the proposed algorithm has an overall complexity of Oðn2 2n Þ (see Table 4 for the complexity
of the different steps of the algorithm).
4.2. The hybrid method
It is hard to derive the complexity for the hybrid method. But we present here qualitative argument. The main component
affecting the complexity of the hybrid method is the multiplication of Boolean expressions. As we proceed in the multiplication three factors are at odds. On one hand the number of terms increases (due to the fact that multiplying two expressions
produces more cross-terms). On the other hand the complete term by term multiplication can be avoided. This is because
there is no need to multiply any two terms having a variable in one term and its complement in the other. From the simulations we found that this situation happens quite frequently in each polynomial multiplication step. Another factor is that
as we proceed, the number of variables decreases due to successive variable elimination. From the simulations we have
found that these latter two factors more than offset the former factor, leading to an even fast decrease in the net number
of terms as we proceed through the elimination process. We have found through empirical analysis that the overall complexity of the hybrid method is then around OðnN 2 Þ. This is, however, only pure empirical observation and is not based on a hard
proof.
4.3. The competing methods
The comparison between the complexities of the proposed methods, the Exhaustive Search (ES) and the tabular method in
[11] is depicted in Table 5. For the tabular approach what makes the complexity so high is the occurrence of a 0 in the right
hand side of any of the equations. For the Exhaustive Search the complexity is computed as follows. We take the first equation, substitute a binary combination of variables into the equation, go on for the next equation and so on as long as the
equations are satisfied. Once an equation is not satisfied, we stop and test another binary combination. The expected number
of equations to check is 2. Hence the complexity equals 2 times the number of possible binary combinations times the number of terms per equation, that is around OðN2n Þ. All complexity numbers in the table are average case complexities. One can
see from the table that as N becomes large N > n2 the ISBE method gives the lowest complexity. For small N most likely the
Hybrid approach will be more suitable than the ISBE method. A rough empirical cut-off is also when N is around n2 .
4.3.1. Memory reduction
The main problem with the proposed ISBE approach is the increase in the number of terms during the substitutions before
their decrease later as the number of remaining variables in the equations decreases.
To alleviate this memory problem, we propose a modification, whereby we combine both the exhaustive search and the
proposed algorithm. This would avoid the exponential expansion of memory requirements at the expense of increasing the
processing time. By performing a search for a number of variables and solving algebraically for the remaining ones, the memory requirements will decrease drastically while the computation time will increase.
Table 4
Complexity of different phases of the elimination process.
Multiplications/substitution
Additions/substitution
Substitutions
Back-substitution
Complete solution
OðNÞ
Oðn2n Þ
OðnÞ
OðNÞ
Oðn2 2n Þ
Author's personal copy
298
A.H. Abdel-Gawad et al. / Information Sciences 180 (2010) 288–300
Table 5
Complexities of different approaches.
ISBE
Hybrid
Tabular
ES
Oðn2 2n Þ
OðnN 2 Þ
OðnN Þ
OðN2n Þ
The percentage of hybridization for each component should be selected based on the size of problem, such as the number
of variables and the number of terms per equation.
5. Experimental results
We performed two experiments. The first one considers synthetic data and aims at comparing the different methods and
validating the theoretical complexity formulas. The other experiment considers a real application, namely hardware
verification.
5.1. Synthetic data
We test here the comparative performance of the new algorithm. We generated a system of Boolean equations consisting
of n equations in n variables in a Monte Carlo fashion with varying the number of terms per equation (N). In the Monte Carlo
procedure we generate minterms randomly for each Boolean equation so that we have a little more than N terms. Then we
simplify the resulting sum of minterms expression so that we get a more conventional Boolean equation. The expression is
kept if it indeed has a number of terms in a certain tight range around the targeted N, otherwise it is discarded and another
try is performed. The only exception is for the case when N ¼ 2n1 as the first two equations are generated as either the XOR
or the XNOR of the variables (XOR of the variables or some of their complements are the only functions that get irreducible
minterms of size 2n1 ).
The generated problems were solved using the ISBE, the Hyrbid, the Exhaustive Search (ES) and the Tabular methods. This
test was repeated for different number of variables n. Table 6 depicts the time taken to solve the system by each of the competing methods. The simulations were carried out on a Pentium III 1.5 GHZ with a 2 GB sized RAM and Windows 2000 server
operating system, and the table gives the total computation time for each method in ms.
From the tables one can observe the following:
For a large number of terms per equation (N), the ISBE method is the clear winner. It beats the other methods with a significant margin. Even for moderate N, its advantage catches up when n grows higher.
The hybrid approach improves in performance when N decreases. It still lags ISBE due to the use of element-by-element
multiplication (in spite of having more compact size). However, the memory requirements for the hybrid method are
much lower due to the fact that it does not store all of the coefficients. This is drastically apparent when N is small. There
are problems where it is not possible to use ISBE because of memory constraints, and in such situations the hybrid method
would be a good substitute.
The tabular approach is better off for small N, but in general its performance lags the other methods.
The exhaustive search is better than we expected, but it scales badly as n grows large (compared to ISBE and to some
extent the hybrid method).
5.2. Application: hardware verification
After the fabrication of integrated circuits it is necessary to perform a hardware verification step to ensure that these
circuits are fault-free [7]. In this testing phase input vectors are pre-calculated such that they cover any testable fault in
the circuit. Then, these inputs are applied and the outputs are checked for correctness. There are several algorithms for
automatically generating test input patterns. The dominant algorithm in this domain of automatic test-pattern generation (ATPG) is Roth’s D-Algorithm [9]. It basically relies on the so-called D-cube which is some form of a collapsed truth
table entry, with a number of operations defined on it. Algorithm 1 below describes the main steps of this approach. The
relevant step in the algorithm is the third step where a backward trace is required to estimate the values of the inputs
of the circuit that give the desired values of the output bins of the circuit. This is equivalent to a system of Boolean
equations. The left hand side of the equation is the equivalent Boolean expression of the gates of the circuit driving
the output bin, and the right hand side is the desired output value. More details about the D-Algorithm can be found
in [3].
Author's personal copy
A.H. Abdel-Gawad et al. / Information Sciences 180 (2010) 288–300
299
Table 6
Results of time (in ms): (a) Number of terms per equation (N) is 2n1 ; (b) 2n3 , (c) 2n5 and (d) 2n7 .
n
ISBE
ES
Hybrid
Tabular
(a)
9
10
11
12
13
14
15
16
17
18
15
31
78
187
406
906
1968
4578
10,625
25,953
15
62
281
1079
5969
43,812
–
–
–
–
281
953
3000
9812
35,969
–
–
–
–
–
281
1,219
6,587
38,609
–
–
–
–
–
–
(b)
9
10
11
12
13
14
15
16
17
18
15
31
78
187
406
906
1968
4578
10,625
25,953
0
0
47
203
844
3750
22,140
–
–
–
78
250
656
1937
5719
18,219
–
–
–
–
78
297
1453
6750
47,000
–
–
–
–
–
(c)
9
10
11
12
13
14
15
16
17
18
15
31
78
187
406
906
1968
4578
10,625
25,953
0
0
0
47
203
781
3078
12,203
54,156
–
15
47
141
422
1094
3000
8656
27,140
–
–
15
47
188
812
4109
20,640
–
–
–
–
(d)
9
10
11
12
13
14
15
16
17
18
15
31
78
187
406
906
1968
4578
10,625
25,953
0
0
0
16
63
219
860
3328
13,234
52,375
0
0
31
78
188
484
1328
4062
11,609
35,531
0
0
31
93
407
1687
8594
50,062
–
–
Algorithm 1. Roth’s D-Algorithm
1. Choose a stuck-at fault source, and from the primitive D-cubes of failure data identify the signals necessary to detect
this fault;
2. Drive this fault D or D forward through all paths to at least one primary output, using the information contained in
the propagation D-cubes;
3. Perform a consistency operation. This means trace backwards from a primary output to which D or D has been driven. Continue backwards till reaching the primary inputs, at which point we get the final test input vector.
Table 7
Results of time (in ms) of solving small combinational circuits.
n
Gates
Average N
Hybrid
Tabular
18
20
22
24
48,548
72,053
205,413
300,209
287
343
812
1000
2453
3985
14,453
25,672
23,672
56,141
–
–
Author's personal copy
300
A.H. Abdel-Gawad et al. / Information Sciences 180 (2010) 288–300
Table 8
Results of time (in ms) of solving large combinational circuits.
n
Gates
Average N
ISBE
ES
12
14
16
18
25,089
112,248
540,487
2,247,994
503
1639
6173
19,789
187
906
4578
25,953
203
9891
95,422
–
The results of solving instances of small combinational circuits are depicted in Table 7 for the tabular and the hybrid
methods (since they are better off for small N). Similarly, since the exhaustive search and ISBE hold quite well for large N,
we tested their performance in solving instances of large combinational circuits (see Table 8). One can see that the ISBE could
solve equations with N close to 20,000, an achievement that has been deemed hopeless to achieve with other methods.
6. Conclusions
This paper proposes a new technique for solving systems of Boolean equations by transforming them to the integer domain. A new algorithm was developed to multiply Boolean-based multivariate polynomials and that lead to improved performance over the exhaustive search and the competing tabular approaches. Experimental results confirmed the theoretical
complexity calculations.
References
[1] F. Chai, X.-S. Gao, C. Yuan, A characteristic set method for solving Boolean equations and applications in cryptanalysis of stream ciphers, Journal of
Systems Science and Complexity 21 (2) (2008) 191–208.
[2] S. Devadas, A.R. Newton, Exact algorithms for output encoding, state assignment, and four-level Boolean minimization, IEEE Transactions on
Computer-Aided Design 10 (1) (1991) 13–27.
[3] S.L. Hurst, VLSI Testing: Digital and Mixed Analogue/Digital Techniques, The Institution of Electrical Engineers, London, 1998.
[4] M. Keinänen, Obtaining memory efficient solutions to Boolean equation systems, Electronic Notes in Theoretical Computer Science, vol. 133, Elsevier,
2005, pp. 175–191.
[5] M. Keinänen, Techniques for solving Boolean equation systems, Research Report A105, Doctoral Dissertation, Helsinki University of Technology,
Laboratory for Theoretical Computer Science, Espoo, Finland, November 2006.
[6] T. Larabee, Test pattern generation using Boolean satisfiability, IEEE Transactions on Computer-Aided Design 11 (1) (1992) 4–15.
[7] S. Malik, Hardware Verification: Methodology, Techniques and Solutions, April 2008 (Keynote address by Sharad Malik).
[8] P.C. McGeer, A. Saldanha, P.R. Stephan, R.K. Brayton, A. Sangiovanni-Vincentelli, Timing analysis and delay-fault test generation using path-recursive
functions, in: Proceedings of the 1991 International Conference on Computer-Aided Design, Santa Clara, CA, November 1991, pp. 180–183.
[9] J.P. Roth, Diagnosis of automata failures: a calculus and a method, IBM Journal of Research and Development 10 (4) (1966) 278–291.
[10] S. Rudeanu, Equations in the algebra of logic, in: Proceedings of the 32nd IEEE International Symposium on Multiple-Valued Logic (ISMVL’02), 2002, pp.
2–8.
[11] P.P. Trabado, A. Lloris-Ruiz, J. Ortega-Lopera, Solution of switching equations based on a tabular algebra, IEEE Transactions on Computers 42 (5) (1993)
591–596.
[12] J.H. Tucker, S.K. Stover, Using genetic algorithms to solve Boolean equations, in: Proceedings of IEEE Southeastcon 95, 1995.
[13] J.H. Tucker, M.A. Tapia, Using karnaugh maps to solve Boolean equations by successive elimination, in: Proceedings of IEEE Southeastcon 92, 1992.
[14] J.H. Tucker, M.A. Tapia, Solution of a class of Boolean equations, in: Proceedings of IEEE Southeastcon 95, 1995.
[15] S.H. Unger, Some additions to solution of switching equations based on a tabular algebra, IEEE Transactions on Computers 43 (3) (1994) 365–367.
[16] Y. Wang, C. McCrosky, Solving Boolean equations using ROSOP forms, IEEE Transactions on Computers 47 (2) (1998) 171–177.
[17] S. Woods, G. Casinovi, Efficient solution of systems of Boolean equations, in: The 1996 IEEE/ACM International Conference on Computer-Aided Design,
1996.