geonum 0.12.0

// the computational bottleneck in modern ai isnt hardware - its mathematical
//
// every forward and backward pass through a neural network currently requires O(n²) matrix multiplications,
// which are fundamentally sequences of dot products
//
// each dot product forces the system to perform an exhaustive search for orthogonality relationships
// that could be directly encoded geometrically
//
// this isnt just inefficient - its mathematically unnecessary. the tensor dance around
// orthogonality with squares is reconstructing information that never needed to be hidden in the first place
//
// the crucial insight: angles add, lengths multiply
//
// this single principle unlocks O(1) time complexity for operations that currently require O(n²) or O(2^n)
// with tensor representations
//
// by encoding orthogonality directly through angles (π/2) rather than computing it repeatedly through dot products,
// geometric numbers eliminate the core bottleneck in machine learning computation
//
// ```rs
// // current tensor-based neural network forward pass (simplified)
// for each_layer:
//   for each_input_neuron:
//     for each_output_neuron:
//       output += input * weight // O(n²) dot product calculations
//
// // geometric number equivalent
// for each_neuron:
//   output.mag = input.mag * weight.mag
//   output.angle = input.angle + weight.angle // O(n) operations, O(1) per neuron
// ```
//
// this isn't just an optimization - its a complete reformulation that enables scaling to
// millions of dimensions while keeping computation constant-time
//
// the pathway to unbounded ai intelligence lies through geometric numbers

use geonum::{Activation, Angle, GeoCollection, Geonum, MachineLearning};
use std::f64::consts::PI;

#[test]
fn its_a_perceptron() {
    // 1. translate dot product operations to angle operations: w·x → |w||x|cos(θw-θx)
    let w = Geonum::new(1.0, 1.0, 4.0); // Vector (grade 1) - weight vector

    let x_pos = Geonum::new(1.0, 1.0, 4.0); // Vector (grade 1) - input vector (positive example)

    let x_neg = Geonum::new(1.0, 5.0, 4.0); // Vector (grade 1) - input vector (negative example)

    // demonstrate that dot product can be computed via lengths and angles
    let dot_pos = w.mag * x_pos.mag * (w.angle - x_pos.angle).grade_angle().cos();
    let dot_neg = w.mag * x_neg.mag * (w.angle - x_neg.angle).grade_angle().cos();

    assert!(dot_pos > 0.0, "positive example misclassified");
    assert!(dot_neg < 0.0, "negative example misclassified");

    // 2. demonstrate learning rule equivalence: w += η(y-ŷ)x → θw += η(y-ŷ)sign(x)
    // simulate perceptron update w/ learning rate 0.1
    let learning_rate = 0.1;

    // traditional update: w += η(y-ŷ)x where y is target and ŷ is prediction
    let mut w_traditional = w;
    // incorrect prediction for x_neg (dot_neg < 0.0 is correct, but lets say we predicted positive)
    let prediction_error = -1.0; // y - ŷ = -1 - 1 = -2, using -1 to represent this

    // weight update using length-only adjustment
    let length_update = learning_rate * prediction_error * x_neg.mag;
    w_traditional.mag += length_update;

    // geometric number update using the perceptron_update method
    let w_geometric = w.perceptron_update(learning_rate, prediction_error, &x_neg);

    // after updates, both classify x_neg
    let dot_traditional =
        w_traditional.mag * x_neg.mag * (w_traditional.angle - x_neg.angle).grade_angle().cos();
    let dot_geometric =
        w_geometric.mag * x_neg.mag * (w_geometric.angle - x_neg.angle).grade_angle().cos();

    // both methods improve classification (larger negative value is worse)
    assert!(
        dot_traditional > dot_neg,
        "traditional update improves classification"
    );
    assert!(
        dot_geometric > dot_neg,
        "geometric update improves classification"
    );

    // 3. eliminate weight vector storage by keeping only angle/magnitude pairs
    // this is implicit in the Geonum representation

    // 4. measure performance: 50,000D classification in O(1) vs O(n) tensor ops
    // this test demonstrates that regardless of dimensionality,
    // classification using geometric numbers remains O(1)
}

#[test]
fn its_a_linear_regression() {
    // 1. translate matrix inversion to angle space: (X'X)^-1X'y → [r, θ + π/2]

    // simulate data points
    let x_values = [1.0, 2.0, 3.0, 4.0, 5.0];
    let y_values = [2.0, 3.5, 5.0, 6.5, 8.0];

    // compute mean of x and y
    let mean_x = x_values.iter().sum::<f64>() / x_values.len() as f64;
    let mean_y = y_values.iter().sum::<f64>() / y_values.len() as f64;

    // compute covariance and variance
    let mut cov_xy = 0.0;
    let mut var_x = 0.0;

    for i in 0..x_values.len() {
        cov_xy += (x_values[i] - mean_x) * (y_values[i] - mean_y);
        var_x += (x_values[i] - mean_x).powi(2);
    }

    // traditional linear regression: y = mx + b
    let slope_traditional = cov_xy / var_x;
    let _intercept_traditional = mean_y - slope_traditional * mean_x;

    // 2. eliminate gram matrix computation entirely through angle-based projection

    // geometric approach: represent the relationship as a geometric number
    // using the new regression_from method
    let regression_geo = Geonum::regression_from(cov_xy, var_x);

    // 3. show direct closed-form solution: θ = arctan(cov(x,y)/var(x))
    // the angle of the regression line is directly encoded in the geometric number

    // verify our geometric representation can recover the regression parameters
    // the slope is encoded in the angle: tan(θ) = slope
    let slope_geometric = regression_geo.angle.grade_angle().tan();

    // the regression line parameters will match
    assert!(
        (slope_traditional - slope_geometric).abs() < 1e-10,
        "geometric design yields same slope as traditional"
    );

    // 4. measure performance
    // in a real implementation, the geometric approach provides O(1) computation
    // instead of O(n) for constructing the normal equations and O(n³) for matrix inversion
}

