Evidence of an exponential speed-up in the solution of hard optimization problems

Optimization problems pervade essentially every scientific discipline and industry. Many such problems require finding a solution that maximizes the number of constraints satisfied. Often, these problems are particularly difficult to solve because they belong to the NP-hard class, namely algorithms that always find a solution in polynomial time are not known. Over the past decades, research has focused on developing heuristic approaches that attempt to find an approximation to the solution. However, despite numerous research efforts, in many cases even approximations to the optimal solution are hard to find, as the computational time for further refining a candidate solution grows exponentially with input size. Here, we show a non-combinatorial approach to hard optimization problems that achieves an exponential speed-up and finds better approximations than the current state-of-the-art. First, we map the optimization problem into a boolean circuit made of specially designed, self-organizing logic gates, which can be built with (non-quantum) electronic components; the equilibrium points of the circuit represent the approximation to the problem at hand. Then, we solve its associated non-linear ordinary differential equations numerically, towards the equilibrium points. We demonstrate this exponential gain by comparing a sequential MatLab implementation of our solver with the winners of the 2016 Max-SAT competition on a variety of hard optimization instances. We show empirical evidence that our solver scales linearly with the size of the problem, both in time and memory, and argue that this property derives from the collective behavior of the simulated physical circuit. Our approach can be applied to other types of optimization problems and the results presented here have far-reaching consequences in many fields.

