Also, "double" rotations, which have no analogue in 3D space. The extra degree of freedom in 4D lets you perform 2 orthogonal rotations. This means that you can rotate around in 4D space, leaving only the origin fixed. In 3D rotations always fix some axis.

Trying to think about this stuff can be mind-bending, since it's natural to try to visualize things. So to give a little intuition, consider the coordinates of a 4D vector (x,y,z,w) and notice that we can spin around in both the x-y and z-w planes at the same time without interfering with each other!

It doesn't make sense in and of itself. We usually think of division as a closed operation: we divide two things (like real numbers) and we get the same kind of thing out (another real number).

In Hamilton's original view of quaternions, he defined a "geometric quotient" of two 3d directed lines (one kind of object) as being a quaternion (another kind of object), and gave all sorts of complicated geometric formulas for how to calculate it.

In a particular sense, division and subtraction are more general than their supposedly more primitive inverse operations.

For example, we can take the "difference" of two points to get a vector, i.e. the grocery store is in that direction, while it doesn't make much sense to add two points---this location plus the grocery store? Similarly with temperature (of a given scale), today can be 5 degrees hotter than yesterday, but saying "the total temperature between yesterday and today is 57 degrees" doesn't have a clear meaning.

So, in that vein, what operation transforms one 3D vector into another?

Well a combination of rotation and scaling, of course! There is some freedom in how you want to represent this scaling+rotation operation; we could use 3x3 matrices, meaning that the quotient of 3D vectors is reasonably described by a matrix. However, 3x3 matrices have 9 degrees of freedom, which is way overkill, since we just need 4 numbers: an axis (2 params), an angle, and a scale factor. For this reason, quaternions are a particularly natural representation of 3D vector division.

The general concept of division that we're getting at here has the terrible name "g-torsor". If you're not familiar with abstract algebra, though, the definition is not very enlightening. However, John Baez has a really accessible article[0] that comes to the rescue!

Side note: notice that in general, the results of division are different objects than the things doing the division. As such, it's somewhat unfortunate that we use the same units for both in many cases, e.g. temperature and temperature differences are really different things. Talking about units quickly turns into type theory, though, so I'll stop there.

[0]:https://math.ucr.edu/home/baez/torsors.html

  > How does it make sense to divide a vector by another? Can we at least multiply two vectors as well?

Yes. That is the point of moving into the 4D complex space. This takes some higher level math, but I think it is essentially anyone can understand but just not taught in the standard coursework[0]. Here's a super quick crash course

This is all about how you abstractly define things like addition and multiplication. We'll call these actions an "operator". So you got these basic algebraic structures:

  Group: a set (some numbers) and an operator (like + or *. I'll use ∘ to be general) that has associativity ( (a∘b)∘c = a∘(b∘c) ), an identity ( a∘=a ), and an inverse ( a∘ā=0 ). There's also closure which just means we don't create something that's outside the set ( ∀ a,b ∊ S, a∘b ∊ S )
    Abelian Group: We also have commutativity ( a∘b=b∘a )

  Ring: Think of as 2 groups. So we now have 2 operators ( ∘,▪ )[1]. This time ∘ is an Abelian Group and ▪ has closure, associativity ( (a▪b)▪c = a▪(b▪c) ), and is distributive with ∘ ( a∘(b▪c) = (a∘b)▪(a∘c) )

  Field: Extend that ring so now ∘,▪ are both Abelian Groups (▪ got an identity element, an inverse, and commutativity), but we give an exception for the inverse on identity of ∘[2]

There's a lot more structures, but what we often really want is this Field thing. Our normal 1D numbers work work like that, the "every day" type of math. But think for a second, how do you do this same math in 2D? How do we make ab consistent? Well, you can't. At least not with our standard +,. So we introduce imaginary numbers. These numbers aren't imaginary so much as we're just changing the rule on +,* (∘,▪) to work differently. So we use imaginary numbers in 2D because it creates a field! You literally could do this with tuples as long as you remember the i^2 rule.

Now we extend this to 3D. Ops, we get a problem. Really no way to make ▪ () consistent here, especially around division. Bummer. We have a Ring.

But going up to 4D we can use a similar rule as to what we did in 2D and get a Field again! Now we can do consistent math. And this is actually why quaternions become useful for 3D rotation. But they can do a lot more, though come with some limitations as well.

This is super high level and just scratches the surface of all of this stuff but I hope it at least makes some sense here. Please ask questions and I'm also sure someone else will add some useful comments. But your question is completely normal and actually gets to the motivation of why kids these days are learning the difference between 3

9 and 93, despite having the same answer they do mean different things and understanding that earlier helps you when you get to abstract nonsense.

[0] It is taught later because this is when you first start getting into math as being about abstractions. You basically learn that you only ever learned one very specific kind of math and that all that breaks down. Your question is absolutely on point due to this. Like how you probably learned matrix multiplication and learned that AB ≠ BA

[1] Whatever ∘,▪ these will usually be referred to as "addition" and "multiplication" but just note that they aren't the same thing you're probably thinking of

[2] Let's return to less abstraction for a second. We have + and

for (standard) addition and multiplication, right? 0 is the identity element for + and note that 0 doesn't have an inverse for multiplication. That is: we can't do a * (0^-1) = a/0. Note here that / is a shorthand for * with an inverse operator.

Sorry, but x,y and z are not even being used in that function...

    fn exp(q: Quat) -> Quat {
        let ijk = sqrt(q.i*q.i + q.j*q.j + q.k*q.k);
        Quat {
            i: exp(q.l) * sin(ijk) * q.i / ijk,
            j: exp(q.l) * sin(ijk) * q.j / ijk,
            k: exp(q.l) * sin(ijk) * q.k / ijk,
            l: exp(q.l) * cos(ijk),
        }
    }

    fn log(q: Quat) -> Quat {
        let ijk = sqrt(q.i*q.i + q.j*q.j + q.k*q.k);
        Quat {
            i: atan2(ijk, q.l) * q.i / ijk,
            j: atan2(ijk, q.l) * q.j / ijk,
            k: atan2(ijk, q.l) * q.k / ijk,
            l: 0.5 * log(q.i*q.i + q.j*q.j + q.k*q.k + q.l*q.l),
        }
    }

Then again, that's just the AI would say...

It cannot work, because x,y,z are not used at all.

Yes, and low effort backhanded comments about "AI slop" are also getting tiresome.

I agree, this is becoming HN's new favourite way to detail a conversation unproductively. It's up there with doxxing and ad hominems in my opinion - unverifiable and usually antagonistic.

I just figured out from subcomments it's an excerpt from article, so my comment just doesn't fit here (thought author of the comment I replied to just braged they can vibe code something ad hoc and don't need to read about domain). Apologies for the mistake (still keeping my opinion about vibe coding).