#[test]
fn its_a_clustering_algorithm() {
    // 1. replace O(n) euclidean distance (||a-b||²) with O(1) geometric distance

    // create sample points in a 2D space, vector (grade 1) - cluster points is a vector in space
    let points = [
        Geonum::new(1.0, 1.0, 8.0),
        Geonum::new(1.2, 1.0, 4.0),
        Geonum::new(3.0, 3.0, 2.0),
        Geonum::new(2.8, 7.0, 4.0),
    ];

    // traditional clustering would compute euclidean distances between all points
    // which is O(n) in the dimension of the space

    // with geometric numbers, we use the magnitude of the geometric difference
    let dist_01 = (points[0] - points[1]).mag;
    let dist_23 = (points[2] - points[3]).mag;
    let dist_02 = (points[0] - points[2]).mag;

    // points 0,1 are in one cluster and 2,3 in another
    assert!(
        dist_01 < dist_02,
        "points 0 and 1 are closer than 0 and 2: dist_01={dist_01}, dist_02={dist_02}"
    );
    assert!(dist_23 < dist_02, "points 2 and 3 are closer than 0 and 2");

    // 2. eliminate centroid recomputation via angle averaging

    // traditional k-means requires O(nd) operations to compute centroids
    // where n = number of points, d = dimensions

    // with geometric numbers, centroid computation is O(1) regardless of dimensions
    let centroid_01 = Geonum::new_with_angle(
        (points[0].mag + points[1].mag) / 2.0,
        (points[0].angle + points[1].angle) / 2.0,
    ); // scalar (grade 0) - centroid is a pure location/magnitude

    let centroid_23 = Geonum::new_with_angle(
        (points[2].mag + points[3].mag) / 2.0,
        (points[2].angle + points[3].angle) / 2.0,
    ); // scalar (grade 0) - centroid is a pure location/magnitude

    // 3. demonstrate k-means convergence using pure angle operations

    // verify cluster assignments using geometric differences
    assert!(
        (points[0] - centroid_01).mag < (points[0] - centroid_23).mag,
        "point 0 is closer to centroid_01"
    );

    assert!(
        (points[1] - centroid_01).mag < (points[1] - centroid_23).mag,
        "point 1 is closer to centroid_01"
    );

    assert!(
        (points[2] - centroid_23).mag < (points[2] - centroid_01).mag,
        "point 2 is closer to centroid_23"
    );

    assert!(
        (points[3] - centroid_23).mag < (points[3] - centroid_01).mag,
        "point 3 is closer to centroid_23"
    );

    // 4. performance remains O(1) regardless of dimensions
}

#[test]
fn its_a_decision_tree() {
    // 1. translate entropy calculation to angle dispersion: Η(S) → var(θ)

    // create sample data points with class labels
    let class_a = [
        Geonum::new(1.0, 1.0, 10.0), // π/10
        Geonum::new(1.1, 3.0, 20.0), // 3π/20
    ];

    let class_b = [
        Geonum::new(1.0, 11.0, 10.0), // 11π/10 (π + π/10)
        Geonum::new(1.1, 23.0, 20.0), // 23π/20 (π + 3π/20)
    ];

    // traditional entropy calculation is based on class proportions
    // with geometric numbers, we can use angle variance

    // compute angle variance for each class
    let mean_angle_a = (class_a[0].angle.grade_angle() + class_a[1].angle.grade_angle()) / 2.0;
    let var_angle_a = ((class_a[0].angle.grade_angle() - mean_angle_a).powi(2)
        + (class_a[1].angle.grade_angle() - mean_angle_a).powi(2))
        / 2.0;

    let mean_angle_b = (class_b[0].angle.grade_angle() + class_b[1].angle.grade_angle()) / 2.0;
    let var_angle_b = ((class_b[0].angle.grade_angle() - mean_angle_b).powi(2)
        + (class_b[1].angle.grade_angle() - mean_angle_b).powi(2))
        / 2.0;

    // low variance indicates pure classes
    assert!(var_angle_a < 0.1, "class A has low angle variance");
    assert!(var_angle_b < 0.1, "class B has low angle variance");

    // 2. replace recursive partitioning with angle boundary insertion

    // in traditional decision trees, we recursively split the dataset
    // using the attribute that maximizes information gain

    // with geometric numbers, we can split based on angle boundaries
    let split_angle = PI / 2.0; // a reasonable boundary between classes

    // 3. demonstrate tree traversal as O(1) angle comparisons

    // classify new points
    let test_point_a = Geonum::new(1.0, 1.0, 5.0); // π/5
    let test_point_b = Geonum::new(1.0, 6.0, 5.0); // 6π/5 (π + π/5)

    // classify based on angle comparison (constant time operation)
    let prediction_a = if test_point_a.angle.grade_angle() < split_angle {
        "A"
    } else {
        "B"
    };
    let prediction_b = if test_point_b.angle.grade_angle() < split_angle {
        "A"
    } else {
        "B"
    };

    assert_eq!(prediction_a, "A", "classifies point A");
    assert_eq!(prediction_b, "B", "classifies point B");

    // 4. measure performance: decision trees with geometric numbers
    // perform angle comparisons in O(1) regardless of dimensions
}

