Why quaternion is defined by [vector,w] why not by [point,w]?

Quaternions: Why [Vector, w] and Not [Point, w] for Rotations?

Explore the fundamental mathematical reasons why quaternions are defined with a vector component and a scalar 'w' for representing rotations, rather than a point. Understand the distinction between vectors and points in geometric algebra and their implications for rotational mechanics.

Quaternions are a powerful mathematical tool widely used in computer graphics, robotics, and aerospace engineering for representing 3D rotations. Unlike rotation matrices or Euler angles, quaternions offer advantages such as avoiding gimbal lock and providing a compact representation. However, a common point of confusion for newcomers is their structure: why are they defined as a combination of a 3D vector and a scalar component w, rather than a 3D point and w? This article delves into the core mathematical distinctions that necessitate this vector-scalar formulation for effective rotational representation.

The Nature of Vectors vs. Points in Geometric Transformations

To understand why quaternions use a vector, it's crucial to differentiate between points and vectors in mathematics and computer graphics. A point represents a specific location in space, often defined relative to an origin. A vector, on the other hand, represents a direction and magnitude; it describes a displacement or a force, not a location. This distinction is fundamental when considering transformations like rotation.

graph TD
    A[Geometric Entity] --> B{Has Location?}
    B -->|Yes| C[Point (e.g., (x,y,z))]
    B -->|No| D[Vector (e.g., <dx,dy,dz>)]
    D --> E[Represents: Direction, Magnitude, Displacement]
    C --> F[Represents: Position]
    E --> G{Rotation Operation}
    F -- X Cannot Directly Rotate --> G

Distinction between Points and Vectors in Geometric Context

When we rotate an object, we are essentially changing its orientation around an axis. This change in orientation is inherently described by a vector (the axis of rotation) and an angle. Points, being fixed locations, do not inherently possess a 'direction' that can be rotated in the same sense. While a point can be transformed by a rotation, the rotation itself is defined by vector-like properties.

Quaternions and Their Rotational Interpretation

A quaternion q is typically written as q = w + xi + yj + zk, where w is the scalar part and (x, y, z) forms the vector part. This vector part (x, y, z) is directly related to the axis of rotation, and w is related to the angle of rotation. Specifically, for a unit quaternion representing a rotation of angle θ around an axis (ax, ay, az) (where (ax, ay, az) is a unit vector):

w = cos(θ/2) x = ax * sin(θ/2) y = ay * sin(θ/2) z = az * sin(θ/2)

Here, (x, y, z) is clearly a scaled version of the rotation axis vector, not a point in space. This structure allows quaternions to encode both the axis and the angle of rotation efficiently.

struct Quaternion {
    float w, x, y, z;

    // Constructor for a rotation around an axis
    Quaternion(float angle, const Vector3& axis) {
        float halfAngle = angle * 0.5f;
        float s = sin(halfAngle);
        w = cos(halfAngle);
        x = axis.x * s;
        y = axis.y * s;
        z = axis.z * s;
    }

    // Example of rotating a vector
    Vector3 rotate(const Vector3& vec) const {
        Quaternion p(0, vec.x, vec.y, vec.z); // Treat vector as a 'pure' quaternion
        Quaternion q_conj = conjugate();
        Quaternion rotated_p = (*this) * p * q_conj;
        return Vector3(rotated_p.x, rotated_p.y, rotated_p.z);
    }

    // ... other quaternion operations (multiplication, conjugate, etc.)
};

// Vector3 struct (simplified)
struct Vector3 {
    float x, y, z;
    // ... constructor, operators
};

C++ structure showing quaternion construction from an axis-angle and vector rotation.

Why a Point-Based Quaternion Would Be Illogical

If a quaternion were defined as [point, w], say q = w + P_x i + P_y j + P_z k where (P_x, P_y, P_z) is a point, it would fundamentally misrepresent the nature of rotation. A point's coordinates are absolute (relative to an origin), whereas a rotation axis is relative and directional. Rotating a point directly with such a quaternion would lead to mathematical inconsistencies and would not align with the geometric interpretation of rotations.

Furthermore, the algebraic properties of quaternions (non-commutative multiplication, conjugate, inverse) are specifically designed to operate on vectors and produce rotational transformations. These properties would not hold or would lose their geometric meaning if the 'vector' part were interpreted as a point.

flowchart TD
    A[Quaternion Definition] --> B{Scalar 'w'}
    A --> C{Vector Part (x,y,z)}
    C --> D[Represents: Axis of Rotation * sin(angle/2)]
    B --> E[Represents: cos(angle/2)]
    D & E --> F[Encodes 3D Rotation]
    F --> G[Transforms Vectors (and implicitly, points relative to origin)]
    H[Hypothetical: Point Part (Px,Py,Pz)] -- X Incompatible with Rotation Algebra --> F

Conceptual Flow: Quaternion Structure and Rotational Encoding

In summary, the [vector, w] structure of quaternions is not arbitrary. It is a direct consequence of how rotations are mathematically defined and how quaternions elegantly encode the axis-angle representation. The vector component specifies the orientation of the rotation axis, while the scalar component w (along with the magnitude of the vector part) determines the angle of rotation. This design makes quaternions an incredibly efficient and robust tool for handling 3D rotations.