Representing fitness landscapes by valued constraints to understand the complexity of local search

TL;DR

This paper introduces a novel representation of fitness landscapes using valued constraints, revealing structural properties that determine the complexity of local search and identifying conditions for tractability.

Contribution

It develops methods to analyze the structure of fitness landscapes via valued constraints, providing bounds on local search complexity and characterizing tractable cases.

Findings

Minimal constraint graphs can be computed efficiently for binary Boolean landscapes.

NP-hardness of minimal constraint graph computation when landscapes are considered up to local search equivalence.

Quadratic bounds on local search steps for landscapes with degree 2 or tree-structured constraint graphs.

Abstract

Local search is widely used to solve combinatorial optimisation problems and to model biological evolution, but the performance of local search algorithms on different kinds of fitness landscapes is poorly understood. Here we consider how fitness landscapes can be represented using valued constraints, and investigate what the structure of such representations reveals about the complexity of local search. First, we show that for fitness landscapes representable by binary Boolean valued constraints there is a minimal necessary constraint graph that can be easily computed. Second, we consider landscapes as equivalent if they allow the same (improving) local search moves; we show that a minimal constraint graph still exists, but is NP-hard to compute. We then develop several techniques to bound the length of any sequence of local search moves. We show that such a bound can be obtained from the numerical values of the constraints in the representation, and show how this bound may be tightened by considering equivalent representations. In the binary Boolean case, we prove that a degree 2 or tree-structured constraint graph gives a quadratic bound on the number of improving moves made by any local search; hence, any landscape that can be represented by such a model will be tractable for any form of local search. Finally, we build two families of examples to show that the conditions in our tractability results are essential. With domain size three, even just a path of binary constraints can model a landscape with an exponentially long sequence of improving moves. With a treewidth-two constraint graph, even with a maximum degree of three, binary Boolean constraints can model a landscape with an exponentially long sequence of improving moves.

Equations

$$g_i^{\prime }(x)=(1-x_i)C_i^{\prime }(0)+x_i{C}_i^{\prime }(1)$$

$$g_{ij}^{\prime }(x)=(1-x_i)(1-x_j)C_{ij}^{\prime }(0,0)$$

$$+x_i(1-x_j)C_{ij}^{\prime }(1,0)+x_i{x}_j{C}_{ij}^{\prime }(1,1).$$

$$f(x)$$

$$=C_{\varnothing }^{\prime }+\sum _{i=1}^n{g}_i^{\prime }(x)+\text{smashoperator}[lr]\sum _{\{i,j\}\in E({\mathcal{C}}^{\prime })}{g}_{ij}^{\prime }(x)$$

$$=C_{\varnothing }+\sum _{i=1}^n{x}_i{c}_i+\text{smashoperator}[lr]\sum _{1\le i<j\le n}{x}_i{x}_j{c}_{ij}$$

$$c_i$$

$$c_{ij}$$

$$f(e_{ij})-f(e_i)-f(e_j)+f(0^n)=c_{ij}$$

$$f(e_{ij})-f(e_i)-f(e_j)+f(0^n)=C_{ij}^{\prime }(1,1)-C_{ij}^{\prime }(1,0)-C_{ij}^{\prime }(0,1)+C_{ij}^{\prime }(0,0)$$

$$(x,x[i\mapsto {\overline{x}}_i])\in E(G)\text{but}(x[j\mapsto {\overline{x}}_j],x[i\mapsto {\overline{x}}_i,j\mapsto {\overline{x}}_j])\notin E(G)$$

$$\text{sgn}(f(x[i\mapsto {\overline{x}}_i])-f(x))\ne \mathrm{sgn}(f(x[i\mapsto {\overline{x}}_i,j\mapsto {\overline{x}}_j])-f(x[j\mapsto {\overline{x}}_j])).$$

$$c_{ij}\ge f(x)-f(x[k\mapsto 0])>0\text{or}{c}_{ij}\le f(x)-f(x[k\mapsto 0])<0$$

$$f(x)>f(x[i\mapsto 0])\text{ but }f(x)-c_{ij}\le f(x[i\mapsto 0]).$$

$$c_{ij}\ge f(x)-f(x[k\mapsto 0])>0\text{or}{c}_{ij}\le f(x)-f(x[k\mapsto 0])<0$$

$$f(x[j\mapsto 0])-f(x[i\mapsto 0,j\mapsto 0])=f(x)-f(x[i\mapsto 0])-c_{ij}\le 0$$

$$f(x)>f(x[i\mapsto \overline{x_i}])\text{and}f(x[j\mapsto \overline{x_j}])\le f(x[i\mapsto \overline{x_i},j\mapsto \overline{x_j}])$$

$$g_i(x)+C_{ij}(x_i,x_j)$$

$$g_i(x)+C_{ij}(x_i,\overline{x_j})$$

$$C_{ij}(x_i,x_j)-C_{ij}(\overline{x_i},x_j)>g_i(x[i\mapsto \overline{x_i}])-g_i(x)\ge C_{ij}(x_i,\overline{x_j})-C_{ij}(\overline{x_i},\overline{x_j})$$

$$f(e_{S}01)$$

$$f(e_{S}00)$$

$$\text{If }\sum _{i\in S}{s}_i\le t-1\text{ then:}$$

$$f(e_{S}01)-f(e_{S}00)\le -4$$

$$f(e_{S}11)-f(e_{S}10)\le -2$$

$$\mathrm{span}(\mathcal{C})=\sum _{C_S\in \mathcal{C}}\left(\underset{z\in D^S}{\max }{C}_S(z)-\underset{z\in D^S}{\min }{C}_S(z)\right).$$

$$\mathrm{span}(\mathcal{C})=\stackrel{{\mathrm{span}}_1(\mathcal{C})}{\overbrace{\sum _{i\in [n]}|c_i|}}+\stackrel{{\mathrm{span}}_2(\mathcal{C})}{\overbrace{\sum _{\{i,j\}\in E(\mathcal{C})}|c_{ij}|}}$$

$$|c_i|$$

$$\le |C_i^{\prime }(1)-C_i^{\prime }(0)|+\sum _{j|\{i,j\}\in E({\mathcal{C}}^{\prime })}|C_{ij}^{\prime }(1,0)-C_{ij}^{\prime }(0,0)|$$

$$\le \mathrm{span}(\{C_i^{\prime }\})+\mathrm{span}(\{C_{ij}^{\prime }|j\in N_{{\mathcal{C}}^{\prime }}(i)\})$$

$${\mathrm{span}}_1(\mathcal{C})=\sum _{i=1}^n|c_i|$$

$$={\mathrm{span}}_1({\mathcal{C}}^{\prime })+2{\mathrm{span}}_2({\mathcal{C}}^{\prime })$$

$$\le 2\mathrm{span}({\mathcal{C}}^{\prime })$$

$$|c_{ij}|$$

$$\le |C_{ij}^{\prime }(1,1)-C_{\{i,j\}}^{\prime }(1,0)|+|C_{ij}^{\prime }(0,0)-C_{ij}^{\prime }(0,1)|$$

$$\le 2\mathrm{span}(\{C_{ij}^{\prime }\})$$

$${\mathrm{span}}_2(\mathcal{C})=\sum _{\{i,j\}\in E(\mathcal{C})}|c_{ij}|\le 2\sum _{\{i,j\}\in E({\mathcal{C}}^{\prime })}\mathrm{span}(\{C_{ij}^{\prime }\})\le 2{\mathrm{span}}_2({\mathcal{C}}^{\prime })$$

Full text

First, we show that for fitness landscapes representable by binary Boolean valued constraints there is a minimal necessary constraint graph that can be easily computed. Second, we consider landscapes as equivalent if they allow the same (improving) local search moves; we show that a minimal constraint graph still exists, but is NP-hard to compute.

We then develop several techniques to bound the length of any sequence of local search moves. We show that such a bound can be obtained from the numerical values of the constraints in the representation, and show how this bound may be tightened by considering equivalent representations. In the binary Boolean case, we prove that a degree 2 or tree-structured constraint graph gives a quadratic bound on the number of improving moves made by any local search; hence, any landscape that can be represented by such a model will be tractable for any form of local search.

Finally, we build two families of examples to show that the conditions in our tractability results are essential. With domain size three, even just a path of binary constraints can model a landscape with an exponentially long sequence of improving moves. With a treewidth-two constraint graph, even with a maximum degree of three, binary Boolean constraints can model a landscape with an exponentially long sequence of improving moves.

1 Introduction

Local search techniques are widely used to solve combinatorial optimisation problems, and have been intensively studied since the 1980’s Aaronson (\APACyear2006); Chapdelaine \BBA Creignou (\APACyear2005); Johnson \BOthers. (\APACyear1988); Llewellyn \BOthers. (\APACyear1989); Malan \BBA Engelbrecht (\APACyear2013); Ochoa \BBA Veerapen (\APACyear2018); Schaffer \BBA Yannakakis (\APACyear1991); Tayarani-Najaran \BBA Prügel-Bennett (\APACyear2014). They have also played a central role in the theory of biological evolution, ever since Sewall Wright \APACyear1932 introduced the idea of viewing the evolution of populations of organisms as a local search process over a space of possible genotypes with associated fitness values that became known as a “fitness landscape”.