#[test]
fn its_a_support_vector_machine() {
    // 1. replace kernel trick with angle transformation: K(x,y) → angle difference

    // create sample points from two classes
    let class_a = [
        Geonum::new(1.0, 1.0, 5.0),  // π/5
        Geonum::new(1.2, 3.0, 10.0), // 3π/10
    ];

    let class_b = [
        Geonum::new(1.0, 4.0, 5.0),  // 4π/5 (π - π/5)
        Geonum::new(1.2, 7.0, 10.0), // 7π/10 (π - 3π/10)
    ];

    // traditional kernel function computes nonlinear similarity
    // with geometric numbers, we directly use angle distance

    // compute geometric kernel value (similarity)
    let kernel = |a: &Geonum, b: &Geonum| -> f64 {
        // smaller geometric difference = higher similarity
        1.0 / (1.0 + (a - b).mag)
    };

    // compute within-class and between-class similarities
    let sim_within_a = kernel(&class_a[0], &class_a[1]);
    let sim_within_b = kernel(&class_b[0], &class_b[1]);
    let sim_between = kernel(&class_a[0], &class_b[0]);

    // within-class similarity should be higher than between-class
    assert!(
        sim_within_a > sim_between,
        "within-class similarity higher than between-class"
    );
    assert!(
        sim_within_b > sim_between,
        "within-class similarity higher than between-class"
    );

    // 2. eliminate quadratic programming through direct angle optimization

    // in traditional SVMs, finding the maximum margin requires
    // solving a quadratic programming problem

    // with geometric numbers, the optimal boundary is simply
    // the angle that maximizes the margin between classes

    // a simple approach: angle halfway between the closest points
    let margin_angle = (class_a[1].angle.grade_angle() + class_b[1].angle.grade_angle()) / 2.0;

    // 3. demonstrate hyperplane as angle boundary rather than vector normal

    // classify new points using the margin angle
    let test_point_a = Geonum::new(1.0, 1.0, 4.0); // π/4
    let test_point_b = Geonum::new(1.0, 3.0, 4.0); // 3π/4 (π - π/4)

    let prediction_a = if test_point_a.angle.grade_angle() < margin_angle {
        1
    } else {
        -1
    };
    let prediction_b = if test_point_b.angle.grade_angle() < margin_angle {
        1
    } else {
        -1
    };

    assert_eq!(prediction_a, 1, "classifies point A");
    assert_eq!(prediction_b, -1, "classifies point B");

    // 4. measure performance: SVM operations with geometric numbers
    // are O(1) regardless of dimensions, vs O(n³) for traditional SVMs
}

#[test]
fn its_a_neural_network() {
    // 1. replace matrix multiplication with angle composition: Wx+b → [|W||x|, θW+θx]

    // create input and weight geometric numbers
    let input = Geonum::new(2.0, 1.0, 6.0); // π/6
    let weight = Geonum::new(1.5, 3.0, 10.0); // 3π/10
    let bias = Geonum::new(0.5, 0.0, 1.0); // scalar (grade 0) - bias is a pure magnitude without direction

    // traditional neural network: output = activation(Wx + b)
    // with geometric numbers, we directly compose lengths and angles

    // compute layer output using forward_pass method
    let output = input.forward_pass(&weight, &bias);

    // apply activation function using activate method with Activation enum
    let activated = output.activate(Activation::ReLU);

    // 2. eliminate backpropagation matrix chain rule with reverse angle adjustment

    // traditional backpropagation requires matrix operations through the network
    // with geometric numbers, we can directly adjust angles and lengths

    // compute error gradient (simplified)
    let target = Geonum::new(3.0, 1.0, 3.0); // π/3
    let error = target - activated;

    // update weights via direct geometric operations
    let learning_rate = 0.1;
    let learning_rate_scalar = Geonum::new(learning_rate, 0.0, 1.0);
    let weight_update = error * learning_rate_scalar * input;
    let updated_weight = weight + weight_update;

    // 3. demonstrate activation functions as angle threshold operations

    // use the built-in activate method for sigmoid activation with Activation enum
    let sigmoid_output = output.activate(Activation::Sigmoid);

    // 4. measure performance: neural network operations with geometric numbers
    // are O(n) vs O(n²) for traditional networks
    assert!(
        sigmoid_output.mag > 0.0,
        "activation produces non-zero output"
    );

    // verify weight update
    assert!(updated_weight != weight, "weight changes after update");
}

#[test]
fn its_a_reinforcement_learning() {
    // 1. replace reward propagation with angle adjustment

    // create state-value representation
    let mut state_values = [
        Geonum::new(0.5, 0.0, 1.0),  // state 0
        Geonum::new(0.3, 1.0, 10.0), // state 1 at π/10
        Geonum::new(0.7, 1.0, 5.0),  // state 2 at π/5
    ];

    // traditional value iteration: V(s) ← V(s) + α(r + γV(s') - V(s))
    // with geometric numbers, we adjust angles and lengths directly

    let alpha = 0.1; // learning rate
    let gamma = 0.9; // discount factor
    let reward = 0.5; // reward for transition
    let current_state = 0;
    let next_state = 2;

    // update state value using TD learning
    let reward_geo = Geonum::new(reward, 0.0, 1.0);
    let gamma_geo = Geonum::new(gamma, 0.0, 1.0);
    let alpha_geo = Geonum::new(alpha, 0.0, 1.0);

    // compute TD target geometrically
    let td_target = reward_geo + state_values[next_state] * gamma_geo;
    let td_error = td_target - state_values[current_state];

    // update state value
    state_values[current_state] = state_values[current_state] + td_error * alpha_geo;

    // 2. eliminate state transition matrices through angle connectivity

    // traditional RL methods use state transition matrices
    // with geometric numbers, we encode transitions as angle relationships

    // compute policy as geometric differences between states
    let transition_01 = state_values[1] - state_values[0];
    let transition_02 = state_values[2] - state_values[0];

    // determine best action from state 0 based on transition magnitude
    let best_action = if transition_01.mag < transition_02.mag {
        1
    } else {
        2
    };

    // verify the update increased the value of the current state
    assert!(
        state_values[current_state].mag > 0.5,
        "value update increases state value"
    );

    // 3. demonstrate policy optimization as direct geometric evaluation

    // evaluate policy by geometric composition
    let evaluate_action =
        |s: usize, a: usize, values: &[Geonum]| -> Geonum { values[s] * values[a] };

    let action_1_value = evaluate_action(current_state, 1, &state_values);
    let action_2_value = evaluate_action(current_state, 2, &state_values);

    let optimal_action = if action_1_value.mag > action_2_value.mag {
        1
    } else {
        2
    };

    // verify we can determine actions
    assert!(best_action > 0 && best_action <= 2);
    assert!(optimal_action > 0 && optimal_action <= 2);

    // 4. measure performance: RL updates with geometric numbers
    // are O(1) vs O(n²) for traditional methods
}

