Question

I’m interested in programming languages that can reason about their own time complexity. To this end, it would be quite useful to have some way of representing time complexity programmatically, which would allow me to do things like:

f_time = O(n)
g_time = O(n^2)
h_time = O(sqrt(n))

fastest_asymptotically = min(f_time, g_time, h_time)  # = h_time
total_time = f_time.inside(g_time).followed_by(h_time)  # = O(n^3)

I’m using Python at the moment, but I’m not particularly tied to a language. I’ve experimented with sympy, but I haven’t been able to find what I need out of the box there.

Is there a library that provides this capability? If not, is there a simple way to do the above with a symbolic math library?

EDIT: I wrote a simple library following @Patrick87‘s advice and it seems to work. I’m still interested if there are other solutions for this problem, though.

Answer 1

SymPy currently only supports the expansion at 0 (you can simulate other finite points by performing a shift). It doesn’t support the expansion at infinity, which is what is used in algorithmic analysis.

But it would be a good base package for it, and if you implement it, we would gladly accept a patch (nb: I am a SymPy core developer).

Be aware that in general the problem is tricky, especially if you have two variables, or even symbolic constants. It’s also tricky if you want to support oscilitory functions. EDIT: If you are interested in oscillating functions, this SymPy mailing list discussion gives some interesting papers.

EDIT 2: And I would recommend against trying to build this yourself from scratch, without the use of a computer algebra system. You will end up having to write your own computer algebra system, which is a lot of work, and even more work if you want to do it right and not have it be slow. There are already tons of systems already existing, including many that can act as libraries for code to be built on top of them (such as SymPy).