The term fitness landscape is now used to designate any structure $(A,f,N)$ consisting of a set of points $A$, a fitness function $f$ defined on those points, and a neighbourhood function $N$ on those points, that indicates which pairs of points are sufficiently close to be considered neighbours. A point $x$ is said to be locally optimal if all neighbours are non-improving (i.e., $\forall y\in N(x)\;f(x)\geq f(y)$) and globally optimal if all points are non-improving. The local search problem for a fitness landscape is to find such a local optimum. We say the problem is solved by a local search algorithm if the only moves allowed in the procedure are from a point $x$ to a point $x^{\prime}$ with $x^{\prime}\in N(x)$ and $f(x^{\prime})>f(x)$.

Many approaches have been developed to try to distinguish fitness landscapes where a local or global optimal point can be found efficiently by local search from those where such optimal points cannot be found efficiently. In the 1980’s and 90’s these attempts focused on statistical measures such as correlation between function values at various distances and various notions of ruggedness Malan \BBA Engelbrecht (\APACyear2013). But, by the late 90’s there were several studies highlighting the existence of fitness landscapes that were not rugged and yet were hard to optimise. Several new approaches have been developed recently, but the performance of local search algorithms on many kinds of fitness landscapes is still poorly understood Malan \BBA Engelbrecht (\APACyear2013); Ochoa \BBA Veerapen (\APACyear2018); Tayarani-Najaran \BBA Prügel-Bennett (\APACyear2014).

In almost all common examples of local search problems, the points in the fitness landscape are tuples of values from some domain, and neighbourhoods are defined by some appropriate notion of distance between tuples. The fitness function in such a landscape can be defined by a collection of valued constraints, and hence the search problem can be translated into a standard valued constraint satisfaction problem (VCSP) Cohen \BOthers. (\APACyear2013); Carbonnel \BOthers. (\APACyear2018); Färnqvist (\APACyear2012); Kolmogorov \BBA Zivny (\APACyear2013); Strimbu (\APACyear2019); Thapper \BBA Zivny (\APACyear2015, \APACyear2016).

In this paper we begin the development of a novel approach to understanding local search on fitness landscapes, based on representing the fitness function using valued constraints and studying the properties of these representations. Using the VCSP framework allows us to classify fitness landscapes in new ways, and hence to distinguish new classes of fitness landscapes with specific properties.

Finding a locally optimal point on an arbitrary fitness landscape is a complete problem for the class of problems known as polynomial local search (PLS) Johnson \BOthers. (\APACyear1988); Schaffer \BBA Yannakakis (\APACyear1991); Chapdelaine \BBA Creignou (\APACyear2005). This means that it is expected to be computationally intractable in general to find such a local optimum. In particular, there exist known constructions to produce families of fitness landscapes where every sequence of improving moves to a local optimum from some starting points is exponentially long Schaffer \BBA Yannakakis (\APACyear1991). On such landscapes, from such points, any local-search algorithm will require an exponentially long sequence of improving moves to reach a local optimum.

A key goal, therefore, is to identify classes of fitness landscapes where finding a local optimum is tractable (i.e., solvable in polynomial-time). We do this by identifying classes of fitness landscapes where every sequence of improving moves from every point is at most polynomially long. These classes are based on properties of the VCSP representation, such as the numerical values of the constraints or the structure of the constraint graph.

We start by showing in Section 3 that for some classes of fitness landscapes it is possible to efficiently compute a unique minimal representation as a VCSP instance (Theorems 3.4 and 3.5), giving a convenient normal form. Then in Section 4 we equate all fitness landscapes that have the same improving local search moves (Definition 4.1); we show that in some important cases a unique minimal representation for each equivalence class still exists (Theorems 4.4 and 4.7), but can be NP-hard to compute (Theorem 4.10).

Using these tools, we then develop several techniques to bound the length of any sequence of local search moves, based on properties of the VCSP representation. In Section 5 we show that such a bound can be obtained from the numerical values of the constraints in the representation (Proposition 5.2), and show how this bound may be tightened by considering equivalent representations (Examples 5.4 and 5.12). In Section 6, we prove that fitness landscapes that can be represented by binary Boolean VCSPs with tree-structured constraint graphs can have only quadratically long sequences of improving moves (Theorem 6.1) – hence they are tractable for any local search algorithm. Finally, in Section 7, we give examples of fitness landscapes that have very simple representations, but have exponentially long sequences of improving moves (Examples 7.1 and 7.2).

Because our results are based on bounding the length of all possible sequences of improving moves, they apply to all possible local search algorithms, and hence are particularly useful for investigating properties of biological evolution, as we discuss in Section 8.

2 Background, Notation, and General Definitions

We will model the points, $A$, in our fitness landscapes as assignments to a collection of $n$ variables, indexed by the set $[n]=1,2,\ldots,n$, with domains $D_{1},\ldots,D_{n}$. Hence each point corresponds to a vector $x\in D_{1}\times\cdots\times D_{n}$. We will generally focus on uniform domains (i.e., cases where $D=D_{1}=\cdots=D_{n}$), where this simplifies to $x\in D^{n}$. In particular, we will often be interested in Boolean domains, where $x\in\{0,1\}^{n}$, so each point can be seen as a bit-vector.

The restriction of a variable assignment $x$ to some subset of variables, with indices in a set $S\subseteq[n]$, will be denoted $x[S]$, so $x[S]\in\prod_{j\in S}D_{j}$. To reference the assignment to the variable at position $i$, we will usually write $x_{i}$ unless it is ambiguous, in which case we’ll use the more general notation $x[i]$. If we want to modify $x$ by changing a single variable, say the variable at position $i$, to some element $b\in D_{i}$, then we’ll write $x[i\mapsto b]$.

Given a set of points, $A$, a fitness function on $A$ is defined to be an integer-valued function defined on $A$, that is, a function $f:A\rightarrow\mathbb{Z}$. Because we are modelling fitness, rather than cost, we maximise our objective functions in this paper. All results can be carried over directly to the minimisation context.

To complete the definition of a fitness landscape, we will define a neighbourhood function on the set of points $A$ to be a function $N:A\rightarrow 2^{A}$. For simplicity, we will assume this function is symmetric in the sense that if $y\in N(x)$, then $x\in N(y)$, and we will call such a pair $x$ and $y$ adjacent points. Throughout the paper, we will focus on the case where the set of points $A$ is the set of assignments $D_{1}\times\cdots\times D_{n}$ and $N$ is the 1-flip neighbourhood defined by $y\in N(x)$ if and only if there is a variable position $i$ such that $x_{i}\neq y_{i}$ and this is the only difference (i.e., $\forall j\neq i\quad x_{j}=y_{j}$). Hence, in the case of the Boolean domain, the graph of the function $N$, where the edges are the pairs of adjacent points, will be the $n$-dimensional hypercube. Note that considering larger neighbourhoods will only increase (or keep the same) the length of the longest ascending path through the fitness landscape.

Definition 2.1** (\shortciteNPdVPK09,CGB13)**

Given any fitness landscape $(A,f,N)$, the corresponding fitness graph $G$ has vertex set $V(G)=A$ and directed edge set $E(G)=\{(x,y)\;|\;y\in N(x)\text{ and }f(y)>f(x)\}$.

The edges of the fitness graph consist of all pairs of adjacent points which have distinct values of the fitness function, and are oriented from the lower value of the fitness function to the higher value; such directed edges represent the possible moves that can be made by a local search algorithm.

A (valued) constraint with scope $S\subseteq[n]$ is a function $C_{S}:\prod_{j\in S}D_{j}\rightarrow\mathbb{Z}$. The arity of a constraint $C_{S}$ is the size $|S|$ of its scope. For unary and binary constraints we will generally omit the set notation and just write $C_{i}$ for $C_{\{i\}}$ or $C_{ij}$ for $C_{\{i,j\}}$, where $i<j$. We will represent the values taken by a unary constraint $C_{i}$ for each domain element by an integer vector of length $|D_{i}|$, and represent the values taken by a binary constraint $C_{ij}$ for each pair of domain elements by an integer matrix, where $x_{i}$ selects the row and $x_{j}$ selects the column. A zero-valued constraint (of any arity) will be denoted by 0.

Definition 2.2

An instance of the valued constraint satisfaction problem (VCSP) is a set of constraints $\mathcal{C}=\{C_{S_{1}},\ldots,C_{S_{m}}\}$. We say that a VCSP instance $\mathcal{C}$ implements a fitness function $f$ if $f(x)=\sum_{k=1}^{m}C_{S_{k}}(x[S_{k}])$.

The arity of a VCSP instance is the maximum arity over its constraints; if this maximum arity is $2$, then we will call it a binary VCSP instance. The instance-size of a VCSP instance is the number of bits needed to specify $n$, $m$ and each constraint.

Given any VCSP instance $\mathcal{C}$, we can take $A$ as the set of all possible assignments, $f$ as the fitness function implemented by $\mathcal{C}$, and $N$ as the 1-flip neighbourhood, to obtain an associated fitness landscape, $(A,f,N)$, and hence an associated fitness graph, $G_{\mathcal{C}}$, by Definition 2.1. The vertex set of $G_{\mathcal{C}}$ is the set of possible assignments, $A$, and hence is exponential in the size of the instance, $\mathcal{C}$, in general. Each binary VCSP instance also has an associated constraint graph, defined as follows, whose vertex set is polynomial in the size of the instance:

Definition 2.3

Given any binary VCSP instance $\mathcal{C}$, the corresponding constraint graph has vertices $V(\mathcal{C})=[n]$, edges $E(\mathcal{C})=\{\{i,j\}\;|\;C_{ij}\in\mathcal{C},C_{ij}\neq 0\}$, and constraint-neighbourhood function $N_{\mathcal{C}}(i)=\{j\;|\;\{i,j\}\in E(\mathcal{C})\}$.

Each fitness landscape has a unique associated fitness graph which specifies all possible improving moves that can be made by a local search on that landscape. On the other hand, for each fitness landscape there may be a number of different VCSP instances that implement the fitness function of that landscape, and they may have different constraint graphs. This motivates the search for canonical, minimal or normalised representations of a given landscape, which we explore in the next two sections.

3 Magnitude-Equivalence

It is clear from Definition 2.2 that different VCSP instances can implement the same fitness function.

Example 3.1

Consider the two small VCSP instances shown in Figure 1.

Although these two instances have different constraint graphs, they both implement the fitness function $[f(00),f(01),f(10),f(11)]=[1,2,2,3]$.

We capture this equivalence with the following definition:

Definition 3.2

If two VCSP instances $\mathcal{C}_{1}$ and $\mathcal{C}_{2}$ implement the same fitness function $f$, then we will say they are magnitude-equivalent.

We will show in this section that for binary Boolean VCSP instances each equivalence class of magnitude-equivalent VCSP instances has a normal form: a unique, minimal, and easy to compute representative member with special properties.

Definition 3.3

A binary Boolean VCSP instance $\mathcal{C}$ is simple if every unary constraint has the form $C_{i}=\begin{pmatrix}0\\ c_{i}\end{pmatrix}$ and every binary constraint has the form $C_{ij}=\begin{pmatrix}0&0\\ 0&c_{ij}\end{pmatrix}$.

Each value $c_{i}$ or $c_{ij}$ will be referred to as the weight of the corresponding constraint.

We now give a direct proof of the following simplification result which is analogous to similar results using constraint propagation in the standard VCSP Cooper \BOthers. (\APACyear2007) (and is essentially a translation of standard results for pseudo-Boolean functions, \citeNPCramaHammer2011).

Theorem 3.4

Any binary Boolean VCSP instance $\mathcal{C}^{\prime}$ can be transformed into a unique simple VCSP instance $\mathcal{C}$ that is magnitude-equivalent to $\mathcal{C}^{\prime}$. Moreover, $\mathcal{C}$ can be constructed from $\mathcal{C}^{\prime}$ in linear time.

*Proof: * First, two key observations:

Any unary Boolean constraint $C^{\prime}_{i}:\{0,1\}\rightarrow\mathbb{Z}$ can be rewritten as a linear function:

[TABLE] 2. 2.

Any binary Boolean constraint $C^{\prime}_{ij}:\{0,1\}\times\{0,1\}\rightarrow\mathbb{Z}$ can be rewritten as a multilinear polynomial of degree $2$:

[TABLE]

From this, we can simplify $\mathcal{C^{\prime}}$ just by simplifying polynomials:

[TABLE]

where we note that Equation 1 is a sum of a constant, some linear functions, and some multilinear polynomials of degree 2, and is thus itself a multilinear polynomial of degree 2 (or less). Equation 2 follows from Equation 1 by multiplying out into monomials and then grouping the coefficients of each similar monomial. In particular, this gives us the following coefficients:

[TABLE]

The above calculation can be done in linear time. As the last step in the simplification, note that Equation 2 corresponds to a VCSP instance $\mathcal{C}$ comprising a nullary constraint $C_{\emptyset}$, unary constraints $C_{i}=\begin{pmatrix}0\\ c_{i}\end{pmatrix}$, and binary constraints $C_{ij}=\begin{pmatrix}0&0\\ 0&c_{ij}\end{pmatrix}$.

The next result shows that a simple VCSP instance has the minimal constraint graph of any binary instance that implements the same fitness function:

Theorem 3.5

Let $\mathcal{C}$ be a simple binary Boolean VCSP instance. If the binary Boolean VCSP instance $\mathcal{C^{\prime}}$ is magnitude-equivalent to $\mathcal{C}$, then $E(\mathcal{C})\subseteq E(\mathcal{C^{\prime}})$.

*Proof: * Let $e_{i}\in\{0,1\}^{n}$ be a variable assignment that sets the $i$th variable to one, and all other variables to zero. Similarly, let $e_{ij}\in\{0,1\}^{n}$ be a variable assignment that sets the $i$th and $j$th variables to one, and all other variables to zero. Let $f$ be the fitness function implemented by $\mathcal{C}$. Since $\mathcal{C}$ is simple, we have:

[TABLE]

where we take $c_{ij}=0$ if $\{i,j\}\notin E(\mathcal{C})$. Similarly, if $\mathcal{C}^{\prime}$ also implements $f$, we have:

[TABLE]

If $\{i,j\}\in E(\mathcal{C})$ then $c_{ij}\neq 0$, so $C^{\prime}_{ij}(1,1)-C^{\prime}_{ij}(1,0)-C^{\prime}_{ij}(0,1)+C^{\prime}_{ij}(0,0)\neq 0$ and hence $\{i,j\}\in E(\mathcal{C}^{\prime})$.

4 Sign-Equivalence

In the previous section we considered the equivalence class of all VCSP instances which implement precisely the same fitness function. However, when investigating the performance of local search algorithms, the exact values of the fitness function are not always relevant; it may be sufficient to consider only the fitness graph.

For example, consider a fitness function $f$, implemented by a VCSP instance $\mathcal{C}$, where all fitness values are distinct, but there is at least one pair $i,j$ of positions with no constraint $C_{ij}$. Now consider the new fitness function $f^{\prime}(x)=2f(x)+C_{ij}(x_{i},x_{j})$ where $C_{ij}=[0,0;0,1]$. The fitness graph corresponding to $f^{\prime}$ is unchanged (since all fitness values given by $2f(x)$ differ by at least 2, every edge is still present in the fitness graph, and no orientations are changed by the new constraint), but we cannot eliminate this new $C_{ij}$ constraint without changing the precise values of the fitness function at some points. To capture this similarity between $f$ and $f^{\prime}$, we introduce a more abstract equivalence relation:

Definition 4.1

If two VCSP instances $\mathcal{C}_{1}$ and $\mathcal{C}_{2}$ give rise to the same fitness graph, then we will say they are sign-equivalent.

As with magnitude-equivalence, we will show that for binary Boolean VCSP instances it is possible to define a normal form or minimal representative member of each equivalence class of sign-equivalent VCSP instances with a unique minimal constraint graph. Unfortunately, we will see that, unlike the situation for magnitude-equivalence, this minimum sign-equivalent constraint graph is NP-hard to compute.

Definition 4.2

In a Boolean fitness graph $G$ with vertex set $\{0,1\}^{n}$, we will say that $i$ sign-depends on $j$ if there exists an assignment $x\in\{0,1\}^{n}$ such that:

[TABLE]

Note that $i$ sign-depends on $j$ if and only if, for any fitness function $f$ that corresponds to the fitness graph $G$, there exists $x\in\{0,1\}^{n}$ such that:

[TABLE]

We will say that $i$ and $j$ sign-interact if $i$ sign-depends on $j$, or $j$ sign-depends on $i$ (or both). If $i$ and $j$ do not sign-interact then we will say that they are sign-independent.

Definition 4.3

A simple binary Boolean VCSP instance $\mathcal{C}$ with associated fitness graph $G_{\mathcal{C}}$ is called trim if for all $\{i,j\}\in E(\mathcal{C})$, $i$ and $j$ sign-interact in $G_{\mathcal{C}}$.

Our next result is the sign-equivalence analog of Theorem 3.4, and guarantees a normal form:

Theorem 4.4

Any simple binary Boolean VCSP instance $\mathcal{C}^{\prime}$ can be transformed into a trim VCSP instance $\mathcal{C}$ that is sign-equivalent to $\mathcal{C}^{\prime}$.

To prove Theorem 4.4 we now establish two propositions: Proposition 4.5 connects the magnitude of constraints with their effect on fitness graphs, and Proposition 4.6 connects the magnitude of constraints to sign-interaction.

Proposition 4.5

Given a simple binary Boolean VCSP instance $\mathcal{C}$ implementing a fitness function $f$, if removing the constraint $C_{ij}$ changes the corresponding fitness graph, then for at least one $k\in\{i,j\}$ there exists some $x\in\{0,1\}^{n}$ with $x_{i}=x_{j}=1$ such that:

[TABLE]

*Proof: * Without loss of generality (by swapping $i$ and $j$ in the variable numbering if necessary), we can suppose that $k=i$. Consider two cases:

Case 1

($c_{ij}>0$): If removing $C_{ij}$ changes the fitness graph, then there exists some $x\in\{0,1\}^{n}$ with $x_{i}=x_{j}=1$ such that:

[TABLE]

We can re-arrange Equation 7 to get $c_{ij}\geq f(x)-f(x[i\mapsto 0])>0$.