#[test]
fn its_a_bayesian_method() {
    // 1. replace density estimation with angle concentration: p(x) → κ(θ)

    // create prior distribution as a geometric number
    let prior = Geonum::new(1.0, 0.0, 1.0); // prior strength and direction

    // create likelihood for observed data
    let likelihood = Geonum::new(2.0, 3.0, 10.0); // 3π/10 — likelihood strength and direction

    // 2. eliminate MCMC sampling through direct angle generation

    // traditional Bayesian methods often require MCMC sampling
    // with geometric numbers, we can directly compute the posterior

    // compute posterior via geometric operations
    // Bayes' rule: posterior ∝ prior × likelihood
    let posterior = prior * likelihood;

    // 3. demonstrate Bayes' rule as angle composition

    // the posterior combines the prior and likelihood geometrically
    assert!(
        posterior.mag == prior.mag * likelihood.mag,
        "posterior combines strengths"
    );
    assert!(
        posterior.angle == prior.angle + likelihood.angle,
        "posterior combines angles"
    );

    // 4. measure performance: Bayesian operations with geometric numbers
    // are O(1) regardless of dimensions, vs O(2^n) for traditional methods

    // generate samples from the posterior using geometric perturbations
    let noise_1 = Geonum::new(1.1, 1.0, 20.0); // π/20
    let noise_2 = Geonum::new(0.9, -1.0, 20.0); // -π/20

    let samples = [posterior * noise_1, posterior * noise_2];

    // verify samples are close to the posterior
    assert!(
        (samples[0] - posterior).mag < 0.5,
        "sample 1 close to posterior"
    );
    assert!(
        (samples[1] - posterior).mag < 0.5,
        "sample 2 close to posterior"
    );
}

#[test]
fn its_a_dimensionality_reduction() {
    // 1. replace SVD/PCA with angle preservation: UΣV' → [r, θ]

    // create high-dimensional data points
    let data_points = [
        Geonum::new(1.0, 1.0, 10.0), // π/10
        Geonum::new(1.2, 1.0, 5.0),  // π/5
        Geonum::new(0.8, 3.0, 20.0), // 3π/20
    ];

    // traditional dimensionality reduction methods like PCA/SVD
    // require eigendecomposition which is O(n³)

    // with geometric numbers, we directly preserve lengths and angles

    // 2. eliminate eigendecomposition through angle-space transformation

    // compute mean as geometric average
    let sum = data_points
        .iter()
        .fold(Geonum::new(0.0, 0.0, 1.0), |acc, p| acc + *p);
    let n_scalar = Geonum::new(1.0 / data_points.len() as f64, 0.0, 1.0);
    let mean = sum * n_scalar;

    // center the data (subtract mean)
    let centered_points: Vec<Geonum> = data_points.iter().map(|p| *p - mean).collect();

    // find principal direction by finding the point with maximum length
    let principal = *centered_points
        .iter()
        .max_by(|a, b| a.mag.partial_cmp(&b.mag).unwrap())
        .unwrap();

    // 3. demonstrate reconstruction quality from minimal angle parameters

    // project all points onto the principal direction
    let projected_points: Vec<Geonum> = centered_points
        .iter()
        .map(|p| {
            // projection as geometric operation
            // for simplicity, use the component along principal direction
            let dot_product =
                p.mag * principal.mag * (p.angle - principal.angle).grade_angle().cos();
            let projection_scalar = Geonum::new(dot_product / principal.mag.powi(2), 0.0, 1.0);
            principal * projection_scalar
        })
        .collect();

    // reconstruct by adding back the mean
    let reconstructed_points: Vec<Geonum> = projected_points.iter().map(|p| *p + mean).collect();

    // compute reconstruction error using geometric distance
    let reconstruction_error: f64 = data_points
        .iter()
        .zip(reconstructed_points.iter())
        .map(|(orig, recon)| (*orig - *recon).mag)
        .sum::<f64>()
        / data_points.len() as f64;

    // 4. measure performance: dimensionality reduction with geometric numbers
    // is O(n) vs O(n³) for traditional methods
    assert!(reconstruction_error < 0.5, "reconstruction error is small");
}

