Mathematics Stack Exchange is a question and answer site for people studying math at any level and professionals in related fields. Join them; it only takes a minute:

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

There are some problems with non-trivial lower bounds for working time of algorithm (that solve this problem): sorting, copying words on Turing machine...

What are some modern methods for proving lower bounds for working time? Can you give a reference? Thank you!

UPD: All appearances there aren't well-developed theory about proof of lower bounds of time working. Nonetheless it is very interesting to know some examples of such proofs (except sorting and copying words on Turing machine)

share|cite|improve this question

One of the most common methods for proving lower-bounds is known as the adversary-method. The idea is that an adversary is allowed to pick the input "piece by piece" depending on what an algorithm does, which in turn can be used to show that there exists an input where an algorithm will do at-least $\Omega(f(n))$ work. An application, as you've mentioned of this can be applied to sorting:

This method has many other applications as well: a brief overview here As an example, we can use the adversary method to show that to evaluate an AND/OR boolean formula, we may potentially need to query every variable in the worst case (though there exists a nice randomized algorithm with query complexity better than $n$). The adversary method has also been used to prove lower-bounds in Quantum Computing (

share|cite|improve this answer

Look here for lower bound of time for matrix multiplication. And here for the following result.

We prove lower bounds of order n log n for both the problem to multiply polynomials of degree n, and to divide polynomials with remainder, in the model of bounded coefficient arithmetic circuits over the complex numbers.


However there is no any strong theory about lower bounds of time, there is one easy not-too-general way to get it. You can get some problem with known lower bound time and reduce it in linear time to your problem. For example speaking about heaps and operations “insert”, “erase maximum” and “get maximum” we get that at least one of these operations should have amortized time $\Omega(\log n)$ where $n$ is number of nodes in the heap. If all three operations could be done in $\mathrm o(\log n)$ time then we could sort $n$ arbitrary objects using this heap in $\mathrm o(n\log n)$ (just insert all objectes to the queue and $n$ times get maximum and erase it).

share|cite|improve this answer

I suggest strongly this book Computational Complexity: A Modern Approach be the best choice for finding things you need.

share|cite|improve this answer

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.