Case 2

($c_{ij}<0$): This is the same as case 1, except that the direction of the inequalities in Equation 7 are reversed.

Proposition 4.6

Given a simple binary Boolean VCSP instance $\mathcal{C}$ implementing a fitness function $f$, if there exists a constraint $C_{ij}$ in $\mathcal{C}$, some assignment $x\in\{0,1\}^{n}$ with $x_{i}=x_{j}=1$, and some $k\in\{i,j\}$ such that:

[TABLE]

then $i$ sign-depends on $j$ in the associated fitness graph $G_{\mathcal{C}}$.

*Proof: * As in the proof of Proposition 4.5, we can suppose that $k=i$ (by swapping $i$ and $j$ in the variable numbering if necessary). Also, as in the proof of Proposition 4.5, the case for $c_{ij}<0$ is symmetric (by flipping the direction of inequalities) to $c_{ij}>0$. Thus, we will just consider the case where $k=i$ and $c_{ij}>0$.

Given that Equation 8 tells us that $f(x)>f(x[i\mapsto 0])$ (i.e., that $(x[i\mapsto 0],x)\in E(G_{\mathcal{C}})$), to establish that $i$ sign-depends on $j$ per Definition 4.2, we need to show that $f(x[j\mapsto 0])\leq f(x[i\mapsto 0,j\mapsto 0])$ (i.e., that $(x[i\mapsto 0,j\mapsto 0],x[j\mapsto 0])\not\in E(G_{\mathcal{C}})$). So, let us look at the difference of the latter:

[TABLE]

where the equality follows from Definition 2.2 ($\mathcal{C}$ implements $f$) and Definition 3.3 ($\mathcal{C}$ is simple), and the inequality follows from the first part of Equation 8.

*Proof: *[of Theorem 4.4] Note that Equations 6 and 8 specify the same conditions, hence the negation of this condition can be used to glue together the contrapositives of Proposition 4.6 (if $i$ and $j$ are sign-independent then Equation 6 does not hold) and Proposition 4.5 (if Equation 8 does not hold then $C_{ij}^{\prime}$ can be removed from $\mathcal{C}^{\prime}$ without changing the corresponding fitness graph). So we can convert $\mathcal{C^{\prime}}$ to a trim VCSP instance that is sign-equivalent to $\mathcal{C^{\prime}}$ by simply removing all $C^{\prime}_{ij}\in\mathcal{C}^{\prime}$ where $i$ and $j$ are sign-independent in the associated fitness graph $G_{\mathcal{C}^{\prime}}$.

The next result is the sign-equivalence analog of Theorem 3.5. It shows that a trim VCSP instance has the minimal constraint graph of any binary instance with the same associated fitness graph.

Theorem 4.7

Let $\mathcal{C}$ be a trim binary Boolean VCSP instance. If the binary Boolean VCSP instance $\mathcal{C}^{\prime}$ is sign-equivalent to $\mathcal{C}$, then $E(\mathcal{C})\subseteq E(\mathcal{C^{\prime}})$.

To prove Theorem 4.7, we just need to show that constraints between sign-interacting positions cannot be removed while preserving sign-equivalence. That is, we just need the following proposition:

Proposition 4.8

Let $\mathcal{C}$ be a binary Boolean VCSP instance with associated fitness graph $G_{\mathcal{C}}$. If $i,j$ sign-interact in $G_{\mathcal{C}}$, then the constraint $C_{ij}$ in $\mathcal{C}$ is non-zero.

*Proof: * Without loss of generality, assume that $i<j$ and we have an edge in $G_{\mathcal{C}}$ from $x[i\mapsto\overline{x_{i}}]$ to $x$. Thus, the fitness function $f$ implemented by $\mathcal{C}$ must satisfy the following two inequalities:

[TABLE]

Define $g_{i}(x)=C_{i}(x_{i})+\sum_{k\in N_{\mathcal{C}}(i)\setminus\{j\}}C_{ik}(x_{i},x_{k})$ and similarly for $g_{j}$. Also let $K_{ij}(x)$ be the part of $f$ independent of $x_{i},x_{j}$: i.e., $f(x)=K_{ij}(x)+g_{i}(x)+g_{j}(x)+C_{ij}(x_{i},x_{j})$. Rewriting (and simplifying) the two parts of Equation 9, we get:

[TABLE]

These equations can be rotated to sandwich the $g_{i}$ terms:

[TABLE]

which simplifies to $C_{ij}(x_{i},x_{j})-C_{ij}(\overline{x_{i}},x_{j})>C_{ij}(x_{i},\overline{x_{j}})-C_{ij}(\overline{x_{i}},\overline{x_{j}})$ and – due to the strict inequality – establishes that $C_{ij}$ is non-zero.

Our next result shows that the signs of the constraint weights on this minimal constraint graph are preserved across all simple VCSPs with the same fitness graph. This gives another motivation for calling these representations sign-equivalent.

Proposition 4.9

Let $\mathcal{C}$ be a simple trim binary Boolean VCSP instance. If the simple binary Boolean VCSP instance $\mathcal{C}^{\prime}$ is sign-equivalent to $\mathcal{C}$, then

for all $i\in[n]$ we have that $\mathop{\mathrm{sgn}}(c_{i})=\mathop{\mathrm{sgn}}(c^{\prime}_{i})$; and 2. 2.

for all $\{i,j\}\in E(\mathcal{C})$ we have that $\mathop{\mathrm{sgn}}(c_{ij})=\mathop{\mathrm{sgn}}(c^{\prime}_{ij})$.

*Proof: * For (1), let $e_{i}\in\{0,1\}^{n}$ be the variable assignment that sets the $i$th variable to one, and all other variables to zero, and let $f_{\mathcal{C}}$ be the fitness function implemented by $\mathcal{C}$. Note that $c_{i}=f_{\mathcal{C}}(e_{i})-f_{\mathcal{C}}(0^{n})$ and $c^{\prime}_{i}=f_{\mathcal{C}^{\prime}}(e_{i})-f_{\mathcal{C}^{\prime}}(0^{n})$. Since $\mathcal{C}$ and $\mathcal{C}^{\prime}$ are sign-equivalent, $\mathop{\mathrm{sgn}}(f_{\mathcal{C}}(e_{i})-f_{\mathcal{C}}(0^{n}))=\mathop{\mathrm{sgn}}(f_{\mathcal{C}^{\prime}}(e_{i})-f_{\mathcal{C}^{\prime}}(0^{n}))$. Hence, $\mathop{\mathrm{sgn}}(c_{i})=\mathop{\mathrm{sgn}}(c^{\prime}_{i})$.

For (2), assume for contradiction that $c_{ij}=a$ and $c^{\prime}_{ij}=-b$ for some positive integer $a$ and non-negative integer $b$ (repeat this argument with $-a$ and $b$ for the other case). Note that the sum of two sign-equivalent VCSP instances is sign-equivalent to both, so $C^{\prime\prime}=b\mathcal{C}+a\mathcal{C}^{\prime}$ is sign-equivalent to $\mathcal{C}$. But $c^{\prime\prime}_{ij}=ba-ab=0$ so $\{i,j\}\not\in E(\mathcal{C}^{\prime\prime})$. Since $\mathcal{C}$ is trim, this contradicts Theorem 4.7. Hence, $\mathop{\mathrm{sgn}}(c_{ij})=\mathop{\mathrm{sgn}}(c^{\prime}_{ij})$.

However, unlike with magnitude-equivalence, it is NP-hard to determine a minimal sign-equivalent VCSP instance, as the next result shows:

Theorem 4.10

Let $\mathcal{C}$ be a simple binary Boolean VCSP instance with associated fitness graph $G_{\mathcal{C}}$. The problem of deciding whether $i,j$ sign-interact in $G_{\mathcal{C}}$ is NP-complete.

*Proof: * To show that this problem is in NP, we observe that we can provide a variable assignment $x$ as a certificate and check that under that variable assignment either $i$ sign-depends on $j$ or $j$ sign-depends on $i$ (or both).

We will establish NP-hardness by reduction from the SubsetSum problem, which is known to be NP-complete Garey \BBA Johnson (\APACyear1979): A set of integers $\{s_{1},\ldots,s_{n}\}$ and a target $t$ is a yes-instance of the SubsetSum problem if there exists some subset $S\subseteq[n]$ such that $\sum_{i\in S}s_{i}=t$.

Now consider a simple binary Boolean VCSP instance $\mathcal{C}$ on $n+2$ variables, that implements fitness function $f$ and has associated fitness graph $G_{\mathcal{C}}$, whose constraint graph has the shape of a star, with variable ${n+2}$ at the centre (see Figure 2).

The constraints of $\mathcal{C}$ are given by:

• •

unary constraints $C_{i}=\begin{pmatrix}0\\ 1\end{pmatrix}$ for all $i\leq n+1$ and $C_{n+2}=\begin{pmatrix}0\\ -(3t+1)\end{pmatrix}$;

• •

binary constraints $C_{i,n+2}=\begin{pmatrix}0&0\\ 0&3s_{i}\end{pmatrix}$ between the central variable ${n+2}$ and variable $i$, for $1\leq i\leq n$; and

• •