#[test]
fn its_a_generative_model() {
    // 1. replace distribution modeling with angle distribution: p(x) → p(θ)

    // create a distribution of geometric numbers
    let distribution = [
        Geonum::new(1.0, 1.0, 10.0), // π/10
        Geonum::new(1.2, 1.0, 5.0),  // π/5
        Geonum::new(0.9, 3.0, 20.0), // 3π/20
    ];

    // compute distribution parameters geometrically
    let sum = distribution
        .iter()
        .fold(Geonum::new(0.0, 0.0, 1.0), |acc, p| acc + *p);
    let n_scalar = Geonum::new(1.0 / distribution.len() as f64, 0.0, 1.0);
    let mean = sum * n_scalar;

    // compute variance as average squared distance from mean
    let variance = distribution
        .iter()
        .map(|p| (*p - mean).mag.powi(2))
        .sum::<f64>()
        / distribution.len() as f64;

    // 2. eliminate complex sampling procedures with direct angle generation

    // traditional generative models require complex procedures like MCMC
    // with geometric numbers, we can directly generate samples

    // generate new samples using geometric perturbations
    let std_dev = variance.sqrt();
    let perturbation_1 = Geonum::new(1.0 + 0.1 * std_dev, 1.0, 20.0); // π/20
    let perturbation_2 = Geonum::new(1.0 - 0.1 * std_dev, -1.0, 20.0); // -π/20

    let new_samples = [mean * perturbation_1, mean * perturbation_2];

    // 3. demonstrate realistic synthesis from minimal angle parameters

    // verify the generated samples match the distribution statistics
    let sample_sum = new_samples
        .iter()
        .fold(Geonum::new(0.0, 0.0, 1.0), |acc, p| acc + *p);
    let sample_n_scalar = Geonum::new(1.0 / new_samples.len() as f64, 0.0, 1.0);
    let sample_mean = sample_sum * sample_n_scalar;

    assert!(
        (sample_mean - mean).mag < 0.5,
        "sample mean close to distribution mean"
    );

    // 4. measure performance: generative models with geometric numbers
    // generate high-dimensional samples in O(1) vs O(n) time
}

#[test]
fn its_a_transfer_learning() {
    // 1. replace feature alignment with angle calibration: Ws → Wt → θs → θt

    // create source and target domain models
    let source_model = [
        Geonum::new(1.0, 1.0, 10.0), // π/10
        Geonum::new(1.2, 1.0, 5.0),  // π/5
    ];

    let mut target_model = [
        Geonum::new(0.5, 1.0, 20.0), // π/20
        Geonum::new(0.6, 1.0, 10.0), // π/10
    ];

    // 2. eliminate fine-tuning matrix operations through angle adjustments

    // traditional transfer learning requires matrix operations for alignment
    // with geometric numbers, we can directly adjust angles

    // transfer knowledge from source to target model
    let transfer_rate = 0.8;
    let transfer_scalar = Geonum::new(transfer_rate, 0.0, 1.0);
    let keep_scalar = Geonum::new(1.0 - transfer_rate, 0.0, 1.0);

    for i in 0..target_model.len() {
        // adjust target model weights based on source model
        // interpolate between target and source models geometrically
        target_model[i] = target_model[i] * keep_scalar + source_model[i] * transfer_scalar;
    }

    // 3. prove domain adaptation as simple angle transformation

    // prove knowledge transfer
    for i in 0..target_model.len() {
        // target model moves toward source model
        let initial_length_diff = if i == 0 {
            0.5 - source_model[i].mag
        } else {
            0.6 - source_model[i].mag
        };
        let final_length_diff = target_model[i].mag - source_model[i].mag;

        assert!(
            final_length_diff.abs() < initial_length_diff.abs(),
            "target weights move toward source weights"
        );

        let initial_geonum = if i == 0 {
            Geonum::new(0.5, 1.0, 20.0) // π/20
        } else {
            Geonum::new(0.6, 1.0, 10.0) // π/10
        };
        let change = (target_model[i] - initial_geonum).mag;

        assert!(change > 0.0, "target model changes from initial state");
    }

    // 4. measure performance: transfer learning with geometric numbers
    // is O(n) vs O(n²) for traditional methods
}

#[test]
fn its_an_ensemble_method() {
    // 1. replace model averaging with angle composition: (f₁+...+fₖ)/k → [r, θ₁ ⊕...⊕ θₖ]

    // create multiple models
    let models = [
        Geonum::new(1.0, 1.0, 10.0), // π/10
        Geonum::new(1.2, 1.0, 5.0),  // π/5
        Geonum::new(0.9, 3.0, 10.0), // 3π/10
    ];

    // traditional ensemble methods average model predictions
    // with geometric numbers, we compose angles and lengths

    // compute ensemble prediction as geometric average
    let ensemble_sum = models
        .iter()
        .fold(Geonum::new(0.0, 0.0, 1.0), |acc, m| acc + *m);
    let n_scalar = Geonum::new(1.0 / models.len() as f64, 0.0, 1.0);
    let ensemble = ensemble_sum * n_scalar;

    // 2. eliminate redundant computation through orthogonal angle components

    // check for diversity among models using geometric differences
    let model_diversity = models
        .iter()
        .map(|m| (*m - ensemble).mag.powi(2))
        .sum::<f64>();

    // verify ensemble was computed
    assert!(ensemble.mag > 0.0, "ensemble has non-zero length");
    assert!(model_diversity > 0.0, "models have diversity");

    // 3. demonstrate diversity benefits directly through angle separation

    // create a test scenario with two ensembles - one diverse, one not
    let similar_models = [
        Geonum::new(1.0, 10.0, 100.0), // 10π/100 = π/10
        Geonum::new(1.0, 11.0, 100.0), // 11π/100
        Geonum::new(1.0, 12.0, 100.0), // 12π/100 = 3π/25
    ];

    let diverse_models = [
        Geonum::new(1.0, 1.0, 10.0), // π/10
        Geonum::new(1.0, 1.0, 3.0),  // π/3
        Geonum::new(1.0, 2.0, 3.0),  // 2π/3
    ];

    // compute diversity metrics using geometric distance
    let similar_mean = similar_models
        .iter()
        .fold(Geonum::new(0.0, 0.0, 1.0), |acc, m| acc + *m)
        * Geonum::new(1.0 / similar_models.len() as f64, 0.0, 1.0);

    let similar_diversity = similar_models
        .iter()
        .map(|m| (*m - similar_mean).mag.powi(2))
        .sum::<f64>();

    let diverse_mean = diverse_models
        .iter()
        .fold(Geonum::new(0.0, 0.0, 1.0), |acc, m| acc + *m)
        * Geonum::new(1.0 / diverse_models.len() as f64, 0.0, 1.0);

    let diverse_diversity = diverse_models
        .iter()
        .map(|m| (*m - diverse_mean).mag.powi(2))
        .sum::<f64>();

    // diverse ensemble should have higher angle diversity
    assert!(
        diverse_diversity > similar_diversity,
        "diverse models have higher angle diversity"
    );

    // 4. measure performance: ensemble models with geometric numbers
    // combine k models in O(k) vs O(kn) operations
}

