# Difference between revisions of "Complexity Garden"

m (→Permanent: What is a 0-1 matrix's permanent: minor grammar fix) |
(→Table of Contents: Added isomorphism problems and algebraic problems as categories) |
||

Line 30: | Line 30: | ||

[[#ksat|k-SAT]] - | [[#ksat|k-SAT]] - | ||

[[#unique-ksat|Unique <math>k</math>-SAT]] | [[#unique-ksat|Unique <math>k</math>-SAT]] | ||

+ | |||

+ | ''Isomorphism problems:'' | ||

+ | [[#graph_automorphism|Graph Automorphism]] - | ||

+ | [[#graph_isomorphism|Graph Isomorphism]] - | ||

+ | [[#ra|Ring Automorphism]] - | ||

+ | [[#ri|Ring Isomorphism]] | ||

+ | |||

+ | ''Algebraic problems:'' | ||

+ | [[#ra|Ring Automorphism]] - | ||

+ | [[#ri|Ring Isomorphism]] - | ||

+ | [[#approximate_shortest_lattice_vector|Approximate Shortest Lattice Vector]] - | ||

+ | [[#group_nonmembership|Group Nonmembership]] - | ||

+ | [[#integer_factorization|Integer Factorization]] - | ||

+ | [[#integer_factor|Integer Factor ≤ k]] - | ||

+ | [[#integer_multiplication|Integer Multiplication]] - | ||

+ | [[#matrix_multiplication|Matrix Multiplication]] - | ||

+ | [[#permanent|Permanent]] - | ||

+ | [[#square_root|Square Root mod n]] | ||

''Sets and partitions:'' | ''Sets and partitions:'' | ||

Line 35: | Line 53: | ||

''Uncategorized problems:'' | ''Uncategorized problems:'' | ||

+ | [[#boolean_matrix_multiplication|Boolean Matrix Multiplication]] - | ||

[[#3sum|3SUM]] - | [[#3sum|3SUM]] - | ||

− | |||

[[#boolean_convolution|Boolean Convolution]] - | [[#boolean_convolution|Boolean Convolution]] - | ||

− | |||

[[#boolean_sorting|Boolean Sorting]] - | [[#boolean_sorting|Boolean Sorting]] - | ||

[[#discrete_logarithm|Discrete Logarithm]] - | [[#discrete_logarithm|Discrete Logarithm]] - | ||

[[#equality|Equality]] - | [[#equality|Equality]] - | ||

− | |||

− | |||

− | |||

− | |||

[[#k-local-ham|k-Local Hamiltonians]] - | [[#k-local-ham|k-Local Hamiltonians]] - | ||

[[#k-round_sorting|k-Round Sorting]] - | [[#k-round_sorting|k-Round Sorting]] - | ||

[[#linear_programming|Linear Programming]] - | [[#linear_programming|Linear Programming]] - | ||

[[#majority|Majority]] - | [[#majority|Majority]] - | ||

− | |||

[[#parity|Parity]] - | [[#parity|Parity]] - | ||

− | |||

− | |||

− | |||

[[#shortest_implicant|Short Implicant]] - | [[#shortest_implicant|Short Implicant]] - | ||

[[#stochastic_games|Stochastic Games]] - | [[#stochastic_games|Stochastic Games]] - | ||

[[#tautology|Tautology]] - | [[#tautology|Tautology]] - | ||

− | |||

[[#threshold(k)|Threshold(k)]] | [[#threshold(k)|Threshold(k)]] | ||

## Revision as of 16:55, 19 November 2021

Welcome to the **Complexity Garden**, the botanical companion to the Complexity Zoo. This field guide lists rigorously defined computational problems, together with their relations to complexity classes, their best algorithmic results, and their relations to other problems. There are now 39 problems and (one can only hope) counting. The initial members either have or might have some exotic property related to speedup (such as O-speedup, monotone-nonmonotone gap, or P-nonuniformity), or provide a canonical example of a complexity class (i.e. NP-complete). *However, all additions are welcome, and it is hoped that this will grow into a comprehensive collection.*

**Gardener**: Hunter Monroe (volunteers welcome)

To create a new problem, click on the edit link of the problem before or after the one that you want to add and copy the format, and save. The preferred format of each problem is as follows: description of the problem, relations to complexity classes, their best algorithmic results (upper-bounds and lower-bounds e.g. see the Set Cover problem), memberships and properties, and relations to other problems. Then, add the problem to the table of contents and increment the total number of problems. After this, you can use the side edit links to edit the individual sections. For more on using the wiki language, see our simple wiki help page.

If your problem is not on the list and you suspect that it might be an open problem you can check the Open Problem Garden.

## Table of Contents

*Graph theoretic problems:*
#Perfect Matching -
Clique-Like -
Graph Automorphism -
Graph Isomorphism -
Perfect Matching

*Satisfiability problems:*
#SAT -
#WSAT -
Constraint Satisfaction -
QBF -
Quantum k-SAT -
SAT -
k-SAT -
Unique -SAT

*Isomorphism problems:*
Graph Automorphism -
Graph Isomorphism -
Ring Automorphism -
Ring Isomorphism

*Algebraic problems:*
Ring Automorphism -
Ring Isomorphism -
Approximate Shortest Lattice Vector -
Group Nonmembership -
Integer Factorization -
Integer Factor ≤ k -
Integer Multiplication -
Matrix Multiplication -
Permanent -
Square Root mod n

*Sets and partitions:*
Set Cover

*Uncategorized problems:*
Boolean Matrix Multiplication -
3SUM -
Boolean Convolution -
Boolean Sorting -
Discrete Logarithm -
Equality -
k-Local Hamiltonians -
k-Round Sorting -
Linear Programming -
Majority -
Parity -
Short Implicant -
Stochastic Games -
Tautology -
Threshold(k)

## The Problems

##### : Count perfect matchings

The #Perfect Matching problem is to count the number of perfect matchings in a bipartite graph. It is the counting version of Perfect Matching.

Algorithms: ?

Memberships: ∈ #P-complete

Related Problems: #Perfect Matching is equivalent to Permanent.

##### : Count satisfying truth assignments

This is the counting version of SAT: given a Boolean formula, compute how many satisfying truth assignments it has.

Algorithms: ?

Memberships: ∈ #P-complete

Related Problems: The version **#CNF-SAT** (counting version of CNF-SAT) and **#3-CNF-SAT** also called **#3SAT** (counting version of 3-CNF-SAT) also are two **#P-complete** problems.

##### : Weighted SAT

Given a Boolean formula, count the number of satisfying assignments of Hamming weight . This is the canonical problem for #WT.

Algorithms: ?

Memberships: ∈ #WT

##### 3SUM: Do there exist members of a list satisfying ?

Given a list of integers, do there exist elements such that ? This problem is important enough to computational geometry that there is defined a class of problems to which it is reducible: 3SUM-hard.

Algorithms: ?

Memberships: ?

##### Approximate Shortest Lattice Vector: Does the shortest vector exceed kn?

Given a lattice L in **Z**^{n} and an integer n, does the shortest vector of L have (Euclidean) length at most kn?

Algorithms: ?

##### Boolean Convolution: Convolution of two n-bit integers.

Compute the convolution of two n-bit integers in binary notation , where the multiplicands are respectively the i-1 and j-1 bits of the two integer inputs, and k is the k-1 bit of the output. It is a Boolean function with n input bits and 2n-1 output bits.

It has monotone circuit complexity (Weiss) and nonmonotone circuit complexity (Furer [Fur07]). means iteratively taking of n until the result is less than 2. Nonmonotone circuits use the discrete Fourier transform (Wegener [Weg87]).

Algorithms: ?

Memberships: ∈ FP

Properties: P-nonuniform?, monotone-nonmonotone gap

##### Boolean Matrix Multiplication: Monotone product of Boolean matrices

Boolean Matrix Multiplication is a Boolean function with 2n^{2} input bits (two nxn matrices) and n^{2} output bits (an nxn matrix). The function is defined using the usual row-column rule, but using OR instead of binary addition.

It has monotone circuit complexity of exactly (Pratt [Pra74]), but its nonmonotone circuit complexity is the same as matrix multiplication, presently (Wegener [Weg87]).

Algorithms: ?

Memberships: ∈ FP

Properties: P-nonuniform?, monotone-nonmonotone gap

##### Boolean Sorting: Sort n input bits.

A Boolean function with n inputs and n outputs that puts the 0s before the 1s. For example, 101 → 011 and 11000 → 00011.

It has monotone circuit complexity (Lamagna and Savage [LS74]) and nonmonotone circuit complexity (Muller and Preparata [MP75]). The nonmonotone circuits use binary rather than unary addition to count the 0 inputs.

The outputs are the Threshold(k) functions in reverse order; in particular, the middle output is Majority.

Algorithms: ?

Memberships: ∈ FP

Properties: O-optimal, symmetric, monotone-nonmonotone gap

##### Clique-Like: Tardos' Clique-like approximation

Clique-Like is a Boolean function with inputs (an adjacency matrix) and one output.

It has monotone circuit complexity of (Tardos [Tar88]). By contrast it has polynomial nonmonotone circuit complexity, because it reduces to Linear Programming.

Algorithms: ?

Memberships: ∈ P

Properties: monotone-nonmonotone gap

##### Constraint Satisfaction Problem: Generalized version of satisfiability problems

Given two sets of relations , where is the *instance* (not to be confused with an instance of CSP) and is the *template*, over the same vocabulary, where the vocabulary defines the names and arities of allowed relations, is there a mapping such that for all relations , ?

Algorithms: ?

*Memberships:* NP-complete.

*See Also:* [FV93].

##### Discrete Logarithm: Reverse exponentiation

The discrete logarithm problem is to solve for x in the equation a^{x} = b in some number-theoretic abelian group, typically either the group of units of a finite field or an elliptic curve over a finite field. Like the related Integer Factorization, the fastest classical algorithm is the number field sieve, with heuristic time complexity . Also like Integer Factorization, Shor's algorithm solves Discrete Logarithm in quantum polynomial time. In fact, Shor's algorithm solves Discrete Logarithm even in a black-box abelian group, provided that group elements have unique names.

Algorithms: ?

Memberships: ∈ FNP ∩ FBQP

Properties: Is a one-way function?

##### Equality: Are two strings equal?

If Alice has a string and Bob has a string , define EQUALITY(*x*, *y*) = 1 if and only if *x* = *y*.

Algorithms: ?

Memberships:

##### Graph Automorphism: Is there a nontrivial automorphism?

Graph Automorphism is equivalent to Graph Isomorphism in the case where the two graphs are identical.

Algorithms: ?

##### Graph Isomorphism: Are two graphs isomorphic?

Given two graphs, are they isomorphic, i.e., is there a bijection between their vertices which preserves edges?

Luks showed that Graph Isomorphism for bounded-valence graphs is in P non-uniformly (the exponent of algorithm's running time depends on the bound). Combining Luks' algorithm with a trick due to Zemlyachenko yields a time complexity upper bound of for graphs with v vertices. However, some practical Graph Isomorphism algorithms, such as NAUTY, seem to run much faster than this rigorous upper bound.

Like Perfect Matching, it is not known to be complete for a natural complexity class.

Algorithms: ?

Memberships: ∈ NP ∩ coAM, P-nonuniform?

Properties: In NP\P but not NP-complete?

##### Group Non-Membership: Is an element of *G* a member of a subgroup *H*?

Defined by [Wat00]. Let be a group, whose elements are represented by polynomial-size strings. We're given a "black box" that correctly multiplies and inverts elements of . Then given elements and , we can asked to find if (the subgroup generated by ).

Algorithms: ?

##### Hamiltonian circuit: Exists one Hamiltonian circuit?

Given a Graph , **exists one Hamiltonian circuit** in ?

Algorithms: ?

*Memberships:* NP-complete

##### Integer Factorization: Find an integer's prime factors

Algorithms: The fastest known algorithm for integer factorization is the number field sieve. It has heuristic randomized time complexity for inputs with n digits.

On the other hand, Shor's algorithm famously solves
Integer Factorization in *quantum* polynomial time.

Properties: In NP\P but not NP-complete?

##### Integer Factor ≤ k : Is there a factor ≤ k?

With an upper bound on the desired prime factor, this problem is subtly different from Integer Factorization.

Algorithms: The fastest algorithm is either the number field sieve or Lenstra's elliptic curve method, depending on the relative size of n and k. Lenstra's algorithm has heuristic randomized time complexity if n and k have n and k digits, respectively.

##### Integer Multiplication: Product of two n-bit integers

Integer Multiplication has an O-optimal linear-time algorithm on a RAM or SMM, but is thought to have O-speedup on Turing machines or P-uniform Boolean circuits.

Algorithms: ?

Memberships: ∈ FP

Properties: P-nonuniform?

##### k-Local Hamiltonians: Find the smallest eigenvalue of *m* *k*-local Hamiltonians acting on *n* qubits.

Given an *n*-qubit Hilbert space, as well as a collection H_{1},...,H_{m} of Hamiltonians (i.e. Hermitian positive semidefinite matrices), each of which acts on at most *k* qubits of the space. Also given real numbers *a*,*b* such that . Decide whether the smallest eigenvalue of is less than *a* or greater than *b*, promised that one of these is the case.

Algorithms: ?

Memberships: ?

*Properties:*

- QMA-complete for
*k*= 5 [KSV02]. - QMA-complete for
*k*= 3 [KR03]. - QMA-complete for
*k*= 2, under the assumption that P≠QMA [KKR04].

##### k-Round Sorting: Sort inputs in ≤ k rounds

There are k-round sorting networks not known to be constructible in deterministic polynomial time which outperform the best-known networks constructible in deterministic polynomial time [GGK03].

Algorithms: ?

Memberships: ?

Properties: P-nonuniform?

##### Linear Programming: Maximize a linear function with linear constraints

The Linear Programming problem is to maximize a linear function in a convex polytope. It was famously shown to be in FP by Leonid Khachiyan by means of the ellipsoid method. The main algorithms used in practice are simplex and interior-point methods.

Algorithms: ?

Memberships: ∈ FP

##### Majority: Are most inputs 1?

Majority is a Boolean function with n input bits and 1 output bit. The output is 1 if the majority of input bits are 1. Examples: 001 → 0, 1100 → 1.

MajorityP. Majority REG. Therefore, REGP.

Algorithms: ?

Memberships: ∈ P

Properties: O-optimal, symmetric.

Related Problems: See also Boolean Sorting and the Complexity Zoology entry.

##### Matrix Multiplication: Multiply two matrices

Multiply two dense matrices over a field . Matrix Multiplication has O-speedup among Strassen-type bilinear algorithms [CW82]. Determining the minimal number of multiplications needed to compute a bilinear form (of which Matrix Multiplication is one) is NP-complete ([Has90]). This suggests that Matrix Multiplication is P-nonuniform over bilinear algorithms if NPcoNP.

If the group-theoretic algorithms of Cohn et al can perform Matrix Multiplication in , then Matrix Multiplication has O-speedup among algorithms of the type they consider [CKSU05].

Algorithms:

Memberships: ∈ FP

Properties: O-speedup?, P-nonuniform?

##### Parity: Is the number of 1 inputs odd?

Parity is a Boolean function with n inputs and 1 output. The output is 1 if the number of 1 inputs is odd. Examples: 001 → 1, 11011 → 0.

ParityP. Parity FO ([Ajt83] and [FSS84]). Therefore, FOP.

Algorithms: ?

Memberships: ∈ P

Properties: O-optimal, symmetric.

Related Problems: Equals XOR. See the Complexity Zoology entry.

##### Perfect Matching: Is there a perfect matching?

Perfect Matching is a Boolean function with n^{2} inputs (an adjacency matrix) describing a bipartite graph and one output which is 1 if the graph has a perfect matching.

Perfect Matching reduces to Linear Programming, and is therefore in P, although specialized algorithms are also known.

It has monotone circuit complexity of (Razborov [Raz85b]) but polynomial nonmonotone circuit complexity.

Perfect Matching is nonuniformly reducible to determinant and is in RNC and [MVV87], [KUW86], but no deterministic NC algorithm is known.

Like Graph Isomorphism, it is not known to be complete for a natural complexity class. There is a randomized or nonuniform log-space reduction of Perfect Matching to Graph Isomorphism [Tor00].

Algorithms: ?

Memberships: ∈ P

Properties: monotone-nonmonotone gap, P-nonuniform?.

##### Permanent: What is a 0-1 matrix's permanent

The permanent of an *n*-by-*n* 0-1 matrix (*a*_{i,j}) is defined as
where σ ranges over all permutations of the numbers 1, 2, ..., *n*. The value of the permanent is equivalent to #Perfect Matching

Algorithms:

Memberships: ∈ #P

Properties: #P-complete

##### Ring Automorphism: Does a ring have a non-trivial automorphism?

A special case of Ring Isomorphism where the two rings investigated are the same, and where we are looking for non-trivial automorphisms.

##### Ring Isomorphism: Are two rings isomorphic?

Given two rings, are they isomorphic to each other? The counting version of the problem, #RI, asks how many different isomorphisms exist between the two rings.

Algorithms: ?

*Memberships:* NP ∩ coAM [KS05].

##### QBF: Quantified Boolean Formula

Given a Boolean formula with universal and existential quantifiers, is it true? Quantified Boolean Formula (QBF) is the canonical PSPACE-complete problem.

Note that [Pap94] calls this problem QSAT to emphasize its relationship to SAT. In particular, any instance of QBF can be written as , where is a Boolean formula as in SAT, and where is either a universal or existential qualifier, depending on whether is even or odd. This characterization lends itself well as a candidate for reductions from two-player games.

Algorithms: ?

Memberships: ∈ PSPACE

##### Quantum k-SAT: Quantum Analog for SAT

Given a set of measurements, each *i* of which involves no more than *k* qubits and accepts with probability *P*_{i}, and given the promise that either there exists a state such that the number of accepting measurements is "very large," or that for all states, the number of accepting measurements is very small. We are asked which of the two promise conditions holds.

Algorithms: ?

*Properties:* QMA-complete for *k* = 3.

*See also:* Democritus Lecture 13.

##### SAT: Is there a satisfying truth assignment?

The SAT problem is to decide whether a given Boolean formula has any satisfying truth assignments. SAT is in NP, since a "yes" answer can be proved by just exhibiting a satisfying assignment.

Algorithms: ?

*Memberships:* ∈ NP-complete

##### Set Cover: Cover a set with some of its subsets

Given a universe and a family of subsets of , a *cover* is a subfamily of sets whose union is . In the set covering decision problem, the input is a pair and an integer ; the question is whether
there is a set covering of size or less. In the set covering optimization problem, the input is a pair , and the task is to find a set covering that uses the fewest sets.

*Algorithms*: A simple greedy algorithm yields an -approximation (and hence, -approximation)where is the size of largest subset in and is th Harmonic number.

Set covering cannot be approximated in polynomial time to within a factor of
, unless **NP** has quasi-polynomial time algorithms [Fie98]. In addition, Set covering cannot be approximated in polynomial time to within a factor of , where is a constant, unless **P****NP**. The largest value of is proved in [AMS06].

*Memberships:* Decision problem ∈ NP-complete, Optimization problem ∈ NP Optimization

#### = -SAT: Satisfiability with clauses of length

For some natural number , an instance of -SAT is an instance of SAT in conjunctive normal form (CNF) where all clauses are the logical OR of Boolean variables.

Algorithms: ?

Memberships: It is known that 2SAT is in P while 3SAT is in NP-complete. }}

##### Short Implicant: Is there a short implicant?

Given a DNF expression Φ, is there a conjunction of at most k negated or non-negated literals that implies Φ?

Algorithms: ?

Memberships: GC-complete

##### Stochastic Games: Is there a first player advantage?

White, Black, and Nature alternate moving a token on the edges of a directed graph. Nature's moves are random. Given a graph, start and target nodes for the token, does White have a strategy which will make the token reach the target with probability ≥ 1/2?

Algorithms: ?

##### Tautology: Are all truth assignments satisfying?

Tautology is coNP-complete.

Algorithms: ?

*Memberships:* ∈ coNP

*Properties:* p-speedup? (If so then NP coNP)

##### Square Root mod n: Find square roots mod n

The Square Root mod n problem is to solve for x in the equation x^{2} = a mod N. Rabin noted that Integer Factorization BPP-reduces to Square Root mod n and vice-versa; the problems are equivalent.

Algorithms: ?

Memberships: ∈ FP

Properties: Is a one-way function?

##### Threshold(k): Are ≥ k inputs 1?

Threshold(k) is a Boolean function with n input bits and one output bit.

Boolean Sorting is equivalent to the n Threshold(k) functions in reverse order. Majority is equivalent to Threshold().

Algorithms: ?

Memberships: ∈ P

Properties: symmetric.

##### Unique *k*-SAT: *k*-SAT with uniqueness promise.

The Unique -SAT problem is a promise problem variant of -SAT, where the promise is that each instance has either no satisfying assignment, or has exactly one satisfying assignment.

Intuitively, adding this promise restricts us to only the hardest instances, as the more satisfying assignments there are, the easier it should be to find one. This intuition is justified by [CIK+03], where it is also shown that if Unique -SAT can be solved in deterministic time for all , then so can -SAT for all .

Algorithms: ?

Memberships: ?