binary constraint $C_{n+1,n+2}=\begin{pmatrix}0&0\\ 0&2\end{pmatrix}$ between variables ${n+1}$ and ${n+2}$.

Claim: $\langle\{s_{1},\ldots,s_{n}\},t\rangle$ is a yes-instance of SubsetSum if and only if ${n+1}$ and ${n+2}$ sign-interact.

We clearly have that for all $x\in\{0,1\}^{n+2}$, $f(x[{n+1}\mapsto 1])>f(x[{n+1}\mapsto 0])$, so ${n+1}$ does not sign-depend on ${n+2}$. Thus our claim becomes equivalent to verifying the conditions under which ${n+2}$ sign-depends on ${n+1}$. Let’s look at the two directions of the if and only if in the claim:

Case 1 ($\Rightarrow$):

If $\langle\{s_{1},\ldots,s_{n}\},t\rangle\in\textsc{SubsetSum}$, then there is a subset $S\subseteq[n]$ such that $\sum_{i\in S}s_{i}=t$. Let $e_{S}\in\{0,1\}^{n}$ be the variable assignment such that for any $i\in S$, $e_{S}[i]=1$ and for any $j\not\in S$, $e_{S}[j]=0$. We have that:

[TABLE]

By Equation 5, these imply that ${n+2}$ sign-depends on ${n+1}$.

Case 2 ($\Leftarrow$):

If $\langle\{s_{1},\ldots,s_{n}\},t\rangle\not\in\textsc{SubsetSum}$, then for any $S\subseteq[n]$ we either have $\sum_{i\in S}s_{i}\leq t-1$ or $\sum_{i\in S}s_{i}\geq t+1$. Thus, given an arbitrary assignment $e_{S}\in\{0,1\}$:

[TABLE]

In either subcase, $\mathop{\mathrm{sgn}}(f(e_{S}01)-f(e_{S}00))=\mathop{\mathrm{sgn}}(f(e_{S}11)-f(e_{S}10))$, so by Equation 5, ${n+2}$ does not sign-depend on ${n+1}$.

5 Span

In this section we show that a simple function of the numerical values of the constraints in a VCSP instance provides an upper bound on the length of the longest directed path in the associated fitness graph, and hence a bound on the number of steps taken by any local search algorithm.

Definition 5.1

Given a VCSP instance $\mathcal{C}$ over domain $D^{[n]}$, define

[TABLE]

Proposition 5.2

Given any VCSP instance $\mathcal{C}$, the length of the longest directed path in the associated fitness graph $G_{\mathcal{C}}$ is less than or equal to $\mathop{\mathrm{span}}(\mathcal{C})$.

*Proof: * The maximum value of the fitness function $f$ implemented by $\mathcal{C}$ cannot exceed the sum of the largest fitness values assigned by each constraint. Similarly, the minimum value of $f$ cannot be less than the sum of the smallest fitness values assigned by each constraint. The difference between these bounds is precisely $\mathop{\mathrm{span}}(\mathcal{C})$. Since we have defined a VCSP instance, and hence the associated fitness function $f$, to be integer-valued, each directed edge in the fitness graph increases fitness by at least one, so there can be at most $\mathop{\mathrm{span}}(\mathcal{C})$ many such steps in any path.

Although the span of a VCSP instance always provides an upper bound on the length of the longest ascent in the associated fitness landscape, in general this bound is not tight, as the following simple example shows:

Example 5.3

Consider the unary VCSP instance $\mathcal{C}=\{C_{i}=\begin{pmatrix}0\\ 2^{i}\end{pmatrix}|\;i=1\ldots n\}$.

The longest directed path in the associated fitness graph $G_{\mathcal{C}}$ is of length $n$, but $\mathop{\mathrm{span}}(\mathcal{C})=2^{n+1}-1$.

To avoid such a large discrepancy between the longest path in the fitness graph and the $\mathop{\mathrm{span}}$, and hence obtain a tighter bound, we can look for sign-equivalent VCSP instances that have a minimal span.

Example 5.4

In the case of Example 5.3, a sign-equivalent minimal-span VCSP instance is given by $\mathcal{C}^{\prime}=\{C_{i}=\begin{pmatrix}0\\ 1\end{pmatrix}|\;i=1\ldots n\}$, which has $\mathop{\mathrm{span}}(\mathcal{C}^{\prime})=n$ – giving us a tight bound on the length of the longest improving path.

Finding a sign-equivalent instance with the smallest possible span may not always be straightforward. However, for simple binary Boolean VCSP instances the span is just the sum of the absolute values of the constraint weights. Hence, for any binary Boolean VCSP instance we can compute the minimal span of a sign-equivalent simple binary Boolean instance by solving an integer linear program over the constraint weights.

Before describing this linear program, we show that restricting the search for sign-equivalent instances to simple trim instances only changes the minimal span that can be obtained by a small constant factor.

Theorem 5.5

For any binary Boolean VCSP instance $\mathcal{C}^{\prime}$, there exists a sign-equivalent simple trim binary Boolean VCSP instance $\mathcal{C}$ such that $\mathop{\mathrm{span}}(\mathcal{C})\leq 4\;\mathop{\mathrm{span}}(\mathcal{C}^{\prime})$.

We establish Theorem 5.5 by showing that if we start with an arbitrary binary Boolean VCSP instance $\mathcal{C}^{\prime}$ and transform it to a simple, trim, sign-equivalent VCSP $\mathcal{C}$, as described in the previous sections, then that will increase the span by at most a factor of $4$. This proceeds by two steps:

Proposition 5.6

Any binary Boolean VCSP instance $\mathcal{C}^{\prime}$ can be transformed into a simple VCSP instance $\mathcal{C}$ that is magnitude-equivalent to $\mathcal{C}^{\prime}$ with $\mathrm{span}(\mathcal{C})\leq 4\;\mathrm{span}(\mathcal{C}^{\prime})$.

*Proof: * Let us decompose the span of $\mathcal{C}$ into the contribution due to unary constraints ($\mathop{\mathrm{span}}_{1}$) and binary constraints ($\mathop{\mathrm{span}}_{2}$):

[TABLE]

Using Equation 3 from the proof of Theorem 3.4, we can express $|c_{i}|$ in terms of $\mathcal{C}^{\prime}$ as:

[TABLE]

Notice that the first span in Equation 10 is of the unary constraint in $\mathcal{C}^{\prime}$ that has $i$ as its scope, and the second span is of all binary constraints in $\mathcal{C}^{\prime}$ that have $i$ in scope (or, equivalently: span of all edges incident on $i$ in the constraint graph of $\mathcal{C}^{\prime}$). This means that if we sum $|c_{i}|$ over all $i\in[n]$ then we cover the whole graph:

[TABLE]

where Equation 11 has a double cover in its second summand because each edge in the constraint graph of $\mathcal{C}^{\prime}$ has two end points (equivalently: all scopes are binary).

Similarly, using Equation 4 from the proof of Theorem 3.4, we can also express $|c_{ij}|$ in terms of $\mathcal{C}^{\prime}$ as:

[TABLE]

As before, if we sum $|c_{ij}|$ over all $\{i,j\}\in E(\mathcal{C})$ then we cover the whole graph:

[TABLE]

where for the last inequality we moved from summing over $\{i,j\}\in E(\mathcal{C})$ to $\{i,j\}\in E(\mathcal{C}^{\prime})$ because $E(\mathcal{C})\subseteq E(\mathcal{C}^{\prime})$ by Theorem 3.5. Combining Equations 12 and 13, we get the final result that $\mathop{\mathrm{span}}(\mathcal{C})=\mathop{\mathrm{span}}_{1}(\mathcal{C})+\mathop{\mathrm{span}}_{2}(\mathcal{C})\leq 4\;\mathop{\mathrm{span}}(\mathcal{C}^{\prime})$.

Note that Proposition 5.6 is the best possible, as the following example shows:

Example 5.7

The two VCSP instances shown in Figure 3 are magnitude-equivalent.

The instance in Figure 3a has a span of $1$ and the simple instance in Figure 3b has a span of $1+2+1=4$. Thus, sometimes the simplifying procedure from Section 3 can increase span by a factor of $4$.

In contrast, the trimming procedure from Section 4 can only decrease span:

Proposition 5.8

For any simple binary Boolean VCSP instance $\mathcal{C}^{\prime}$, there exists a sign-equivalent simple trim binary Boolean VCSP instance $\mathcal{C}$ such that $\mathop{\mathrm{span}}(\mathcal{C})\leq\mathop{\mathrm{span}}(\mathcal{C}^{\prime})$

*Proof: * The trimming procedure from Section 4 removes constraints but doesn’t change any remaining ones.

Combining Propositions 5.6 and 5.8, establishes Theorem 5.5.

Theorem 5.5 implies that, in the binary Boolean case, restricting our search for a minimal-span sign-equivalent instance to simple trim instances will only increase the span obtained by a factor of at most four. Hence, given any binary Boolean VCSP instance $\mathcal{C}$, we will formulate the problem of finding a minimal-span sign-equivalent instance as an optimisation problem over the weights of a simple binary Boolean instance on the same constraint graph. This will considerably simplify the search procedure, compared with searching for an arbitrary minimal-span sign-equivalent instance.