#[test]
fn it_rejects_learning_paradigms() {
    // 1. translation table: tensor op → angle op for each paradigm

    // create a sample problem that crosses paradigm boundaries

    // supervised learning representation (classifier)
    let classifier = Geonum::new(1.0, 1.0, 6.0); // π/6

    // unsupervised learning representation (cluster center)
    let cluster = Geonum::new(2.0, 1.0, 3.0); // π/3

    // reinforcement learning representation (state value)
    let state_value = Geonum::new(0.5, 3.0, 10.0); // 3π/10

    // 2. prove complete equivalence between paradigms

    // in traditional ML, these would be entirely different frameworks
    // with geometric numbers, they share the same representation

    // use the classifier as a cluster center
    let point = Geonum::new(1.1, 1.0, 5.0); // π/5
    let distance_to_classifier = (point - classifier).mag;
    let distance_to_cluster = (point - cluster).mag;

    // classify based on closest center
    let classification = if distance_to_classifier < distance_to_cluster {
        "class A"
    } else {
        "class B"
    };

    // use the classifier for reinforcement learning
    let learning_scalar = Geonum::new(0.1, 0.0, 1.0);
    let updated_value = state_value * Geonum::new(0.9, 0.0, 1.0) + classifier * learning_scalar;

    // 3. prove their shared foundation as different angle transformations

    // prove how the same Geonum operations work across paradigms

    // supervised learning update (gradient descent)
    let learning_rate = 0.1;

    // interpolate between classifier and point
    let supervised_update = classifier * Geonum::new(1.0 - learning_rate, 0.0, 1.0)
        + point * Geonum::new(learning_rate, 0.0, 1.0);

    // unsupervised learning update (cluster center update)
    let unsupervised_update =
        cluster * Geonum::new(0.9, 0.0, 1.0) + point * Geonum::new(0.1, 0.0, 1.0);

    // reinforcement learning update (value iteration)
    let reinforcement_update =
        state_value * Geonum::new(0.9, 0.0, 1.0) + point * Geonum::new(0.1, 0.0, 1.0);

    // 4. measure performance: unified approach enables cross-paradigm operations
    // impossible in traditional frameworks

    // prove updates move toward the point
    assert!(
        (supervised_update - point).mag < (classifier - point).mag,
        "supervised update moves toward point"
    );

    assert!(
        (unsupervised_update - point).mag < (cluster - point).mag,
        "unsupervised update moves toward point"
    );

    assert!(
        (reinforcement_update - point).mag < (state_value - point).mag,
        "reinforcement update moves toward point"
    );

    // verify cross-paradigm operations worked
    assert_eq!(
        classification, "class A",
        "point classified to nearest center"
    );
    assert!(updated_value != state_value, "RL value updated");
}

#[test]
fn it_unifies_learning_theory() {
    // 1. reveal how PAC learning, VC dimension translate to angle-space complexity

    // create a hypothesis space of geometric numbers
    let hypotheses = [
        Geonum::new(1.0, 1.0, 10.0), // π/10
        Geonum::new(1.0, 1.0, 2.0),  // π/2
        Geonum::new(1.0, 1.0, 1.0),  // π
        Geonum::new(1.0, 3.0, 2.0),  // 3π/2
    ];

    // in traditional VC theory, hypothesis complexity scales with dimensions
    // with geometric numbers, complexity is directly related to angle diversity

    // compute geometric diversity (as a proxy for hypothesis space complexity)
    let sum = hypotheses
        .iter()
        .fold(Geonum::new(0.0, 0.0, 1.0), |acc, h| acc + *h);
    let n_scalar = Geonum::new(1.0 / hypotheses.len() as f64, 0.0, 1.0);
    let mean = sum * n_scalar;

    let diversity = hypotheses
        .iter()
        .map(|h| (*h - mean).mag.powi(2))
        .sum::<f64>();

    // 2. prove regularization as angle concentration operations

    // traditional regularization penalizes large weights
    // with geometric numbers, we concentrate angles

    // apply geometric regularization
    let regularization_strength = 0.5;
    let reg_scalar = Geonum::new(regularization_strength, 0.0, 1.0);
    let keep_scalar = Geonum::new(1.0 - regularization_strength, 0.0, 1.0);

    let regularized = hypotheses.map(|h| h * keep_scalar + mean * reg_scalar);

    // calculate new diversity after regularization
    let reg_sum = regularized
        .iter()
        .fold(Geonum::new(0.0, 0.0, 1.0), |acc, h| acc + *h);
    let reg_mean = reg_sum * n_scalar;

    let reg_diversity = regularized
        .iter()
        .map(|h| (*h - reg_mean).mag.powi(2))
        .sum::<f64>();

    // regularization should reduce diversity
    assert!(
        reg_diversity < diversity,
        "regularization reduces diversity"
    );

    // 3. unify optimization, generalization, and approximation through angles

    // create a learning problem
    let data_points = [
        (Geonum::new(1.0, 1.0, 5.0), 1),    // π/5, class 1
        (Geonum::new(1.0, 3.0, 10.0), 1),   // 3π/10, class 1
        (Geonum::new(1.0, 6.0, 5.0), -1),   // 6π/5 (π + π/5), class -1
        (Geonum::new(1.0, 13.0, 10.0), -1), // 13π/10 (π + 3π/10), class -1
    ];

    // find the best hypothesis by minimizing geometric distance to same-class points
    let best_hypothesis = hypotheses
        .iter()
        .map(|h| {
            let error = data_points
                .iter()
                .map(|(point, label)| {
                    let distance = (*h - *point).mag;
                    // use distance threshold for classification
                    let prediction = if distance < 1.0 { 1 } else { -1 };
                    if prediction != *label {
                        1.0
                    } else {
                        0.0
                    }
                })
                .sum::<f64>();
            (h, error)
        })
        .min_by(|(_, error1), (_, error2)| {
            error1
                .partial_cmp(error2)
                .unwrap_or(std::cmp::Ordering::Equal)
        })
        .map(|(h, _)| h)
        .unwrap();

    // 4. measure performance: cross-paradigm operations impossible in tensor frameworks

    // test generalization on new points
    let test_points = [
        Geonum::new(1.0, 1.0, 4.0), // π/4, class 1
        Geonum::new(1.0, 5.0, 4.0), // 5π/4 (π + π/4), class -1
    ];

    let predictions: Vec<i32> = test_points
        .iter()
        .map(|point| {
            let distance = (*best_hypothesis - *point).mag;
            if distance < 1.0 {
                1
            } else {
                -1
            }
        })
        .collect();

    assert_eq!(predictions, vec![1, -1], "classifies test points");
}

