Auto Research: Integer multiplication below n log n

(app.getsupers.com)

31 points by swesnow1 day ago

2 comments

krackers2 hours ago
Is there any good writeup yet of intuitively where the speedup comes from? E.g. with fast fourier transform you can see that there's a lot of symmetry & recomputation in the Vandermonde matrix, so that's where the speed up comes from.
- AnotherGoodName53 minutes ago
 The site is taking forever to load but complexity theory doesn't really have the hard walls at things like O(nlogn) that people seem to think.You can always always tradeoff time vs space. It's actually a fundamental part of complexity theory called Blums speedup theorem by the guy who invented complexity theory no less.As an example you give me an nlogn solution and i take a portion of the inner loop, put it in a lookup table (who cares if the lookup table is 2^n in size, that's not what we're measuring here since we're specifically measuring time not space) and suddenly i have something better than nlogn since that lookup table is O(1).That's not to say there's some merit to all of this. It's just that people shouldn't be as astonished by these results as they are. It's complexity theory. There's literally no such thing as a hard wall where something is nlogn in time and can't get lower. It can always get lower. But you need both the time and space complexities together to reason about this.
 - cma45 minutes ago
 Wouldn't it take an infinite lookup table to do this satisfying any two integers and still get an order-complexity speedup? The integers can be any size. You can't specify an arbitrarily variable sized lookup table in the normal formulation of these problems without computing the lookup table as part of the computation.
 - AnotherGoodName37 minutes ago
 Never infinite if you have bounds on integer size. For n bits of input it's always possible to have a 2^n space complexity lookup table that's O(1) speed since 2^n covers all possibilities of n bits.You don't need to go to these extremes regardless though. For small speedups take an nlogn algorithm and just move a very small part of the inner portion out in a similar tradeoff. Eg. "Every nth input is now part of a lookup." If you look at the openAIs <nlogn results there was a series of small improvements of this type (we take this part out, precomputing it, and likewise with this part and that small portion, aha! <nlogn!). I finally loaded the link above and it's 262million lines of such tricks in fact.
oliculipolicula3 hours ago
Some more context<a href="https://nitter.kareem.one/RohanArun/status/2109336015814959200?s=20" rel="nofollow">https://nitter.kareem.one/RohanArun/status/21093360158149592...</a>(Replace top-level with healthy instances or x.com as needed)
- ViscountPenguin1 hour ago
 Huh, apparently I "look like a bot". Must be my sick-as apm.