Given a simple trim binary Boolean VCSP instance, $\mathcal{C}$, it follows from Proposition 4.9 that any sign-equivalent simple instance must preserve the signs of each of the constraint weights. Moreover, the values of these weights must satisfy a collection of linear inequalities, to ensure that the edges of the fitness graph are preserved, as indicated in Equation 6. Each of these inequalities constrains the weights of constraints with scopes including a particular variable. We therefore have the optimisation problem given in Definition 5.10, which involves linear inequality and equality constraints of the following forms:

Definition 5.9

Given two sets of variables $L$ and $R$, let $\leq_{+k}[L,R]$ be a constraint of arity $|L|+|R|$ that is satisfied when $k+\sum_{x\in L}x\leq\sum_{y\in R}y$. Call $L$ the left side of the constraint and $R$ the right side. Similarly, define $=_{+k}[L,R]$ as above but with $\leq$ replaced by $=$.

Using these two constraint types, we can now define the span-minimisation problem for binary Boolean VCSP instances as follows:

Definition 5.10

Given a simple binary Boolean VCSP instance $\mathcal{C}$ on $n$ variables (with a constraint graph that has neighbourhood function $N:[n]\rightarrow 2^{[n]}$), the corresponding span-minimisation problem for $\mathcal{C}$ has a set of variables $V$, each with domain $\mathbb{N}$, where:

[TABLE]

Divide the set $V$ into two sets $V_{+},V_{-}$ with $p_{i}\in V_{+}$ or $p_{\{i,j\}}\in V_{+}$ if $c_{i}>0$ or $c_{ij}>0$ and otherwise $p_{i}\in V_{-}$ or $p_{\{i,j\}}\in V_{-}$ if $c_{i}<0$ or $c_{ij}<0$.

For each variable $i\in[n]$ of $\mathcal{C}$, introduce $2^{|N(i)|}$ linear constraints, one for each $Y\subseteq\{p_{\{i,j\}}\mid j\in N(i)\}$, depending on the sign of $s=c_{i}+\sum_{j\in Y}c_{ij}$:

• •

If $s<0$ then add the constraint $\leq_{+1}[(Y\cup\{p_{i}\})\cap V_{+},(Y\cup\{p_{i}\})\cap V_{-}]$, else

• •

If $s=0$ then add the constraint $=_{+0}[(Y\cup\{p_{i}\})\cap V_{+},(Y\cup\{p_{i}\})\cap V_{-}]$, else

• •

If $s>0$ then add the constraint $\leq_{+1}[(Y\cup\{p_{i}\})\cap V_{-},(Y\cup\{p_{i}\})\cap V_{+}]$.

A feasible solution to this span-minimisation problem is an assignment of values to the variables in $V$ that satisfies all the constraints. A feasible solution is optimal if it minimises the sum of the assigned values.

Note that there is at least one feasible solution to the span-minimisation problem for $\mathcal{C}$ given by $p_{i}=|c_{i}|$ and $p_{\{i,j\}}=|c_{ij}|$ (i.e., the absolute values of the weights of the original simple VCSP constraints).

Example 5.11

(Unary instances have linear minimal span) For any unary Boolean VCSP instance with $n$ variables, the span-minimisation problem only has inequalities of the form $1\leq p_{i}$. Hence an optimal solution sets each $p_{i}$ to $1$, so the corresponding minimal-span sign-equivalent instance has each $c_{i}$ equal to $1$ or $-1$, and so has span $n$. This is precisely the length of the longest improving path, as illustrated in Example 5.4.

Example 5.12

(Degree 2 binary instances have quadratic minimal span)

Consider the binary Boolean VCSP instance on $8$ variables shown in Figure 4(a), where the constraint graph is a cycle. The span of this instance is quite large, but if we convert to a simple instance, and then solve the span-minimisation problem, we obtain a sign-equivalent instance with a much smaller span, as shown in Figure 4(b).

In general, by analysing the structure of the inequalities in Definition 5.10, it can be shown that for any binary Boolean VCSP instance whose constraint graph has maximum degree 2 (e.g., a cycle) the weights of a minimal-span sign-equivalent simple instance can grow only linearly with the number of variables, and hence the span and longest improving path in the associated fitness graph can grow only quadratically at most. For a full analysis, see Section 5.1.1 of Kaznatcheev \APACyear2020\APACexlab\BCnt1.

Unfortunately, span arguments like the one above cannot be used to obtain tight bounds for all binary Boolean VCSP instances, as we show with the following example of a VCSP with only short improving paths but exponential minimal span.

Example 5.13

(Large span in tree-structured constraint graph)

Consider the family of binary Boolean VCSP instances on $3K+2$ variables illustrated in Figure 5, where the constraint graph of each instance is a tree.

Solving the span-minimisation problem shows that the weight values cannot be reduced any further without changing the fitness graph, hence all such instances are span-minimal.

The span of each such instance is $3(2^{K+2}-5K-9)$, and hence grows exponentially with the number of variables. However, the longest improving path in the associated fitness graph grows only quadratically with the number of variables (Theorem 6.1).

In the next section, we will show that for any binary Boolean VCSP instance whose constraint graph is a tree (like Example 5.13), the longest improving path in the associated fitness graph is bounded by a quadratic function of the number of variables. This analysis will require us to develop more sophisticated techniques than simply computing the span.

6 Tree-Structured Boolean VCSP Instances

In this section, we will prove the following:

Theorem 6.1

For any binary Boolean VCSP instance $\mathcal{C}$ on $n$ variables, if the constraint-graph of $\mathcal{C}$ is a tree, then any directed path in the associated fitness graph $G_{\mathcal{C}}$ has length at most ${n\choose 2}+n$.

Note that this result bounds the length of any directed path in $G_{\mathcal{C}}$, not just the path taken by a particular local-search algorithm. Thus, on such landscapes even choosing the worst possible sequence of improving moves results in a local optimum being found in polynomial time.

We will show in Section 7 that being Boolean and tree-structured are both essential conditions to obtain a polynomial bound on the length of all improving paths in the associated fitness graph.

To see that the bound in Theorem 6.1 is the best possible for binary Boolean tree-structured VCSP instances, consider the path-structured VCSP instance on $n$ variables described in Example 6.2.

Example 6.2

(Path of length ${n\choose 2}+n$)

Consider the binary Boolean VCSP instance on $n$ variables illustrated in Figure 6, where the constraint graph is a path, and the constraint on each edge $\{i,i+1\}$ is $\begin{pmatrix}i&0\\ 0&i\end{pmatrix}$.

To obtain an improving path of length ${n\choose 2}+n$ in the corresponding fitness graph, consider an initial variable assignment of $x=(10)^{\frac{n}{2}}$ if $n$ is even and $x=(10)^{\frac{n-1}{2}}1$ if $n$ is odd, and always select the leftmost variable that is able to flip. This will increase the fitness by $1$ at each step, starting from [math] to $\frac{n(n+1)}{2}$.

For example, when $n=4$, this gives the following sequence of eleven assignments, each of which increases the value of the fitness function by one:

[TABLE]

For the proof of Theorem 6.1, we introduce some further definitions.

Definition 6.3

Given any directed path $p=x^{1}\ldots x^{t}\ldots x^{T}$ in a fitness graph $G$, where each $x^{t}$ is a Boolean assignment, define the flip function $m$ at time $t$ as follows: $m(t)=(i\mapsto b)$ where $x^{t+1}\oplus x^{t}=e_{i}$ and $b=x^{t+1}_{i}$ (i.e., the $i$-th variable is flipped at time $t$ to value $b$).

For illustration, consider the sequence of moves listed in Equation 14 of Example 6.2. It corresponds to the following flip function:

[TABLE]

To obtain the bound on the length of all paths in a fitness graph given by Theorem 6.1, we will identify conditions on any possible flip function, and hence bound the maximum possible value for $T$.

Definition 6.4

Given any fitness function $f$ on Boolean assignments, define the gain function for value $b$ in position $i$ of an assignment $x$ as follows:

[TABLE]

Definition 6.5

We say that a flip $m(t^{\prime})=(j\mapsto c)$ supports a flip $m(t)=(i\mapsto b)$ if

[TABLE]

and $t^{\prime}<t$. If $x^{t}_{j}=c$, then the support is said to be strong.

It is useful to note that the inequality in Equation 15 implies that position $i$ sign-depends on position $j$ and also means that $C_{ij}(b,c)-C_{ij}(\overline{b},c)>C_{ij}(b,\overline{c})-C_{ij}(\overline{b},\overline{c})$. This inequality on $C_{ij}$ is symmetric in the sense that:

[TABLE]

Definition 6.6

We say that a flip $m(t^{\prime})=(j\mapsto c)$ encourages a flip $m(t)=(i\mapsto b)$, and write $(t^{\prime},j\mapsto c)\Leftarrow(t,i\mapsto b)$, if $m(t^{\prime})$ is the most recent flip that strongly supports $m(t)$. If there are no flips that encourage $m(t)$, then we say that $m(t)$ is courageous, and write $\bot\Leftarrow(t,i\mapsto b)$.

For illustration, consider the sequence of moves listed in Equation 14 of Example 6.2. It corresponds to the following encouragement relation:

[TABLE]