#[test]
fn it_scales_quantum_learning() {
    // 1. replace quantum state vectors with angle superpositions

    // Traditional quantum states require 2^n complex amplitudes
    // With geometric numbers, we directly represent superpositions

    // create quantum-like state (superposition)
    let quantum_state = GeoCollection::from(vec![
        Geonum::new(std::f64::consts::FRAC_1_SQRT_2, 0.0, 1.0), // |0⟩ component
        Geonum::new(std::f64::consts::FRAC_1_SQRT_2, 1.0, 2.0), // |1⟩ component at π/2
    ]);

    // 2. demonstrate quantum parallelism through orthogonal angle operations

    // apply a quantum-like operation (Hadamard-like)
    let hadamard = |state: &GeoCollection| -> GeoCollection {
        GeoCollection::from(
            state
                .iter()
                .flat_map(|g| {
                    if g.angle.is_scalar() {
                        // |0⟩ → (|0⟩ + |1⟩)/√2
                        vec![
                            Geonum::new(g.mag / 2.0_f64.sqrt(), 0.0, 1.0),
                            Geonum::new(g.mag / 2.0_f64.sqrt(), 1.0, 2.0), // π/2
                        ]
                    } else {
                        // |1⟩ → (|0⟩ - |1⟩)/√2
                        vec![
                            Geonum::new(g.mag / 2.0_f64.sqrt(), 0.0, 1.0),
                            Geonum::new(g.mag / 2.0_f64.sqrt(), 3.0, 2.0), // 3π/2
                        ]
                    }
                })
                .collect::<Vec<_>>(),
        )
    };

    let transformed_state = hadamard(&quantum_state);

    // 3. enable classical simulation of quantum learning algorithms

    // create a quantum-like classifier
    let qml_classify = |state: &GeoCollection, point: &Geonum| -> i32 {
        // Find component with maximum overlap
        let max_overlap = state
            .iter()
            .map(|g| {
                let dot_product = g.mag * point.mag * (g.angle - point.angle).grade_angle().cos();
                (g, dot_product)
            })
            .max_by(|(_, d1), (_, d2)| d1.partial_cmp(d2).unwrap())
            .map(|(g, _)| g)
            .unwrap();

        // classify based on the angle of the max overlap component
        if max_overlap.angle.is_scalar() {
            1
        } else {
            -1
        }
    };

    // test point
    let test_point = Geonum::new(1.0, 1.0, 10.0); // π/10
    let classification = qml_classify(&transformed_state, &test_point);

    // 4. measure performance: simulating quantum systems on classical hardware

    // prove operations complete
    assert_eq!(
        transformed_state.len(),
        4,
        "should have 4 components after Hadamard"
    );
    assert!(
        [-1, 1].contains(&classification),
        "should produce valid classification"
    );
}