Optimization problems pervade essentially every scientific discipline and industry.Many such problems require finding a solution that maximizes the number of constraints satisfied.Often, these problems are particularly difficult to solve because they belong to the NP-hard class, namely algorithms that always find a solution in polynomial time are not known.Over the past decades, research has focused on developing heuristic approaches that attempt to find an approximation to the solution.However, despite numerous research efforts, in many cases even approximations to the optimal solution are hard to find, as the computational time for further refining a candidate solution grows exponentially with input size.Here, we show a non-combinatorial approach to hard optimization problems that achieves an exponential speed-up and finds better approximations than the current state-of-the-art.First, we map the optimization problem into a boolean circuit made of specially designed, self-organizing logic gates, which can be built with (non-quantum) electronic components [1]; the equilibrium points of the circuit represent the approximation to the problem at hand.Then, we solve its associated non-linear ordinary differential equations numerically, towards the equilibrium points.We demonstrate this exponential gain by comparing a sequential MatLab implementation of our solver with the winners of the 2016 Max-SAT competition on a variety of hard optimization instances.We show empirical evidence that our solver scales linearly with the size of the problem, both in time and memory, and argue that this property derives from the collective behavior of the simulated physical circuit.Our approach can be applied to other types of optimization problems and the results presented here have far-reaching consequences in many fields.
In real-life applications it is common to encounter problems where one needs to find the best solution within a vast set of possible solutions.These optimization problems are routinely faced in many commercial segments, including transportation, goods delivery, software packages or hardware upgrades, network traffic and conges-tion management, and circuit design, to name just a few [2,3].Many of these problems can be easily mapped into combinatorial optimization problems, namely they can be written as boolean formulas with many constraints (clauses) among different variables, (either negated or not i.e., literals), with the constraints themselves related by some logical proposition [2].
It is typical to write the boolean formulas as conjunctions (the logical ANDs, also represented by the symbol ∧) of disjunctions (the logical ORs, represented by the symbol ∨), in the so called conjunctive normal form (CNF).The CNF representation is universal in that any boolean formula can be written in this form [4].
A simple example of a CNF formula ϕ(x) is ϕ(x) = (¬x 1 ∨x 2 )∧(¬x 2 ∨¬x 3 ∨x 4 )∧ (x 1 ∨¬x 2 ∨x 3 ∨¬x 4 )∧ (¬x 1 ∨x 4 )∧(x 1 ∨x 2 ∨¬x 4 ) in which we have four variables, x j , with j = 1, 2, 3, 4, five clauses, and fourteen literals (the symbol ¬ indicates negation).The problem is then to find an assignment satisfying the maximum number of clauses, i.e., in which as many clauses as possible have at least one literal that is true.Such a clause is then said to be satisfied, otherwise it is unsatisfied [4], and the problem itself is known as Max-SAT (maximum satisfiability).A Max-SAT problem whose CNF representation has exactly k literals (k ≥ 2) per clause, is called Max-EkSAT.Max-EkSAT is a ubiquitous optimization problem with widespread industrial applications.We will focus on its solution as a test bed in the main text, and refer the reader to the Supplemental Information for other optimization problems, including weighted SAT.
Due to its NP-hard nature, complete algorithms that attempt to solve Max-EkSAT quickly become unfeasible for large problems.Much research has instead focused on incomplete solvers that perform a stochastic local search, by generating an initial assignment, and iteratively improving upon it.This approach has proven effective at approximating and sometimes solving large instances of SAT and other problems.For instance, in recent Max-SAT competitions [5], incomplete solvers outpace complete solvers by two orders of magnitude on random and crafted benchmarks, and perform similarly on industrial problems.However, they too suffer from the same exponential time dependence as complete solvers for sufficiently large or hard instances [6][7][8].
In the worst cases, it has been shown using probabilistically checkable proofs [9] that many classes of combinatorial optimization problems (including the Max-EkSAT) Boolean circuit representation of MaxSAT CNF formula have an inapproximability gap.This means that no algorithm can overcome, in polynomial time, a fraction of the optimal solution, unless NP=P [9,10].In other words, for heuristics to improve on their approximation would require exponentially increasing time.For example, for the Max-E3SAT it has been proved that, if NP =P, then there is no algorithm that can give an approximation better than 7/8 of the optimal number of satisfied clauses [10].
In this work, we consider instead a radically different non-combinatorial approach to hard optimization problems.Our approach is based on the simulation of digital memcomputing machines (DMMs) [1,11] discussed in Methods.Their practical realization can be accomplished using standard circuit elements and those with memory (time non-locality, hence the name "memcomputing" [12]).
Time non-locality allows us to build logic gates that self-organize into their logical proposition, irrespective of whether the signal comes from the traditional input or output [1].We call them self-organizing logic gates (SOLGs), and circuits built out of them, self-organizing logic circuits (SOLCs).Our approach then follows these steps.
1) We first construct the boolean circuit that represents the problem at hand (e.g., the Max-EkSAT of Fig. 1).
2) We replace the traditional (uni-directional) boolean gates of this boolean circuit with SOLGs.
3) We feed the appropriate terminals with the required output of the problem (e.g., the logical 1 if we are inter-ested in checking its satisfiability).
4) Finally, the electronic circuit built out of these SOLGs can be described by non-linear ordinary differential equations, which can be solved to find the equilibrium (steady-state) points.These equilibria represent the approximation to the optimization problem [1].
The procedure of how we transform a combinatorial optimization problem into an electronic circuit, as well as a sketch of its numerical solution is discussed further in the Methods section.The important point to note is that SOLGs and SOLCs manifest long-range order due to the presence of instantons [13].Instantons connect topologically inequivalent critical points in the phase space, hence generating non-locality in the system.This translates into a collective dynamical behavior that allows gates at an arbitrary distance to correlate very efficiently so that, when a terminal of one gate needs to change its truth value to satisfy that gate's logical proposition, a terminal at any other gate may provide the correct truth assignment while satisfying its own logical proposition.As we will explain later, this is the key feature that allows these memcomputing machines to solve complex problems efficiently, without the need to explore a vast space of possibilities, as standard combinatorial approaches would do.
This radical change of perspective manifests its power already in comparing simulations of DMMs with those performed by the winners of the 2016 Max-SAT competition [5] on the competition benchmarks.When run on similar hardware, our solver, which we named Falcon [1,14,15], performs orders of magnitude faster than the winners in the incomplete track of the competition, and in some cases it finds the solution when the best solvers did not.
Since a direct comparison is difficult across hardware and implementations (our solver is written in MatLab which is notoriously inefficient compared with the compiled languages of the competition solvers), we have presented these results in Figs. 6, 7, 8, and 9 of the Supplemental Information.Nevertheless, these tests already provide strong indication of the advantages of our approach using digital memcomputing machines over traditional combinatorial optimization.
However, in order to form a direct comparison and more clearly show the exponential speed-up of our approach, we have crafted three Max-SAT problems with increasing levels of difficulty.We then compared our memcomputing solver against two of the best solvers of the 2016 Max-SAT competition, (CCLS [16] and DeciLS [17] -a new version of CnC-LS-, kindly provided by their developers) which are specifically designed to solve these types of problems, but employing very different solution strategies.(Note that we expect other types of algorithms, e.g., those based on message passing, to show the same behavior as these two local solvers for the balanced and constrained Max-XORSAT instances we consider in this work [18].)Random 3-SAT instances may be generated by selecting 3 variables out of n, joining them in a 3-SAT clause where each is randomly negated, and then repeating this for the desired number of clauses M .These instances are known to undergo a SAT/UNSAT transition when the ratio of clauses to variables, M/n = ρ (hereafter the "density"), crosses the critical value ρ c ≈ 4.3 [19,20].Exponential time is required to demonstrate that an instance is UNSAT [21] and thus must also be required to solve the corresponding Max-SAT, offering a simple way to generate benchmarks.
However, the difficulty of computing approximations for these instances varies widely.This can be partially attributed to the fluctuations in variable occurrences and their negations [22] leading to 'fields' which point towards the optima.More balanced instances may be produced by starting with a Random-XORSAT instance (also called hyperSAT [23] ) i.e., a set of boolean formulas defined by the XOR of boolean variables (the XOR symbol is ⊕) and converting it to a Max-SAT instance.
Each XORSAT clause may be converted to a block of four SAT clauses, e.g., x ⊕ y ⊕ z = 1 → (x∨y∨z)∧(x∨¬y∨¬z)∧(¬x∨¬y∨z)∧(¬x∨y∨¬z), in which a variable and its negation appear symmetrically.The special structure of XORSAT gives rise to a global algorithm when the instance is satisfiable, allowing for a solution in polynomial time using Gaussian elimination [23].However, when unsatisfiable, occurring for ρ > 4 • 0.918 ≈ 3.7, this same structure makes these problems very difficult for local search solvers [21,24].
A basic understanding of this difficulty can be obtained by considering that changing a variable assignment affects positively (namely contributes a true literal to) the same number of clauses as those affected negatively (where the literal is false), because of the balanced occurences of the variables.Therefore, for any combinatorial approach, when a certain amount of satisfied clauses is reached, any further improvement requires many simultaneous variable flips, which is a non-local type of assignment.In other words, the distance between two assignments at successive approximations becomes of the same order of the input length |x|.This means that going from an assignment x to a better one y, if they have a distance d(x, y) = j (x j − y j ) 2 = O(|x|), would require checking O(2 d(x,y) ) variable flips, which is a number of configurations that is exponential with respect to the distance d(x, y).(The actual calculation requires the enumeration of all possible flips of 1, 2, ..., d(x, y) literals because the distance d(x, y) is not known a priori.Hence, the actual number of flips is y) .)While more difficult, these instances also display wide variation in resolution time.In order to obtain instances of more predictable difficulty, we impose a further constraint requiring all variables to appear the same number of times (or as near as possible while remaining consistent with the number of clauses M = ρN ), i.e., the variable occurrences are distributed as a δ-function.This variant is expected to be harder than the previous one because of the additional balance induced by the variable distribution, and our results indicate that they display much lower variability in their difficulty.
In the following, we will call "random-Max-E3SAT" a Max-E3SAT completely generated at random.This will be used as an "easy" problem to test the performance of all solvers.We refer to "hyper-Max-E3SAT" as the Max-E3SAT generated from a random Max-E3XOR, and finally to "delta-Max-E3SAT" as a problem generated by the Max-E3XOR with δ-function distribution of variables.
While the balanced structure of Max-XORSAT poses a challenge to local search algorithms (or message-passingbased ones), our memcomputing solver easily overcomes these limits because, due to the collective (instantonic) behavior of the circuit, the dynamics evolve towards deep minima very close to the global optimum (see also Methods).The reason is that, as already anticipated, the collective state of the machine allows simultaneous, nonlocal change of literals belonging to gates arbitrarily far from each other [13].This change is consistent with the physics and the topology of the memcomputing circuit that naturally drive the system towards the maximum number of satisfied SOLGs, without recourse to any combinatorial selection scheme.
The optimum for all problems can be estimated using an ensemble of small instances for which it is easier to find a fairly good approximation.For example, instances of about 300 variables and density (clauses/variables) of ρ = 5 provide a good indication of the global optimum in terms of percentage of unsatisfied clauses.We found that for the random-Max-E3SAT the optimum is expected at about 0.4% of unsatisfied clauses, while for both the hyper-and delta-Max-E3SAT this value is about 1.3%.The difference between these values is not surprising.As mentioned previously, it is well known that for the latter two problems the transition from satisfiable to unsatisfiable is around a density of ρ ≈ 3.7, while for random-Max-E3SAT it is around ρ ≈ 4.3.We have then chosen the same density of ρ = 5 for the random-, hyperand delta-Max-E3SAT.
In order to prove the superior efficiency of our noncombinatorial approach for this class of hard problems, we have evaluated their scaling properties up to 2 × 10 6 variables (while keeping the density constant).We recall that the simulations of DMMs have been done using a MatLab code, while CCLS and DeciLS are compiled codes.Therefore, the level of optimization is expected to be higher in the compiled codes, making a direct performance comparison harder, although for large problem sizes, our solver has much better performance compared to CCLS and DeciLS.Nevertheless, we are more interested in the scaling of the approximation time.Specifically, for hard cases where incomplete solvers diverge exponentially in time, our solver diverges linearly.This is the most important test and the central result of our paper.It is shown in Fig. 2.
The hard inapproximability limit and its exponential nature for both the combinatorial heuristics CCLS and DeciLS is clearly visible in Fig. 2, where we have 2. Simulation time comparison between incomplete solvers CCLS and DeciLS against our solver, Falcon, for the balanced and constrained delta-Max-E3SAT.A threshold of 1.5% of unsatisfiable clauses has been set.We have then tested how long CCLS, DeciLS and our solver Falcon take to overcome this limit with increasing number of variables.All calculations have been performed on a single thread of an Intel Xeon E5-2680 v3 with 128 Gb DRAM shared on 24 threads.The local solvers require an exponentially increasing time to reach that limit already visible at a few hundred variables for the CCLS and a few thousands for the DeciLS.Our solver has been tested up to 2 × 10 6 variables, and required order of 10 4 seconds for that maximum number of variables.We show also the estimate of time that would have been required these local solvers to run up to 2 × 10 6 variables.The estimated time (dashed and dashed-dotted lines) has been calculated using a linear regression of the log 10 (time) versus the number of variables.
set a threshold of 1.5% of unsatisfiable clauses for the delta-Max-E3SAT.We have then tested how long CCLS, DeciLS and our solver Falcon take to overcome this limit with increasing number of clauses.All calculations have been done on a single core of an Intel Xeon E5-2680 v3.
The exponential blowup of CCLS and DeciLS is already evident for small instances of the problem, while our non-combinatorial approach performs linearly, in both time and memory, for any number of variables we have tested so far.In fact, we have tested our solver up to 2 × 10 6 variables, requiring ∼ 10 4 seconds to reach the target 1.5% threshold.The heuristic solvers, if they could run up to the same number of variables would require, in the best case, about ∼ 10 2500 seconds, which is ∼ 10 2480 times the estimated age of the Universe.
To better highlight the linear scaling of our solver, we compare it in Fig. 3 with CCLS (qualitatively, all other incomplete solvers should perform similarly).Each plot of Fig. 3 displays the percentage of unsatisfied clauses versus time, normalized with respect to the number of variables n.Clearly, linear scaling for these hard problems is a very desirable feature, and very difficult to achieve with combinatorial approaches.However, the reason for such linear scaling is subtle.
Regarding memory, since we simulate (integrate) differential equations in time, and the circuit scales linearly with the number of literals, the linear scaling in memory requirements of our simulations is easy to understand (see also Methods).On the other hand, linear scaling in simulation time implies constant scaling, namely independent of the problem size, when we look at the "machine time", which is the number of (differential equation discretized time) steps for the simulation to reach equilibrium.The reason for this unexpected machinetime constant scaling can be found again in the longrange order of the dynamics of the system [13] (see also the Methods section).As we have shown analytically in Ref. [13] using topological field theory, this long-range order leads to non-decreasing spatial (and temporal) correlations in memcomputing machines (see Methods for further discussion).In fact, Fig. 3 clearly shows that self-organizing logic circuits relax close to the predicted global minimum, while the CCLS does so only for the ("easy") random-Max-E3SAT.This is further illustrated in Fig. 4 of the Methods section for random-, hyper-, and delta-Max-E3SAT.
In conclusion, we have shown empirical evidence that a non-combinatorial approach -based on the simulation of digital memcomputing machines-to the solution of hard combinatorial optimization problems outperforms exponentially heuristics specifically designed to solve such problems.In particular, with our approach we were able to find far better approximations to hard instances with millions of variables in a few hours on a single core, with linear scaling both in time and memory of the processor.For the same sizes, winners of the 2016 Max-SAT competition would require several orders of magnitude more than the age of the Universe to find the same approximations.Of course, these numerical results are not intended to prove that there are polynomial solutions to NP-hard problems.Rather, they show that physics-inspired approaches can help tremendously in solving some of the most complex problems faced in academia and industry.We thus hope that this work will motivate further research along these lines.

