We investigate the effects of precision on the efficiency of various local search algorithms on 1-D unimodal functions. We present a (1+1)-EA with adaptive step size which finds the optimum in O(log n) steps, where n is the number of points used. We then consider binary and Gray representations with single bit mutations. The standard binary method does not guarantee locating the optimum, whereas using Gray code does so in O((log n)2) steps. A (1+1)-EA with a fixed mutation probability distribution is then presented which also runs in O((log n)2). Moreover, a recent result shows that this is optimal (up to some constant scaling factor), in that there exist unimodal functions for which a lower bound of Ω((log n)2) holds regardless of the choice of mutation distribution. Finally, we show that it is not possible for a black box algorithms to efficiently optimise unimodal functions for two or more dimensions (in terms of the precision used).

We analyze a simple random process in which a token is moved in the interval $A={0,dots,n$: Fix a probability distribution $mu$ over ${1,dots,n$. Initially, the token is placed in a random position in $A$. In round $t$, a random value $d$ is chosen according to $mu$. If the token is in position $ageq d$, then it is moved to position $a-d$. Otherwise it stays put. Let $T$ be the number of rounds until the token reaches position 0. We show tight bounds for the expectation of $T$ for the optimal distribution $mu$. More precisely, we show that $min_mu{E_mu(T)=Thetaleft((log n)^2 ight)$. For the proof, a novel potential function argument is introduced. The research is motivated by the problem of approximating the minimum of a continuous function over $[0,1]$ with a ``blind'' optimization strategy.

MOTIVATION: Not individual single nucleotide polymorphisms (SNPs), but high-order interactions of SNPs are assumed to be responsible for complex diseases such as cancer. Therefore, one of the major goals of genetic association studies concerned with such genotype data is the identification of these high-order interactions. This search is additionally impeded by the fact that these interactions often are only explanatory for a relatively small subgroup of patients. Most of the feature selection methods proposed in the literature, unfortunately, fail at this task, since they can either only identify individual variables or interactions of a low order, or try to find rules that are explanatory for a high percentage of the observations. In this article, we present a procedure based on genetic programming and multi-valued logic that enables the identification of high-order interactions of categorical variables such as SNPs. This method called GPAS cannot only be used for feature selection, but can also be employed for discrimination. RESULTS: In an application to the genotype data from the GENICA study, an association study concerned with sporadic breast cancer, GPAS is able to identify high-order interactions of SNPs leading to a considerably increased breast cancer risk for different subsets of patients that are not found by other feature selection methods. As an application to a subset of the HapMap data shows, GPAS is not restricted to association studies comprising several 10 SNPs, but can also be employed to analyze whole-genome data. AVAILABILITY: Software can be downloaded from http://ls2-www.cs.uni-dortmund.de/~nunkesser/#Software

It is well known that the hardest bit of integer multiplication is the middle bit, i.e., MUL n−1,n . This paper contains several new results on its complexity. First, the size s of randomized read-k branching programs, or, equivalently, their space (log s) is investigated. A randomized algorithm for MUL n−1,n with $$k = {\mathcal{O}}(\hbox{log}\, n)$$ (implying time $${\mathcal{O}}(n\, \hbox{log}\, n))$$ , space $${\mathcal{O}}(\hbox{log}\, n)$$ and error probability n −c for arbitrarily chosen constants c is presented. Second, the size of general branching programs and formulas is investigated. Applying Nechiporuk’s technique, lower bounds of $$\Omega (n^{3/2}/ \hbox{log}\, n)$$ and Ω (n 3/2), respectively, are obtained. Moreover, by bounding the number of subfunctions of MUL n−1,n , it is proven that Nechiporuk’s technique cannot provide larger lower bounds than $${\mathcal{O}}(n^{5/3}/ \hbox{log}\, n)$$ and $${\mathcal{O}}(n^{5/3})$$ , respectively.

To understand the working principles of randomized search heuristics like evolutionary algorithms they are analyzed on optimization problems whose structure is well-studied. The idea is to investigate when it is possible to simulate clever optimization techniques for combinatorial optimization problems by random search. The maximum matching problem is well suited for this approach since long augmenting paths do not allow immediate improvements by local changes. It is known that randomized search heuristics like simulated annealing, the Metropolis algorithm, the (1+1) EA and randomized local search efficiently approximate maximum matchings for any graph; however, there are graphs where they fail to find maximum matchings in polynomial time. In this paper, we examine randomized local search (RLS) for graphs whose structure is simple. We show that RLS finds maximum matchings on trees in expected polynomial time.

Simulated annealing and the (1+1) EA, a simple evolutionary algorithm, are both general randomized search heuristics that optimize any objective function with probability converging to 1. But they use very different techniques to achieve this global convergence. The (1+1) EA applies global mutations than can reach any point in the search space in one step together with an elitist selection mechanism. Simulated annealing restricts its search to a neighborhood but employs a randomized selection scheme where the probability for accepting a move to a new point in the search space depends on the difference in function values as well as on the current time step. Otherwise, the two algorithms are equal. It is known that the different philosophies of search implemented in the two heuristics can lead to exponential performance gaps between the two algorithms with respect to the expected optimization time. Even for very restricted classes of objective functions where the differences in function values between neighboring points are strictly limited the performance differences can be huge. Here, a more local point of view is taken. Considering obstacles in the fitness landscapes it is proven that the local performance of the two algorithms is remarkably similar in spite of their different search behaviors.

Many real-world problems are multi-objective optimization problems and evolutionary algorithms are quite successful on such problems. Since the task is to compute or approximate the Pareto front, multi-objective optimization problems are considered as more difficult than single-objective problems. One should not forget that the fitness vector with respect to more than one objective contains more information that in principle can direct the search of evolutionary algorithms. Therefore, it is possible that a single-objective problem can be solved more efficiently via a generalized multi-objective model of the problem. That this is indeed the case is proved by investigating the computation of minimum spanning trees.

Evolutionary algorithms (EAs) generally come with a large number of parameters that have to be set before the algorithm can be used. Finding appropriate settings is a difficult task. The influence of these parameters on the efficiency of the search performed by an evolutionary algorithm can be very high. But there is still a lack of theoretically justified guidelines to help the practitioner find good values for these parameters. One such parameter is the offspring population size. Using a simplified but still realistic evolutionary algorithm, a thorough analysis of the effects of the offspring population size is presented. The result is a much better understanding of the role of offspring population size in an EA and suggests a simple way to dynamically adapt this parameter when necessary.

We study how big the blow-up in size can be when one switches between the CNF and DNF representations of Boolean functions. For a function f:{0,1}n→{0,1}, cnfsize(f) denotes the minimum number of clauses in a CNF for f; similarly, dnfsize(f) denotes the minimum number of terms in a DNF for f. For 0⩽m⩽2n-1, let dnfsize(m,n) be the maximum dnfsize(f) for a function f:{0,1}n→{0,1} with cnfsize(f)⩽m. We show that there are constants c1,c2⩾1 and ε>0, such that for all large n and all m∈[1εn,2εn], we have2n-c1(n/log(m/n))⩽dnfsize(m,n)⩽2n-c2(n/log(m/n)).In particular, when m is the polynomial nc, we get dnfsize(nc,n)=2n-θ(c-1(n/logn)).

Many experiments have proved that crossover is an essential search operator in evolutionary algorithms, at least for certain functions. However, the rigorous analysis of such algorithms on crossover-friendly functions is still in its infancy. Here, a recombinative hill-climber is analyzed on the crossover-friendly function hierarchical-if-and-only-if (H-IFF) introduced by Watson et al. (1998). The dynamics of this algorithm are investigated and it is proved that the expected optimization time equals /spl Theta/(n log n).

Branching problems are considered as a nonuniform model of computation in complexity theory as well as a data structure for boolean functions in several applications. In many applications (e.g., verification), exact representations are required. For learning boolean functions f on the basis of classified examples, it is sufficient to produce the representation of a function g approximating f. This motivates the investigation of the size of the smallest branching program approximating f. Although several non-approximability results are contained in the papers on randomized branching programs, these results often do not work for the uniform distribution (which is the most important one in applications). Here, the following non-approximability results are presented. (1) It is proven that a simple function from the branching program literature requires exponential size to be approximated with respect to the uniform distribution by OBDDs, which are the most important type of branching programs in applications. (2) The first truly exponential lower bound on the size of approximating syntactic read-k-times branching programs with respect to the uniform distribution and error probability 1/2-2/sup -/spl Omega/(n)/, n the input size, is shown. In order to improve upon the so far best results for error probabilities smaller than 1/3, a strong combinatorial lemma from a recent paper of Ajtai on linear-length branching programs is exploited.

We discuss an open problem with constructing an OBDD using composition and prove that the worst case complexity of the construction is truly cubic. Using this insight, we show compactness of partitioned-OBDD over monolithic OBDD.

The most simple evolutionary algorithm (EA), the so-called (1 + 1) EA, accepts an offspring if its fitness is at least as large (in the case of maximization) as the fitness of its parent. The variant (1 + 1)* EA only accepts an offspring if its fitness is strictly larger than the fitness of its parent. Here, two functions related to the class of long-path functions are presented such that the (1 + 1) EA maximizes one in polynomial time and needs exponential time for the other while the (1 + 1)* EA has the opposite behavior. These results demonstrate that small changes of an EA may change its behavior significantly. Since the (1 + 1) EA and the (1 + 1)* EA differ only on plateaus of constant fitness, the results also show how EAs behave on such plateaus. The (1 + 1) EA can pass a path of constant fitness and polynomial length in polynomial time. Finally, for these functions, it is shown that local performance measures like the quality gain and the progress rate do not describe the global behavior of EAs.

We discuss an open problem in ROBDD construction using composition and prove that the worst case complexity of the construction is truly cubic. With this insight we show that the process of composition naturally leads to construction of (even exponentially) compact partitioned-OBDDs (POBDDs)[17]. Our algorithm which incorporates dynamic partitioning, leads to the most general (and compact) form of POBDDs - graphs with multiple root variables. To show our algorithm is robust and practical, we have analyzed some well known problems in Boolean function representation, verification and finite state machine analysis where our approach generates graphs which are even orders of magnitude smaller.

Evolutionary algorithms (EAs) are heuristic randomized algorithms which, by many impressive experiments, have been proven to behave quite well for optimization problems of various kinds. In this paper a rigorous theoretical complexity analysis of the (1 + 1) evolutionary algorithm for separable functions with Boolean inputs is given. Different mutation rates are compared, and the use of the crossover operator is investigated. The main contribution is not the result that the expected run time of the (1 + 1) evolutionary algorithm is theta (n ln n) for separable functions with n variables but the methods by which this result can be proven rigorously.

Ordered binary decision diagrams are a useful representation of Boolean functions, if a good variable ordering is known. Variable orderings are computed by heuristic algorithms and then improved with local search and simulated annealing algorithms. This approach is based on the conjecture that the following problem is NP-complete. Given an OBDD G representing f and a size bound s, does there exist an OBDD G* (respecting an arbitrary variable ordering) representing f with at most s nodes? This conjecture is proved.

The problem of constructing an OBDD cover of minimal size for an incompletely specified Boolean function arises in several applications in the CAD domain, e.g., the verification of sequential machines and the construction of OBDD's for incompletely specified circuits. The complexity of this problem is determined. The decision problem is NP-complete. Efficient approximation algorithms exist only if NP=P.

Chakravarty presents a characterization of BDD's in terms of the complexity of some computational problems, ibid., vol. 42, p. 129-137, Feb. 1993. In these comments, some incorrectly stated restrictions on the "number of repeated variables" are corrected and results on the translation problem (to include EXOR and NEXOR gates) are generalized.>

Boolean functions are often represented by ordered binary-decision diagrams (OBDDs) introduced by Bryant (1986). Liaw and Lin (1992) have proved upper and lower bounds on the minimal OBDD size of almost all Boolean functions. Now tight bounds are proved for the minimal OBDD size for arbitrary or optimal variable orderings and for the minimal read-once branching program size of almost all functions. Almost all Boolean functions have a sensitivity of almost 1, i.e., the minimal OBDD size for an optimal variable ordering differs from the minimal OBDD size for a worst variable ordering by a factor of at most 1+/spl epsi/(n) where /spl epsi/(n) converges exponentially fast to 0.>

Xunrang and Yuzhang have presented the HEAPSORT variant NEWheapsort whose worst case complexity is (4/3)n log 2 n+O(n). By a simple modification this algorithm can he improved to have a better average case complexity and a worst case complexity of only (7/6)n log 2 n+O(n)

Exponential lower bounds on the complexity of computing the clique functions in the Boolean decision-tree model are proved. For one-time-only branching programs, large polynomial lower bounds are proved for k -clique functions if k is fixed, and exponential lower bounds if k increases with n . Finally, the hierarchy of the classes BP d ( P ) of all sequences of Boolean functions that may be computed by d -times only branching programs of polynomial size is introduced. It is shown constructively that BP 1 ( P ) is a proper subset of BP 2 ( P ).

A sequence of monotone switching functions fn:{0,1}n →{0,1}n is constructed, such that the monotone complexity of fn grows faster than O(n2-ε) for any ε>O. Previously the best lower bounds of this nature were several O(n3/2) bounds due to Pratt, Paterson, Mehlhorn/Galil and Savage.