Note that for any path $p=x^{1}\ldots x^{t}\ldots x^{T}$ in a fitness graph, the value of the associated fitness function $f$ must strictly increase at each step, so if $m(t)=(i\mapsto b)$ then $f(x^{t}[i\mapsto b])>f(x^{t}[i\mapsto\overline{b}])$.

Proposition 6.7

If $(t_{1},j\mapsto c)\Leftarrow(t_{2},i\mapsto b)$ (or if $\bot\Leftarrow(t_{2},i\mapsto b)$, set $t_{1}=0$) then for all $t$ with $t_{1}<t\leq t_{2}$ we have $\mathop{\mathrm{gain}}(x^{t},i,b)>0$.

*Proof: * Since $m(t_{2})=(i\mapsto b)$, we have that $\mathop{\mathrm{gain}}(x^{t_{2}},i,b)>0$.

Now assume, for contradiction, that for some $t_{0}$ with $t_{1}<t_{0}<t_{2}$ we have $\mathop{\mathrm{gain}}(x^{t_{0}},i,b)\leq 0$.

In order to change the assignment $x^{t_{0}}$ so that $\mathop{\mathrm{gain}}(x^{t_{2}},i,b)>0$, there must be at least one flip $m(t^{\prime})$ for some value of $t^{\prime}$ with $t_{0}<t^{\prime}<t_{2}$ which increases the value of the gain function at $x^{t_{2}}$ above zero, and hence strongly supports $m(t_{2})$.

Hence $m(t_{1})$ is not the most recent flip that satisfies the conditions in Definition 6.6, which contradicts the assertion that $(t_{1},j\mapsto c)\Leftarrow(t_{2},i\mapsto b)$.

By Definition 6.6, each flip can only be encouraged by at most one other flip, that occurs earlier in time, so each node in the graph of the encouragement relation has out-degree at most one, and is acyclic. Directed acyclic graphs where each vertex has at most one parent are forests, so the encouragement graph is a forest. This forest has a component for each courageous flip, and we will now show that there are at most $n$ of these:

Proposition 6.8

At each variable position $i$, only the first flip can be courageous.

*Proof: * Consider a courageous flip $\bot\Leftarrow(t,i\mapsto b)$, by Proposition 6.7, we know that for all $t^{\prime}<t$, $\mathop{\mathrm{gain}}(x^{t},i,b)>0$. Thus, there is no time $t^{\prime}\leq t$ such that $i$ could have flipped to $\overline{b}$: hence $i$ was always at $\overline{b}$ for $t^{\prime}\leq t$. So the courageous flip had to be the first flip at that position.

We will now prove that an encouragement tree cannot double-back on itself in position (Proposition 6.9), and that every branch is a branch in position (Proposition 6.10). When the constraint graph is itself a tree, this will imply that each tree in the encouragement forest is a sub-tree of the constraint graph.

Proposition 6.9

If $(t_{1},i\mapsto a)\Leftarrow(t_{2},j\mapsto b)\Leftarrow(t_{3},k\mapsto c)$, then $i\neq k$

*Proof: * Since $(t_{1},i\mapsto a)$ encourages $(t_{2},j\mapsto b)$, we have $x^{t_{2}}_{i}=a$. If, for the sake of contradiction, we assume that $i=k$ then $a=c$ (because if we had $c=\overline{a}$ then the two encouragements would force a contradiction via clashing Equations 16) and by Proposition 6.7: $\mathop{\mathrm{gain}}(x^{t},i,a)>0$ for all $t_{2}<t\leq t_{3}$. But this means that $i$ cannot be flipped to $\overline{a}$ in this interval, and thus $m(t_{3})=(i\mapsto a)$ is not a legal flip. This is a contradiction and so $i\neq k$.

Proposition 6.10

*For all $i,j$ and $t_{1}<t_{2}\leq t_{3}$, if $(t_{1},i\mapsto a)\Leftarrow(t_{2},j\mapsto b)$ and

$(t_{1},i\mapsto a)\Leftarrow(t_{3},j\mapsto c)$, then $t_{2}=t_{3}$.*

*Proof: * From Proposition 6.7, we can see that for all $t^{\prime}\in[t_{1}+1,t_{3}]$, $\mathop{\mathrm{gain}}(x^{t^{\prime}},j,c)>0$, so $b=c$ and $j$ couldn’t have flipped from $c$ to $\overline{c}$ between $t_{2}$ and $t_{3}$. Thus, for $(t_{2},j\mapsto c)$ to be a legal flip, we must have $t_{2}=t_{3}$.

Now, if we trace back along the arrows of the encouragement relation, then each flip in the path $p$ is the start of a path of encouraged-by links that ends at one of the $n$ courageous flips.

One final case to exclude is that there might be two encouragement paths that go in the opposite direction over the same positions. This cannot happen:

Proposition 6.11

Having both of the following encouragement paths is impossible:

[TABLE]

*Proof: * Without loss of generality (by relabeling), we can assume that $t_{1}<s_{1}$. We can extend this with the following claim:

Claim: If $t_{k}<s_{k}$ then $t_{k+1}<s_{k+1}$

Since $(t_{k},i_{k}\mapsto b_{k})\Leftarrow(t_{k+1},i_{k+1}\mapsto b_{k+1})$, we have, for all $t\in[t_{k}+1,t_{k+1}],\;x^{t}[i_{k}]=b_{k}$. Thus we can’t have $i_{k}$ flipping in that interval, so $s_{k}>t_{k+1}$.

But now look at $(s_{k+1},i_{k+1}\mapsto c_{k+1})\Leftarrow(s_{k},i_{k}\mapsto c_{k})$. This shows that we also have, for all $t^{\prime}\in[s_{k+1}+1,s_{k}],\;x^{t^{\prime}}[i_{k+1}]=c_{k+1}$. So for both flips at $i_{k+1}$ to happen, we need $s_{k+1}>t_{k+1}$.

Applying the claim repeatedly gets us $t_{m}<s_{m}$. But this means that $i_{m}$ flipped before $m(s_{m})$, so by Proposition 6.8, $(s_{m},i_{m}\mapsto c_{m})$ could not have been courageous.

This means that it is sufficient to simply count the number of undirected paths in the encouragement trees. We now pull all the results together to complete the proof.

*Proof: *[of Theorem 6.1] Consider any directed path $P$ in the fitness graph, and its corresponding flip function $m$. By the completeness of Definition 6.6, we know that every flip must have been either courageous or encouraged.

Any encouraged flip is the end-point of a unique (non-zero length) path in the graph of the encouragement relation, starting from some courageous flip, and hence of some path in the constraint graph (where Proposition 6.9 established that they’re encouragement paths, not walks; and Proposition 6.10 established that the encouragement paths are uniquely determined by the sequence of variable positions that they pass through.) From Proposition 6.11, we know that there cannot be two encouragement paths that traverse the same positions but in opposite directions. Thus, there can only be as many non-zero-length encouragement paths as undirected paths in our constraint graph. Since our constraint graph is a tree, an undirected non-zero length path is uniquely determined by its pair of endpoints. Thus, there are at most ${n\choose 2}$ of these paths.

From Proposition 6.8, there are at most $n$ courageous flips (encouragement paths of length [math]). Thus, our path $P$ must have length at most $n+{n\choose 2}$.

7 Long Paths in Landscapes with Simple Constraint Graphs

In this section we show that the conditions in Theorem 6.1 are essential. We exhibit binary VCSP instances with very simple constraint graphs where the associated fitness graphs have exponentially-long directed paths, and hence the performance of local search algorithms on the associated fitness landscapes might be extremely poor.

Example 7.1

(Domain size 3)

Consider the family of binary VCSP instances on $n+1$ variables with domain $\{0,1,\rhd\}$ illustrated in Figure 7, where the constraint graph of each instance is a path, and all constraints are defined by matrices of the form:

[TABLE]

Even though the constraint graph of each instance is just a path of length $n$, we now show that the corresponding fitness graph, contains a directed path whose length grows exponentially in $n$.

Notice that given two natural numbers $M,M^{\prime}<2^{n}$, written in binary as $x^{M}$, $x^{M^{\prime}}\in\{0,1\}^{n}$ (with the most significant bit on the left and the least significant bit on the right), we have that if $M^{\prime}>M$ then $f(x^{M^{\prime}})>f(x^{M})$. Thus, counting up in binary from $0^{n+1}$ to $01^{n}$ is monotonically increasing in fitness. However, $x^{M+1}$ is often more than a single flip away from $x^{M}$ (consider the transition from $x^{M}=01^{n}$ for an extreme example). We handle these multi-flip cases with our third domain value, $\rhd$, as follows: (1) given $x^{M}=y01^{k}$ for some $y\in\{0,1\}^{n-k}$, we proceed to replace the $1$s in the right-most block of $1$s by $\rhd$, starting from $x^{M}_{k}$ and moving to the right; (2) from $y0\rhd^{k}$ we can take a 1-flip to $y1\rhd^{k}$ (regardless of whether $y$ ends with [math] or $1$); (3) from $x^{\prime}=y1\rhd^{k}$, we replace the $\rhd$s by [math]s, starting from the rightmost $\rhd$ (i.e., $x^{\prime}_{1}$) and moving to the left. Each of these individual 1-flips increases the overall fitness, since the fitness gain due to the constraint to the left is greater than the fitness loss due to the constraint on the right (where there is one).