Methods
The non-combinatorial approach we discuss here is based on the concept of Universal Memcomputing Machines (UMMs) [11] introduced by two of us (F.T. and M.D.).UMMs are a class of computing machines composed of interconnected memory units.The topology of such network is chosen to solve the specific problem at hand.UMMs use the collective state of the interconnected memory units to perform computation [1,25], so they can take advantage of long-range correlations that can significantly boost the efficiency of the computation [1,13].If the input and output of UMMs can be mapped into strings of integers, belonging to a limited subset of N, we obtain the digital (hence scalable) version of UMMs (DMMs) [1].In particular, we consider DMMs whose input and output can be mapped into Z 2 .
A possible, practical realization of DMMs are self-organizing logic circuits (SOLCs) composed of SOLGs [1].SOLGs are logic gates that can accept inputs from any terminals, and self-organize their internal state to satisfy their logic relations.For example, a selforganizing OR (SO-OR) is a 3-terminal gate whose internal machinery drives the terminal states to satisfy the relation , where x o is the state of the conventional output terminal, and x 1 , x 2 are the states of the conventional input terminals.Therefore, unlike conventional logic gates, the SO-OR can be fed also at the output terminal.If we set x o to some state, the SO-OR then will self-organize to give consistent states x 1 and x 2 .
We can use SOLCs to solve combinatorial problems by expressing the problem in boolean format and then mapping the latter onto logic circuits.As a relevant example for this work, we can take the Max-SAT problem written in CNF.When we transform the SAT into a boolean circuit we have multi-terminal OR gates connected together in order to represent a logic formula (see Fig. 1).Hence, we can substitute conventional logic gates by SOLGs, and set all output of the SO-ORs to logical 1.We now let the SOLC to self-organize to satisfy the largest number of SO-ORs.
We have previously shown [1] that SOLCs can be realized via standard (non-quantum) electronic components (we employ the realization described in Ref. [1], just slightly modified to deal with CNF formulas).
One of the key components of SOLGs is the dynamic correction module we have designed to correct the inconsistent logic gate configurations.While the design and details of this component can be found in [1], we recall here its working principle.The error correction module dynamically reads the voltages at the terminals of the gate, and injects a large current when the gate is in an inconsistent configuration, a small current otherwise.
The non-quantum electronic nature of SOLCs can be fully described by a system of non-linear ordinary differential equations of the type where x = {v j , x i } ∈ X (X is the phase space) is the collection of voltages, v j , at the terminals and the internal state variables, x i , of the electronic elements with memory; F is a system of nonlinear ordinary differential equations, representing the flow vector field [1].We can then efficiently simulate them by numerical integration.Therefore, SOLCs are nothing other than dynamical systems.In this case, a solution of the problem we want to solve (e.g., the Max-SAT) employing a DMM is mapped into an equilibrium point of the dynamical system.The system is engineered in such a way that, starting from any initial condition (generally chosen at random) it evolves to converge into an equilibrium.
We have discussed in Ref. [1] the relevant properties that the dynamical systems representing DMMs should have to behave in this way.Among them, an important feature, fundamental to guarantee the convergence, is that they are point dissipative [26].This implies that the dynamical system has bounded orbits (no divergences), and it is endowed with an asymptotically stable global attractor, i.e., a compact set in the phase space that attracts any other point.This feature has also allowed us to prove that no chaotic behavior can emerge if equilibrium points are present [27], as well as absence of periodic orbits [28].Finally, the point dissipative property guarantees convergence to equilibrium irrespective of the initial conditions.
We can finally summarize the power of these machines with the following hierarchical picture.DMMs use the topology of the internal connectivity of its elements to represent the problem to solve (this is called information overhead in Ref [1]).Then, the collective state of the machine can manipulate all inputs, outputs and connecting variables in a massively-parallel fashion (intrinsic parallelism [1]).
In addition, the non-linearity of the dynamical system equations induces a transient instantonic phase with long-range order, both in space and time [13].This longrange order allows the system to converge exponentially fast to the equilibrium points that are associated to the approximations of optimization problems, by exploring a sub-space (that scales at most polynomially with input size) of the phase space.This sub-space is considerably smaller than the entire phase space itself [13].
In fact, as briefly discussed in the main text, the particular realization of DMMs we have presented in this work (similar to the ones in Ref. [1]) supports infiniterange correlations in the infinite input size limit, as shown in Ref [13].This enables an ideal scale-free behavior (namely one where the correlations do not decay) of the SOLC.This was derived analytically using topological field theory in Ref. [13], and can also be supported numerically from Fig. 5 as follows.
In order to simulate the system, we have employed a time-step size-controlled forward-integration scheme for the differential equations that describe it [29].Since the number of variables of the problem grows linearly with the input size because the number of gates grows only linearly, each time step to be simulated requires only a linear number of floating-point operations, and a memory linearly growing with input size.Then, the simulation time is just a linear function of the machine time.In Fig. 5 it is reported the same Fig. 3 but with the SOLC time (not normalized) on the x axis.It is evident that the relaxation of the system is independent of the input size (ideal scale-free scaling).This is a very interesting, and rare result for an extensive interconnected system.All these ingredients are necessary for the correct, efficient operation of a DMM.
The approximations to an optimization problem found by DMMs are very close to the global minimum of the problem, and this is guaranteed by the topology of the connectivity.This is clearly demonstrated in Fig. 4 where the unsatisfied clauses are plotted versus variables for different simulation times, scaled linearly by the number of variables.While for the random-Max-E3SAT both our solver and the CCLS approach the 0.4% minimum, in the case of the hyper-Max-E3SAT, CCLS reaches a hard inapproximability limit of about 2% for large instances.As expected, the delta-Max-E3SAT, instead, is a much worse case, and the inapproximability limit for CCLS is at about 3%.
In contrast, our non-combinatorial approach directly reaches the global minimum in all cases.Interestingly, our solver shows slightly better performances for the delta-Max-E3SAT (the most difficult of the three cases) as can be seen by taking a closer look at Fig.

