Solving Boolean equation systems.
Proposition 6.1 ([[ E ]])(X 1 ) = true i there exists a successful
6.4 Gau elimination.
6.4.2 Complexity for the general case.
In this section we argue that the naive algorithm derived from Gau elimination is of complexity exponential in the number of equations, and give an example for it. The source of complexity here is the size of right-hand side expressions, which in an example growths exponen- tially. However, it is not known, whether there exists a version of the algorithm, where this exponential blow up is avoided by more intelli- gent storage of expressions.
In comparison to the approximation algorithm the behaviour cwof Gau elimination algorithms is very di erent. We show that the com- plexity of Gau elimination is independent from the alternation depth of the Boolean equation system, i.e. given an arbitrary Boolean equa- tion system there exists a Boolean equation system with the same number of equations, but alternation depth 1, and for both systems the algorithm needs same time and space. An example demonstrates a case, where the approximation based algorithms needs exponentially many steps, but Gau elimination only polynomial time and space. For some fragments we show that Gau elimination has complexity polynomial in the number of equations. Especially for the fragment corresponding to L2 Gau elimination provides an O(n2) algorithm.
The number of substitution steps during the Gau elimination in the global algorithm is less than (n 1)+(n 2)+:::+1n2. The local
version includes at most n applications of the global algorithm giving alltogether less than n3 substitution steps.
The crucial point concerning complexity is the size of the Boolean ex- pressions arising from iterative substitutions. In general substitution of Boolean expressions into Boolean expressions leads to size exponen- tial in the number of variables involved. Assuming that a Boolean equation system in normal form consists of n equations (and di erent
variables), then the size of the Boolean expressions created during the algorithm is bound by 2n. Hence the worst case complexity of the
global and local algorithm is O(2n).
Trying a big number of examples showed that the application of eval- uation rules as discussed above and the elimination rule keep the ex- pressions created relatively small. Finding an example where the right- hand side expressions are of exponential size turned out to be a di- cult task. The example below was constructed with help of Brinksma [Bri96] and Rossmanith [Ros96]. The basic idea is to nd an expres- sion where one variable appears twice and the laws for evaluation of Boolean expressions as xed for the algorithm are not applicable in order to reduce it. Such an expression gives a scheme for iterative sub- stitution with no possibility of reduction. The xpoint operators in this example are irrelevant, because when building up expressions for Xnup to Xn=2there is no application of the elimination rule possible.
Therefore xpoint operators are left away. Assume n210IN. The size
of expressions is then bound by O(2n=5).
X1 = X2 X2 = X3 X3 = X4 X4 = X5 ::: Xn=2 = Xn=2+1 Xn=2+1 = Xn=2+2 _ Xn=2+3 Xn=2+2 = Xn=2+4 ^ Xn=2 1 Xn=2+3 = Xn=2+5 ^ Xn=2 2 Xn=2+4 = Xn=2+6 _ Xn=2 3 Xn=2+5 = Xn=2+6 _ Xn=2 4 ::: Xn 14 = Xn 13 _ Xn 12 Xn 13 = Xn 11 ^ X13 Xn 12 = Xn 10 ^ X12 Xn 11 = Xn 9 _ X11 Xn 10 = Xn 9 _ X10
6.4. Gau elimination. 89 Xn 9 = Xn 8 _ Xn 7 Xn 8 = Xn 6 ^ X9 Xn 7 = Xn 5 ^ X8 Xn 6 = Xn 4 _ X7 Xn 5 = Xn 4 _ X6 Xn 4 = Xn 3 _ Xn 2 Xn 3 = Xn 1 ^ X5 Xn 2 = Xn ^ X4 Xn 1 = X1 _ X3 Xn = X1 _ X2
In order to make the conceptual di erence to the approximationmethod clear we show that Gau elimination is independent of the alternation depth of a Boolean equation system. Least and greatest xpoints are treated in a similar way: the corresponding variables are substituted by a constant, true for a variable with greatest xpoint, false for a
variable with least xpoint.
Proposition 6.4
The complexity of the naive algorithm based on Gau elimination is independent of the alternation depth of the Boolean equation system and hence also of the underlying -calculus formula.Proof: The idea is that for a given Boolean equation systemE of ar-
bitrary alternation depth we construct a Boolean equation systemE 0
with only - xpoints, andE
0has the property that the size of expres-
sions created during Gau elimination is at least the size of expressions created forE. (Their solutions may di er.)
For this purpose we have to restrict the class of Boolean equation sys- tems we consider to those which do not contain constants and all right hand side variables are bound. In fact this is not a real restriction, because constants and xed right hand side variables can be elimi- nated from a Boolean equation system in linear time (in the size of the system) such that the solution of the system is preserved. Hence ap- plying this elimination before starting any algorithm will not increase
its complexity. Furthermore we consider Boolean equation systems in standard form. This representation can be achieved by a linear blow-up of the original system (in the size of the underlying -calculus formula).
The transformation fromE toE
0works as follows:
every conjunction containing a -variable is transformed to a dis-
junction (of the same variables), and
every is substituted by a .
Note that the solution of E
0 will be 0, where 0(X) =
false for all
X 2lhs(E 0).
We have to show that the size of expressions when applying Gau elimination toE
0is greater or equal to those for
E. Both systems have
the same dependency graph, and therefore also the same structure of substitutions. We just have to make sure that inE
0\no variables get
lost" in comparison toE.
The property to show holds for the initial systems E and E 0. Fur-
thermore corresponding equations of both systems contain the same variables. Let iXi=f;jXj=g be equations ofEand Xi=f
0, X
j=g0
the corresponding equations ofE
0, where i < j.
Applying a substitution step leads to an expression iXi=f[Xj=g] and
Xi=f0[X
j=g0] respectively. If f and g contained at least the same
(number of) variables as f0 and g0then this will also hold for f[X
j=g]
and f0[X
j=g0] and the size of f0[X
j=g0] is greater or equal to the size
of f[Xj=g].
For an elimination step consider as part of an expression of E a con-
junction Xi^Xj, where Xi is a -variable and Xj is a -variable, and
Xi is substituted by true. Then the conjunction evaluates to Xj. In
the transformed systemE
0the conjunction was transformed to a dis-
junction Xi_Xj and Xi will be substituted byfalse. The disjunction
evaluates to Xj as in the other case. When Xj is substituted byfalse
then the conjunction ofE will evaluate to false, whereas the disjunc-
tion ofE
0will evaluate to X
i, leading to a greater expression (with at
least one more variable) than inE. Note that the case of substituting truefor a variable in a disjunction introduced in E
6.4. Gau elimination. 91
because the solution ofE 0gives
falsefor every variable ofE 0.
Any statement about size of Boolean expressions makes only sense if we choose a sensible representation of Boolean expressions. In the case here we evaluate expressions just with the rules for constants.
We now want to demonstrate by some examples \good" behaviour of Gau elimination, where tableau method and approximation method need exponential space and/or time. Two examples have already been treated in section 6.3, illustrating the exponential blow-up of the plain tableau method. These examples can easily be solved with the tech- niques from this section without any blow-up. This might not be too surprising as already extensions of the tableau method in [Cle90] and [Mad92] can deal with these examples.
Here we present another example. Its features are the following:
It is scalable, i.e. it is a set of examples, which can have arbitrary
size n and alternation depth n.
The Gau elimination method produces only expressions of a xed
constant length for any of the examples, and the complexity is O(n2).
Known algorithms based on the approximation technique are ex-
ponentially in n.
The last aspect is due to the fact that the example is constructed in a way that a maximal number of backtracking steps is required. Let n22IN X1 = X2^Xn X2 = X1_Xn X3 = X2^Xn X4 = X3_Xn ::: Xn 3 = Xn 4^Xn Xn 2 = Xn 3_Xn Xn 1 = Xn 2^Xn Xn = Xn 1_Xn=2