2,695 research outputs found

    The algorithm by Ferson et al. is surprisingly fast: An NP-hard optimization problem solvable in almost linear time with high probability

    Full text link
    We start with the algorithm of Ferson et al. (\emph{Reliable computing} {\bf 11}(3), p.~207--233, 2005), designed for solving a certain NP-hard problem motivated by robust statistics. First, we propose an efficient implementation of the algorithm and improve its complexity bound to O(nlogn+n2ω)O(n \log n+n\cdot 2^\omega), where ω\omega is the clique number in a certain intersection graph. Then we treat input data as random variables (as it is usual in statistics) and introduce a natural probabilistic data generating model. On average, we get 2ω=O(n1/loglogn)2^\omega = O(n^{1/\log\log n}) and ω=O(logn/loglogn)\omega = O(\log n / \log\log n). This results in average computing time O(n1+ϵ)O(n^{1+\epsilon}) for ϵ>0\epsilon > 0 arbitrarily small, which may be considered as ``surprisingly good'' average time complexity for solving an NP-hard problem. Moreover, we prove the following tail bound on the distribution of computation time: ``hard'' instances, forcing the algorithm to compute in time 2Ω(n)2^{\Omega(n)}, occur rarely, with probability tending to zero faster than exponentially with nn \rightarrow \infty

    The Computational Complexity of the Restricted Isometry Property, the Nullspace Property, and Related Concepts in Compressed Sensing

    Full text link
    This paper deals with the computational complexity of conditions which guarantee that the NP-hard problem of finding the sparsest solution to an underdetermined linear system can be solved by efficient algorithms. In the literature, several such conditions have been introduced. The most well-known ones are the mutual coherence, the restricted isometry property (RIP), and the nullspace property (NSP). While evaluating the mutual coherence of a given matrix is easy, it has been suspected for some time that evaluating RIP and NSP is computationally intractable in general. We confirm these conjectures by showing that for a given matrix A and positive integer k, computing the best constants for which the RIP or NSP hold is, in general, NP-hard. These results are based on the fact that determining the spark of a matrix is NP-hard, which is also established in this paper. Furthermore, we also give several complexity statements about problems related to the above concepts.Comment: 13 pages; accepted for publication in IEEE Trans. Inf. Theor

    Approximating the least hypervolume contributor: NP-hard in general, but fast in practice

    Get PDF
    The hypervolume indicator is an increasingly popular set measure to compare the quality of two Pareto sets. The basic ingredient of most hypervolume indicator based optimization algorithms is the calculation of the hypervolume contribution of single solutions regarding a Pareto set. We show that exact calculation of the hypervolume contribution is #P-hard while its approximation is NP-hard. The same holds for the calculation of the minimal contribution. We also prove that it is NP-hard to decide whether a solution has the least hypervolume contribution. Even deciding whether the contribution of a solution is at most (1+\eps) times the minimal contribution is NP-hard. This implies that it is neither possible to efficiently find the least contributing solution (unless P=NPP = NP) nor to approximate it (unless NP=BPPNP = BPP). Nevertheless, in the second part of the paper we present a fast approximation algorithm for this problem. We prove that for arbitrarily given \eps,\delta>0 it calculates a solution with contribution at most (1+\eps) times the minimal contribution with probability at least (1δ)(1-\delta). Though it cannot run in polynomial time for all instances, it performs extremely fast on various benchmark datasets. The algorithm solves very large problem instances which are intractable for exact algorithms (e.g., 10000 solutions in 100 dimensions) within a few seconds.Comment: 22 pages, to appear in Theoretical Computer Scienc
    corecore