I. SUPPLEMENTAL INFORMATION II. A BRIEF SURVEY ON MAXSAT SOLVERS
As mentioned in the main text, there are two main (combinatorial) approaches to solve or approximate the Max-SAT problem.The first is based on the exhaustive exploration of the solution space and leads to the socalled "complete" solvers [6,21].The complete solvers use algorithms typically based on the branch-and-bound approach [2,8] in which a greedy bound is first put on the optimum and then this is used to prune the resulting search tree.Despite this pruning, they still scale exponentially with input size |x| because they exhaustively search a space Z O(|x|) 2 = {0, 1} O(|x|) .However, when the computation is finished, complete solvers are guaranteed to have found the global optimum of the Max-SAT.
Incomplete solvers [6,7], in comparison, cannot guarantee the optimality of their solution as they do not explore the entire solution space.Instead they proceed by generating an initial assignment, and iteratively improving upon it.This trade-off allows them to find solutions, when they do, much more quickly than complete algorithms.In the most recent Max-SAT competition [5], incomplete track solvers found solutions two orders of magnitude faster than complete track solvers in random and crafted benchmarks, and performed comparably on industrial benchmarks.
The quintessential incomplete solver is WalkSAT [7] which proceeds through a stochastic local search.After an initial assignment is generated, an unsatisfied clause is selected and one variable from the clause has its assignment flipped.This will leave this clause satisfied but may alter the state of other clauses in which the variable occurs.The procedure is continued for a specified number of steps or until a solution is found.Most current local search solvers work similarly with various heuristics to select the next variable flip, utilize restarts and/or noise, and a host of other features.
We compared our solver, Falcon, with two of the best solvers from this years Max-SAT competition, CCLS [16] and DeciLS [17].CCLS won the crafted track for unweighted Max-SAT and performs a local search (LS) with configuration checking (CC).Local search solvers will often retrace flips many times leading to an inefficient search.Configuration checking keeps track of when neighboring variables have been flipped and only allows a variable to be flipped again when at least one of its neighbors has changed its assignment.DeciLS is an updated version of CnC-LS which won the industrial track for unweighted Max-SAT and combines a unit propagation based decimation (Deci) and local search (LS) with restarts.An assignment is first generated through unit propagation-based decimation [21] in which conflicts are allowed, and the result is given to a local search for a specified number of steps.The process is then restarted and the best result of the previous search is used to guide the subsequent decimation and resolve conflicts.This allows the solver to explore very different reasoning chains and areas of the solution space.

