PLS (complexity)

In computational complexity theory, Polynomial Local Search (PLS) is a complexity class that models the difficulty of finding a locally optimal solution to an optimization problem. The main characteristics of problems that lie in PLS are that the cost of a solution can be calculated in polynomial time and the neighborhood of a solution can be searched in polynomial time. Therefore it is possible to verify whether or not a solution is a local optimum in polynomial time. Furthermore, depending on the problem and the algorithm that is used for solving the problem, it might be faster to find a local optimum instead of a global optimum.

## Contents

* 1 Description
* 1.1 Example
* 2 Formal Definition
* 2.1 Alternative Definition
* 2.2 Example neighborhood structures
* 3 The standard Algorithm
* 4 Reductions
* 4.1 PLS-reduction
* 4.2 Tight PLS-reduction
* 4.2.1 Definition Transition graph
* 4.2.2 Definition Tight PLS-reduction
* 5 Relationship to other complexity classes
* 6 PLS-completeness
* 6.1 Definition
* 6.2 List of PLS-complete Problems
* 7 Relations to other complexity classes
* 8 Further reading
* 9 References

## Description

When searching for a local optimum, there are two interesting issues to deal with: First how to find a local optimum, and second how long it takes to find a local optimum. For many local search algorithms, it is not known, whether they can find a local optimum in polynomial time or not.[1] So to answer the question of how long it takes to find a local optimum, Johnson, Papadimitriou and Yannakakis [2] introduced the complexity class PLS in their paper "How easy is local search?". It contains local search problems for which the local optimality can be verified in polynomial time.

A local search problem is in PLS, if the following properties are satisfied:

* The size of every solution is polynomially bounded in the size of the instance I.
* It is possible to find some solution of a problem instance in polynomial time.
* It is possible to calculate the cost of each solution in polynomial time.
* It is possible to find all neighbors of each solution in polynomial time.

With these properties, it is possible to find for each solution s the best neighboring solution or if there is no such better neighboring solution, state that s is a local optimum.

### Example

Consider the following instance I of the Max-2Sat Problem: (x1∨x2)∧(¬x1∨x3)∧(¬x2∨x3). The aim is to find an assignment, that maximizes the sum of the satisfied clauses.

A solution s for that instance is a bit string that assigns every xi the value 0 or 1. In this case, a solution consists of 3 bits, for example s=000, which stands for the assignment of x1 to x3 with the value 0. The set of solutions FL(I) is the set of all possible assignments of x1, x2 and x3.

The cost of each solution is the number of satisfied clauses, so cL(I,s=000)=2 because the second and third clause are satisfied.

The Flip-neighbor of a solution s is reached by flipping one bit of the bit string s, so the neighbors of s are N(I,000)={100,010,001} with the following costs:

cL(I,100)=2

cL(I,010)=2

cL(I,001)=2

There are no neighbors with better costs than s, if we are looking for a solution with maximum cost. Even though s is not a global optimum (which for example would be a solution s′=111 that satisfies all clauses and has cL(I,s′)=3), s is a local optimum, because none of its neighbors has better costs.

Intuitively it can be argued that this problem lies in PLS, because:

* It is possible to find a solution to an instance in polynomial time, for example by setting all bits to 0.
* It is possible to calculate the cost of a solution in polynomial time, by going once through the whole instance and counting the clauses that are satisfied.
* It is possible to find all neighbors of a solution in polynomial time, by taking the set of solutions that differ from s in exactly one bit.

If we are simply counting the number of satisfied clauses, the problem can be solved in polynomial time since the number of possible costs is polynomial. However, if we assign each clause a positive integer weight (and seek to locally maximize the sum of weights of satisfied clauses), the problem becomes PLS-complete (below).

## Formal Definition

A local search problem L has a set DL of instances which are encoded using strings over a finite alphabet Σ. For each instance I there exists a finite solution set FL(I). Let R be the relation that models L. The relation R⊆DL×FL(I):={(I,s)∣I∈DL,s∈FL(I)} is in PLS [2][3][4] if:

* The size of every solution s∈FL(I) is polynomial bounded in the size of I
* Problem instances I∈DL and solutions s∈FL(I) are polynomial time verifiable
* There is a polynomial time computable function A:DL->FL(I) that returns for each instance I∈DL some solution s∈FL(I)
* There is a polynomial time computable function B:DL×FL(I)->ℝ+ [5] that returns for each solution s∈FL(I) of an instance I∈DL the cost cL(I,s)
* There is a polynomial time computable function N:DL×FL(I)->Powerset(FL(I)) that returns the set of neighbors for an instance-solution pair
* There is a polynomial time computable function C:DL×FL(I)->N(I,s)∪{OPT} that returns a neighboring solution s′ with better cost than solution s, or states that s is locally optimal
* For every instance I∈DL, R exactly contains the pairs (I,s) where s is a local optimal solution of I

An instance DL has the structure of an implicit graph (also called Transition graph [6]), the vertices being the solutions with two solutions s,s′∈FL(I) connected by a directed arc iff s′∈N(I,s).

A local optimum is a solution s, that has no neighbor with better costs. In the implicit graph, a local optimum is a sink. A neighborhood where every local optimum is a global optimum, which is a solution with the best possible cost, is called an exact neighborhood.[6][1]

### Alternative Definition

The class PLS is the class containing all problems that can be reduced in polynomial time to the problem Sink-of-DAG[7] (also called Local-Opt [8]): Given two integers n and m and two Boolean circuits S:{0,1}n->{0,1}n such that S(0n)≠0n and V:{0,1}n->{0,1,..,2m−1}, find a vertex x∈{0,1}n such that S(x)≠x and either S(S(x))=S(x) or V(S(x))≤V(x).

### Example neighborhood structures

Example neighborhood structures for problems with boolean variables (or bit strings) as solution:

* Flip[2] \- The neighborhood of a solution s=x1,...,xn can be achieved by negating (flipping) one arbitrary input bit xi. So one solution s and all its neighbors r∈N(I,s) have Hamming distance one: H(s,r)=1.
* Kernighan-Lin[2][6] \- A solution r is a neighbor of solution s if r can be obtained from s by a sequence of greedy flips, where no bit is flipped twice. This means, starting with s, the Flip-neighbor s1 of s with the best cost, or the least loss of cost, is chosen to be a neighbor of s in the Kernighan-Lin structure. As well as best (or least worst) neighbor of s1 , and so on, until si is a solution where every bit of s is negated. Note that it is not allowed to flip a bit back, if it once has been flipped.
* k-Flip[9] \- A solution r is a neighbor of solution s if the Hamming distance H between s and r is at most k, so H(s,r)≤k.

Example neighborhood structures for problems on graphs:

* Swap[10] \- A partition (P2,P3) of nodes in a graph is a neighbor of a partition (P0,P1) if (P2,P3) can be obtained from (P0,P1) by swapping one node p0∈P0 with a node p1∈P1.
* Kernighan-Lin[1][2] \- A partition (P2,P3) is a neighbor of (P0,P1) if (P2,P3) can be obtained by a greedy sequence of swaps from nodes in P0 with nodes in P1. This means the two nodes p0∈P0 and p1∈P1 are swapped, where the partition ((P0∖p0)∪p1,(P1∖p1)∪p0) gains the highest possible weight, or loses the least possible weight. Note that no node is allowed to be swapped twice.
* Fiduccia-Matheyses [1][11] \- This neighborhood is similar to the Kernighan-Lin neighborhood structure, it is a greedy sequence of swaps, except that each swap happens in two steps. First the p0∈P0 with the most gain of cost, or the least loss of cost, is swapped to P1, then the node p1∈P1 with the most cost, or the least loss of cost is swapped to P0 to balance the partitions again. Experiments have shown that Fiduccia-Mattheyses has a smaller run time in each iteration of the standard algorithm, though it sometimes finds an inferior local optimum.
* FM-Swap[1] \- This neighborhood structure is based on the Fiduccia-Mattheyses neighborhood structure. Each solution s=(P0,P1) has only one neighbor, the partition obtained after the first swap of the Fiduccia-Mattheyses.

## The standard Algorithm

Consider the following computational problem: Given some instance I of a PLS problem L, find a locally optimal solution s∈FL(I) such that cL(I,s′)≥cL(I,s) for all s′∈N(I,s).

Every local search problem can be solved using the following iterative improvement algorithm:[2]

1. Use AL to find an initial solution s
2. Use algorithm CL to find a better solution s′∈N(I,s). If such a solution exists, replace s by s′ and repeat step 2, else return s

