Geonum: Shattering Dimensional Barriers with Two-Number Geometry

For decades, scientific computing has been trapped in what geonum's creator calls "the scalar prison" - representing geometric entities as linear combinations of basis vectors, requiring exponentially growing storage (2ⁿ components for n-dimensional geometric algebra) and O(n³) operations. This paradigm collapses beyond trivial dimensions, making 30D calculations practically impossible and 1000D computations theoretically infeasible.

Geonum shatters these constraints through a radical insight: All geometric information can be encoded in just two values - a length and an angle with rotational dimension tracking. The Rust implementation embodies this as:

struct Geonum {
    length: f64,      // Multiplicative magnitude
    angle: Angle {    // Additive orientation
        blade: usize,     // Counts π/2 rotations (dimensionality)
        value: f64        // Current [0, π/2) angle
    }
}

How Geometric Numbers Redefine Dimensions

Traditional coordinates force numbers into predefined axes, while geonum treats dimensions as rotational states. Each +π/2 blade rotation creates a new orthogonal direction without coordinate scaffolding:

This architecture enables astonishing performance breakthroughs. Tensor operations that scale cubically (O(n³)) become constant-time (O(1)):

Operation Benchmarks

Calculus as Rotation

Geonum's most elegant breakthrough comes from its treatment of calculus. Differentiation becomes a simple π/2 rotation:

f  = [4, 0]      # Original function (blade 0)
f' = [4, π/2]    # First derivative (blade 1)
f''= [4, π]      # Second derivative (blade 2)
f'''=[4, 3π/2]   # Third derivative (blade 3)
f''''=[4, 2π]=[4,0] # Full cycle

This geometric interpretation generates polynomial coefficients through trigonometric identities like sin(θ+π/2) = cos(θ), eliminating symbolic manipulation.

Million-Dimensional Algebra

Traditional geometric algebra becomes impossible beyond 30 dimensions (requiring 2³⁰ = 1 billion components). Geonum handles any dimension with two values:

// Million-dimensional projection in constant time
let p_huge = vector.project(Angle::new(1_000_001.0, 2.0));

Key features enabling this:
1. Blade arithmetic replaces pseudoscalars with grade cycling (k → (k+2)%4)
2. Dimension-free projection without basis vectors
3. Automatic calculus via rotational differentiation
4. Geometric product unification avoiding component explosion

Practical Impact

Geonum's implications span multiple domains:
- Machine Learning: O(1) Jacobians enable real-time 1000D gradient updates
- Physics Simulation: Million-dimensional quantum states become tractable
- Computer Graphics: Conformal transformations without homogeneous coordinates
- Robotics: Constant-time kinematics for hyperdimensional manipulators

// Example: Projection without coordinate systems
let origin = Angle::new(0.0, 1.0);
let end = Geonum::new(7.0, origin + Angle::new(1.0, 6.0));
let px = end.length * end.angle.project(Angle::x_axis());

The Geometric Future

By reducing nᵏ(2ⁿ) complexity to O(1), geonum liberates mathematical objects from their scalar shackles. As computational demands grow into higher dimensions, this geometric primitive offers an escape from exponential tyranny - transforming how we compute everything from financial models to quantum systems.

Source: mxfactorial/geonum