III. WEIGHTED PARTIAL MAX-SAT
In order to more efficiently map a large number of maximization problems into Max-SAT, it is sometimes useful to consider a variant: weighted partial Max-SAT [2,8].Weighted partial Max-SAT is a version of Max-SAT for which a subset of clauses must be satisfied ("hard" clauses), while the remaining clauses ("soft" clauses) may be weighted, and the sum of the weights of satisfied clauses must be maximized.The Max-SAT is a particular case of the weighted partial MaxSAT in which all clauses are soft and have the same weight.
Because of the presence of hard clauses, the weighted partial Max-SAT is, in general, harder than the Max-SAT for all kind of solvers.In fact, this is one of the main reasons heuristics are often unable to find even approximations to those problems (see, e.g., Fig. 8-9).
Including weights and hard clauses in self-organizing logic circuits (SOLCs) is simple.Recalling that each OR gate representing a clause has attached at each terminal a dynamic correction module that injects a large current when the gate is in an inconsistent configuration, we can tune the maximum current allowed for each correction module in the following way.We set the maximum current injected by the dynamic correction modules connected to the SO-OR gates proportionally to the weights of the clauses.For the hard clauses we can set the maximum current injected by the dynamic correction modules connected to the hard SO-OR gates, larger than the sum of all maximum currents injected by the dynamic correction modules connected to all soft SO-OR gates connected to that hard SO-OR gate.This will guarantee that the hard clauses will have always the priority on the soft clauses.

