With my limited knowledge, I read through it stumbling along, and from what I gather, this GA is not Clifford Algebra, and the argument is that the GA movement itself is misguided, and that combining operators and geometric objects without distinguishing between them is problematic.
From a programmer's perspective, it seems like they're saying it's a flawed abstraction, while the GA stance is different. I'd like to hear the other side of the argument too. I'm sure HN will get a long GA comment thread, so from their standpoint, what would it feel like? I agree that merging objects and operators is problematic, but I'm curious what the GA camp would say
Reading this article, I think there are quite a few interesting points to consider further. C started as a DSL for the Unix kernel. JavaScript is also a DSL, and successful languages are often described as DSLs in certain respects. Then, as they grow and gain broader adoption, they evolve into general purpose languages.
But if you think about it the other way around, since all programs are ultimately about data transformation, you could argue that UIs should essentially be drawn in SQL, but that would sound strange. That's because the tools we use have moved away from that mental model. (Though React's FRP premise does lean in that direction.)
And when I think about why languages split apart, it seems to me that it's because the word 'programming' covers so many different things at once. Languages end up diverging because they serve different purposes. In fact, as a programmer, I see programming languages as a collection of tools that essentially decide what to give up. C gives you safety and low-level hardware access through its ABI. Python gives you expressiveness. They exist because their target goals are fundamentally different.
In that sense, though I'm not an expert in this field, from my limited perspective this debate feels like it's just the noise that arises when Algebra tries to encompass too much and inevitably splits apart. I imagine these kinds of cases will only increase in the future. As things become more specialized, there will be more situations where existing frameworks don't fit, and new systems will be needed. Is there a term for this phenomenon? At that point, we might say we need to change the old system to fit the new one.
Personally, I wonder if there isn't a general purpose language at the bottom that models the entire world, with other languages layered on top of it.
> this GA is not Clifford Algebra
What makes you say that?
[dead]
GA is Clifford algebra plus a bunch of new terminology plus advocacy that it should replace linear algebra.
Mathematician here.
> As I see it, GA is not so much a subject as an ideological position, consisting of basically two ideological claims about the world:
> Claim 1: That the concepts of EA (so, wedge products, multivectors, duality, contraction) are incredibly powerful and ought to be used everywhere, starting at a much lower level of math pedagogy—basically rewriting classical linear algebra and vector calculus.
I support this claim, so I suppose I’m a proponent of geometric algebra.
I think it’s more or less been carried out for vector calculus by Spivak’s “classical” Calculus on Manifolds, which is somewhat widely taught.
> Claim 2: That the Geometric Product (henceforth: GP) should be added to that list as the most fundamental operation, where by “fundamental” I mean that other operations should be constructed in terms of it, and theorems should be stated using it.
Like the author, I also believe this claim is nonsense.
“Rewriting classical linear algebra” is a honored pastime but it’s very difficult to make any headway doing it—the classical texts are classical for a reason, we more or less know how to teach them as an “80% solution” and it’s unclear that the investment in a new pedagogy would get us to an “81% solution.”
Especially with today’s undergrads. If you’re not churning arithmetic, they’re not into it.
I get why it is interesting and useful to write complex numbers in '+' notation rather than the conventional way to denote a 2d vector, like a tuple of components.
The benefit is that multiplication and distributive property is a beauty in the '+' notation, no special rules need to be memorized for multiplying 2d vectors, i*i = -1 takes care of it.
On the other hand I never understood what the benefit, of writing the tuple of wedge and dot products in '+'notation, is.
Perhaps I am not being fair, that it is the same idea and I have not used it as much as I have used complex numbers.
More or less agreed. I think though that one reason the geometric product is so tempting is that if you take matrix representations of all of these objects, then the geometric product is literally just straightforward matrix multiplication.
Because of that, it just becomes so tempting to try and phrase everything you can in terms of this geometric product. I'm very sympathetic to the temptation, and I even think the geometric product has some great uses (it shows up a lot in some physics I do), and using it makes writing rotations a treat, but I think it's still vastly overemphasized by GA people.
I still don't really know what my favoured notation for differential geometry is, I find myself switching around so much.
> I still don't really know what my favoured notation for differential geometry is, I find myself switching around so much.
Yep, me too. Maybe someday the HoTT folks will get around to formalizing it and standardizing the notation. /j
Interesting. To summarize your argument: the current state of Algebra is like an 80 point solution, but to push it a few points higher requires an enormous cognitive load, and the question is whether that's really worth it, even from an educational perspective. As mentioned in another comment, this is exactly the kind of issue that comes up in Rust discussions. It seems the argument from the GA camp is that top tier mathematicians are already using these tools just fine without needing to talk about it in that way, so there's no reason for it to become general purpose. Thank you for explaining it in a way that's easy to understand. But on the other hand, maybe anomalies like these could actually become generally useful concepts. Thanks for the comment. upvoted!
As someone who studies physics and then went into a long IT career (but kept reading papers casually), my view is that this whole GA saga is very reminiscent of how after decades of experience, I still can't convince juniors of the benefits of what I now consider obvious best practices. No amount of demonstrations of the blindingly obvious improvement of some better technique seems to work on someone who "finally got the thing to work".[1]
Certain kinds of perfect correctness are like pure and shining crystallised bits of refined knowledge created by the greatest wizards. "Parse, don't validate" or "Make invalid states unrepresentable." ought to be familiar to the better programmers here, the ones with decades of experience built on iterative, collaborative foundations with real consequences for error.
Theoretical physics doesn't have those same consequences, because there is no real punishment for their equivalent of "spaghetti code". Perversely, there's cachet to be gained for gaining understanding of its unnecessarily esoteric knowledge, much like how biologists and lawyers spend half a decade or more studying... Latin.[2]
Introducing Geometric Algebra to physics is like that wizard coder who sweeps away reams of spaghetti code and replaces it all with a call to a single standard library function. It's that "cheff's kiss" of cleanup. Meanwhile the juniors are screaming about how the senior "deleted all their hard work!"
Meanwhile, I never understood where Pauli and Dirac matrices came from! It's like they were pulled from fat air.
You've seen this in code, I bet. Some junior worked really hard on solving a problem and wrote a solid screen-filling wall of "a && b || c || !d && e && (f || g)..." continuing up to "ba, bc, bd", etc.. as they ran out single letters until they're well into the alphabet in double-character symbols.[3]
That's what those matrices are. Someone's hacky attempt at "making things work".
The problem is that we gave those people Nobel prizes and told everyone they're geniuses.
They are, but they were like that brilliant junior. Brilliant.. but junior.
Geometric Algebra sweeps all of that into one beautiful, consistent, crystal clear abstraction that is widely applicable. The magic matrix constants vanish. Bugs in 100-year-old textbook formulas suddenly come to light. Dozens of formulas, one set for each of the 1D, 2D, 3D, and 4D cases collapse into a single formula valid for any number of dimensions.
It's like watching someone struggle with "catching every possible instance of JavaScript injection".
No son, no. Just no. Stop enumerating badness. Stop. Just stop. Escape everything at the boundary instead, enforced by the type system. You'll thank me later.
I know it might be obvious to you, and you always use properly parameterised SQL queries or whatever. This is not the norm everywhere! I still get arguments, long drawn out arguments from people convinced that this is unnecessary and just one more search & replace is all they need to be safe from the bad hackers.
Physicists (and mathematicians) are still making that argument against GA.
"It's isomorphic!"
"That isn't the point!"
[1] You can't convince someone to climb Everest if they struggled to hike up to the top of one of its foothills.
[2] Let me be crystal clear: They're spending their precious time on this Earth learning a dead language instead of learning about the law or bugs. No amount of arguments will sway me. The bugs don't care what you call them. Criminals are guilty or innocent whether or not you speak funny in court. You've just made a simple thing harder for no good reason, that is all. Please stop.
[3] Yes, I've seen this. Twice, from two different people whom have never met. Aliens are amongst us.
We run into these kinds of issues quite often. I also majored in physics, but unlike you, I dropped out of my master's program (I just didn't have the talent. Given my generally limited intelligence, it was probably an inevitable outcome). From what I've read, the article seems to be arguing against the claim that because so many anomalies have accumulated in the field of GA, it's now ready to become a general purpose tool. Your argument appears to be that GA has been nicely organized as a standard library, essentially defining invalid states. So it's a high level abstraction perspective, but on the other hand, I think it could also be framed as a case against excessive abstraction. Interesting
> biologists and lawyers spend half a decade or more studying... Latin.[2]
> [2] Let me be crystal clear: They're spending their precious time on this Earth learning a dead language instead of learning about the law or bugs. No amount of arguments will sway me. The bugs don't care what you call them. Criminals are guilty or innocent whether or not you speak funny in court. You've just made a simple thing harder for no good reason, that is all. Please stop.
The absurdity of this claim is enough to call into question everything else in your post.
As a programmer I’m wondering how you get a decent graphics library out of it. If it’s conceptually better, shouldn’t it make writing code to do calculations easier?
It can write some fascinating stuff, but you have to learn to think in it:
https://enkimute.github.io/ganja.js/examples/coffeeshop.html
A major problem is that its a very general theory. Most calculations turn into very large but very sparse matrix multiplications. To make them work fast requires code generation and an optimization pass.
These types of optimization problems show up all over graphics programming though:
* Representing rotations with matrices takes more space than quaternions.
* Sacrificing a dimension to projective geometry actually makes representing things like projections (duh) but also translations more efficient.
> shouldn’t it make writing code to do calculations easier?
You need an optimizing compiler that would take the high level description (in GA) and compile it to add subtract multiply divide of reals (the assembly language). I don't think we have that yet.
Till we have such a compiler it will be tempting to drop down to assembly. Assembly being a metaphor.
(This is a nitpick and does not argue against your main claim that GA is a better abstraction to represent and solve physics problems with, that I have no way to evaluate because I don't speak GA, though now I'm curious and will maybe spend an afternoon trying to figure out)
I mean, come on, lawyers and biologists don't really spend half a decade studying Latin. You can tell because smart people that spend a year or two studying Latin are conversationally fluent in it, and lawyers aren't.
They spend a month or two memorizing some latin words that could have been in English, and then (for biologists, lawyers just stop there) years memorizing lots of names of things that they'd have to memorize no matter what language they were in, and it's not really any slower in Latin than it would be in English once you spent that O(1) effort to get used to it.
Like us (systems) programmers don't spend decades studying the C language, we spend a year or two getting comfortable in C and then the rest of our careers learning all sorts of interesting ideas like generational GC that come phrased in pseudo-C but might as well have been phrased in English pseudocode with a similar cognitive load to grokking them.
That wonderful popcnt() algorithm that uses 0x33333333 and 0x55555555 constants would be just as hard to decipher if it was written in plain English.