scaling scientific computing with the geometric number spec

geonum

setting a metric with euclidean and squared norms creates a k^n component problem for transforming vectors

traditional geometric algebra solutions require 2^n components to represent multivectors in n dimensions

geonum reduces k^n(2^n) to 2

geonum dualizes (⋆) components inside algebra's most general form

setting the metric from the quadrature's bivector shields it from entropy with the log2(4) bit minimum:

• 1 scalar, cos(θ)
• 2 vector, sin(θ)cos(φ), sin(θ)sin(φ)
• 1 bivector, sin(θ+π/2) = cos(θ)

/// a geometric number
pub struct Geonum {
    pub length: f64, // multiply
    pub angle: f64,  // add
    pub blade: usize // count π/2 angle turns
}

use

cargo add geonum

see tests to learn how geometric numbers unify and simplify mathematical foundations including set theory, category theory and algebraic structures

benches

rank-3 tensor comparison

geonum achieves constant O(1) time complexity regardless of problem size, 270× faster than tensor operations at size 4 and 4300× faster at size 16, eliminating cubic scaling of traditional tensor implementations

extreme dimension comparison

geonum enables geometric algebra in million-dimensional spaces with constant time operations, achieving whats mathematically impossible with traditional implementations (requires more storage than atoms in the universe)

multivector ops

geonum performs all major multivector operations with exceptional efficiency in million-dimensional spaces, maintaining sub-microsecond performance for grade-specific operations that would require exponential time and memory in traditional geometric algebra implementations

features

• dot product, wedge product, geometric product
• inverse, division, normalization
• million-dimension geometric algebra with O(1) complexity
• multivector support and trivector operations
• rotations, reflections, projections, rejections
• exponential, interior product, dual operations
• meet and join, commutator product, sandwich product
• left-contraction, right-contraction
• anti-commutator product
• grade involution and clifford conjugate
• grade extraction
• section for pseudoscalar (extracting components for which a given pseudoscalar is the pseudoscalar)
• square root operation for multivectors
• undual operation (complement to the dual operation)
• regressive product (alternative method for computing the meet of subspaces)
• automatic differentiation through angle rotation (v' = [r, θ + π/2]) (differential geometric calculus)
• transforms category theory abstractions into simple angle transformations
• unifies discrete and continuous math through a common geometric framework
• provides physical geometric interpretations for abstract mathematical concepts
• automates away unnecessary mathematical formalism using length-angle representation
• enables scaling precision in statistical modeling through direct angle quantization
• supports time evolution via simple angle rotation (angle += energy * time)
• provides statistical methods for angle distributions (arithmetic/circular means, variance, expectation values)
• enables O(1) machine learning operations that would otherwise require O(n²) or O(2^n) complexity
• implements perceptron learning, regression modeling, neural networks and activation functions
• replaces tensor-based neural network operations with direct angle transformations
• enables scaling to millions of dimensions with constant-time ML computations
• eliminates the "orthogonality search" bottleneck in traditional tensor based machine learning implementations
• angle-encoded data paths for O(1) structure traversal vs O(depth) conventional methods
• optical transformations via direct angle operations (refraction, aberration, OTF)
• Manifold trait for collection operations with lens-like path transformations

tests

cargo check # compile
cargo fmt --check # format
cargo clippy # lint
cargo test --lib # unit
cargo test --test "*" # feature
cargo bench # bench
cargo llvm-cov # coverage

learn with ai

1. install rust: https://www.rust-lang.org/tools/install
2. create an api key with your preferred ai:
   1. anthropic: https://console.anthropic.com/
   2. openai: https://platform.openai.com/
3. purchase api credit
4. install a command line agent:
   1. anthropic: claude code
   2. openai: codex
5. clone the geonum repo: git clone https://github.com/mxfactorial/geonum
6. change your current working directory to geonum: cd geonum
7. start the agent from the geonum directory:
   1. anthropic: claude
   2. openai: codex
8. configure the ai agent with your api key
9. supply it this series of prompts:

   read README.md
   
   read the math-1-0.md geometric number spec
   
   read tests/numbers_test.rs
   
   read tests/multivector_test.rs
   
   read tests/machine_learning_test.rs
   
   read tests/astrophysics_test.rs
   
   read tests/em_field_theory_test.rs
   
   run 'grep "pub fn" ./src/dimensions.rs' to learn the dimensions module
   
   run 'grep "pub fn" ./src/geonum_mod.rs' to learn the geonum module
   
   run 'grep "pub fn" ./src/multivector.rs' to learn the multivector module
   
   now run 'touch tests/my_test.rs'
   
   import geonum in tests/my_test.rs with use geonum::*;
   

10. using the other test suites and library as a reference, describe the test you want the agent to implement for you
11. execute your test: cargo test --test my_test -- --show-output
12. revise and add tests
13. ask the agent to summarize your tests and how they benefit from angle-based complexity
14. ask the agent more questions:
    • what does the math in the leading readme section mean?
    • how does the geometric number spec in math-1-0.md improve computing performance?
    • what is the tests/tensor_test.rs file about?