IV. COMPARISON FROM THE 2016 MAX-SAT COMPETITION
We have tested SOLCs on problems taken from the 2016 Max-SAT competition, and compared them against the results of the winners of each category of that competition.Even if the comparison is not completely fair because our code is written in MatLab while the other codes are written in compiled languages, and the benchmark is not the same because we ran on different processors (we ran all our simulations on an Intel Xeon E5-2680 v3 but used the same number of threads allowed in the Max-Sat competition) the results are still interesting.
In Figs. 6 and 7 we compare the random Max-2SAT and random Max-CUT instances, which are nonweighted problems [2].In those cases the scaling is sim- FIG. 2. Simulation time comparison between incomplete solvers CCLS andDeciLS against our solver, Falcon, for the balanced and constrained delta-Max-E3SAT.A threshold of 1.5% of unsatisfiable clauses has been set.We have then tested how long CCLS, DeciLS and our solver Falcon take to overcome this limit with increasing number of variables.All calculations have been performed on a single thread of an Intel Xeon E5-2680 v3 with 128 Gb DRAM shared on 24 threads.The local solvers require an exponentially increasing time to reach that limit already visible at a few hundred variables for the CCLS and a few thousands for the DeciLS.Our solver has been tested up to 2 × 10 6 variables, and required order of 10 4 seconds for that maximum number of variables.We show also the estimate of time that would have been required these local solvers to run up to 2 × 10 6 variables.The estimated time (dashed and dashed-dotted lines) has been calculated using a linear regression of the log 10 (time) versus the number of variables.

