1. Upper Bounds on the Time and Space Complexity of Optimizing Additively Separable Functions Matthew J. Streeter Carnegie Mellon University Pittsburgh, PA matts@cs.cmu.edu

2. Outline Introduction Definitions & notation Detecting linkage Algorithm, analysis & performance Conclusions

3. Introduction An additively separable function f of order k is one that can be expressed as: where each f i depends on at most k characters of s, and each character contributes to at most one f i Studied extensively in EC literature, particularly in relation to competent GAs.

4. Introduction David Goldberg, The Design of Innovation (p. 51-2) “[W]e would like a procedure that scales polynomially, as O(j b ) with b as small a number as possible (current estimates of b suggest that subquadratic—b≤2—solutions are possible).”

5. Introduction Previous bound: time O(j 2 ); space O(1) (Munemoto & Goldberg 1999) New bound: time O(j*ln(j)); space O(1)

6. Definitions & notation s i = ith character of binary string s s[i  c] = a copy of s with s i set to c  f i (s) = f(s[i  (  s i )]) - f(s) = effect on fitness of flipping i th bit (Munemoto & Goldberg 1999)

7. Definitions & notation Linkage: positions i and j are linked, written  (i, j), if there is some string s such that:  f i (s[j  0])   f i (s[j  1]) Grouping: i and j are grouped, written  (i, j), if i=j or if there is some sequence i 0, i 1,..., i n such that: i 0 = i i n = j  (i m, i m+1 ) for 0  m < n

8. Definitions & notation Linkage group: a non-empty set g such that if i  g then j  g iff.  (i, j) Linkage group partition: the unique set  f = {g 1, g 2,..., g n } of linkage groups of f.

9. Example f(s) = s 1 s 2 + s 2 s 3 + s 4 s 5 Linkage:  (1, 2)  (2, 3)  (4, 5)  (2, 1)  (3, 2)  (5, 4) Linkage groups: {1,2,3} and {4,5}, so  f = {{1,2,3}, {4,5}} f is an additively separable function of order 3

10. Relationship to additively separable functions If  f = {g 1, g 2,..., g n } then f can be written as: where each f i depends only on the positions in g i So f is additively separable of order k = max 1≤i≤n |g i | So once we know  f, we can find the global optimum of f in time O(2 k *j) by local search

11. Algorithm overview Start with a random string  and the trivial linkage group partition  = {{1}, {2},..., {j}}. Repeatedly perform a randomized test to detect pairs of positions that are linked Every time we find a new link  (i,j), merge i’s and j’s subset to form a new subset g’, and use local search to make  optimal w.r.t. g’ Once  =  f, we will have found a globally optimal string

12. Detecting linkage: O(j 2 ) approach For fixed i and j, pick a random string s and check if  f i (s[j  0])   f i (s[j  1]). Test requires 4 function evaluations, and is conclusive with probability at least 2 -k. Leads to an algorithm that requires O(2 k *j 2 ) function evaluations. (Munemoto & Goldberg 1999)

13. Detecting linkage: O(j*ln(j)) approach For fixed i, generate two random strings s and t that have the same character at i, and check whether  f i (s)   f i (t). Suppose  f i (s)   f i (t). Let d be the hamming distance from s to t. –If d=1, call the position that differs j and we have  (i, j) by definition –Otherwise create a string s’ that differs from both s and t in d/2 positions. We must have either  f i (s’)   f i (s) or  f i (s’)   f i (t), so just recurse until we get d=1.

14. Example f(s) = s 1 s 2 + s 2 s 3 + s 4 s 5 i = 2 Iteration 1 s  f 2 (s) s (1) 00000 0 t (1) 101112 s (1) ’000110 Iteration 2 s  f 2 (s) s (2) 00011 0 t (2) 101112 s (2) ’001111 Iteration 3 s  f 2 (s) s (2) 00111 1 t (2) 101112 Conclusion:  (1, 2)

15. How to use this? Some links are more “obvious” than others Ideally we would like to only discover novel links (those that let us update  ) We would like test to be conclusive with probability at least 2 -k

16. Discovering novel links Binary search starting at s and t will always return a position j where s and t disagree (s j  t j ) So, when looking for a link from i, just make sure s and t agree on all the positions in whichever subset in  contains i

17. Probability that test is conclusive Let g be the subset in  that contains i, and let g f be i’s true linkage group (g  g f ) Can show that with probability at least 2 -|g|, will choose an s such that for some t,  f i (t)   f i (s) Because there only |g f | - |g| positions left in t that affect  f i (t), test will be conclusive with probability at least:

18. Finding  f On each iteration, let i run from 1 to j and perform test for link out of i

19. Analysis Each conclusive test requires time O(ln(j)) and we do at most j-1 of them, so total time is O(j*ln(j)) Time for local search is O(2 k *j) Only thing left is time for inconclusive tests, each of which is O(1). Need to know the number t of rounds needed to discover the correct  with probability ≥ p

20. Calculating number of rounds To discover  f it is sufficient that each position participate in 1 conclusive test If this hasn’t happened yet, it happens with probability at least 2 -k This means we get a lower bound by analyzing the following algorithm: for n from 1 to t do: for i from 1 to j do: with probability 2 -k, mark i if all positions are marked, return ‘success’ return ‘failure’

21. Calculating number of rounds The probability that this algorithm succeeds is p = (1-(1-2 -k ) t )  To succeed with probability p, we must set t  Some calculus shows that this is O(2 k *ln(j))

22. Performance Near-linear scaling as expected Have solved up to 100,000 bit problems with this algorithm Ran on folded trap functions with k=5, 5 ≤ j ≤ 1000

23. Limitations Function must be strictly additively separable On any real problem, this algorithm will become an exhaustive search Can start to address this using averaging and thresholding (Munemoto & Goldberg 1999) I believe these limitations can be overcome

24. Conclusions New upper bounds on time complexity (O(2 k *j*ln(j))) and space complexity (O(1)) of optimizing additively separable functions Algorithm not practical as-is Linkage detection algorithm presented here could be used to construct more powerful competent GAs