Unfortunately, it generally takes an exponential number of improvement steps to find a local optimum even if the problem L can be solved exactly in polynomial time.[2] It is not necessary always to use the standard algorithm, there may be a different, faster algorithm for a certain problem. For example a local search algorithm used for Linear programming is the Simplex algorithm.

The run time of the standard algorithm is pseudo-polynomial in the number of different costs of a solution.[12]

The space the standard algorithm needs is only polynomial. It only needs to save the current solution s, which is polynomial bounded by definition.[1]

## Reductions

A Reduction of one problem to another may be used to show that the second problem is at least as difficult as the first. In particular, a PLS-reduction is used to prove that a local search problem that lies in PLS is also PLS-complete, by reducing a PLS-complete Problem to the one that shall be proven to be PLS-complete.

### PLS-reduction

A local search problem L1 is PLS-reducible[2] to a local search problem L2 if there are two polynomial time functions f:D1->D2 and g:D1×F2(f(I1))->F1(I1) such that:

* if I1 is an instance of L1 , then f(I1) is an instance of L2
* if s2 is a solution for f(I1) of L2 , then g(I1,s2) is a solution for I1 of L1
* if s2 is a local optimum for instance f(I1) of L2 , then g(I1,s2) has to be a local optimum for instance I1 of L1

It is sufficient to only map the local optima of f(I1) to the local optima of I1, and to map all other solutions for example to the standard solution returned by A1.[6]

PLS-reductions are transitive.[2]

### Tight PLS-reduction

#### Definition Transition graph

The transition graph[6] TI of an instance I of a problem L is a directed graph. The nodes represent all elements of the finite set of solutions FL(I) and the edges point from one solution to the neighbor with strictly better cost. Therefore it is an acyclic graph. A sink, which is a node with no outgoing edges, is a local optimum. The height of a vertex v is the length of the shortest path from v to the nearest sink. The height of the transition graph is the largest of the heights of all vertices, so it is the height of the largest shortest possible path from a node to its nearest sink.

#### Definition Tight PLS-reduction

A PLS-reduction (f,g) from a local search problem L1 to a local search problem L2 is a tight PLS-reduction[10] if for any instance I1 of L1, a subset R of solutions of instance I2=f(I1) of L2 can be chosen, so that the following properties are satisfied:

* R contains, among other solutions, all local optima of I2
* For every solution p of I1 , a solution q∈R of I2=f(I1) can be constructed in polynomial time, so that g(I1,q)=p
* If the transition graph Tf(I1) of f(I1) contains a direct path from q to q0, and q,q0∈R, but all internal path vertices are outside R, then for the corresponding solutions p=g(I1,q) and p0=g(I1,q0) holds either p=p0 or TI1 contains an edge from p to p0

## Relationship to other complexity classes

PLS lies between the functional versions of P and NP: FP ⊆ PLS ⊆ FNP.[2]

PLS also is a subclass of TFNP,[13] that describes computational problems in which a solution is guaranteed to exist and can be recognized in polynomial time. For a problem in PLS, a solution is guaranteed to exist because the minimum-cost vertex of the entire graph is a valid solution, and the validity of a solution can be checked by computing its neighbors and comparing the costs of each one to another.

It is also proven that if a PLS problem is NP-hard, then NP = co-NP.[2]

## PLS-completeness

### Definition

A local search problem L is PLS-complete,[2] if

* L is in PLS
* every problem in PLS can be PLS-reduced to L

The optimization version of the circuit problem under the Flip neighborhood structure has been shown to be a first PLS-complete problem.[2]

### List of PLS-complete Problems

This is an incomplete list of some known problems that are PLS-complete. The problems here are the weighted versions; for example, Max-2SAT/Flip is weighted even though Max-2SAT ordinarily refers to the unweighted version.

Overview of PLS-complete problems and how they are reduced to each other. Syntax: Optimization-Problem/Neighborhood structure. Dotted arrow: PLS-reduction from a problem L to a problem Q:L<-Q. Black arrow: Tight PLS-reduction.[4]

Notation: Problem / Neighborhood structure