FIG. 3 .
FIG. 3. Comparison between the incomplete solver CCLSversus our non-combinatorial solver, Falcon, for (a) Random-Max-E3SAT, (b) hyper-Max-E3SAT, (c) delta-Max-E3SAT.In these plots the percentage of unsatisfied clauses versus the time normalized with respect to the number of variables is shown to highlight the linear scaling of our solver.All calculations have been performed on a single thread of an Intel Xeon E5-2680 v3 with 128 Gb DRAM shared on 24 treads.

FIG. 4 .
FIG. 4. Comparison between the CCLS solver versus our solver, Falcon, for (a) random-Max-E3SAT, (b) hyper-Max-E3SAT, (c) delta-Max-E3SAT.In these plots the percentage of unsatisfied clauses versus the number of variables is shown.Different curves are for different simulation time outs (in seconds) following the relation tout = kn with n = |x|, and k an integer given in the legend.All calculations have been performed on a single thread of an Intel Xeon E5-2680 v3 with 128 Gb DRAM shared on 24 treads.

FIG. 5 .
FIG. 5. Percentage of unsatisfied clauses versus the machine time (i.e., simulated time steps) is shown to highlight the linear scaling of our solver, Falcon, for (a) random-Max-E3SAT, (b) hyper-Max-E3SAT, (c) delta-Max-E3SAT.All calculations have been performed on a single thread of an Intel Xeon E5-2680 v3 with 128 Gb DRAM shared on 24 treads.
Example of the mapping between a boolean satisfiability formula in conjunctive normal form and a boolean circuit made of multi-terminal OR and NOT gates.Each clause of the SAT formula is mapped into an OR with as many terminals as the literals in the clause (the satisfiability of this multi-terminal OR requires that at least one terminal has a truth value of 1).The global optimum of the SAT formula, [1]., the maximum number of satisfied clauses, corresponds to the maximum number of OR gates with output one.This boolean circuit is then transformed into a self-organizing logic circuit by substituting each standard boolean gate with a selforganizing logic gate[1], and each OR output is fed with a DC voltage generator representing the logic value of 1.