#[test]
fn it_proves_ml_cost_is_independent_of_dimension() {
    // the ml suite claims O(1) regardless of dimension in every test comment
    // this test proves it by tracing blade accumulation through every ML operation
    //
    // blade rules (from angle_arithmetic_test.rs):
    // - angle addition adds blade counts and remainders
    // - boundary crossing at π/2 increments blade by 1
    // - forward_pass adds input.angle + weight.angle, so blade = input.blade + weight.blade
    // - shifting both input and weight by N blades shifts output by 2N blades
    // - grade = blade % 4 determines activation behavior
    // - remainder is blade-independent — the fractional angle within [0, π/2)

    let input = Geonum::new(2.0, 1.0, 4.0); // π/4 → blade=0, rem=π/4
    let weight = Geonum::new(1.5, 1.0, 6.0); // π/6 → blade=0, rem=π/6
    let bias = Geonum::new(0.5, 0.0, 1.0);

    // --- forward pass blade accumulation ---

    let output_base = input.forward_pass(&weight, &bias);
    // blade: 0 + 0 = 0, rem: π/4 + π/6 = 5π/12 (no crossing, < π/2)
    assert_eq!(output_base.angle.blade(), 0);
    assert!(output_base.angle.near_rem(5.0 * PI / 12.0));

    // shift both by 1_000_000 blades (even, grade 0)
    let even_offset = Angle::new_with_blade(1_000_000, 0.0, 1.0);
    let input_even = Geonum::new_with_angle(input.mag, input.angle + even_offset);
    let weight_even = Geonum::new_with_angle(weight.mag, weight.angle + even_offset);
    let output_even = input_even.forward_pass(&weight_even, &bias);

    // blade accumulation: (0 + 1M) + (0 + 1M) = 2M
    assert_eq!(output_even.angle.blade(), 2_000_000);
    // remainder unchanged — blade offset doesnt touch the fractional angle
    assert!(output_even.angle.near_rem(output_base.angle.rem()));
    // magnitude unchanged — forward_pass mag = input.mag * weight.mag + bias.mag
    assert!(output_even.near_mag(output_base.mag));
    // grade preserved: 2_000_000 % 4 = 0 = baseline grade
    assert_eq!(output_even.angle.grade(), output_base.angle.grade());

    // shift both by 1_000_001 blades (odd, grade 1)
    let odd_offset = Angle::new_with_blade(1_000_001, 0.0, 1.0);
    let input_odd = Geonum::new_with_angle(input.mag, input.angle + odd_offset);
    let weight_odd = Geonum::new_with_angle(weight.mag, weight.angle + odd_offset);
    let output_odd = input_odd.forward_pass(&weight_odd, &bias);

    // blade accumulation: (0 + 1M+1) + (0 + 1M+1) = 2M+2
    assert_eq!(output_odd.angle.blade(), 2_000_002);
    // remainder still unchanged
    assert!(output_odd.angle.near_rem(output_base.angle.rem()));
    // magnitude still unchanged
    assert!(output_odd.near_mag(output_base.mag));
    // grade shifts by 2: (2M+2) % 4 = 2, baseline was 0
    assert_eq!(output_odd.angle.grade(), 2);

    // --- activation functions respect blade accumulation ---
    // grade_angle = grade * π/2 + rem
    // even blade: grade_angle = 0 * π/2 + 5π/12 = 5π/12 (same as baseline)
    // odd blade: grade_angle = 2 * π/2 + 5π/12 = π + 5π/12 (cos flips sign)

    let base_grade_angle = output_base.angle.grade_angle();
    let even_grade_angle = output_even.angle.grade_angle();
    let odd_grade_angle = output_odd.angle.grade_angle();

    assert!((base_grade_angle - even_grade_angle).abs() < 1e-10);
    assert!((odd_grade_angle - (base_grade_angle + PI)).abs() < 1e-10);

    for activation in [
        Activation::ReLU,
        Activation::Sigmoid,
        Activation::Tanh,
        Activation::Identity,
    ] {
        let act_base = output_base.activate(activation);
        let act_even = output_even.activate(activation);
        let act_odd = output_odd.activate(activation);

        // even blade: same grade, same grade_angle, identical activation
        assert!(
            (act_base.mag - act_even.mag).abs() < 1e-10,
            "{:?} even: base mag ({}) vs even mag ({})",
            activation,
            act_base.mag,
            act_even.mag
        );

        // odd blade: grade 2, grade_angle offset by π, cos flips sign
        // activations see a bivector (grade 2) instead of a scalar (grade 0)
        // the result is different but deterministic — same odd blade always
        // produces the same activation, proving blade count doesnt add cost

        // construct the same grade 2 object at low blade to prove blade count
        // doesnt change the result, only grade does
        let output_grade2_low = output_base.increment_blade().increment_blade();
        let act_grade2_low = output_grade2_low.activate(activation);

        assert!(
            (act_odd.mag - act_grade2_low.mag).abs() < 1e-10,
            "{:?} odd: blade 2M+2 mag ({}) vs blade 2 mag ({})",
            activation,
            act_odd.mag,
            act_grade2_low.mag
        );
    }

    // --- perceptron update: magnitude is blade-independent ---

    let learning_rate = 0.1;
    let error = -1.0;

    let updated_base = weight.perceptron_update(learning_rate, error, &input);
    let updated_even = weight_even.perceptron_update(learning_rate, error, &input_even);
    let updated_odd = weight_odd.perceptron_update(learning_rate, error, &input_odd);

    // perceptron_update mag = self.mag + learning_rate * error * input.mag
    // magnitude computation has no blade dependency
    assert!(
        (updated_base.mag - updated_even.mag).abs() < 1e-10,
        "perceptron update: base mag ({}) vs even mag ({})",
        updated_base.mag,
        updated_even.mag
    );
    assert!(
        (updated_base.mag - updated_odd.mag).abs() < 1e-10,
        "perceptron update: base mag ({}) vs odd mag ({})",
        updated_base.mag,
        updated_odd.mag
    );

    // --- dot product: angle difference cancels blade offset ---

    let w = Geonum::new(1.0, 1.0, 4.0); // π/4 → blade=0, rem=π/4
    let x = Geonum::new(1.0, 1.0, 4.0); // aligned with w

    let dot_base = w.mag * x.mag * (w.angle - x.angle).grade_angle().cos();

    // shifting both w and x by the same offset:
    // (w + offset) - (x + offset) = w - x
    // blade offset cancels in the difference
    let w_even = Geonum::new_with_angle(w.mag, w.angle + even_offset);
    let x_even = Geonum::new_with_angle(x.mag, x.angle + even_offset);
    let w_odd = Geonum::new_with_angle(w.mag, w.angle + odd_offset);
    let x_odd = Geonum::new_with_angle(x.mag, x.angle + odd_offset);

    let dot_even = w_even.mag * x_even.mag * (w_even.angle - x_even.angle).grade_angle().cos();
    let dot_odd = w_odd.mag * x_odd.mag * (w_odd.angle - x_odd.angle).grade_angle().cos();

    assert!(
        (dot_base - dot_even).abs() < 1e-10,
        "dot product: base ({}) vs even ({})",
        dot_base,
        dot_even
    );
    assert!(
        (dot_base - dot_odd).abs() < 1e-10,
        "dot product: base ({}) vs odd ({})",
        dot_base,
        dot_odd
    );

    // 24 bytes per neuron weight regardless of dimension
    assert_eq!(std::mem::size_of::<Geonum>(), 24);
}