* Min/Max-circuit/Flip has been proven to be the first PLS-complete problem.[2]
* Sink-of-DAG is complete by definition.
* Positive-not-all-equal-max-3Sat/Flip has been proven to be PLS-complete via a tight PLS-reduction from Min/Max-circuit/Flip to Positive-not-all-equal-max-3Sat/Flip. Note that Positive-not-all-equal-max-3Sat/Flip can be reduced from Max-Cut/Flip too.[10]
* Positive-not-all-equal-max-3Sat/Kernighan-Lin has been proven to be PLS-complete via a tight PLS-reduction from Min/Max-circuit/Flip to Positive-not-all-equal-max-3Sat/Kernighan-Lin.[1]
* Max-2Sat/Flip has been proven to be PLS-complete via a tight PLS-reduction from Max-Cut/Flip to Max-2Sat/Flip.[1][10]
* Min-4Sat-B/Flip has been proven to be PLS-complete via a tight PLS-reduction from Min-circuit/Flip to Min-4Sat-B/Flip.[9]
* Max-4Sat-B/Flip(or CNF-SAT) has been proven to be PLS-complete via a PLS-reduction from Max-circuit/Flip to Max-4Sat-B/Flip.[14]
* Max-4Sat-(B=3)/Flip has been proven to be PLS-complete via a PLS-reduction from Max-circuit/Flip to Max-4Sat-(B=3)/Flip.[15]
* Max-Uniform-Graph-Partitioning/Swap has been proven to be PLS-complete via a tight PLS-reduction from Max-Cut/Flip to Max-Uniform-Graph-partitioning/Swap.[10]
* Max-Uniform-Graph-Partitioning/Fiduccia-Matheyses is stated to be PLS-complete without proof.[1]
* Max-Uniform-Graph-Partitioning/FM-Swap has been proven to be PLS-complete via a tight PLS-reduction from Max-Cut/Flip to Max-Uniform-Graph-partitioning/FM-Swap.[10]
* Max-Uniform-Graph-Partitioning/Kernighan-Lin has been proven to be PLS-complete via a PLS-reduction from Min/Max-circuit/Flip to Max-Uniform-Graph-Partitioning/Kernighan-Lin.[2] There is also a tight PLS-reduction from Positive-not-all-equal-max-3Sat/Kernighan-Lin to Max-Uniform-Graph-Partitioning/Kernighan-Lin.[1]
* Max-Cut/Flip has been proven to be PLS-complete via a tight PLS-reduction from Positive-not-all-equal-max-3Sat/Flip to Max-Cut/Flip.[1][10]
* Max-Cut/Kernighan-Lin is claimed to be PLS-complete without proof.[6]
* Min-Independent-Dominating-Set-B/k-Flip has been proven to be PLS-complete via a tight PLS-reduction from Min-4Sat-B′/Flip to Min-Independent-Dominating-Set-B/k-Flip.[9]
* Weighted-Independent-Set/Change is claimed to be PLS-complete without proof.[2][10][6]
* Maximum-Weighted-Subgraph-with-property-P/Change is PLS-complete if property P = "has no edges", as it then equals Weighted-Independent-Set/Change. It has also been proven to be PLS-complete for a general hereditary, non-trivial property P via a tight PLS-reduction from Weighted-Independent-Set/Change to Maximum-Weighted-Subgraph-with-property-P/Change.[16]
* Set-Cover/k-change has been proven to be PLS-complete for each k ≥ 2 via a tight PLS-reduction from (3, 2, r)-Max-Constraint-Assignment/Change to Set-Cover/k-change.[17]
* Metric-TSP/k-Change has been proven to be PLS-complete via a PLS-reduction from Max-4Sat-B/Flip to Metric-TSP/k-Change.[15]
* Metric-TSP/Lin-Kernighan has been proven to be PLS-complete via a tight PLS-reduction from Max-2Sat/Flip to Metric-TSP/Lin-Kernighan.[18]
* Local-Multi-Processor-Scheduling/k-change has been proven to be PLS-complete via a tight PLS-reduction from Weighted-3Dimensional-Matching/(p, q)-Swap to Local-Multi-Processor-scheduling/(2p+q)-change, where (2p + q) ≥ 8.[5]
* Selfish-Multi-Processor-Scheduling/k-change-with-property-t has been proven to be PLS-complete via a tight PLS-reduction from Weighted-3Dimensional-Matching/(p, q)-Swap to (2p+q)-Selfish-Multi-Processor-Scheduling/k-change-with-property-t, where (2p + q) ≥ 8.[5]
* Finding a pure Nash Equilibrium in a General-Congestion-Game/Change has been proven PLS-complete via a tight PLS-reduction from Positive-not-all-equal-max-3Sat/Flip to General-Congestion-Game/Change.[19]
* Finding a pure Nash Equilibrium in a Symmetric General-Congestion-Game/Change has been proven to be PLS-complete via a tight PLS-reduction from an asymmetric General-Congestion-Game/Change to symmetric General-Congestion-Game/Change.[19]
* Finding a pure Nash Equilibrium in an Asymmetric Directed-Network-Congestion-Games/Change has been proven to be PLS-complete via a tight reduction from Positive-not-all-equal-max-3Sat/Flip to Directed-Network-Congestion-Games/Change [19] and also via a tight PLS-reduction from 2-Threshold-Games/Change to Directed-Network-Congestion-Games/Change.[20]
* Finding a pure Nash Equilibrium in an Asymmetric Undirected-Network-Congestion-Games/Change has been proven to be PLS-complete via a tight PLS-reduction from 2-Threshold-Games/Change to Asymmetric Undirected-Network-Congestion-Games/Change.[20]
* Finding a pure Nash Equilibrium in a Symmetric Distance-Bounded-Network-Congestion-Games has been proven to be PLS-complete via a tight PLS-reduction from 2-Threshold-Games to Symmetric Distance-Bounded-Network-Congestion-Games.[21]
* Finding a pure Nash Equilibrium in a 2-Threshold-Game/Change has been proven to be PLS-complete via a tight reduction from Max-Cut/Flip to 2-Threshold-Game/Change.[20]
* Finding a pure Nash Equilibrium in Market-Sharing-Game/Change with polynomial bounded costs has been proven to be PLS-complete via a tight PLS-reduction from 2-Threshold-Games/Change to Market-Sharing-Game/Change.[20]
* Finding a pure Nash Equilibrium in an Overlay-Network-Design/Change has been proven to be PLS-complete via a reduction from 2-Threshold-Games/Change to Overlay-Network-Design/Change. Analogously to the proof of asymmetric Directed-Network-Congestion-Game/Change, the reduction is tight.[20]
* Min-0-1-Integer Programming/k-Flip has been proven to be PLS-complete via a tight PLS-reduction from Min-4Sat-B′/Flip to Min-0-1-Integer Programming/k-Flip.[9]
* Max-0-1-Integer Programming/k-Flip is claimed to be PLS-complete because of PLS-reduction to Max-0-1-Integer Programming/k-Flip, but the proof is left out.[9]
* (p, q, r)-Max-Constraint-Assignment
* (3, 2, 3)-Max-Constraint-Assignment-3-partite/Change has been proven to be PLS-complete via a tight PLS-reduction from Circuit/Flip to (3, 2, 3)-Max-Constraint-Assignment-3-partite/Change.[22]
* (2, 3, 6)-Max-Constraint-Assignment-2-partite/Change has been proven to be PLS-complete via a tight PLS-reduction from Circuit/Flip to (2, 3, 6)-Max-Constraint-Assignment-2-partite/Change.[22]
* (6, 2, 2)-Max-Constraint-Assignment/Change has been proven to be PLS-complete via a tight reduction from Circuit/Flip to (6,2, 2)-Max-Constraint-Assignment/Change.[22]
* (4, 3, 3)-Max-Constraint-Assignment/Change equals Max-4Sat-(B=3)/Flip and has been proven to be PLS-complete via a PLS-reduction from Max-circuit/Flip.[15] It is claimed that the reduction can be extended so tightness is obtained.[22]
* Nearest-Colorful-Polytope/Change has been proven to be PLS-complete via a PLS-reduction from Max-2Sat/Flip to Nearest-Colorful-Polytope/Change.[3]
* Stable-Configuration/Flip in a Hopfield network has been proven to be PLS-complete if the thresholds are 0 and the weights are negative via a tight PLS-reduction from Max-Cut/Flip to Stable-Configuration/Flip.[1][10][18]
* Weighted-3Dimensional-Matching/(p, q)-Swap has been proven to be PLS-complete for p ≥9 and q ≥ 15 via a tight PLS-reduction from (2, 3, r)-Max-Constraint-Assignment-2-partite/Change to Weighted-3Dimensional-Matching/(p, q)-Swap.[5]
* The problem Real-Local-Opt (finding the ɛ local optimum of a λ-Lipschitz continuous objective function V:[0,1]3->[0,1] and a neighborhood function S:[0,1]3->[0,1]3) is PLS-complete.[8]
* Finding a local fitness peak in a biological fitness landscapes specified by the NK-model/Point-mutation with K ≥ 2 was proven to be PLS-complete via a tight PLS-reduction from Max-2SAT/Flip.[23]