This lets our sequence of moves count in binary from $0^{n+1}$ to $01^{n}$, while using extra steps with $\rhd$s to make sure all transitions are improving 1-flips; thus, this directed path in the fitness graph has a length greater than $2^{n}$.

Note that although the fitness graphs corresponding to Example 7.1 have long improving paths, standard local search algorithms would be unlikely to follow these paths. However, with careful padding, Example 7.1 has been converted to a family of Boolean VCSP instances of treewidth $7$ where even a popular local search algorithm like steepest ascent will follow an exponentially long improving path Cohen \BOthers. (\APACyear2020).

Our final example is a family of binary Boolean VCSP instances where the constraint graph of each instance has tree-width two and maximum degree three, but the associated fitness graph contains an exponentially long directed path. This example is a simplified and corrected version of a similar example for the Max-Cut problem, described by Monien and Tscheuschner \APACyear2010. Note, however, that by allowing general valued constraints, instead of just Max-Cut constraints, we are able to reduce the required maximum degree from four to three.

Example 7.2

(Tree-width 2)

Consider a family of binary Boolean VCSP instances with $n=4K+1$ variables. For each instance the constraint graph contains a sequence of disjoint cycles of length four, linked together by a single additional edge joining each consecutive pair of cycles. The $i$-th cycle (for $0\leq i\leq K-1$) has the constraints illustrated in Figure 8 (where the $w_{i}$ values are defined recursively with $w_{0}=0$).

The final cycle is replaced by a single variable $n$ with unary constraint $\begin{pmatrix}1\\ -w_{K}\end{pmatrix}$. Hence the constraint graph of any instance has maximum degree three and treewidth two as illustrated in Figure 9

To begin the long path all variables are assigned 0, except $x_{n}=1$. The path will proceed by always flipping variables in the smallest $4$-cycle block possible.

Within each $4$-cycle block, we number the variables anti-clockwise, from the top left, and write the assignment to these $4$ variables ordered by decreasing index as $x_{4i+4}x_{4i+3}x_{4i+2}x_{4i+1}$. We will make the following transitions within each cycle: if $x_{4(i+1)+1}=1$ then we’ll transition $0000\rightarrow 1000\rightarrow 1001\rightarrow 1101$; if $x_{4(i+1)+1}=0$ then we’ll transition $1101\rightarrow 0101\rightarrow 0100\rightarrow 0110\rightarrow 0010\rightarrow 0011\rightarrow 0001\rightarrow 0000$. Every time that $x_{4i+1}$ is flipped from [math] to $1$ or vice versa, we’ll recurse to the $(i-1)$th cycle. Because $x_{4i+1}$ ends up flipping from $1$ to [math] twice as often as $x_{4(i+1)+1}$, this means that we double the number of flips in each cycle. Variable $n$ will flip once, from $1$ to [math], due to the unary constraint, which will cause $x_{4(K-1)+1}$ to flip twice from $1$ to [math], which will cause $x_{4(K-2)+1}$ to flip four times from $1$ to [math], and so on, until eventually this will cause $x_{1}$ to flip $2^{K}$ times from $1$ to [math]. Hence we have an improving path in the fitness graph of length greater than $2^{K}$.

8 Applications to Models of Biological Evolution

Focusing on the maximum length of improving paths in a fitness graph, rather than the run-time of a particular local search algorithm, lets us use our results in settings where the details of the local search algorithm are unknown or highly contingent.

The most notable example of this is in modelling biological evolution. In such models, the value of the fitness function is interpreted as a measure of biological fitness (for example, expected number of offspring) and each variable assignment represents the values of the alleles at a sequence of genetic loci. The constraint graph can then be interpreted as a gene-interaction network. This gene-interaction network representation of biological fitness landscapes is similar to, but more general than, classic biological models such as the NK-model of fitness landscapes Kauffman \BBA Levin (\APACyear1987); Kauffman \BBA Weinberger (\APACyear1989); Kaznatcheev (\APACyear2019); Strimbu (\APACyear2019).

The notion of sign-interaction that is central to Section 4 is based on the biological idea of sign-epistasis that is central to the analysis of evolutionary dynamics on fitness landscapes Poelwijk \BOthers. (\APACyear2007, \APACyear2011); Crona \BOthers. (\APACyear2013); Kaznatcheev (\APACyear2019). Our uniqueness results for minimal representations of fitness landscapes and fitness graphs can be seen as a way to unambiguously answer which loci have sign-epistasis and to represent the structure of that sign-epistasis.

The process of biological evolution is often viewed as some form of randomised uphill climb in a given fitness landscape. However, the exact probability of any particular adaptive mutation arising and fixing in a given population is often unknown (or even potentially unknowable in historic cases). Hence it is very helpful to be able to reason over wide classes of local search algorithms, as we do here. By showing that for some kinds of fitness landscapes all improving paths are short, we have shown that any such randomised algorithm will perform well on such landscapes, regardless of the exact probabilities of particular moves. For example, we have shown that when the structure of the sign-epistasis is a tree, then evolution will always reach a local fitness peak in a small number of moves, whatever sequence of improving moves is chosen.

This work has focused on bounding the worst-case complexity of local search algorithms. Future work could identify further examples of fitness landscapes where local peaks can be found efficiently by considering less restrictive measures such as randomised complexity. For randomised complexity, it would be possible to relax the condition that moves must be strictly improving ($f(x^{t})<f(x^{t+1})$) and consider the expected length of walks that include neutral ($f(x^{t})=f(x^{t+1})$) or even deleterious steps ($f(x^{t})<f(x^{t+1})$). For worst-case complexity, considering neighbourhoods larger than 1-flip can only increase the length of the longest improving path. However, for randomised complexity it would also be possible to consider the effects of larger neighbourhoods (corresponding to larger mutations), or model the effects of recombination and sex.

In a different direction, it is known that there are classes of landscapes where locally optimal assignments cannot be found efficiently by any local search algorithm Kaznatcheev (\APACyear2019). In such cases the structure of the fitness graph can be viewed as an ultimate constraint, that prevents evolution from stabilizing at a local fitness peak Kaznatcheev (\APACyear2019); such cases will give rise to open-ended evolution. Identifying families of constraint graphs that lead to intractable local search problems therefore corresponds to finding forms of gene-interaction network that enable open-ended evolution.

Of course, by treating fitness as a scalar, fitness landscapes are themselves an idealization of the rich multi-faceted concept of biological fitness. One direction for future work would be to find representations similar to VCSPs but for the richer model of game landscapes that account for frequency-dependent fitness Kaznatcheev (\APACyear2020\APACexlab\BCnt2).

9 Conclusion

In this paper, we have considered the broad class of fitness landscapes that can be modelled by the combined effect of simple interactions of a few variables, where each of these interactions is described by an arbitrary valued constraint. Modelling fitness landscapes in this way allows us to classify them in new ways: for example by identifying a minimal constraint graph, and then characterising properties of this constraint graph.

This work raises a number of immediate further questions:

How can we characterise the fitness landscapes that can be represented by VCSP instances of each fixed arity? Since the results on magnitude-equivalence (Theorems 3.4 and 3.5) are based on representations of pseudo-boolean functions, they are easy to generalise to higher arity. But generalising the results on sign-equivalence (Theorems 4.4 and  4.7) to higher arity will require new techniques. 2. 2.

We have shown that when a family of fitness landscapes can be represented by binary Boolean VCSP instances where the constraint graph has maximum degree 2, then the minimal span of a sign-equivalent instance grows only polynomially (Example 5.12), and hence finding a local optimum in the corresponding fitness landscapes by any local search algorithm takes only polynomial time (Proposition 5.2).

Can this result be generalised to wider classes of landscapes? This may be difficult: we have shown that even for landscapes representable by binary Boolean VCSP instances with tree-structured constraint graphs, the minimal span may grow exponentially with the number of variables (Example 5.13). 3. 3.

We have shown that when a family of fitness landscapes can be represented by binary Boolean VCSP instances where the constraint graph is tree-structured, then finding a local optimum in the corresponding fitness landscapes by any local search algorithm takes only polynomial time (Theorem 6.1).

Can this result be generalised to wider classes of landscapes? This may be difficult: we have shown examples over a slightly larger domain, or allowing slightly more general constraint graphs, where some local search algorithms can take exponential time to find a local optimum (Examples 7.1 and 7.2).

An alternative approach is to move away from considering just topological features of constraint graphs and look at features of the valued constraints themselves. Restricting the kinds of constraints (for example, considering only constraints that are convex, or sub-modular) could allow us to identify additional classes of VCSP instances that are tractable for local search.

We believe that the tools for classifying fitness landscapes that we have begun to develop here will allow considerable further progress, and may eventually help to shed more light on the question of why local search algorithms can be extremely effective in practice, for many kinds of optimisation problems.

Acknowledgments

David A. Cohen was supported by Leverhulme Trust Grant RPG-2018-161. Artem Kaznatcheev was supported by the Theory Division at the Department of Translational Hematology and Oncology Research, Cleveland Clinic. An earlier version of some parts of this paper was presented at the 25th International Conference on Principles and Practice of Constraint Programming Kaznatcheev \BOthers. (\APACyear2019).