This is a bad take. I will happily acknowledge the new term "slopository" which I had not heard before, while taking the author to task for malice towards theorists. STOC/FOCS/SODA, etc are not about "doing practical algorithms". If you want that, you go to ESA, ALENEX, or VLDB/SIGMOD, or any of the other more applied venues featuring this work. I don't think it's fair to just shit on theory because they don't do experiments---they're mathematicians, and it is fine to have absurd constants in your big-O as long as they are constants.
PS. I can have this view while simultaneously thinking that Ben is a badass.
As a theorist, it's sort of true that I "don't care" about galactic constants. I'm interested in the structure of computation for philosophical reasons. But I really do care about the model of computation.
To put it another way, the constants inside a big-O are not really constant: they depend on what you assume is a constant-time operation.
About big-O constant, I came to the realization that in the real world, constant time is actually a log at best, but more likely a cube root.
The simple idea is that the most basic thing, that is reading the number "n" depends on the number of digits, so that's a log.
But in most algorithms, the "n" refers to the size of a data set. This set is usually stored in some kind of memory, and memory is a physical array of little cells in 3D space. Accessing that cell means travelling through the array, with a time to reach it proportional to its distance, and since capacity increases with the cube of the distance, the time it takes to get the data is proportional to the cube root of n.
The conclusion, to me, is that when complexity gets down to less than a cube root, mathematical abstractions start to break down and you need to consider the actual machine, in particular its cache architecture.
No, memory reads do not depend on the address distance, unless you create a list.
Ordinary memory is not a list. It's a flat space read in O(1).
In theory. In practice there are multiple levels of cache, and cached reads will be much, much faster than main memory reads.
So if your entire data structure lives in cache and you repeatedly loop through it, it's going to be processed much more quickly than a bigger and more spread-out structure.
There's also paging, and alloc/dealloc to consider, and maybe garbage collection.
By the time you include all of that big-O estimates can become wildly misleading generalisations, unless your n is always >a million or so.
They mean physical distance, not "address distance".
And in the general case, memory reads do depend on distance. Hence:
> In practice there are multiple levels of cache, and cached reads will be much, much faster than main memory reads.
This is why we have the cache levels in the first place. And the hierarchy continues: L1, L2, RAM, block of spinning rust in the closet, "the cloud" somewhere... There is only so much storage you can fit close to core! More = physically bigger = physically further away.
Sure, within a level might feel like constant time. But that's because the optimal case for that level is slowed down to match the suboptimal cases. The step discontinuities in access time are caused by our inability to engineer a system to manage this tradeoff continuously, not a fundamental law.
Cache is not fast because it's physically close to the core. Well okay, closeness does matter but it doesn't matter as much as the fact that cache is static, i.e. it's (effectively) made of flip-flops.
If you build a computer with DRAM 10 cm away from the CPU and static RAM 50 cm away, access times for the static RAM will still be much lower than access times for the DRAM.
Why don't we just build all RAM as static? Because it's more expensive per bit, it uses more energy, and it requires a great deal more silicon area.
When we are talking about galactic algorithms we have long since left the realm of things that might fit on one computer. Some of these algorithms are only starting to become faster on n so large that we have trouble fitting the data in this solar system. At those scales the distinction between the type of RAM is irrelevant. At that point "how long to read memory address X" is pretty much the same as "how long does light take to reach X" which is pretty much "how far to X" which scales with a cube root. (Well, probably a square root if we look at physical limits for weird reasons)
For any big enough memory the speed of the memory reads will depend on address distance, at least due to the finite propagation speed of the data that is read.
Sequential reads from adjacent cells will be pipelined, so they can have a throughput that does not depend on the distance in address, but the latency to start another sequential read stream from a different address must depend on the address, for very big memories, e.g. of rack size, where the propagation from a corner of the rack to the other corner takes a long time in comparison with the memory clock.
My understanding is that in the limit (i.e. before you create a black hole), information density actually scales with surface area, not volume, so square root. And then of course at that kind of density, you'd have to account for time dilation as well...
"Information density" is a ratio, i.e. the ratio between the amount of information and the length, area or volume in which it is stored, so it does not "scale".
The amount of information at high enough amounts scales with the volume in which it is stored.
Because of the need to be able to reach the cells that store information, the density of information is normally high in 2 directions an low in the 3rd direction.
This is why it is useful to distinguish between the density of information per area, which is determined by things like the size of a magnetic head or the resolution of a photolithographic process, and the density of information per volume, which is determined by the density of information per area and by some kind of layer thickness, which is usually determined by mechanical considerations, e.g. to ensure enough strength for a tape or a disk or an integrated circuit package.
Like I have said, at high enough amounts of information you reach an almost constant information density per volume, like in a rack full with HDDs or in a magnetic tape robotic library.
Yes, misspoken. Anyway, not that I'm an expert here but my understanding is that at maximum density, information in a region does not scale with the volume in which it is stored; it scales with the surface area of the event horizon it creates (at least for a Schwarzschild black hole). Is that incorrect?
The amount of information you are talking about is quite a bit lower than the amount I'm talking about. Big O is about limits, so if we're going to bring physical limitations into play to say there's some limit to density, you'd might as well go all the way. It's not limit as n -> 10^18; it's limit as n->infinity. You can't keep adding information and still get cubic scaling.
Some of the computation models (including the ones in some of the OpenAI papers in question) avoid this particular concern by working in a multi-tape Turing machine model. One might quibble about the energy cost of moving an entire infinite tape (because it’s multi-tape and, for bounded communication code, the heads need to stay near each other), but the machines really are local in a fairly strong sense.
I contemplated the article and it occurred to me that integer matrix multiplication is probably O(n^2), without even any galactic constants. But it will need unit-cost integer math.
First, find a sufficiently large base b so that no intermediate calculation exceeds b-1 (one pass over the matrices should do the trick). Then encode each row of the left matrix as a big value A_i = sum_k a_ik * b^k. Encode each column of the the right matrix as B_j = sum_k b_kj * b^(n-k). Compute A and B explicitly (takes O(n^2) integer operations).
Now you extract the answer one element at a time. A_i * B_j has a bunch of terms including sum_k a_ik * b_kj * b^n. All other terms have different powers of b. So do an integer division by b^(n-1), discard the remainder, then take the result mod b, and that gives (a*b)_ij, costing one integer multiplication and two divmod operations per output element. Problem solved. Can I publish in FOCS?
This is, of course, a wild cheat: even with OpenAI’s latest and greatest galactic integer multiplication algorithm, this would be asymptotically slower than the plain high school matrix multiplication algorithm in any remotely realistic model of a computer.
I wonder whether the OpenAI papers contain cheats quite as outrageous as mine :)
(The moral here is that exact math is quite powerful, and exact math in time sublinear in the number of bits of precision is a great way to steal some performance.)
I haven't come up with anything using natural integer operations. I can come up with really disgusting hacks using highly unnatural integer operations, but that feels too gross to even include in this category of cheats -- if you're willing to use unit-costs unnatural integer operations, then you might as well give up: you can do literally any operation on inputs that can be kludged into a integer in constant time.
If algorithmic theorists don't care about practical performance then why should we care about what they're doing? It's just a strange game they're playing, of no interest to anyone else.
It seems like rather than coming up with more "galactic" algorithms, a more useful thing to do might be to come up with a replacement for big-O that's not so exploitable, and to convince theoreticians to play that game instead.
You care because Pierre de Fermat 16th century work on modular arithmetic was of “no intest to anyone else” except other theorists but it got to shine in the twentienth century in modern cryptography.
Doing theory is what gives you a chance to push the envelope to places you can’t even imagine when you’re knee deep in real world problems. And proving something is possible (if impractical) gives an incentive to find a better algorithm and may attract others.
" In 1973, Jacques Morgenstern proved that you couldn’t get a Fourier transform faster than ½ n log n if you required that complex coefficients used in the computation had bounded magnitude"
I highly doubt this is going to somehow inspire people to make faster algorithms than the mathematical bound...
I have no problem with pure mathematics, my training was in it; but it seems very possible to me that most people funding theoretical computer science (as opposed to pure maths) probably assume the work has a more realistic computational model backing it up.
>I have no problem with pure mathematics, my training was in it; but it seems very possible to me that most people funding theoretical computer science (as opposed to pure maths) probably assume the work has a more realistic computational model backing it up.
Most people getting funding for pure maths probably just lie and/or stretch the truth that it tangentially has some relation to or possible benefit to practical things like cryptography. It doesn't need to actually be true. It just needs to feel true enough.
The algorithm from OpenAI works also in prime-order finite fields. Such FFTs are used all over the place in cryptography. So clearly their result is not useless and works in a realistic computational model
Huh, I wasn't aware; I haven't looked into the construction, I was just taking the blog posts claims for granted. Does it extend to all finite fields, that'd be super cool if so.
I disagree with your implication; modular arithmetic is much more obviously useful, and would have been back then too (supposing hypothetically you explained the notion of a galactic algorithm to Fermat), because it's an abstract mathematical structure and thus likely to recur in new scenarios.
I find that an extremely inefficient way of thinking. Spending time on problems on the minuscule off chance that a few centuries later they will be useful whereas you could be spending time right now on problems you know for a fact are useful is a weird trade off to make.
Both opinions are being voiced here (albeit maybe some are just bad at wording things). And gatekeeping what others should do with their money is stupid. And coincidentally, actually communist, or oligarchist of some flavor.
No, I don’t care. Until there is a real, practical result, I don’t care. There are plenty of examples of math discovered in service of solving a problem. There is nothing that says math has to be purely abstract first.
Dudeee how far up your hind do you need to be to nit even appreciate the groundwork being laid out?
Like imagine Einstein without access to geometry work. You had others point you to number theory. What about Boole's algebra.
There is a pretty big list of seemingly useless pure math things suddenly finding a very practical use. Sometimes quite a bit later too. And we have no way of knowing beforehand.
And it's fine to not want to do such work yourself. But to dismiss it is, well, not very thoughtful.
Imagine Newton without access to calculus. Poincaré and the three-body problem without topology. Gibbs and Heaviside without vector calculus. Or Fourier without, well, Fourier analysis.
The lack of mathematical tools posed no special challenge for any of them. They invented the math they needed to do their work.
You are presenting a false alternative history, where they would not be capable of making great insights without the math coming first. But the causality is often the other way around.
Relativity is required to explain the time dilation, but it's not needed to notice that the GPS clocks run 40µs too fast. It wouldn't take too long for them to measure enough data to create an empirical skew-versus-altitude table, which should then be enough for them to correct the time skew, even without understanding what was going on.
I think this is a difficult counterfactual to assess, we didn’t develop clock accurate enough to notice the time dilation until 50 plus years after the theory of relativity was published.
Still, how long would it take someone to work it out empirically enough to have confidence that there wasn’t just some bug somewhere? Maybe they would mothball the GPS project for not working before figuring it out? It’s hard to know, 50 years in an alternate timeline allows for a lot of domino effect
> Still, how long would it take someone to work it out empirically enough to have confidence that there wasn’t just some bug somewhere?
They probably would just assume that it's a bug at first, since "our clock is slightly broken" is far more likely than "we've discovered some cool new physics". But I don't think that that would be an issue here, since even if they thought it was a bug, they'd still try to work around it.
> Maybe they would mothball the GPS project for not working before figuring it out?
I doubt it, since if you think about all the possible issues after sending a complex untested satellite to space, a 40μs clock discrepancy is fairly minor.
I've always wondered - if special and general relativity weren't known, could the GPS engineers have just measured the error and empirically accounted for it? I don't know relativity or GPS or engineering well enough to answer.
Yes, the clock slippage is a constant factor, entirely predictable. If made public it would probably have catalyzed the discovery of special relativity soon afterwards, but then people would’ve been super confused because its predictions still wouldn’t match the observations and indeed would widen the discrepancy rather than narrowing it!
Yeah, absolutely. You'd be surprised how much high-precision engineering absolutely relies on "this but you have to mill a tiny amount off the end because if you do the maths it comes out ever so slightly too big, and then adjust on test".
It's possible, but it seems more likely that the first tests would have shown "weird timing errors we couldnt diagnose" and then the project never got a follow up.
For something so militarily useful? When the Soviet Union was still seen as a threat to the US? When it was already so expensive anyway? I guess it's possible, but it's hard to believe they'd just give up like that.
The problem with "it's hard to believe" is that this is an area where I'm not even sure how to effectively estimate the counterposition, I've seen things that I thought were interesting get cancelled or have no follow up all the time, and it makes sense, no idea if it will matter, or even work, and even if it does, how much will it cost to realise any value?
Who knows how often really impactful tech is gated behind some non-obvious thing which we never follow up on.
I mean Douglas Engelbart basically bet his entire career behind the Mother of All Demos[0], if it had flopped, modern computing as we know it would be fundamentally different, same with Hiroo Kinoshita and Extreme Ultraviolet Lithography[1][2], we just would have had Moore's law falling off a cliff.
And that's fine, caring about everything is exhausting, someone has to solve real world problem. But dismissing a result since it's not practical is not fine
Not everyone needs to care about everything and there is reason to say that a result like this one from openai is quite sterile and possibly damaging to the socio-cultural dynamic of the field.
How far are you willing to go? In your radical pragmatism, are you an intuitionist, or even a finitist? Oh wait, these are pure math topics that you do not care a about!
I think you are free not to care about what they are doing. It turns out that big O notation has some useful properties, and in particular it is a useful definition as it allows you to define complexity classes which are a very useful tool for analyzing algorithms in general.
Much of our 'practical' understanding of algorithms also in part came from theoretical advances.
The argument in the article isn’t about whether big O notation is useful it’s about whether the n in any particular big O is relevant. In this case the algorithm’s claim is that you can multiply arbitrarily large numbers faster than n log n where n is the size of the numbers being multiplied. But that result holds only if you don’t include the cost to multiple arbitrarily large complex numbers in that n, which are assumed to be able to multiply in constant time.
> In this case the algorithm’s claim is that you can multiply arbitrarily large numbers faster than n log n where n is the size of the numbers being multiplied. But that result holds only if you don’t include the cost to multiple arbitrarily large complex numbers in that n, which are assumed to be able to multiply in constant time.
Well that's certainly not the claim. Think about it, that would mean the whole thing is trivially O(1), so why would they be bothering with the rest?
You've missed part in the analysis, or I believe added an assumption they're not making (the constant-time-multiply one, specifically).
This all _is_ almost certainly impractical, but it's for the usual reason of it only being faster for numbers nobody could ever care about. It's theoretically _quite_ interesting though, because hey...what _is_ the fastest you can actually multiply numbers if it's not O(n lg n) as many ~assumed.
The complex FFT is a generalization of the n-bit integer multiplication algorithm, not the other way around. No complex-number operations are required for the integer case.
> If algorithmic theorists don't care about practical performance then why should we care about what they're doing? It's just a strange game they're playing, of no interest to anyone else.
You don't need to care. But every so often breakthroughs in theory can be turned into breakthroughs in practice.
> It seems like rather than coming up with more "galactic" algorithms, a more useful thing to do might be to come up with a replacement for big-O that's not so exploitable, and to convince theoreticians to play that game instead.
There's plenty of replacements.
Btw, we already have the optimal (in big-O terms) algorithm for every NP hard problem. We just don't know whether it runs in polynomial time or takes longer. And, yes, that algorithm called Levin's Universal Search is a galactic algorithm. Simplifying a lot, Levin's Universal Search does some clever interleaving to essentially try all possible algorithms in sort-of parallel.
Lo and behold, even the theorists you complain about don't see that 'loophole' as a solution, declare victory and go home. They still keep researching.
As I read it, that was sort of their point: if the theorists were blindly focused on Big O complexity, they could 'cheat' by invoking the universal search algorithm as a good-enough solution to a huge class of problems; but they don't, because they're not mindlessly playing a game where Big O complexity is all that matters.
The reason universal search doesn't solve big O complexity is that nobody knows the big O complexity of universal search. You want to know the complexity of SAT.
"Ok, here's an optimal SAT algorithm (universal search)".
"Nice, but what is the big O complexity of universal search for SAT?".
"Nobody knows".
You're no better off than before if you wanted an answer like "exponential". On the other hand a provably sub-exponential SAT algorithm would be a huge theoretical breakthrough even if "galactic". Same for a proof that P=NP where the exponent in the P-time SAT algorithm was the 5000th busy beaver number, or whatever.
Also empirically, pretty much any provably polynomial algorithm we have found for anything has fairly tame exponents. That's a big part of why 'polynomial' works as a short-hand for 'tractable' that also has nice theoretical properties.
Btw, I don't know whether the tame exponents are in some sense natural, or whether they are a product of how humans find and design algorithms. Perhaps AI will change that.
Yeah I seem to remember that the earliest known algorithm (Schoof's algorithm) for counting points on an elliptic curve over a characteristic-p field was O(n^8) where n is the bit length of p. But, much more efficient algorithms are known now. I don't know of anything with a higher exponent than 8. The time hierarchy theorem says higher exponents let you solve more problems, but idk if there are natural examples of such problems.
Well, it's an 'exploit' in the sense that normally we assume that the constant factors are modest enough so that O(n) can be reliant upon to be faster than O(2^n) or even than O(n^2) in practice.
They do care. They also care about partial results. As of last week, we thought we knew the best possible algorithm. We now know that there's a galactic algorithm that's an asymptotic improvement. The question then becomes "Is there a non-galactic algoritm that does the same, or is any such algorithm necessarily galactic?"
The problem is that proving an algorithm is necessarily galactic is incredibly hard. If you knew how to do this, you would become one of the most celebrated complexity theorists of the age. Stanford would be calling.
Theory is theoretical, that's what the word theoretical means. Set theorists deal with numbers and collections that are literally infinite and nobody complains. Complexity theory is much more down-to-earth since the numbers are finite. That's about as good as it gets. If you want practical, study engineering.
If you read the entire argument, it makes perfect sense. It’s simultaneously mocking the poorly established ways of measuring asymptotic complexity of algorithms.
TL;DR - time complexity calculations ignore constant values. So if algorithm A takes 10^10 + n number of iterations to do something, and B does n^2, in theory B is worse, because n < n^2. But in practice, you’d be waiting a very long time for the first iteration of A to even be useful.
So in other words, time complexity gives you how well an algorithm can scale beyond the first iteration. What it doesn’t tell you is if you’d have to wait until the end of the universe to even get started.
Youre just repeating the argument made in the blog without responding to the poster who said the argument is bad. Not wrong, bad. If you want to say theory is useless, do it.
"Malicious" is an overstatement, but "exploit" is completely fair in my view. Theory with no possible practical relevance is useless, and I think a computational complexity result requiring arbitrary-precision arithmetic that is impossible to implement using any physical system qualifies.
It's hard to know for certain, but that doesn't mean we should throw up our hands and say anything goes. We can still say that some things are more likely to be useful than others.
The idea that FFT's decomposition is non-optimal is surprising. What the new bound means is we basically were looking at the problem and its structure incorrectly, and therefore implicates other problems for which we have used recursion to get to our currently-best bounds.
Almost no interesting math problems are just sitting there alone in their little corner. Getting a hint like that is a big deal.
Is it surprising though? If you assume constant time when it doesn't exist (in this case arbitrary precision arithmetic), it should be obvious that you will be able to devise algorithms that are faster than the commonly accepted best results.
If you can do arithmetic on arbitrarily large integers in constant time, you can sort lists in linear time.
The author is attacking the field of theoretical algorithm design broadly as being useless. If we take the author's logic to its conclusion, many algorithms we learn about in a standard Algorithm Design course such as "median of medians" (finding the median in a list in O(n) worst-case time) is useless because it is not used in practice. Even the original 2019 Harvey–van der Hoeven result, showing integration multiplication can be done in O(n log n), has a galactic overhead and no applications.
> theory gets so unmoored from the original question that an “open problem” becomes nothing more than an academic status puzzle...The theory of computer science has become a form of mathematics that doesn’t concern itself with computers, and it offers little reward for impact outside those mathematical pursuits
I thought it is common knowledge (and a common warning from profs to first-year CS students) that computer science has very little to do with computers. The very concept of Turing machines and decidability are mathematical in nature, far removed from how computers these days are run. The undecidability of Wang tiling, for example, is definitely a notable CS result, but it has nothing to do with computers." It is essentially a branch of mathematics. "Computer Science Is Not About Computers, Any More Than Astronomy Is About Telescopes" is a famous quote attributed to Dikstra. There is even famous MIT Open Courseware clip: https://youtu.be/2Op3QLzMgSY?t=30
I don't think that is necessarily true, the post is making a stronger point than what you describe
> Indeed, the algorithm requires you to multiply complex numbers whose magnitudes grow superpolynomially with n. If you stored these numbers as bits, the memory requirement would effectively be exponential in the input length. It assumes you can multiply such arbitrarily large complex numbers together in a single operation.
Another way to think about what the author said, imagine you had access to an oracle which could execute arbitrary precision arithmetic expressions in constant time. You could encode a wide range of computations in these and execute impossible algorithms.
Replace the complex numbers with a finite field and O(1) arithmetic stops being an unrealistic assumption, as you can actually perform the required operations in constant time on a real computer. You can't do that for infinitely-precise complex numbers, but you'll never be able to provide an infinitely-precise complex number as the input anyway. If you start with finite-precision numbers (e.g. 64-bit floats) you can do all operations in a finite-field representation (e.g. the Ozaki scheme II is an actually practical implementation of that idea for matrix multiplication https://arxiv.org/abs/2504.08009 ) and the magnitude of intermediate values is no longer a problem.
Are you certain that applies here? The length of the intermediate numbers grows superpolynomially, so you would be sure to overflow fixed width numbers. Floats are not a field.
Yes, floats are not a field, which is why you don't use floating point except to convert to and from a different representation. Overflow is expected and cancels out as long as the final result is uniquely representable. See the paper I linked, which implements 64-bit floating point matrix multiplication using 8-bit numbers with wrapping overflow modulo a set of small coprime integers. The result is reconstructed at the end using the Chinese Remainder Theorem.
That depends on the scale. A couple jobs ago we had enough objects that an 80-bit key wouldn't have had a low enough collision rate (better models of computation for that domain include sqrt/cube-root ideas to account for information propagation in physical space). Sometimes you have to use more constrained devices so that your max effective constant-time word size (for the same computational cost -- not to quite be confused with the CPU's "native" word size, whatever that means in your circumstances) is 8, 16 or 32 bits (or, most recently at my last job, for _reasons_, 11 bits), making even quite small tables not quite O(1).
Many compsci researchers like the word-ram model of computation to avoid a bunch of extraneous log factors and to apply exactly the intuition you're describing, so that hashtables are actually O(1). That's not a bad habit. It introduces extra log factors in other places though, so I think it's a bit of a wash, and given that it doesn't model the actual register machines we use it feels a bit intellectually dishonest to me.
actually thinking about it more I think my oracle model is more powerful than the computer used in openai's fft but maybe its a good way to think about it.
It's worse case linear, as used for sorting it beats the Go standard library on the average and worst cases, lagging a bit on the best cases.
In my experience, median-on-ninthers (which is only slightly more complicated than median-of-medians) definitely beats both heap sort and particularly heap select as a fall back for the degenerate case.
And it's not just academic: I've sped up significant stuff at work by switching from sorting to partial sorting and/or selection.
That's not median-of-medians, that's quickselect. Quickselect is useful and practical yes. Theoreticians don't like it because of the randomization (or non-worst-caseness)
> In computer science, the median of medians is an approximate median selection algorithm, frequently used to supply a good pivot for an exact selection algorithm, most commonly quickselect…
That's pretty much what I posted: median-of-ninthers is an evolution of median-of-medians, that I use to pick a better pivot whenever the pivot supplied by median-of-3 turns out to be bad.
Using it all the time would simply make quicksort/quickselect about twice as slow as it is now, but still faster than heapsort/heapselect. It's a better backstop algorithm than the common introsort/introselect.
There's also no randomisation, the implementation is completely deterministic, and depends exclusively on the input order.
And median-of-ninthers is faster, but median-of-medians is far from terrible, so calling it a galactic algorithm or completely useless in practice is far from the truth, IMO.
The irony being Dijkstra had lots of deep ideas about how programming ought to be done (from a basic science approach as informed by CS) and that the industry is still in the stone/bronze ages in terms of putting advanced ideas into practice.
Dijkstra was an academic with no skin in the game.
If Dijkstra was so confident that he was right, he should have started a business and put his money where his mouth was. Hell, any True Believer of Dijkstra's could have done the same in the last 60 years. The fact that they haven't - or they've never succeeded enough for me to know of any - speaks volumes about their effectiveness.
HN is such an experience nowadays. This has to be some form of LARP; insinuating the ineffectiveness of the inventor of the semaphore, 'not succeeded enough'.
Dijkstra's jeremiads were about promoting "formal methods" as the One True Method for software construction. Maybe there's a future for formal methods, but it wasn't ready in the past. No one was arguing about semaphores.
If not for Dijsktra you would not even exist to write the very sentence "Maybe there's a future for formal methods, but...".
What basic science does is open up new areas and new ideas. And you and I benefit from those foundations.
Dijkstra's proof methods derived from higher math sophistication than most programmers before, and today, have. Like, in one short essay he showed what invariants mean. He made formal theory accessible to mere non-pure-math mortals. You and I today know what invariants are. That's just one example.
A lovely theory, and yet the field is called "computer science".
Also, while I am not an expert, I suspect it is frequently useful to understand how telescopes actually work when you're trying to do astronomy with them.
The history of the term is actually really interesting. There has been debate about whether or not its the correct name basically since the advent of computer science departments in the 60s.
I don't think the author is "wrong" about the gap between theoretical discussions computation and the actual design constraints of building usable computers. I don't know if that's really a general refutation of proving new things mathematically though. The word "computer" doesn't appear once in the paper OpenAI released, nor do they make any claims specifically about "computer science": https://github.com/openai/math/blob/main/preprints/An-explic...
It's a novel bit of math. Whether or not it means anything in the context of writing software realistically is an interesting conversation, but it doesn't have much bearing on the substance of the result itself. OpenAI is pretty explicit that they view these as research results in the domain of mathematics.
The field has a lot of names. Computer science is the most common, but you can also find other names such as computing, informatics, datalogy, and data processing science (or their foreign equivalents).
Within computer science, there is a clear mathematical tradition, an engineering tradition, and a social science tradition. There are also plenty of applied computer scientists who use computer science to study topics in other fields.
yes and I'd like to sue whoever named that field for false advertising. when I went to school (Precambrian era - no internet) I thought computer science would be great because I wanted to learn how to program. I dropped it after the 2nd year when I realized it was more about calculus than programming. (and I sucked at calculus. well, the teachers who were supposed to teach me about calculus sucked, but the end result was the same.)
It is a misnomer because it's not really about computers, nor is it science (although machine learning has always been much more scientific IMO). But it is about programming. It's just from first principles. It's like learning to build furniture: you first have to learn about wood. Sure, most people will just put something together from IKEA, and that might be satisfying. But they don't really know how to build furniture.
The author could have left AI entirely out of the essay and come to the same conclusions. He just really doesn't like TCS. That's fine, it's really a part of mathematics not science, but it's silly to dismiss a field with "theoretical" in its name for being impractical.
There are other impractical aspects of TCS besides galactic algorithms, e.g. theoretically optimal data structures that are either too complex to be implemented or only achieve optimality in the limit (I guess the latter could be called "galactic data structures").
No, I don't think you (or the part of the thread I read thus far, top to bottom) are giving the most charitative interpretation of the post.
In my understanding, the article wants to raise awareness of the potential dynamics of a mathematics/theoretical computer science field governed by the imperfect rules (as they must be) of human sensemaking when the merit system (publication and community standards) are hacked by a machines for which the cost-benefit calculation is very different than for human reseachers for which the rules were invented / sedimented in the first place.
The foregoing discussion above about the emergent utility of now seemingly wasteful theoretical research is as old as any other, but equally predicated on human effort/apability ratios. And AI should invite us to rethink, because to be relevant to humans, its unwieldy results will have to be judged by humans, on their timescales and effort budgets. So we are discussing whether SPAM or HAM before we literally spend our lives as human critics of what ultimately could just be a reward hacking exercise by somebody with access to free tokens.
Did not realize that the model of computation for all of the banner computational complexity results from last week was "exact complex arithmetic." Is this and/or "exact real arithmetic" a common premise for papers in this field? My assumption as an outsider was that people mostly care about things equivalent to Turing machines.
edit: by "things equivalent to" I really mean universal register machines, something that operates on integers and not directly on real numbers.
And exact arithmetic on Q + i*Q (complex numbers but the coordinates are rational numbers, not real numbers) is perfectly feasible.
Of course, in a real computer, long rational numbers take longer to manipulate than short rational numbers. But it's just a model. Similar to how we often assume we can handle arbitrary integers in unit time, but in reality longer integers also take longer to handle on a real computer (or we just refuse to handle them and stick to u64 only.)
Either a model can be wrong or it is just a model. If it's the former, it matters whether Turing machines are less wrong than exact complex arithmetic machines.
There is, of course, the very rich field of Numerical Analysis which deals with how we actually represent these things in real life, but for a starting point assuming this sort of thing is par for the course.
I can't speak for the FFT claim, but least the sub-O(n log n) multiplication claim is for the multitape Turing machine model with a fixed number of tapes, which if anything is more restrictive than actual random-access memory. Of course, it's still galactic just like the O(n log n) algorithm, but it definitely seems like there's something there.
No, because in the model of computation they're using, you can multiply any two numbers in constant time. See https://enwp.org/Real_RAM for a similar model.
So, the pseudo-FFT exploits algorithmic similarity between DFT and multiplication to translate part of the DFT work into multiplication work, which is O(1) in the exact arithmetic model.
Thus, the magnitudes of the numbers being multiplied grow superpolynomially with n (the DFT problem size): because the robot's stuffing its work in there and using it as an oracle.
I am astounded by the activity in this repo... what is going on? 508 PRs on 408 commits..? It's getting additions at a frenetic pace by a large number of contributors.
It’s unintentionally making a mockery of OpenAIs results by highlighting Blums speedup theorem in action. Namely that you can always reduce time complexity with a small move into space complexity.
That unintentional mockery of a repo is 262million lines of such moves and growing. I don’t think for a second anyone involved has a clue about complexity theory though or they’d just jump to the obvious “O(1) time complexity using an O(2^n) lookup table to cover all possible n bits of input” which is the final end state of Blums speedup theorem.
The above 2^n is just the extreme. There’s always baby steps to that direction. If you want you can point an agent at any known nlogn algorithm (eg. Sorting) and quickly get similar improvements in a similar way. We’re about to see an explosion of ‘complexity bound of x broken!’ as people discover what the creator of complexity theory warned us about. Namely that there’s never hard limits in complexity theory and you can always speed up any time complexity with a cost in space complexity. There never was some impassable nlogn boundary for any algorithm.
I’ve made some half hearted attempts to try and understand even the framing of some of these problems that were solved, and my god theoretical math is hard. It’s completely impenetrable with unknown symbols and hard to comprehend bounds and several orders of derivatives. It’s all unintuitive to me.
i resolved this a coder with adding math symbols to my keyboard.
When you can start doing A₁₂ ⟨M⟩₃† (complete made up nonsense) in your code or just comments without going latex etc it comes more naturally as you wont have to switch context so often.
I'm confused by some of the reactions here. Isn't this the first step toward taking theory into reality? So, FT could be faster if we could multiply larger numbers. The problem has now moved from is it possible to "do we have the hardware to do it?" Not my area, so maybe someone could explain to me why this isn't a question of how large the instruction limit is right now? Would 128bit systems change this meaningfully?
No, not in this case. The assumption of unit cost arithmetic is simply not physically realizable. It's probably easier to understand the integer case: numbers take bits to store and represent. In a typical computer, you would store numbers as either 32 or 64 bits, where 32 bits could store a number up to about 4 billion (or a signed number between -2 and +2 billion). If you want to store and multiply numbers larger than that, they take up more space and they require more work on the part of the processor, and fundamentally, more energy - adding two 128 bit numbers takes twice the work as adding two 64 bit numbers.
The same applies to the precision of floating point numbers. What Ben is arguing is happening in this case is the AI has found a way to hide work by moving it into operations that, in one (unrealistic) model of computation, are assumed to cost the same regardless of how large or precise the numbers are. Other models of computation have a more accurate model of the cost of these things, but that was not the model the AI chose to apply in this case.
> Did I read this paper? Of course not. No one at OpenAI read this paper either, so why should I? I did what every other mathematician in the world does with AI slop mathematics: I fed it back into the slop machine and ran an information retrieval session with a chatbot interface to extract salient facts. Anthropomorphically speaking: I asked ChatGPT what it thinks about its own output. This is how we do mathematical research now. What a world.
"I found the rot that develops inside applied mathematical theory when formalism becomes so detached from reality that a “breakthrough” is nothing more than an artifact of mathematicians not being able to properly specify the rules of their games in natural language."
it's like in my company, where some software developers get frustrated with an LLM that writes poor code. Understanding what you want—and providing the right examples and explanations—is crucial !
> This new OpenAI result is thus less a mathematical breakthrough and more an oddity of computer scientists being bad at formalizing their design specifications.
Related, another article about proofs that may depend on bad formalizations:
AI seems to be very good at getting answers, but not always answers to the correct questions. These remind me of Deep Thought from The Hitchhiker's Guide to the Galaxy, where they got an answer to the ultimate question before actually knowing what the ultimate question is.
> AI seems to be very good at getting answers, but not always answers to the correct questions.
I don't think that's an accurate summary of the article you linked. The Lean proof solved the exact problem it was supposed to, it just had minor discrepancies from the writeup of the proof (on the level of saying a theorem requires m+4 derivatives when it actually requires m+5 derivatives). Obviously a problem but not really a bombshell.
> The theory of computer science has become a form of mathematics that doesn’t concern itself with computers
Perfectly summarizes the post, which I'd qualify as a rant (the author's main gripe seems to be that it's a galactic algorithm that assumes exact complex multiplication). The theory of computer science literally started with a mathematical model by Alan Turing that has nothing to do with computers (ones that we could physically build, anyway; and even if we brush aside the infinite tape, it's just architecturally completely different from any computers we've ever built for practical purposes).
If you don't like mathematics without direct applicability, you do you, but it's a legitimate mathematical undertaking and cheap way to rant against this AI drop. Do the work and show us if there's a mistake in the argument, missing attribution or whatever actual problems with the paper, but spare us your sour grapes.
I am as upset as the slew of math slop from OpenAI as the next guy, but I do not understand this article. Are they saying that this was not a true improvement because the algorithm is _galactic_? Human algorithm researchers have been publishing those sorts of results for decades now
I think it's reasonable to give the benefit of the doubt to humans, but not LLMs, that their galactic constants are not just attempts to "hack" the problem description. If LLMs are going to turn up a bunch of them, we have to develop a better version of complexity theory that accounts for them.
> “The model uses exact complex arithmetic.” That means it assumes you can store and multiply complex numbers at arbitrary precision. Indeed, the algorithm requires you to multiply complex numbers whose magnitudes grow superpolynomially with n.
This in particular is the kind of thing that I'd expect a human would at least pause on and ideally note as a severe caveat to any claimed asymptotic improvement. I don't know off the top of my head if the story is as simple as "you can tuck part of the asymptote into your presumed constant arithmetic", but it sounds kinda plausible?
To be honest this reminds me of interview leetcode. Like I remember one where you could get constant time if you made nested hashtables covering character sequences that might have made sense in USCII but probably would be impossible to maintain in UTF. In general leetcode problems love goading you to treat the ASCII character space as constant time to deal with and it's stupid. And it seems very similar to this.
“breakthrough” is nothing more than an artifact of mathematicians not being able to properly specify the rules of their games in natural language… the theory of computer science has a culture that actively discourages running algorithms on a computer.
This is not an entirely faithful characterization. TCS and does make the distinction between galactic algorithms and what are called “feasible” algorithms (e.g., Karatsuba’s or Strassens’s algorithm), which yield a measurable speedup on practical inputs.
In my experience reading TCS papers, it is rarely made clear whether or not an algorithm is practical; generally one has to go pretty deep to figure that out
This article has basically nothing to do with the OpenAI paper; it's a critique of the entire field of computer science, rehashed to pick at one of their papers.
An unpleasant part of the AI math revolution is that people's hatred of AI is bringing to bear their hatred of pure mathematics in general. I've always known in the back of my mind that mathematicians were secretly despised and looked down upon by many, but it's a bad feeling to see it become so mainstream.
And people's love of AI is also surfacing their dislike of pure mathematicians. Plenty of comments along the lines of "turns out mathematicians were just idiot savants solving puzzles".
This is a bad take. I will happily acknowledge the new term "slopository" which I had not heard before, while taking the author to task for malice towards theorists. STOC/FOCS/SODA, etc are not about "doing practical algorithms". If you want that, you go to ESA, ALENEX, or VLDB/SIGMOD, or any of the other more applied venues featuring this work. I don't think it's fair to just shit on theory because they don't do experiments---they're mathematicians, and it is fine to have absurd constants in your big-O as long as they are constants.
PS. I can have this view while simultaneously thinking that Ben is a badass.
As a theorist, it's sort of true that I "don't care" about galactic constants. I'm interested in the structure of computation for philosophical reasons. But I really do care about the model of computation.
To put it another way, the constants inside a big-O are not really constant: they depend on what you assume is a constant-time operation.
About big-O constant, I came to the realization that in the real world, constant time is actually a log at best, but more likely a cube root.
The simple idea is that the most basic thing, that is reading the number "n" depends on the number of digits, so that's a log.
But in most algorithms, the "n" refers to the size of a data set. This set is usually stored in some kind of memory, and memory is a physical array of little cells in 3D space. Accessing that cell means travelling through the array, with a time to reach it proportional to its distance, and since capacity increases with the cube of the distance, the time it takes to get the data is proportional to the cube root of n.
The conclusion, to me, is that when complexity gets down to less than a cube root, mathematical abstractions start to break down and you need to consider the actual machine, in particular its cache architecture.
No, memory reads do not depend on the address distance, unless you create a list.
Ordinary memory is not a list. It's a flat space read in O(1).
In theory. In practice there are multiple levels of cache, and cached reads will be much, much faster than main memory reads.
So if your entire data structure lives in cache and you repeatedly loop through it, it's going to be processed much more quickly than a bigger and more spread-out structure.
There's also paging, and alloc/dealloc to consider, and maybe garbage collection.
By the time you include all of that big-O estimates can become wildly misleading generalisations, unless your n is always >a million or so.
For small n it can be way off.
They mean physical distance, not "address distance".
And in the general case, memory reads do depend on distance. Hence:
> In practice there are multiple levels of cache, and cached reads will be much, much faster than main memory reads.
This is why we have the cache levels in the first place. And the hierarchy continues: L1, L2, RAM, block of spinning rust in the closet, "the cloud" somewhere... There is only so much storage you can fit close to core! More = physically bigger = physically further away.
Sure, within a level might feel like constant time. But that's because the optimal case for that level is slowed down to match the suboptimal cases. The step discontinuities in access time are caused by our inability to engineer a system to manage this tradeoff continuously, not a fundamental law.
Cache is not fast because it's physically close to the core. Well okay, closeness does matter but it doesn't matter as much as the fact that cache is static, i.e. it's (effectively) made of flip-flops.
If you build a computer with DRAM 10 cm away from the CPU and static RAM 50 cm away, access times for the static RAM will still be much lower than access times for the DRAM.
Why don't we just build all RAM as static? Because it's more expensive per bit, it uses more energy, and it requires a great deal more silicon area.
When we are talking about galactic algorithms we have long since left the realm of things that might fit on one computer. Some of these algorithms are only starting to become faster on n so large that we have trouble fitting the data in this solar system. At those scales the distinction between the type of RAM is irrelevant. At that point "how long to read memory address X" is pretty much the same as "how long does light take to reach X" which is pretty much "how far to X" which scales with a cube root. (Well, probably a square root if we look at physical limits for weird reasons)
For any big enough memory the speed of the memory reads will depend on address distance, at least due to the finite propagation speed of the data that is read.
Sequential reads from adjacent cells will be pipelined, so they can have a throughput that does not depend on the distance in address, but the latency to start another sequential read stream from a different address must depend on the address, for very big memories, e.g. of rack size, where the propagation from a corner of the rack to the other corner takes a long time in comparison with the memory clock.
My understanding is that in the limit (i.e. before you create a black hole), information density actually scales with surface area, not volume, so square root. And then of course at that kind of density, you'd have to account for time dilation as well...
"Information density" is a ratio, i.e. the ratio between the amount of information and the length, area or volume in which it is stored, so it does not "scale".
The amount of information at high enough amounts scales with the volume in which it is stored.
Because of the need to be able to reach the cells that store information, the density of information is normally high in 2 directions an low in the 3rd direction.
This is why it is useful to distinguish between the density of information per area, which is determined by things like the size of a magnetic head or the resolution of a photolithographic process, and the density of information per volume, which is determined by the density of information per area and by some kind of layer thickness, which is usually determined by mechanical considerations, e.g. to ensure enough strength for a tape or a disk or an integrated circuit package.
Like I have said, at high enough amounts of information you reach an almost constant information density per volume, like in a rack full with HDDs or in a magnetic tape robotic library.
Yes, misspoken. Anyway, not that I'm an expert here but my understanding is that at maximum density, information in a region does not scale with the volume in which it is stored; it scales with the surface area of the event horizon it creates (at least for a Schwarzschild black hole). Is that incorrect?
The amount of information you are talking about is quite a bit lower than the amount I'm talking about. Big O is about limits, so if we're going to bring physical limitations into play to say there's some limit to density, you'd might as well go all the way. It's not limit as n -> 10^18; it's limit as n->infinity. You can't keep adding information and still get cubic scaling.
Some of the computation models (including the ones in some of the OpenAI papers in question) avoid this particular concern by working in a multi-tape Turing machine model. One might quibble about the energy cost of moving an entire infinite tape (because it’s multi-tape and, for bounded communication code, the heads need to stay near each other), but the machines really are local in a fairly strong sense.
I contemplated the article and it occurred to me that integer matrix multiplication is probably O(n^2), without even any galactic constants. But it will need unit-cost integer math.
First, find a sufficiently large base b so that no intermediate calculation exceeds b-1 (one pass over the matrices should do the trick). Then encode each row of the left matrix as a big value A_i = sum_k a_ik * b^k. Encode each column of the the right matrix as B_j = sum_k b_kj * b^(n-k). Compute A and B explicitly (takes O(n^2) integer operations).
Now you extract the answer one element at a time. A_i * B_j has a bunch of terms including sum_k a_ik * b_kj * b^n. All other terms have different powers of b. So do an integer division by b^(n-1), discard the remainder, then take the result mod b, and that gives (a*b)_ij, costing one integer multiplication and two divmod operations per output element. Problem solved. Can I publish in FOCS?
This is, of course, a wild cheat: even with OpenAI’s latest and greatest galactic integer multiplication algorithm, this would be asymptotically slower than the plain high school matrix multiplication algorithm in any remotely realistic model of a computer.
I wonder whether the OpenAI papers contain cheats quite as outrageous as mine :)
(The moral here is that exact math is quite powerful, and exact math in time sublinear in the number of bits of precision is a great way to steal some performance.)
Nice. I was trying to think of a linear time sorting algorithm using a similar cheat. Any ideas?
I haven't come up with anything using natural integer operations. I can come up with really disgusting hacks using highly unnatural integer operations, but that feels too gross to even include in this category of cheats -- if you're willing to use unit-costs unnatural integer operations, then you might as well give up: you can do literally any operation on inputs that can be kludged into a integer in constant time.
If algorithmic theorists don't care about practical performance then why should we care about what they're doing? It's just a strange game they're playing, of no interest to anyone else.
It seems like rather than coming up with more "galactic" algorithms, a more useful thing to do might be to come up with a replacement for big-O that's not so exploitable, and to convince theoreticians to play that game instead.
You care because Pierre de Fermat 16th century work on modular arithmetic was of “no intest to anyone else” except other theorists but it got to shine in the twentienth century in modern cryptography.
Doing theory is what gives you a chance to push the envelope to places you can’t even imagine when you’re knee deep in real world problems. And proving something is possible (if impractical) gives an incentive to find a better algorithm and may attract others.
For example see the first graph here: http://klotza.blogspot.com/2016/06/the-fall-of-twin-prime-ga...
Considering this line:
" In 1973, Jacques Morgenstern proved that you couldn’t get a Fourier transform faster than ½ n log n if you required that complex coefficients used in the computation had bounded magnitude"
I highly doubt this is going to somehow inspire people to make faster algorithms than the mathematical bound...
I have no problem with pure mathematics, my training was in it; but it seems very possible to me that most people funding theoretical computer science (as opposed to pure maths) probably assume the work has a more realistic computational model backing it up.
>I have no problem with pure mathematics, my training was in it; but it seems very possible to me that most people funding theoretical computer science (as opposed to pure maths) probably assume the work has a more realistic computational model backing it up.
Most people getting funding for pure maths probably just lie and/or stretch the truth that it tangentially has some relation to or possible benefit to practical things like cryptography. It doesn't need to actually be true. It just needs to feel true enough.
It's like all the robotics works that obviously might be applicable to Search and Rescue and help firemen fight fires.
The algorithm from OpenAI works also in prime-order finite fields. Such FFTs are used all over the place in cryptography. So clearly their result is not useless and works in a realistic computational model
Huh, I wasn't aware; I haven't looked into the construction, I was just taking the blog posts claims for granted. Does it extend to all finite fields, that'd be super cool if so.
Does the apply to representation of complex numbers, which is not uncountably infinite and represented by floats?
Yes. It applies to "linear algorithms", which are basically functions of the form
where each ti is a linear combination of previous t vars, inputs x vars, or constants.The cost model is just the number of additions performed.
That's absolutely fascinating. I need to read up on this -- thanks for sharing!
I disagree with your implication; modular arithmetic is much more obviously useful, and would have been back then too (supposing hypothetically you explained the notion of a galactic algorithm to Fermat), because it's an abstract mathematical structure and thus likely to recur in new scenarios.
I find that an extremely inefficient way of thinking. Spending time on problems on the minuscule off chance that a few centuries later they will be useful whereas you could be spending time right now on problems you know for a fact are useful is a weird trade off to make.
Spending time commenting on HN is even less likely to yield useful mathematical results in a few centuries, but here you are.
OK, here's a different tack, then.
It is almost completely impossible, and therefore a waste of time, to attempt to gatekeep what other people wish to spend their time and energy on.
There's no single hand holding the pursestrings of research. There's no single path to implementation of theory IRL.
Talking about what "should" be studied is arrogant at best.
Yeah but we are not talking about what should be studied, but rather what should be funded
Both opinions are being voiced here (albeit maybe some are just bad at wording things). And gatekeeping what others should do with their money is stupid. And coincidentally, actually communist, or oligarchist of some flavor.
No, I don’t care. Until there is a real, practical result, I don’t care. There are plenty of examples of math discovered in service of solving a problem. There is nothing that says math has to be purely abstract first.
Dudeee how far up your hind do you need to be to nit even appreciate the groundwork being laid out?
Like imagine Einstein without access to geometry work. You had others point you to number theory. What about Boole's algebra.
There is a pretty big list of seemingly useless pure math things suddenly finding a very practical use. Sometimes quite a bit later too. And we have no way of knowing beforehand.
And it's fine to not want to do such work yourself. But to dismiss it is, well, not very thoughtful.
Imagine Newton without access to calculus. Poincaré and the three-body problem without topology. Gibbs and Heaviside without vector calculus. Or Fourier without, well, Fourier analysis.
The lack of mathematical tools posed no special challenge for any of them. They invented the math they needed to do their work.
You are presenting a false alternative history, where they would not be capable of making great insights without the math coming first. But the causality is often the other way around.
Because clearly we’d have invented GPS if we had asked ourselves “how do I create a global positioning system with centimeter accuracy”?
That is how we invented GPS...
And without relativity theory positioning error would be measured in kilometers.
Relativity is required to explain the time dilation, but it's not needed to notice that the GPS clocks run 40µs too fast. It wouldn't take too long for them to measure enough data to create an empirical skew-versus-altitude table, which should then be enough for them to correct the time skew, even without understanding what was going on.
I think this is a difficult counterfactual to assess, we didn’t develop clock accurate enough to notice the time dilation until 50 plus years after the theory of relativity was published.
Still, how long would it take someone to work it out empirically enough to have confidence that there wasn’t just some bug somewhere? Maybe they would mothball the GPS project for not working before figuring it out? It’s hard to know, 50 years in an alternate timeline allows for a lot of domino effect
> Still, how long would it take someone to work it out empirically enough to have confidence that there wasn’t just some bug somewhere?
They probably would just assume that it's a bug at first, since "our clock is slightly broken" is far more likely than "we've discovered some cool new physics". But I don't think that that would be an issue here, since even if they thought it was a bug, they'd still try to work around it.
> Maybe they would mothball the GPS project for not working before figuring it out?
I doubt it, since if you think about all the possible issues after sending a complex untested satellite to space, a 40μs clock discrepancy is fairly minor.
I've always wondered - if special and general relativity weren't known, could the GPS engineers have just measured the error and empirically accounted for it? I don't know relativity or GPS or engineering well enough to answer.
Yes, the clock slippage is a constant factor, entirely predictable. If made public it would probably have catalyzed the discovery of special relativity soon afterwards, but then people would’ve been super confused because its predictions still wouldn’t match the observations and indeed would widen the discrepancy rather than narrowing it!
Yeah, absolutely. You'd be surprised how much high-precision engineering absolutely relies on "this but you have to mill a tiny amount off the end because if you do the maths it comes out ever so slightly too big, and then adjust on test".
It's possible, but it seems more likely that the first tests would have shown "weird timing errors we couldnt diagnose" and then the project never got a follow up.
For something so militarily useful? When the Soviet Union was still seen as a threat to the US? When it was already so expensive anyway? I guess it's possible, but it's hard to believe they'd just give up like that.
The problem with "it's hard to believe" is that this is an area where I'm not even sure how to effectively estimate the counterposition, I've seen things that I thought were interesting get cancelled or have no follow up all the time, and it makes sense, no idea if it will matter, or even work, and even if it does, how much will it cost to realise any value?
Who knows how often really impactful tech is gated behind some non-obvious thing which we never follow up on.
I mean Douglas Engelbart basically bet his entire career behind the Mother of All Demos[0], if it had flopped, modern computing as we know it would be fundamentally different, same with Hiroo Kinoshita and Extreme Ultraviolet Lithography[1][2], we just would have had Moore's law falling off a cliff.
-[0]: [The Mother of All Demos, presented by Douglas Engelbart (1968)](https://www.youtube.com/watch?v=yJDv-zdhzMY)
-[1]: https://spie.org/news/photonics-focus/mayjune-2023/developin...
-[2]: [The Closest Thing We Have to Alien Technology by Veritasium](https://www.youtube.com/watch?v=MiUHjLxm3V0)
[dead]
A modern-time retrograde of Mercury.
Of course, the good-old-fashioned retrograde of Mercury would still be a real puzzler in that timeline, too.
[dead]
doesn't it use special relativity or some modern physics?
If only we could figure out how to get rid of the pesky ionosphere....
... at least in a way less intrusive than https://www.sciencedirect.com/science/article/pii/0021916964...
You can't imagine how that severely limits the potential size of the discovery space shackling it to present day problems?
I think the poster is distinguishing between currently practical and ever practical. Galactic algorithms can never be realized.
The constants can be made lower. If we didn't know about the galactic algorithm beforehand, we couldn't begin to do that.
And that's fine, caring about everything is exhausting, someone has to solve real world problem. But dismissing a result since it's not practical is not fine
Why not.
Not everyone needs to care about everything and there is reason to say that a result like this one from openai is quite sterile and possibly damaging to the socio-cultural dynamic of the field.
Ironic username as I doubt we'd get to the stars with your philosophy.
And I don't care about your opinion. Checkmate: two conflicting, essentially valueless, opinions.
How far are you willing to go? In your radical pragmatism, are you an intuitionist, or even a finitist? Oh wait, these are pure math topics that you do not care a about!
I think you are free not to care about what they are doing. It turns out that big O notation has some useful properties, and in particular it is a useful definition as it allows you to define complexity classes which are a very useful tool for analyzing algorithms in general.
Much of our 'practical' understanding of algorithms also in part came from theoretical advances.
The argument in the article isn’t about whether big O notation is useful it’s about whether the n in any particular big O is relevant. In this case the algorithm’s claim is that you can multiply arbitrarily large numbers faster than n log n where n is the size of the numbers being multiplied. But that result holds only if you don’t include the cost to multiple arbitrarily large complex numbers in that n, which are assumed to be able to multiply in constant time.
> In this case the algorithm’s claim is that you can multiply arbitrarily large numbers faster than n log n where n is the size of the numbers being multiplied. But that result holds only if you don’t include the cost to multiple arbitrarily large complex numbers in that n, which are assumed to be able to multiply in constant time.
Well that's certainly not the claim. Think about it, that would mean the whole thing is trivially O(1), so why would they be bothering with the rest?
You've missed part in the analysis, or I believe added an assumption they're not making (the constant-time-multiply one, specifically).
This all _is_ almost certainly impractical, but it's for the usual reason of it only being faster for numbers nobody could ever care about. It's theoretically _quite_ interesting though, because hey...what _is_ the fastest you can actually multiply numbers if it's not O(n lg n) as many ~assumed.
The complex FFT is a generalization of the n-bit integer multiplication algorithm, not the other way around. No complex-number operations are required for the integer case.
That’s sloppy reasoning. There might be notations that allow for classifying complexity classes that don’t suffer this problem.
There might not be, how is your reasoning any less “sloppy”?
your reasoning is sloppy. so confidently incorrect throughout this thread!
That may well be the case, in theory.
You're free to propose one and see if it catches on
> If algorithmic theorists don't care about practical performance then why should we care about what they're doing? It's just a strange game they're playing, of no interest to anyone else.
You don't need to care. But every so often breakthroughs in theory can be turned into breakthroughs in practice.
> It seems like rather than coming up with more "galactic" algorithms, a more useful thing to do might be to come up with a replacement for big-O that's not so exploitable, and to convince theoreticians to play that game instead.
There's plenty of replacements.
Btw, we already have the optimal (in big-O terms) algorithm for every NP hard problem. We just don't know whether it runs in polynomial time or takes longer. And, yes, that algorithm called Levin's Universal Search is a galactic algorithm. Simplifying a lot, Levin's Universal Search does some clever interleaving to essentially try all possible algorithms in sort-of parallel.
Lo and behold, even the theorists you complain about don't see that 'loophole' as a solution, declare victory and go home. They still keep researching.
If Big-O lets you run every possible algorithm in "parallel" while still being in some sense "optimal," that seems like yet another exploit?
As I read it, that was sort of their point: if the theorists were blindly focused on Big O complexity, they could 'cheat' by invoking the universal search algorithm as a good-enough solution to a huge class of problems; but they don't, because they're not mindlessly playing a game where Big O complexity is all that matters.
The reason universal search doesn't solve big O complexity is that nobody knows the big O complexity of universal search. You want to know the complexity of SAT.
"Ok, here's an optimal SAT algorithm (universal search)".
"Nice, but what is the big O complexity of universal search for SAT?".
"Nobody knows".
You're no better off than before if you wanted an answer like "exponential". On the other hand a provably sub-exponential SAT algorithm would be a huge theoretical breakthrough even if "galactic". Same for a proof that P=NP where the exponent in the P-time SAT algorithm was the 5000th busy beaver number, or whatever.
Agreed.
Also empirically, pretty much any provably polynomial algorithm we have found for anything has fairly tame exponents. That's a big part of why 'polynomial' works as a short-hand for 'tractable' that also has nice theoretical properties.
Btw, I don't know whether the tame exponents are in some sense natural, or whether they are a product of how humans find and design algorithms. Perhaps AI will change that.
Yeah I seem to remember that the earliest known algorithm (Schoof's algorithm) for counting points on an elliptic curve over a characteristic-p field was O(n^8) where n is the bit length of p. But, much more efficient algorithms are known now. I don't know of anything with a higher exponent than 8. The time hierarchy theorem says higher exponents let you solve more problems, but idk if there are natural examples of such problems.
Yes, exactly. I'm afraid I didn't make myself very clear. Thanks for explaining it better than I did.
It's not an exploit, it's a gap in our understanding of the algorithms. We know it's optimal, but we don't know the Big-O complexity.
Well, it's an 'exploit' in the sense that normally we assume that the constant factors are modest enough so that O(n) can be reliant upon to be faster than O(2^n) or even than O(n^2) in practice.
They do care. They also care about partial results. As of last week, we thought we knew the best possible algorithm. We now know that there's a galactic algorithm that's an asymptotic improvement. The question then becomes "Is there a non-galactic algoritm that does the same, or is any such algorithm necessarily galactic?"
The problem is that proving an algorithm is necessarily galactic is incredibly hard. If you knew how to do this, you would become one of the most celebrated complexity theorists of the age. Stanford would be calling.
Theory is theoretical, that's what the word theoretical means. Set theorists deal with numbers and collections that are literally infinite and nobody complains. Complexity theory is much more down-to-earth since the numbers are finite. That's about as good as it gets. If you want practical, study engineering.
> If you want that, you go to ESA, ALENEX, or VLDB/SIGMOD, or any of the other more applied venues featuring this work
Well, I want openAI to focus on these things instead, so it is not a totally unreasonable thing to advocate against their current focus
If you read the entire argument, it makes perfect sense. It’s simultaneously mocking the poorly established ways of measuring asymptotic complexity of algorithms.
TL;DR - time complexity calculations ignore constant values. So if algorithm A takes 10^10 + n number of iterations to do something, and B does n^2, in theory B is worse, because n < n^2. But in practice, you’d be waiting a very long time for the first iteration of A to even be useful.
So in other words, time complexity gives you how well an algorithm can scale beyond the first iteration. What it doesn’t tell you is if you’d have to wait until the end of the universe to even get started.
Youre just repeating the argument made in the blog without responding to the poster who said the argument is bad. Not wrong, bad. If you want to say theory is useless, do it.
>malice >shit on I don't think this is a productive or interesting way to discuss mathematics.
> I can have this view while simultaneously thinking that Ben is a badass
Yeah? Seems more like an ass.
[dead]
"Malicious" is an overstatement, but "exploit" is completely fair in my view. Theory with no possible practical relevance is useless, and I think a computational complexity result requiring arbitrary-precision arithmetic that is impossible to implement using any physical system qualifies.
Plenty of mathematics was practically useless for long periods of time, waiting for us to invent computers, cryptography, error correcting codes, etc.
It's extremely hard to know what mathematics may be useful in the future or not.
It's hard to know for certain, but that doesn't mean we should throw up our hands and say anything goes. We can still say that some things are more likely to be useful than others.
The idea that FFT's decomposition is non-optimal is surprising. What the new bound means is we basically were looking at the problem and its structure incorrectly, and therefore implicates other problems for which we have used recursion to get to our currently-best bounds. Almost no interesting math problems are just sitting there alone in their little corner. Getting a hint like that is a big deal.
Is it surprising though? If you assume constant time when it doesn't exist (in this case arbitrary precision arithmetic), it should be obvious that you will be able to devise algorithms that are faster than the commonly accepted best results.
If you can do arithmetic on arbitrarily large integers in constant time, you can sort lists in linear time.
It depends on what you're doing to the integers. You still cannot comparison-sort arbitrarily large integers in linear time.
Also, consider this: it would have been trivial to get a so-called "better bound" on FFT if such a "cheat" were what people allowed.
How can we say that without knowing the future?
The author is attacking the field of theoretical algorithm design broadly as being useless. If we take the author's logic to its conclusion, many algorithms we learn about in a standard Algorithm Design course such as "median of medians" (finding the median in a list in O(n) worst-case time) is useless because it is not used in practice. Even the original 2019 Harvey–van der Hoeven result, showing integration multiplication can be done in O(n log n), has a galactic overhead and no applications.
> theory gets so unmoored from the original question that an “open problem” becomes nothing more than an academic status puzzle...The theory of computer science has become a form of mathematics that doesn’t concern itself with computers, and it offers little reward for impact outside those mathematical pursuits
I thought it is common knowledge (and a common warning from profs to first-year CS students) that computer science has very little to do with computers. The very concept of Turing machines and decidability are mathematical in nature, far removed from how computers these days are run. The undecidability of Wang tiling, for example, is definitely a notable CS result, but it has nothing to do with computers." It is essentially a branch of mathematics. "Computer Science Is Not About Computers, Any More Than Astronomy Is About Telescopes" is a famous quote attributed to Dikstra. There is even famous MIT Open Courseware clip: https://youtu.be/2Op3QLzMgSY?t=30
I don't think that is necessarily true, the post is making a stronger point than what you describe
> Indeed, the algorithm requires you to multiply complex numbers whose magnitudes grow superpolynomially with n. If you stored these numbers as bits, the memory requirement would effectively be exponential in the input length. It assumes you can multiply such arbitrarily large complex numbers together in a single operation.
Another way to think about what the author said, imagine you had access to an oracle which could execute arbitrary precision arithmetic expressions in constant time. You could encode a wide range of computations in these and execute impossible algorithms.
Replace the complex numbers with a finite field and O(1) arithmetic stops being an unrealistic assumption, as you can actually perform the required operations in constant time on a real computer. You can't do that for infinitely-precise complex numbers, but you'll never be able to provide an infinitely-precise complex number as the input anyway. If you start with finite-precision numbers (e.g. 64-bit floats) you can do all operations in a finite-field representation (e.g. the Ozaki scheme II is an actually practical implementation of that idea for matrix multiplication https://arxiv.org/abs/2504.08009 ) and the magnitude of intermediate values is no longer a problem.
Are you certain that applies here? The length of the intermediate numbers grows superpolynomially, so you would be sure to overflow fixed width numbers. Floats are not a field.
Yes, floats are not a field, which is why you don't use floating point except to convert to and from a different representation. Overflow is expected and cancels out as long as the final result is uniquely representable. See the paper I linked, which implements 64-bit floating point matrix multiplication using 8-bit numbers with wrapping overflow modulo a set of small coprime integers. The result is reconstructed at the end using the Chinese Remainder Theorem.
This reminds me of 'O(1)' hash maps, but far more egregious.
What's wrong with `O(1)` hash maps? I'm not aware of any underhanded tricks related to, for example, cuckoo hashing.
Hash maps are only O(1) for sufficiently small n. You need O(log n) bits just to write out the hash.
It's not any faster in practice to write a byte than a word (log(n) bits)
That depends on the scale. A couple jobs ago we had enough objects that an 80-bit key wouldn't have had a low enough collision rate (better models of computation for that domain include sqrt/cube-root ideas to account for information propagation in physical space). Sometimes you have to use more constrained devices so that your max effective constant-time word size (for the same computational cost -- not to quite be confused with the CPU's "native" word size, whatever that means in your circumstances) is 8, 16 or 32 bits (or, most recently at my last job, for _reasons_, 11 bits), making even quite small tables not quite O(1).
Many compsci researchers like the word-ram model of computation to avoid a bunch of extraneous log factors and to apply exactly the intuition you're describing, so that hashtables are actually O(1). That's not a bad habit. It introduces extra log factors in other places though, so I think it's a bit of a wash, and given that it doesn't model the actual register machines we use it feels a bit intellectually dishonest to me.
actually thinking about it more I think my oracle model is more powerful than the computer used in openai's fft but maybe its a good way to think about it.
> "median of medians" (finding the median in a list in O(n) worst-case time) is useless because it is not used in practice.
This one is just not true. Here it is in 255 lines of well commented Go code: https://github.com/ncruces/sort/blob/v1.0.3/quick/quick.go
It's worse case linear, as used for sorting it beats the Go standard library on the average and worst cases, lagging a bit on the best cases.
In my experience, median-on-ninthers (which is only slightly more complicated than median-of-medians) definitely beats both heap sort and particularly heap select as a fall back for the degenerate case.
And it's not just academic: I've sped up significant stuff at work by switching from sorting to partial sorting and/or selection.
That's not median-of-medians, that's quickselect. Quickselect is useful and practical yes. Theoreticians don't like it because of the randomization (or non-worst-caseness)
> In computer science, the median of medians is an approximate median selection algorithm, frequently used to supply a good pivot for an exact selection algorithm, most commonly quickselect…
https://en.wikipedia.org/wiki/Median_of_medians
That's pretty much what I posted: median-of-ninthers is an evolution of median-of-medians, that I use to pick a better pivot whenever the pivot supplied by median-of-3 turns out to be bad.
Using it all the time would simply make quicksort/quickselect about twice as slow as it is now, but still faster than heapsort/heapselect. It's a better backstop algorithm than the common introsort/introselect.
There's also no randomisation, the implementation is completely deterministic, and depends exclusively on the input order.
And median-of-ninthers is faster, but median-of-medians is far from terrible, so calling it a galactic algorithm or completely useless in practice is far from the truth, IMO.
The irony being Dijkstra had lots of deep ideas about how programming ought to be done (from a basic science approach as informed by CS) and that the industry is still in the stone/bronze ages in terms of putting advanced ideas into practice.
Dijkstra was an academic with no skin in the game.
If Dijkstra was so confident that he was right, he should have started a business and put his money where his mouth was. Hell, any True Believer of Dijkstra's could have done the same in the last 60 years. The fact that they haven't - or they've never succeeded enough for me to know of any - speaks volumes about their effectiveness.
HN is such an experience nowadays. This has to be some form of LARP; insinuating the ineffectiveness of the inventor of the semaphore, 'not succeeded enough'.
Dijkstra's jeremiads were about promoting "formal methods" as the One True Method for software construction. Maybe there's a future for formal methods, but it wasn't ready in the past. No one was arguing about semaphores.
If not for Dijsktra you would not even exist to write the very sentence "Maybe there's a future for formal methods, but...".
What basic science does is open up new areas and new ideas. And you and I benefit from those foundations.
Dijkstra's proof methods derived from higher math sophistication than most programmers before, and today, have. Like, in one short essay he showed what invariants mean. He made formal theory accessible to mere non-pure-math mortals. You and I today know what invariants are. That's just one example.
https://en.wikipedia.org/wiki/Galactic_algorithm for those not in the know.
A lovely theory, and yet the field is called "computer science".
Also, while I am not an expert, I suspect it is frequently useful to understand how telescopes actually work when you're trying to do astronomy with them.
The history of the term is actually really interesting. There has been debate about whether or not its the correct name basically since the advent of computer science departments in the 60s.
I don't think the author is "wrong" about the gap between theoretical discussions computation and the actual design constraints of building usable computers. I don't know if that's really a general refutation of proving new things mathematically though. The word "computer" doesn't appear once in the paper OpenAI released, nor do they make any claims specifically about "computer science": https://github.com/openai/math/blob/main/preprints/An-explic...
It's a novel bit of math. Whether or not it means anything in the context of writing software realistically is an interesting conversation, but it doesn't have much bearing on the substance of the result itself. OpenAI is pretty explicit that they view these as research results in the domain of mathematics.
The field has a lot of names. Computer science is the most common, but you can also find other names such as computing, informatics, datalogy, and data processing science (or their foreign equivalents).
Within computer science, there is a clear mathematical tradition, an engineering tradition, and a social science tradition. There are also plenty of applied computer scientists who use computer science to study topics in other fields.
yes and I'd like to sue whoever named that field for false advertising. when I went to school (Precambrian era - no internet) I thought computer science would be great because I wanted to learn how to program. I dropped it after the 2nd year when I realized it was more about calculus than programming. (and I sucked at calculus. well, the teachers who were supposed to teach me about calculus sucked, but the end result was the same.)
It is a misnomer because it's not really about computers, nor is it science (although machine learning has always been much more scientific IMO). But it is about programming. It's just from first principles. It's like learning to build furniture: you first have to learn about wood. Sure, most people will just put something together from IKEA, and that might be satisfying. But they don't really know how to build furniture.
The author could have left AI entirely out of the essay and come to the same conclusions. He just really doesn't like TCS. That's fine, it's really a part of mathematics not science, but it's silly to dismiss a field with "theoretical" in its name for being impractical.
No, it is only a subset of TCS that involves galactic algorithms; plenty of theoretical results have been practical
There are other impractical aspects of TCS besides galactic algorithms, e.g. theoretically optimal data structures that are either too complex to be implemented or only achieve optimality in the limit (I guess the latter could be called "galactic data structures").
No, I don't think you (or the part of the thread I read thus far, top to bottom) are giving the most charitative interpretation of the post.
In my understanding, the article wants to raise awareness of the potential dynamics of a mathematics/theoretical computer science field governed by the imperfect rules (as they must be) of human sensemaking when the merit system (publication and community standards) are hacked by a machines for which the cost-benefit calculation is very different than for human reseachers for which the rules were invented / sedimented in the first place.
The foregoing discussion above about the emergent utility of now seemingly wasteful theoretical research is as old as any other, but equally predicated on human effort/apability ratios. And AI should invite us to rethink, because to be relevant to humans, its unwieldy results will have to be judged by humans, on their timescales and effort budgets. So we are discussing whether SPAM or HAM before we literally spend our lives as human critics of what ultimately could just be a reward hacking exercise by somebody with access to free tokens.
Yes, this is clickbait. The author does not like the definition of big-O. OpenAI is just a scapegoat.
> The author does not like the definition of big-O
Nobody really likes the definition of Big-O. It's been unmoored from actual computing performance ever since caches were invented...
N is usually small, but not always.
Did not realize that the model of computation for all of the banner computational complexity results from last week was "exact complex arithmetic." Is this and/or "exact real arithmetic" a common premise for papers in this field? My assumption as an outsider was that people mostly care about things equivalent to Turing machines.
edit: by "things equivalent to" I really mean universal register machines, something that operates on integers and not directly on real numbers.
Almost no one uses Turing machines for complexity theory.
At most you use them for stuff like P vs NP, because Turing machines are 'only' polynomially slower than register machines, so it doesn't matter.
But when you are talking about linear vs quadratic on something resembling real computers, Turing machines are the wrong model.
So what? Using something that can carry out "exact complex arithmetic" is even more wrong.
Why? It's just a model.
And exact arithmetic on Q + i*Q (complex numbers but the coordinates are rational numbers, not real numbers) is perfectly feasible.
Of course, in a real computer, long rational numbers take longer to manipulate than short rational numbers. But it's just a model. Similar to how we often assume we can handle arbitrary integers in unit time, but in reality longer integers also take longer to handle on a real computer (or we just refuse to handle them and stick to u64 only.)
> Turing machines are the wrong model.
> Why? It's just a model.
Either a model can be wrong or it is just a model. If it's the former, it matters whether Turing machines are less wrong than exact complex arithmetic machines.
This kind of this is pretty common (see, for example https://en.wikipedia.org/wiki/Blum%E2%80%93Shub%E2%80%93Smal...).
There is, of course, the very rich field of Numerical Analysis which deals with how we actually represent these things in real life, but for a starting point assuming this sort of thing is par for the course.
No, it’s unusual to use Turing machines as the model.
Turing machines are good for computability but not great for complexity.
> the algorithm requires you to multiply complex numbers whose magnitudes grow superpolynomially with n.
Err... doesn't that completely invalidate the big-O analysis!?
I suspected that these Open AI "proofs" of sub-nlogn times were cheating somehow, by sweeping something under a rug. This seems to be it!
I can't speak for the FFT claim, but least the sub-O(n log n) multiplication claim is for the multitape Turing machine model with a fixed number of tapes, which if anything is more restrictive than actual random-access memory. Of course, it's still galactic just like the O(n log n) algorithm, but it definitely seems like there's something there.
You can be linear in the bit length of the input number, but exponential in the magnitude.
This is a common thing in complexity, and I think even the abstract says it is talking about “length n” and not “magnitude n”
No, because in the model of computation they're using, you can multiply any two numbers in constant time. See https://enwp.org/Real_RAM for a similar model.
So, the pseudo-FFT exploits algorithmic similarity between DFT and multiplication to translate part of the DFT work into multiplication work, which is O(1) in the exact arithmetic model.
Thus, the magnitudes of the numbers being multiplied grow superpolynomially with n (the DFT problem size): because the robot's stuffing its work in there and using it as an oracle.
Did I get that much right? What a cool hack.
Declaring your most expensive operation to be O(1) is the oldest trick in the book for shrinking problem bounds
There is currently an effort underway to improve the bound. They have reached at a much larger kappa around 0.001635527380375392
https://github.com/CrocSwap/integer-mult-bounds
I am astounded by the activity in this repo... what is going on? 508 PRs on 408 commits..? It's getting additions at a frenetic pace by a large number of contributors.
It’s unintentionally making a mockery of OpenAIs results by highlighting Blums speedup theorem in action. Namely that you can always reduce time complexity with a small move into space complexity.
That unintentional mockery of a repo is 262million lines of such moves and growing. I don’t think for a second anyone involved has a clue about complexity theory though or they’d just jump to the obvious “O(1) time complexity using an O(2^n) lookup table to cover all possible n bits of input” which is the final end state of Blums speedup theorem.
The input is unlimited size and the algorithm is achieving a speedup with constant size code.
The above 2^n is just the extreme. There’s always baby steps to that direction. If you want you can point an agent at any known nlogn algorithm (eg. Sorting) and quickly get similar improvements in a similar way. We’re about to see an explosion of ‘complexity bound of x broken!’ as people discover what the creator of complexity theory warned us about. Namely that there’s never hard limits in complexity theory and you can always speed up any time complexity with a cost in space complexity. There never was some impassable nlogn boundary for any algorithm.
I’ve made some half hearted attempts to try and understand even the framing of some of these problems that were solved, and my god theoretical math is hard. It’s completely impenetrable with unknown symbols and hard to comprehend bounds and several orders of derivatives. It’s all unintuitive to me.
i resolved this a coder with adding math symbols to my keyboard.
When you can start doing A₁₂ ⟨M⟩₃† (complete made up nonsense) in your code or just comments without going latex etc it comes more naturally as you wont have to switch context so often.
https://krei.se/Doc/hardware/003-xkb-Keyboardflow
This is a theoretical computer science paper. This is what they are like! Post sucks.
I'm confused by some of the reactions here. Isn't this the first step toward taking theory into reality? So, FT could be faster if we could multiply larger numbers. The problem has now moved from is it possible to "do we have the hardware to do it?" Not my area, so maybe someone could explain to me why this isn't a question of how large the instruction limit is right now? Would 128bit systems change this meaningfully?
No, not in this case. The assumption of unit cost arithmetic is simply not physically realizable. It's probably easier to understand the integer case: numbers take bits to store and represent. In a typical computer, you would store numbers as either 32 or 64 bits, where 32 bits could store a number up to about 4 billion (or a signed number between -2 and +2 billion). If you want to store and multiply numbers larger than that, they take up more space and they require more work on the part of the processor, and fundamentally, more energy - adding two 128 bit numbers takes twice the work as adding two 64 bit numbers.
The same applies to the precision of floating point numbers. What Ben is arguing is happening in this case is the AI has found a way to hide work by moving it into operations that, in one (unrealistic) model of computation, are assumed to cost the same regardless of how large or precise the numbers are. Other models of computation have a more accurate model of the cost of these things, but that was not the model the AI chose to apply in this case.
Thanks for the reply!
This made me chortle:
> Did I read this paper? Of course not. No one at OpenAI read this paper either, so why should I? I did what every other mathematician in the world does with AI slop mathematics: I fed it back into the slop machine and ran an information retrieval session with a chatbot interface to extract salient facts. Anthropomorphically speaking: I asked ChatGPT what it thinks about its own output. This is how we do mathematical research now. What a world.
That should have been the gate all along. Not "You didn't write it, so why should I read it?" [0] but "You didn't even read it, so why should I?"
[0] https://news.ycombinator.com/item?id=49794330
great article, and when i read that:
"I found the rot that develops inside applied mathematical theory when formalism becomes so detached from reality that a “breakthrough” is nothing more than an artifact of mathematicians not being able to properly specify the rules of their games in natural language."
it's like in my company, where some software developers get frustrated with an LLM that writes poor code. Understanding what you want—and providing the right examples and explanations—is crucial !
> This new OpenAI result is thus less a mathematical breakthrough and more an oddity of computer scientists being bad at formalizing their design specifications.
Related, another article about proofs that may depend on bad formalizations:
https://news.ycombinator.com/item?id=49994145 - Navier-Stokes Lost in Translation (5 days ago, 237 comments)
AI seems to be very good at getting answers, but not always answers to the correct questions. These remind me of Deep Thought from The Hitchhiker's Guide to the Galaxy, where they got an answer to the ultimate question before actually knowing what the ultimate question is.
> AI seems to be very good at getting answers, but not always answers to the correct questions.
I don't think that's an accurate summary of the article you linked. The Lean proof solved the exact problem it was supposed to, it just had minor discrepancies from the writeup of the proof (on the level of saying a theorem requires m+4 derivatives when it actually requires m+5 derivatives). Obviously a problem but not really a bombshell.
> The theory of computer science has become a form of mathematics that doesn’t concern itself with computers
Perfectly summarizes the post, which I'd qualify as a rant (the author's main gripe seems to be that it's a galactic algorithm that assumes exact complex multiplication). The theory of computer science literally started with a mathematical model by Alan Turing that has nothing to do with computers (ones that we could physically build, anyway; and even if we brush aside the infinite tape, it's just architecturally completely different from any computers we've ever built for practical purposes).
If you don't like mathematics without direct applicability, you do you, but it's a legitimate mathematical undertaking and cheap way to rant against this AI drop. Do the work and show us if there's a mistake in the argument, missing attribution or whatever actual problems with the paper, but spare us your sour grapes.
I am as upset as the slew of math slop from OpenAI as the next guy, but I do not understand this article. Are they saying that this was not a true improvement because the algorithm is _galactic_? Human algorithm researchers have been publishing those sorts of results for decades now
I think it's reasonable to give the benefit of the doubt to humans, but not LLMs, that their galactic constants are not just attempts to "hack" the problem description. If LLMs are going to turn up a bunch of them, we have to develop a better version of complexity theory that accounts for them.
> “The model uses exact complex arithmetic.” That means it assumes you can store and multiply complex numbers at arbitrary precision. Indeed, the algorithm requires you to multiply complex numbers whose magnitudes grow superpolynomially with n.
This in particular is the kind of thing that I'd expect a human would at least pause on and ideally note as a severe caveat to any claimed asymptotic improvement. I don't know off the top of my head if the story is as simple as "you can tuck part of the asymptote into your presumed constant arithmetic", but it sounds kinda plausible?
A lot of people are emphatically NOT upset about the OpenAI math dump.
Agree, my neighbor isn’t upset about it. But he also doesn’t know mathematics
> Human algorithm researchers have been publishing those sorts of results for decades now
This is a superfluous remark because the article already said it. He criticizes theoretical computer science for doing it, not just OpenAI.
To be honest this reminds me of interview leetcode. Like I remember one where you could get constant time if you made nested hashtables covering character sequences that might have made sense in USCII but probably would be impossible to maintain in UTF. In general leetcode problems love goading you to treat the ASCII character space as constant time to deal with and it's stupid. And it seems very similar to this.
In my experience reading TCS papers, it is rarely made clear whether or not an algorithm is practical; generally one has to go pretty deep to figure that out
This article has basically nothing to do with the OpenAI paper; it's a critique of the entire field of computer science, rehashed to pick at one of their papers.
Wake me up when someone has understood the proof.
"…nothing to do with the OpenAI paper; it's a critique of the entire field of computer science…"
That field being exacerbated by the deluge of OpenAI papers. There is a pretty direct tie-in.
I expect though it will be the theoretical computer scientists that we'll hear the most from in the coming days/years in this new era of LLM papers.
> it's a critique of the entire field of computer science
A good one though. A theoretical computer science which researchs "algorithms" which are impossible to run on a real computer has gone astray.
An unpleasant part of the AI math revolution is that people's hatred of AI is bringing to bear their hatred of pure mathematics in general. I've always known in the back of my mind that mathematicians were secretly despised and looked down upon by many, but it's a bad feeling to see it become so mainstream.
And people's love of AI is also surfacing their dislike of pure mathematicians. Plenty of comments along the lines of "turns out mathematicians were just idiot savants solving puzzles".
I have seen no despisal just a bit of a dismissal which was always there
[dead]
I Fairly know about FFT, its an algorithm of DFT.
As the argmin suggests Writing computational complexity in Big O isn't great here.
since we generally see the interms of no.of complex additions and no.of Multiplications in the FFT algorithm.