## Relations to other complexity classes

Fearnley, Goldberg, Hollender and Savani[24] proved that a complexity class called CLS is equal to the intersection of PPAD and PLS.

## Further reading

* Equilibria, fixed points, and complexity classes: a survey.[25]

## References

* Yannakakis, Mihalis (2009), "Equilibria, fixed points, and complexity classes", Computer Science Review 3 (2): 71–85, doi:10.1016/j.cosrev.2009.03.004 .

1. ↑ 1.00 1.01 1.02 1.03 1.04 1.05 1.06 1.07 1.08 1.09 1.10 1.11 Yannakakis, Mihalis (2003). Local search in combinatorial optimization - Computational complexity. Princeton University Press. pp. 19–55. ISBN 9780691115221.
2. ↑ 2.00 2.01 2.02 2.03 2.04 2.05 2.06 2.07 2.08 2.09 2.10 2.11 2.12 2.13 2.14 2.15 Johnson, David S; Papadimitriou, Christos H; Yannakakis, Mihalis (1988). "How easy is local search?". Journal of Computer and System Sciences 37 (1): 79–100. doi:10.1016/0022-0000(88)90046-3.
3. ↑ 3.0 3.1 Mulzer, Wolfgang; Stein, Yannik (14 March 2018). "Computational Aspects of the Colorful Caratheodory Theorem". Discrete & Computational Geometry 60 (3): 720–755. doi:10.1007/s00454-018-9979-y. Bibcode: 2014arXiv1412.3347M.
4. ↑ 4.0 4.1 Borzechowski, Michaela. "The complexity class Polynomial Local Search (PLS) and PLS-complete problems". http://www.mi.fu-berlin.de/inf/groups/ag-ti/theses/download/Borzechowski16.pdf.
5. ↑ 5.0 5.1 5.2 5.3 Dumrauf, Dominic; Monien, Burkhard; Tiemann, Karsten (2009). "Multiprocessor Scheduling is PLS-Complete" (in en). System Sciences, 2009. HICSS'09. 42nd Hawaii International Conference on: 1–10. https://www.researchgate.net/publication/224373381.
6. ↑ 6.0 6.1 6.2 6.3 6.4 6.5 6.6 Michiels, Wil; Aarts, Emile; Korst, Jan (2010). Theoretical aspects of local search. Springer Science & Business Media. ISBN 9783642071485.
7. ↑ Fearnley, John; Gordon, Spencer; Mehta, Ruta; Savani, Rahul (December 2020). "Unique end of potential line". Journal of Computer and System Sciences 114: 1–35. doi:10.1016/j.jcss.2020.05.007. https://drops.dagstuhl.de/opus/volltexte/2019/10632/.
8. ↑ 8.0 8.1 Daskalakis, Constantinos; Papadimitriou, Christos (23 January 2011). "Continuous Local Search". Proceedings of the Twenty-Second Annual ACM-SIAM Symposium on Discrete Algorithms: 790–804. doi:10.1137/1.9781611973082.62. ISBN 978-0-89871-993-2.
9. ↑ 9.0 9.1 9.2 9.3 9.4 Klauck, Hartmut (1996). "On the hardness of global and local approximation". Proceedings of the 5th Scandinavian Workshop on Algorithm Theory: 88–99. https://www.researchgate.net/publication/221209488.
10. ↑ 10.0 10.1 10.2 10.3 10.4 10.5 10.6 10.7 10.8 Schäffer, Alejandro A.; Yannakakis, Mihalis (February 1991). "Simple Local Search Problems that are Hard to Solve". SIAM Journal on Computing 20 (1): 56–87. doi:10.1137/0220004.
11. ↑ Fiduccia, C. M.; Mattheyses, R. M. (1982). "A Linear-time Heuristic for Improving Network Partitions". Proceedings of the 19th Design Automation Conference: 175–181. ISBN 9780897910200. https://dl.acm.org/citation.cfm?id=809204.
12. ↑ Angel, Eric; Christopoulos, Petros; Zissimopoulos, Vassilis (2014). Paradigms of Combinatorial Optimization: Problems and New Approaches - Local Search: Complexity and Approximation (2 ed.). John Wiley & Sons, Inc., Hoboken. pp. 435–471. doi:10.1002/9781119005353.ch14. ISBN 9781119005353.
13. ↑ Megiddo, Nimrod; Papadimitriou, Christos H (1991). "On total functions, existence theorems and computational complexity". Theoretical Computer Science 81 (2): 317–324. doi:10.1016/0304-3975(91)90200-L.
14. ↑ Krentel, M. (1 August 1990). "On Finding and Verifying Locally Optimal Solutions". SIAM Journal on Computing 19 (4): 742–749. doi:10.1137/0219052. ISSN 0097-5397.
15. ↑ 15.0 15.1 15.2 Krentel, Mark W. (1989). "Structure in locally optimal solutions". 30th Annual Symposium on Foundations of Computer Science. pp. 216–221. doi:10.1109/SFCS.1989.63481. ISBN 0-8186-1982-1. https://www.researchgate.net/publication/3501884.
16. ↑ Shimozono, Shinichi (1997). "Finding optimal subgraphs by local search". Theoretical Computer Science 172 (1): 265–271. doi:10.1016/S0304-3975(96)00135-1.
17. ↑ Dumrauf, Dominic; Süß, Tim (2010). "On the Complexity of Local Search for Weighted Standard Set Problems" (in en). CiE 2010: Programs, Proofs, Processes. Lecture Notes in Computer Science. 6158. Springer, Berlin, Heidelberg. pp. 132–140. doi:10.1007/978-3-642-13962-8_15. ISBN 978-3-642-13961-1.
18. ↑ 18.0 18.1 Papadimitriou, C.H.; Schäffer, A. A.; Yannakakis, M. (1990). "On the complexity of local search". Proceedings of the twenty-second annual ACM symposium on Theory of computing - STOC '90. pp. 438–445. doi:10.1145/100216.100274. ISBN 0897913612. http://dl.acm.org/citation.cfm?doid=100216.100274.
19. ↑ 19.0 19.1 19.2 Fabrikant, Alex; Papadimitriou, Christos; Talwar, Kunal (2004). "The complexity of pure Nash equilibria". Proceedings of the thirty-sixth annual ACM symposium on Theory of computing. ACM. pp. 604–612. doi:10.1145/1007352.1007445. ISBN 978-1581138528.
20. ↑ 20.0 20.1 20.2 20.3 20.4 Ackermann, Heiner; Röglin, Heiko; Vöcking, Berthold (2008). "On the Impact of Combinatorial Structure on Congestion Games". J. ACM 55 (6): 25:1–25:22. doi:10.1145/1455248.1455249. ISSN 0004-5411.
21. ↑ Yang, Yichen; Jia, Kai; Rinard, Martin (2022). "On the Impact of Player Capability on Congestion Games". Algorithmic Game Theory. Lecture Notes in Computer Science. 13584. pp. 311–328. doi:10.1007/978-3-031-15714-1_18. ISBN 978-3-031-15713-4. https://link.springer.com/chapter/10.1007/978-3-031-15714-1_18.
22. ↑ 22.0 22.1 22.2 22.3 Dumrauf, Dominic; Monien, Burkhard (2013). "On the PLS-complexity of Maximum Constraint Assignment". Theor. Comput. Sci. 469: 24–52. doi:10.1016/j.tcs.2012.10.044. ISSN 0304-3975.
23. ↑ Kaznatcheev, Artem (2019). "Computational Complexity as an Ultimate Constraint on Evolution". Genetics 212 (1): 245–265. doi:10.1534/genetics.119.302000. PMID 30833289.
24. ↑ Fearnley, John; Goldberg, Paul; Hollender, Alexandros; Savani, Rahul (2022-12-19). "The Complexity of Gradient Descent: CLS = PPAD ∩ PLS". Journal of the ACM 70 (1): 7:1–7:74. doi:10.1145/3568163. ISSN 0004-5411. https://doi.org/10.1145/3568163.
25. ↑ Yannakakis, Mihalis (2009-05-01). "Equilibria, fixed points, and complexity classes" (in en). Computer Science Review 3 (2): 71–85. doi:10.1016/j.cosrev.2009.03.004. ISSN 1574-0137. https://www.sciencedirect.com/science/article/pii/S1574013709000161.

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/PLS (complexity). Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=PLS_(complexity)&oldid=261297"