|
|
| Line 1: |
Line 1: |
| Average-case complexity is a subfield of [[computational complexity theory]] that studies the complexity of [[algorithms]] over inputs drawn randomly from a particular [[probability distribution]]. It is frequently contrasted with [[worst-case complexity]] which considers the maximal complexity of the algorithm over all possible inputs.
| | My name is Amparo from Harwood studying Chinese Studies. I did my schooling, secured 85% and hope to find someone with same interests in Fishing.<br><br>Feel free to surf to my web site :: [http://nbnatural.com/xe/?document_srl=442177 wordpress backup plugin] |
| | |
| There are two primary motivations for studying average-case complexity.<ref name="gol07">O. Goldreich and S. Vadhan, Special issue on worst-case versus average-case complexity, Comput. Complex. 16, 325-330, 2007.</ref> First, although some problems may be intractable in the worst-case, the inputs which elicit this behavior may rarely occur in practice, so the average-case complexity may be a more accurate measure of an algorithm's performance. Second, average-case complexity analysis provides tools and techniques to generate hard instances of problems which can be utilized in areas such as [[cryptography]] and [[derandomization]].
| |
| | |
| ==History and Background==
| |
| | |
| The average-case performance of algorithms has been studied since modern notions of computational efficiency were developed in the 1950s. Much of this initial work focused on problems for which worst-case polynomial time algorithms were already known.<ref name="bog06">A. Bogdanov and L. Trevisan, "Average-Case Complexity," Foundations and Trends in Theoretical Computer Science, Vol. 2, No 1 (2006) 1-106.</ref> In 1973, [[Donald Knuth]]<ref name="knu73">D. Knuth, The Art of Computer Programming. Vol. 3, Addison-Wesley, 1973.</ref> published Volume 3 of the [[Art of Computer Programming]] which extensively surveys average-case performance of algorithms for problems solvable in worst-case polynomial time, such as sorting and median-finding.
| |
| | |
| An efficient algorithm for [[NP-complete]] problems in generally characterized as one which runs in polynomial time for all inputs; this is equivalent to requiring efficient worst-case complexity. However, an algorithm which is inefficient on a "small" number of inputs may still be efficient for "most" inputs that occur in practice. Thus, it is desirable to study the properties of these algorithms where the average-case complexity may differ from the worst-case complexity and find methods to relate the two.
| |
| | |
| The fundamental notions of average-case complexity were developed by [[Leonid Levin]] in 1986 when he published a one-page paper<ref name="levin86">L. Levin, "Average case complete problems," SIAM Journal on Computing, vol. 15, no. 1, pp. 285-286, 1986.</ref> defining average-case complexity and completeness while giving an example of a complete problem for distNP, the average-case analogue of [[NP (complexity)|NP]].
| |
| | |
| ==Definitions==
| |
| | |
| ===Efficient Average-Case Complexity===
| |
| | |
| The first task is to precisely define what is meant by an algorithm which is efficient "on average". An initial attempt might define an efficient average-case algorithm as one which runs in expected polynomial time over all possible inputs. Such a definition has various shortcomings; in particular, it is not robust to changes in the computational model. For example, suppose algorithm A runs in time t<sub>A</sub>(x) on input x and algorithm B runs in time t<sub>A</sub>(x)<sup>2</sup> on input x; that is, B is quadratically slower than A. Intuitively, any definition of average-case efficiency should capture the idea that A is efficient-on-average if and only if B is efficient on-average. Suppose, however, that the inputs are drawn randomly from the uniform distribution of strings with length n, and that A runs in time n<sup>2</sup> on all inputs except the string 1<sup>n</sup> for which A takes time 2<sup>n</sup>. Then it can be easily checked that the expected running time of A is polynomial but the expected running time of B is exponential.<ref name="bog06" />
| |
| | |
| To create a more robust definition of average-case efficiency, it makes sense to allow an algorithm A to run longer than polynomial time on some inputs but the fraction of inputs on which on which A requires larger and larger running time becomes smaller and smaller. This intuition is captured in the following formula for average polynomial running time, which balances the polynomial trade-off between running time and fraction of inputs:
| |
| | |
| <math>
| |
| \Pr_{x \in_R D_n}[t_A(x) \geq t] \leq \frac{p(n)}{t^\epsilon}
| |
| </math>
| |
| | |
| for every n, t, ε > 0 and polynomial p, where t<sub>A</sub>(x) denotes the running time of algorithm A on input x.<ref name="wangsurvey">J. Wang, "Average-case computational complexity theory," Complexity Theory Retrospective II, pp. 295-328, 1997.</ref> Alternatively, this can be written as
| |
| | |
| <math> | |
| E_{x \in_R D_n}[\frac{t_{A}(x)^{\epsilon}}{n}] \leq C
| |
| </math>
| |
| | |
| for some constant C, where n = |x|.<ref name="ab09">S. Arora and B. Barak, Computational Complexity: A Modern Approach, Cambridge University Press, New York, NY, 2009.</ref> In other words, an algorithm A has good average-case complexity if, after running for t<sub>A</sub>(n) steps, A can solve all but a <math>\frac{n^c}{(t_A(n))^{\epsilon}}</math> fraction of inputs of length n, for some ε, c > 0.<ref name="bog06"/>
| |
| | |
| ===Distributional Problem===
| |
| The next step is to define the "average" input to a particular problem. This is achieved by associating the inputs of each problem with a particular probability distribution. That is, an "average-case" problem consists of a language L and an associated probability distribution D which forms the pair (L, D).<ref name="ab09"/> The two most common classes of distributions which are allowed are:
| |
| | |
| #Polynomial-time computable distributions (P-computable): these are distributions for which it is possible to compute the cumulative density of any given input x. More formally, given a probability distribution μ and a string x ∈ {0, 1}<sup>n</sup> it is possible to compute the value <math>\mu(x) = \sum\limits_{y \in \{0, 1\}^n : y \leq x} \Pr[y]</math> in polynomial time. This implies that Pr[x] is also computable in polynomial time.
| |
| #Polynomial-time samplable distributions (P-samplable): these are distributions from which it is possible to draw random samples in polynomial time.
| |
| | |
| These two formulations, while similar, are not equivalent. If a distribution is P-computable it is also P-samplable, but the converse is not true if [[P (complexity)|P]] ≠ P<sup>#P</sup>.<ref name="ab09"/>
| |
| | |
| ===AvgP and distNP===
| |
| A distributional problem (L, D) is in the complexity class AvgP if there is an efficient average-case algorithm for L, as defined above. The class AvgP is occasionally called distP in the literature.<ref name="ab09"/>
| |
| | |
| A distributional problem (L, D) is in the complexity class distNP if L is in NP and D is P-computable. When L is in NP and D is P-samplable, (L, D) belongs to sampNP.<ref name="ab09"/>
| |
| | |
| Together, AvgP and distNP define the average-case analogues of P and NP, respectively.<ref name="ab09"/>
| |
| | |
| ==Reductions Between Distributional Problems==
| |
| Let (L,D) and (L',D') be two distributional problems. (L, D) average-case reduces to (L', D') (written (L, D) ≤<sub>AvgP</sub> (L', D')) if there is a function f that for every n, on input x can be computed in time polynomial in n and
| |
| | |
| #(Correctness) x ∈ L if and only if f(x) ∈ L'
| |
| #(Domination) There are polynomials p and m such that, for every n and y, <math>\sum\limits_{x: f(x) = y} D_n(x) \leq p(n)D'_{m(n)}(y)</math>
| |
| | |
| The domination condition enforces the notion that if problem (L, D) is hard on average, then (L', D') is also hard on average. Intuitively, a reduction should provide a way to solve an instance x of problem L by computing f(x) and feeding the output to the algorithm which solves L'. Without the domination condition, this may not be possible since the algorithm which solves L in polynomial time on average may take super-polynomial time on a small number of inputs but f may map these inputs into a much larger set of D' so that algorithm A' no longer runs in polynomial time on average. The domination condition only allows such strings to occur polynomially as often in D'.<ref name="wangsurvey"/>
| |
| | |
| ===DistNP-Complete Problems===
| |
| The average-case analogue to NP-completeness is distNP-completeness. A distributional problem (L', D') is distNP-complete if (L', D') is in distNP and for every (L, D) in distNP, (L, D) is average-case reducible to (L', D').<ref name="ab09" />
| |
| | |
| An example of a distNP-complete problem is the Bounded Halting Problem, BH, defined as follows:
| |
| | |
| BH = {(M,x,1<sup>t</sup>) : M is a non-deterministic Turing machine that accepts x in ≤ t steps.}<ref name="ab09"/>
| |
| | |
| In his original paper, Levin showed an example of a distributional tiling problem that is average-case NP-complete.<ref name="levin86"/> A survey of known distNP-complete problems is available online.<ref name="wangsurvey"/>
| |
| | |
| One area of active research involves finding new distNP-complete problems. However, finding such problems can be complicated due to a result of Gurevich which shows that any distributional problem with a flat distribution cannot be distNP-complete unless [[EXP]] = [[NEXP]].<ref name="gur87">Y. Gurevich, "Complete and incomplete randomized NP problems", Proc. 28th Annual Symp. on Found. of Computer Science, IEEE (1987), pp. 111-117.</ref> (A flat distribution μ is one for which there exists an ε > 0 such that for any x, μ(x) ≤ 2<sup>-|x|<sup>ε</sup></sup>.) A result by Livne shows that all natural NP problems have DistNP-complete versions.<ref name="livne06">N. Livne, "All Natural NPC Problems Have Average-Case Complete Versions," Computational Complexity, to appear. Preliminary version in ECCC, TR06-122, 2006.</ref> However, the goal of finding a natural distributional problem that is DistNP-complete has not yet been achieved.<ref name="gol97">O. Goldreich, "Notes on Levin's theory of average-case complexity," Technical Report TR97-058, Electronic Colloquium on Computational Complexity, 1997.</ref>
| |
| | |
| ==Applicatons==
| |
| ===Sorting Algorithms===
| |
| As mentioned above, much early work relating to average-case complexity focused on problems for which polynomial-time algorithms already existed, such as sorting. For example, many sorting algorithms which utilize randomness, such as [[Quicksort]], have a worst-case running time of O(n<sup>2</sup>), but an average-case running time of O(nlog(n)), where n is the length of the input to be sorted.<ref name="clrs">Cormen, Thomas H.; Leiserson, Charles E., Rivest, Ronald L., Stein, Clifford (2009) [1990]. Introduction to Algorithms (3rd ed.). MIT Press and McGraw-Hill. ISBN 0-262-03384-4.</ref>
| |
| | |
| ===Cryptography===
| |
| For most problems, average-case complexity analysis is undertaken to find efficient algorithms for a problem that is considered difficult in the worst-case. In cryptographic applications, however, the opposite is true: the worst-case complexity is irrelevant; we instead want a guarantee that the average-case complexity of every algorithm which "breaks" the cryptographic scheme is inefficient.<ref name="katz07">J. Katz and Y. Lindell, Introduction to Modern Cryptography (Chapman and Hall/Crc Cryptography and Network Security Series), Chapman and Hall/CRC, 2007.</ref>
| |
| | |
| Thus, all secure cryptographic schemes rely on the existence of [[one-way functions]].<ref name="bog06"/> Although the existence of one-way functions is still an open problem, many candidate one-way functions are based on NP-hard problems such as [[integer factorization]] or computing the [[discrete log]]. Note that it is not desirable for the candidate function to be NP-complete since this would only guarantee that there is likely no efficient algorithm for solving the problem in the worst case; what we actually want is a guarantee that no efficient algorithm can solve the problem over random inputs (i.e. the average case). In fact, both the integer factorization and discrete log problems are in NP ∩ [[coNP]], and are therefore not believed to be NP-complete.<ref name="ab09"/> The fact that all of cryptography is predicated on the existence of average-case intractable problems in NP is one of the primary motivations for studying average-case complexity.
| |
| | |
| ==Other Results==
| |
| In 1990, Impagliazzo and Levin showed that if there is an efficient average-case algorithm for a distNP-complete problem under the uniform distribution, then there is an average-case algorithm for every problem in NP under any polynomial-time samplable distribution.<ref name="imp90">R. Impagliazzo and L. Levin, "No Better Ways to Generate Hard NP Instances than Picking Uniformly at Random," in Proceedings of the 31st IEEE Sympo- sium on Foundations of Computer Science, pp. 812-821, 1990.</ref> Applying this theory to natural distributional problems remains an outstanding open question.<ref name="bog06"/>
| |
| | |
| In 1992, Ben-David et al., showed that if all languages in distNP have good-on-average decision algorithms, they also have good-on-average search algorithms. Further, they show that this conclusion holds under a weaker assumption: if every language in NP is easy on average for decision algorithms with respect to the uniform distribution, then it is also easy on average for search algorithms with respect to the uniform distribution.<ref name="bd92">S. Ben-David, B. Chor, O. Goldreich, and M. Luby, "On the theory of average case complexity," Journal of Computer and System Sciences, vol. 44, no. 2, pp. 193-219, 1992.</ref> Thus, cryptographic one-way functions can exist only if there are distNP problems over the uniform distribution that are hard on average for decision algorithms.
| |
| | |
| In 1993, Feigenbaum and Fortnow showed that it is not possible to prove, under non-adaptive random reductions, that the existence of a good-on-average algorithm for a distNP-complete problem under the uniform distribution implies the existence of worst-case efficient algorithms for all problems in NP.<ref name="ff93">J. Feigenbaum and L. Fortnow, "Random-self-reducibility of complete sets," SIAM Journal on Computing, vol. 22, pp. 994-1005, 1993.</ref> In 2003, Bogdanov and Trevisan generalized this result to arbitrary non-adaptive reductions.<ref name="bog03">A. Bogdanov and L. Trevisan, "On worst-case to average-case reductions for NP problems," in Proceedings of the 44th IEEE Symposium on Foundations of Computer Science, pp. 308-317, 2003.</ref> These results show that it is unlikely that any association can be made between average-case complexity and worst-case complexity via reductions.<ref name="bog06"/>
| |
| | |
| ==Related topics==
| |
| * [[Probabilistic analysis of algorithms]]
| |
| | |
| ==Literature==
| |
| | |
| The literature of average case complexity includes the following work:
| |
| *{{citation
| |
| | last = Franco | first = John
| |
| | doi = 10.1016/0020-0190(86)90051-7
| |
| | issue = 2
| |
| | journal = Information Processing Letters
| |
| | pages = 103–106
| |
| | title = On the probabilistic performance of algorithms for the satisfiability problem
| |
| | volume = 23
| |
| | year = 1986}}.
| |
| *{{citation
| |
| | last = Levin | first = Leonid | author-link = Leonid Levin
| |
| | doi = 10.1137/0215020
| |
| | issue = 1
| |
| | journal = SIAM Journal on Computing
| |
| | pages = 285–286
| |
| | title = Average case complete problems
| |
| | volume = 15
| |
| | year = 1986}}.
| |
| *{{citation
| |
| | last1 = Flajolet | first1 = Philippe | author1-link = Philippe Flajolet
| |
| | last2 = Vitter | first2 = J. S. | author2-link = Jeffrey Vitter
| |
| | date = August 1987
| |
| | publisher = Institut National de Recherche en Informatique et en Automatique, B.P. 105-78153 Le Chesnay Cedex France
| |
| | series = Tech. Report
| |
| | title = Average-case analysis of algorithms and data structures}}.
| |
| *{{citation
| |
| | last1 = Gurevich | first1 = Yuri | author1-link = Yuri Gurevich
| |
| | last2 = Shelah | first2 = Saharon | author2-link = Saharon Shelah
| |
| | doi = 10.1137/0216034
| |
| | issue = 3
| |
| | journal = SIAM Journal on Computing
| |
| | pages = 486–502
| |
| | title = Expected computation time for [[Hamiltonian path problem]]
| |
| | volume = 16
| |
| | year = 1987}}.
| |
| *{{citation
| |
| | last1 = Ben-David | first1 = Shai
| |
| | last2 = Chor | first2 = Benny
| |
| | last3 = Goldreich | first3 = Oded | author3-link = Oded Goldreich
| |
| | last4 = Luby | first4 = Michael | author4-link = Michael Luby
| |
| | contribution = On the theory of average case complexity
| |
| | pages = 204–216
| |
| | publisher = [[Association for Computing Machinery]]
| |
| | title = [[Symposium on Theory of Computing|Proc. 21st Annual Symposium on Theory of Computing]]
| |
| | year = 1989}}.
| |
| *{{citation
| |
| | last = Gurevich | first = Yuri | author-link = Yuri Gurevich
| |
| | doi = 10.1016/0022-0000(91)90007-R
| |
| | issue = 3
| |
| | journal = Journal of Computer and`System Sciences
| |
| | pages = 346–398
| |
| | title = Average case completeness
| |
| | volume = 42
| |
| | year = 1991}}. See also [http://research.microsoft.com/~gurevich/Opera/76.pdf 1989 draft].
| |
| *{{citation
| |
| | last1 = Selman | first1 = B.
| |
| | last2 = Mitchell | first2 = D.
| |
| | last3 = Levesque | first3 = H.
| |
| | contribution = Hard and easy distributions of SAT problems
| |
| | pages = 459–465
| |
| | title = Proc. 10th National Conference on Artificial Intelligence
| |
| | year = 1992}}.
| |
| *{{citation
| |
| | last1 = Schuler | first1 = Rainer
| |
| | last2 = Yamakami | first2 = Tomoyuki
| |
| | contribution = Structural average case complexity
| |
| | pages = 128–139
| |
| | publisher = Springer-Verlag
| |
| | series = Lecture Notes in Computer Science
| |
| | title = Proc. Foundations of Software Technology and Theoretical Computer Science
| |
| | volume = 652
| |
| | year = 1992}}.
| |
| *{{citation
| |
| | last1 = Reischuk | first1 = Rüdiger
| |
| | last2 = Schindelhauer | first2 = Christian
| |
| | contribution = Precise average case complexity
| |
| | pages = 650–661
| |
| | title = Proc. 10th Annual Symposium on Theoretical Aspects of Computer Science
| |
| | year = 1993}}.
| |
| *{{citation
| |
| | last1 = Venkatesan | first1 = R.
| |
| | last2 = Rajagopalan | first2 = S.
| |
| | contribution = Average case intractability of matrix and Diophantine problems
| |
| | pages = 632–642
| |
| | publisher = [[Association for Computing Machinery]]
| |
| | title = [[Symposium on Theory of Computing|Proc. 24th Annual Symposium on Theory of Computing]]
| |
| | year = 1992}}.
| |
| *{{citation
| |
| | last1 = Cox | first1 = Jim
| |
| | last2 = Ericson | first2 = Lars
| |
| | last3 = Mishra | first3 = Bud
| |
| | series = Technical Report TR1995-711 | publisher = New York University Computer Science Department
| |
| | title = The average case complexity of multilevel syllogistic
| |
| | url = http://www.cs.nyu.edu/csweb/Research/TechReports/TR1995-711/TR1995-711.pdf
| |
| | year = 1995}}.
| |
| *{{citation
| |
| | last = Impagliazzo | first = Russell | author-link = Russell Impagliazzo
| |
| | date = April 17, 1995
| |
| | publisher = [[University of California, San Diego]]
| |
| | title = A personal view of average-case complexity
| |
| | url = http://www-cse.ucsd.edu/~russell/average.ps}}.
| |
| *Paul E. Black, [http://www.itl.nist.gov/div897/sqg/dads/HTML/theta.html "Θ"], in Dictionary of Algorithms and Data Structures[online]Paul E. Black, ed., U.S. National Institute of Standards and Technology. 17 December 2004.Retrieved Feb. 20/09.
| |
| *Christos Papadimitriou (1994). Computational Complexity. Addison-Wesley.
| |
| | |
| ==See also==
| |
| | |
| *[[NP-complete problems]]
| |
| *[[Worst-case complexity]]
| |
| | |
| ==References==
| |
| {{Reflist}}<!--added above categories/infobox footers by script-assisted edit-->
| |
| | |
| [[Category:Probabilistic complexity theory]]
| |