noether 0.3.0

use noether::{
    AssociativeAddition, CommutativeAddition, Field, FreeModule, InnerProductSpace, Module,
    VectorSpace,
};
use num_traits::{One, Zero};
use std::fmt::{Debug, Display};
use std::marker::PhantomData;
use std::ops::{Add, AddAssign, Div, Mul, MulAssign, Neg, Sub, SubAssign};

/// A generic vector implementation that works over any field.
///
/// This allows us to build vector spaces over any mathematical field,
/// not just the typical ones like real numbers (f64) or complex numbers.
#[derive(Debug, Clone, PartialEq)]
struct Vector<F: Field + Clone> {
    elements: Vec<F>,
}

impl<F: Field + Clone> Vector<F> {
    /// Creates a new vector from a slice of elements
    fn new(elements: &[F]) -> Self {
        Self {
            elements: elements.to_vec(),
        }
    }

    /// Gets the dimension of the vector
    fn dim(&self) -> usize {
        self.elements.len()
    }
}

// Additional methods for vectors over fields
impl<F: Field + Clone> Vector<F> {
    /// Creates a standard basis vector e_i in the given dimension
    fn basis_vector(dimension: usize, index: usize) -> Self
    where
        F: One,
    {
        assert!(index < dimension, "Index must be less than dimension");

        let mut elements = vec![F::zero(); dimension];
        elements[index] = F::one();
        Self { elements }
    }

    /// Creates a set of standard basis vectors for an n-dimensional space
    fn standard_basis(dimension: usize) -> Vec<Self>
    where
        F: One,
    {
        (0..dimension)
            .map(|i| Self::basis_vector(dimension, i))
            .collect()
    }

    /// Computes the dot product with another vector
    fn dot(&self, other: &Self) -> F {
        assert_eq!(
            self.dim(),
            other.dim(),
            "Vectors must have the same dimension for dot product"
        );

        let mut result = F::zero();
        for i in 0..self.dim() {
            result = result.clone() + (self.elements[i].clone() * other.elements[i].clone());
        }

        result
    }

    /// Scales the vector by a scalar
    fn scale(&self, scalar: F) -> Self {
        let mut result = Vec::with_capacity(self.dim());
        for i in 0..self.dim() {
            result.push(self.elements[i].clone() * scalar.clone());
        }

        Self { elements: result }
    }

    /// Returns the ith component of the vector
    fn get(&self, i: usize) -> F {
        assert!(i < self.dim(), "Index out of bounds");
        self.elements[i].clone()
    }

    /// Creates a linear combination of vectors
    fn linear_combination<I>(vectors_and_scalars: I) -> Self
    where
        I: IntoIterator<Item = (Self, F)>,
    {
        let mut result: Option<Self> = None;

        for (vector, scalar) in vectors_and_scalars {
            let scaled = vector.scale(scalar);

            if let Some(r) = &mut result {
                *r = r.clone() + scaled;
            } else {
                result = Some(scaled);
            }
        }

        result.unwrap_or_else(|| Self::new(&[]))
    }

    /// Checks if this vector is a linear combination of the given vectors
    fn is_in_span(&self, vectors: &[Self]) -> bool
    where
        F: PartialEq + Div<Output = F>,
    {
        if vectors.is_empty() {
            return self.is_zero();
        }

        // This is a simple implementation - in practice, you would use
        // Gaussian elimination to solve the system of linear equations

        // Build augmented matrix for the system of equations
        let dimension = vectors[0].dim();
        assert!(
            vectors.iter().all(|v| v.dim() == dimension),
            "All vectors must have the same dimension"
        );

        // Very simplified approach - only works for vectors of dimension 1 or 2
        if dimension == 1 {
            // In 1D case, check if any non-zero vector exists
            for vector in vectors {
                if !vector.is_zero() {
                    // If we have any non-zero vector, we can represent any 1D vector
                    return true;
                }
            }
            // If all vectors are zero, we can only represent zero
            return self.is_zero();
        } else if dimension == 2 {
            // In 2D, check if we have linearly independent vectors
            if vectors.len() >= 2 {
                let v1 = &vectors[0];
                let v2 = &vectors[1];

                // Check if v1 and v2 are linearly independent
                let determinant =
                    v1.get(0).clone() * v2.get(1).clone() - v1.get(1).clone() * v2.get(0).clone();
                if determinant != F::zero() {
                    // Two linearly independent vectors span R²
                    return true;
                }
            }

            // Check if self is parallel to any of the vectors
            for vector in vectors {
                if !vector.is_zero() {
                    // Check if self is a multiple of vector
                    let ratio = if vector.get(0) != F::zero() {
                        self.get(0).clone() / vector.get(0).clone()
                    } else if vector.get(1) != F::zero() {
                        self.get(1).clone() / vector.get(1).clone()
                    } else {
                        continue;
                    };

                    // Check if self = ratio * vector
                    if (self.get(0) == ratio.clone() * vector.get(0).clone())
                        && (self.get(1) == ratio * vector.get(1).clone())
                    {
                        return true;
                    }
                }
            }

            return self.is_zero();
        }

        // For higher dimensions, this would require a more sophisticated approach
        // (e.g., Gaussian elimination or computing the rank of the matrix)
        false
    }
}

// Implement the required operations for algebraic structures

impl<F: Field + Clone> Add for Vector<F> {
    type Output = Self;

    fn add(self, rhs: Self) -> Self::Output {
        assert_eq!(
            self.dim(),
            rhs.dim(),
            "Vectors must have the same dimension"
        );

        let mut result = Vec::with_capacity(self.dim());
        for i in 0..self.dim() {
            result.push(self.elements[i].clone() + rhs.elements[i].clone());
        }

        Self { elements: result }
    }
}

impl<F: Field + Clone> AddAssign for Vector<F> {
    fn add_assign(&mut self, rhs: Self) {
        assert_eq!(
            self.dim(),
            rhs.dim(),
            "Vectors must have the same dimension"
        );

        for i in 0..self.dim() {
            self.elements[i] = self.elements[i].clone() + rhs.elements[i].clone();
        }
    }
}

impl<F: Field + Clone> Sub for Vector<F> {
    type Output = Self;

    fn sub(self, rhs: Self) -> Self::Output {
        assert_eq!(
            self.dim(),
            rhs.dim(),
            "Vectors must have the same dimension"
        );

        let mut result = Vec::with_capacity(self.dim());
        for i in 0..self.dim() {
            result.push(self.elements[i].clone() - rhs.elements[i].clone());
        }

        Self { elements: result }
    }
}

impl<F: Field + Clone> SubAssign for Vector<F> {
    fn sub_assign(&mut self, rhs: Self) {
        assert_eq!(
            self.dim(),
            rhs.dim(),
            "Vectors must have the same dimension"
        );

        for i in 0..self.dim() {
            self.elements[i] = self.elements[i].clone() - rhs.elements[i].clone();
        }
    }
}

impl<F: Field + Clone> Neg for Vector<F> {
    type Output = Self;

    fn neg(self) -> Self::Output {
        let mut result = Vec::with_capacity(self.dim());
        for i in 0..self.dim() {
            result.push(-self.elements[i].clone());
        }

        Self { elements: result }
    }
}

impl<F: Field + Clone> Mul<F> for Vector<F> {
    type Output = Self;

    fn mul(self, scalar: F) -> Self::Output {
        self.scale(scalar)
    }
}

impl<F: Field + Clone> MulAssign<F> for Vector<F> {
    fn mul_assign(&mut self, scalar: F) {
        for i in 0..self.dim() {
            self.elements[i] = self.elements[i].clone() * scalar.clone();
        }
    }
}

// Implement Zero trait (additive identity)
impl<F: Field + Clone> Zero for Vector<F> {
    fn zero() -> Self {
        Self { elements: vec![] }
    }

    fn is_zero(&self) -> bool {
        self.elements.iter().all(|e| e.is_zero())
    }
}

// Implement Noether's marker traits for algebraic properties
impl<F: Field + Clone> CommutativeAddition for Vector<F> {}
impl<F: Field + Clone> AssociativeAddition for Vector<F> {}

// Implement Module trait for scalar fields
impl<F: Field + Clone + 'static> Module<F> for Vector<F> {
    fn scale(&self, r: &F) -> Self {
        let mut result = Vec::with_capacity(self.dim());
        for i in 0..self.dim() {
            result.push(self.elements[i].clone() * r.clone());
        }
        Self { elements: result }
    }

    fn zero() -> Self {
        // For a default zero vector, we use an empty vector
        // In practice, we'd often use zero_like() with a specific dimension
        Self { elements: vec![] }
    }

    fn is_free() -> bool {
        true // Our vectors always have a basis
    }
}

// Implement FreeModule trait for scalar fields
impl<F: Field + Clone + 'static> FreeModule<F> for Vector<F> {
    fn rank() -> usize {
        // In general, this should be the dimension of the specific vector space
        // We'll use a default that would be overridden in specific implementations
        3
    }

    fn basis_element(index: usize) -> Self {
        let dim = Self::rank();
        assert!(index < dim, "Index must be less than rank");

        let mut elements = vec![F::zero(); dim];
        elements[index] = F::one();
        Self { elements }
    }

    fn coordinates(&self) -> Vec<F> {
        // Since our standard basis is the canonical basis, coordinates
        // are just the elements themselves
        self.elements.clone()
    }
}

// Implement VectorSpace trait for scalar fields
impl<F: Field + Clone + 'static> VectorSpace<F> for Vector<F> {
    fn dimension() -> usize {
        // This would be overridden by concrete types with specific dimensions
        Self::rank()
    }

    fn shape(&self) -> Vec<usize> {
        // For a simple vector, the shape is [n] where n is the dimension
        vec![self.dim()]
    }

    fn scale(&self, scalar: &F) -> Self {
        // Reuse our existing scale implementation
        let mut result = Vec::with_capacity(self.dim());
        for i in 0..self.dim() {
            result.push(self.elements[i].clone() * scalar.clone());
        }
        Self { elements: result }
    }

    fn zero_like(&self) -> Self {
        // Create a zero vector with the same dimension
        Self {
            elements: vec![F::zero(); self.dim()],
        }
    }

    fn ones_like(&self) -> Self {
        // Create a vector of ones with the same dimension
        Self {
            elements: vec![F::one(); self.dim()],
        }
    }

    fn basis() -> Vec<Self> {
        // Return the standard basis
        (0..Self::dimension())
            .map(|i| Self::basis_element(i))
            .collect()
    }
}

// Implement InnerProductSpace for Vector with the standard inner product
impl<F: Field + Clone + PartialOrd + 'static> InnerProductSpace<F> for Vector<F> {
    fn inner_product(&self, other: &Self) -> F {
        self.dot(other)
    }

    fn norm(&self) -> F {
        // For real fields, we should take the square root
        // For simplicity, we'll just return the squared norm
        self.dot(self)
    }

    fn normalize(&self) -> Self {
        let norm = self.norm();
        if norm == F::zero() {
            self.clone()
        } else {
            let scale = F::one() / norm;
            self.clone() * scale
        }
    }

    fn distance(&self, other: &Self) -> F {
        let diff = self.clone() - other.clone();
        diff.norm()
    }

    fn is_orthogonal(&self, other: &Self) -> bool {
        self.dot(other) == F::zero()
    }
}

// Display implementation for nicer output
impl<F: Field + Clone + Display> Display for Vector<F> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "[")?;
        for (i, e) in self.elements.iter().enumerate() {
            if i > 0 {
                write!(f, ", ")?;
            }
            write!(f, "{}", e)?;
        }
        write!(f, "]")
    }
}

/// A vector space with a fixed dimension over a field F
#[derive(Debug)]
struct FixedDimensionVectorSpace<const N: usize, F>
where
    F: Field + Clone,
{
    _phantom: PhantomData<F>,
}

impl<const N: usize, F> FixedDimensionVectorSpace<N, F>
where
    F: Field + Clone + 'static,
{
    /// Create a vector within this space
    fn vector(elements: &[F]) -> Vector<F> {
        assert_eq!(elements.len(), N, "Vector must have exactly {} elements", N);
        Vector::new(elements)
    }

    /// Get the standard basis vectors
    fn basis() -> Vec<Vector<F>> {
        Vector::<F>::standard_basis(N)
    }
}

/// A fixed-size matrix with a specified number of rows and columns over a field F
#[derive(Debug, Clone, PartialEq)]
struct Matrix<F>
where
    F: Field + Clone,
{
    elements: Vec<F>,
    rows: usize,
    cols: usize,
}

impl<F> Matrix<F>
where
    F: Field + Clone,
{
    /// Creates a new matrix from a 2D array of elements
    fn new(elements: &[&[F]]) -> Self {
        let rows = elements.len();
        let cols = if rows > 0 { elements[0].len() } else { 0 };

        // Verify all rows have the same length
        assert!(
            elements.iter().all(|row| row.len() == cols),
            "All rows must have the same number of columns"
        );

        let mut flat_elements = Vec::with_capacity(rows * cols);
        for row in elements {
            for element in *row {
                flat_elements.push(element.clone());
            }
        }

        Self {
            elements: flat_elements,
            rows,
            cols,
        }
    }

    /// Creates an identity matrix of the specified size
    fn identity(size: usize) -> Self {
        let mut elements = vec![F::zero(); size * size];
        for i in 0..size {
            elements[i * size + i] = F::one();
        }

        Self {
            elements,
            rows: size,
            cols: size,
        }
    }

    /// Creates a zero matrix of the specified size
    fn zero(rows: usize, cols: usize) -> Self {
        Self {
            elements: vec![F::zero(); rows * cols],
            rows,
            cols,
        }
    }

    /// Gets an element at the specified position
    fn get(&self, row: usize, col: usize) -> F {
        assert!(row < self.rows && col < self.cols, "Index out of bounds");
        self.elements[row * self.cols + col].clone()
    }

    /// Sets an element at the specified position
    fn set(&mut self, row: usize, col: usize, value: F) {
        assert!(row < self.rows && col < self.cols, "Index out of bounds");
        self.elements[row * self.cols + col] = value;
    }

    /// Multiplies this matrix by a vector
    fn multiply_vector(&self, v: &Vector<F>) -> Vector<F> {
        assert_eq!(
            self.cols,
            v.dim(),
            "Matrix columns must match vector dimension"
        );

        let mut result = vec![F::zero(); self.rows];
        for (i, res) in result.iter_mut().enumerate().take(self.rows) {
            for j in 0..self.cols {
                *res = res.clone() + self.get(i, j).clone() * v.get(j);
            }
        }

        Vector { elements: result }
    }

    /// Multiplies this matrix by another matrix
    fn multiply(&self, other: &Self) -> Self {
        assert_eq!(
            self.cols, other.rows,
            "Inner dimensions must match for matrix multiplication"
        );

        let mut result = Self::zero(self.rows, other.cols);
        for i in 0..self.rows {
            for j in 0..other.cols {
                let mut sum = F::zero();
                for k in 0..self.cols {
                    sum += self.get(i, k).clone() * other.get(k, j).clone();
                }
                result.set(i, j, sum);
            }
        }

        result
    }

    /// Returns the transpose of this matrix
    fn transpose(&self) -> Self {
        let mut result = Self::zero(self.cols, self.rows);
        for i in 0..self.rows {
            for j in 0..self.cols {
                result.set(j, i, self.get(i, j));
            }
        }

        result
    }

    /// Checks if this matrix is symmetric
    fn is_symmetric(&self) -> bool {
        if self.rows != self.cols {
            return false;
        }

        for i in 0..self.rows {
            for j in (i + 1)..self.cols {
                if self.get(i, j) != self.get(j, i) {
                    return false;
                }
            }
        }

        true
    }
}

impl<F: Field + Clone + Display> Display for Matrix<F> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        for i in 0..self.rows {
            write!(f, "[")?;
            for j in 0..self.cols {
                if j > 0 {
                    write!(f, ", ")?;
                }
                write!(f, "{}", self.get(i, j))?;
            }
            writeln!(f, "]")?;
        }
        Ok(())
    }
}

/// A simple demonstration of Vector operations and properties
/// that would typically be defined by a VectorSpace in abstract algebra.
fn demonstrate_vector_space<F>(v1: &Vector<F>, v2: &Vector<F>, scalar: F, other_scalar: F)
where
    F: Field + Clone + Display + PartialOrd + 'static,
{
    println!("Vector 1: {}", v1);
    println!("Vector 2: {}", v2);

    // Vector addition
    let v3 = v1.clone() + v2.clone();
    println!("Vector addition: v1 + v2 = {}", v3);

    // Vector subtraction
    let v4 = v1.clone() - v2.clone();
    println!("Vector subtraction: v1 - v2 = {}", v4);

    // Additive inverse
    let neg_v1 = -v1.clone();
    println!("Additive inverse: -v1 = {}", neg_v1);

    // Scalar multiplication
    let scaled_v1 = v1.scale(scalar.clone());
    println!("Scalar multiplication: {} * v1 = {}", scalar, scaled_v1);

    // Distributivity of scalar multiplication over vector addition
    // (a + b)v = av + bv
    let sum_scalar = scalar.clone() + other_scalar.clone();
    let left_side = v1.scale(sum_scalar.clone());
    let right_side = v1.scale(scalar.clone()) + v1.scale(other_scalar.clone());
    println!("Distributivity 1: (a + b)v = av + bv:");
    println!(
        "  Left side: ({} + {}) * v1 = {}",
        scalar, other_scalar, left_side
    );
    println!(
        "  Right side: {} * v1 + {} * v1 = {}",
        scalar, other_scalar, right_side
    );
    println!("  Equality: {}", left_side == right_side);

    // Distributivity of scalar multiplication over scalar addition
    // a(v + w) = av + aw
    let sum_vector = v1.clone() + v2.clone();
    let left_side = sum_vector.scale(scalar.clone());
    let right_side = v1.scale(scalar.clone()) + v2.scale(scalar.clone());
    println!("Distributivity 2: a(v + w) = av + aw:");
    println!("  Left side: {} * (v1 + v2) = {}", scalar, left_side);
    println!(
        "  Right side: {} * v1 + {} * v2 = {}",
        scalar, scalar, right_side
    );
    println!("  Equality: {}", left_side == right_side);

    // Scalar product properties
    // a(bv) = (ab)v
    let product_scalar = scalar.clone() * other_scalar.clone();
    let left_side = v1.scale(other_scalar.clone()).scale(scalar.clone());
    let right_side = v1.scale(product_scalar.clone());
    println!("Scalar product: a(bv) = (ab)v:");
    println!(
        "  Left side: {} * ({} * v1) = {}",
        scalar, other_scalar, left_side
    );
    println!(
        "  Right side: ({} * {}) * v1 = {}",
        scalar, other_scalar, right_side
    );
    println!("  Equality: {}", left_side == right_side);

    // Identity scalar
    // 1v = v
    let id_scaled = v1.scale(F::one());
    println!("Identity scalar: 1 * v1 = {}", id_scaled);
    println!("  Equality: {}", id_scaled == *v1);

    // Inner product
    let dot_product = v1.dot(v2);
    println!("Inner product: v1 · v2 = {}", dot_product);

    // Inner product properties
    println!("\nInner Product Space Properties:");
    println!("Norm of v1: ||v1|| = {}", v1.norm());

    // Orthogonality
    println!("Are v1 and v2 orthogonal? {}", v1.is_orthogonal(v2));

    // Linear combinations and span
    println!("\nLinear Combinations and Span:");
    let basis_vectors = Vector::<F>::standard_basis(v1.dim());
    println!("Standard basis vectors:");
    for (i, basis) in basis_vectors.iter().enumerate() {
        println!("  e_{} = {}", i + 1, basis);
    }

    let linear_combo = Vector::linear_combination(vec![
        (v1.clone(), scalar.clone()),
        (v2.clone(), other_scalar.clone()),
    ]);
    println!(
        "Linear combination {}*v1 + {}*v2 = {}",
        scalar, other_scalar, linear_combo
    );

    // Test linear independence
    let test_vector = v1.clone() + v2.clone();
    println!(
        "Is {} in the span of {} and {}? {}",
        test_vector,
        v1,
        v2,
        test_vector.is_in_span(&[v1.clone(), v2.clone()])
    );

    // Convert to different basis
    if v1.dim() == 2 {
        println!("\nMatrix Transformations:");
        // Define a transformation matrix
        let rotation_matrix = Matrix::new(&[&[F::zero(), -F::one()], &[F::one(), F::zero()]]);
        println!("Rotation matrix (90 degrees):");
        println!("{}", rotation_matrix);

        // Apply the transformation
        let transformed_v1 = rotation_matrix.multiply_vector(v1);
        println!("Transformed v1 = {}", transformed_v1);
    }
}

/// Demonstrates working with fields that aren't built-in numeric types
fn demonstrate_specialized_field() {
    // This would be a placeholder for demonstrating more exotic fields:
    // - Finite fields (GF(p) or GF(p^n))
    // - Function fields
    // - Algebraic number fields
    // - etc.
    println!("\n=== Specialized Field Operations ===");
    println!("In a full implementation, we could demonstrate vector spaces over:");
    println!("1. Finite fields (e.g., GF(5) or GF(2^8))");
    println!("2. Rational function fields");
    println!("3. Algebraic extensions (e.g., Q(√2))");
    println!("4. Complex number fields");
    println!("For example, using our finite_field.rs example's Fp<P> type");
    println!("to create vector spaces over GF(p).");
}

fn main() {
    println!("=== Vector Space with f64 Scalars ===");
    let v1 = Vector::new(&[1.0, 2.0, 3.0]);
    let v2 = Vector::new(&[4.0, 5.0, 6.0]);
    demonstrate_vector_space(&v1, &v2, 2.0, 3.0);

    println!("\n=== Vector Space with Fixed Dimension (R²) ===");
    let u1 = FixedDimensionVectorSpace::<2, f64>::vector(&[1.0, 0.0]);
    let u2 = FixedDimensionVectorSpace::<2, f64>::vector(&[0.0, 1.0]);

    println!("Working in 2D vector space R²");
    println!("Basis vectors:");
    for (i, basis) in FixedDimensionVectorSpace::<2, f64>::basis()
        .iter()
        .enumerate()
    {
        println!("  e_{} = {}", i + 1, basis);
    }

    demonstrate_vector_space(&u1, &u2, 2.0, 3.0);

    // Demonstrate a matrix space example
    println!("\n=== Matrix Operations ===");
    let a = Matrix::<f64>::new(&[&[1.0, 2.0], &[3.0, 4.0]]);
    let b = Matrix::<f64>::new(&[&[0.0, 1.0], &[1.0, 0.0]]);

    println!("Matrix A:");
    println!("{}", a);
    println!("Matrix B:");
    println!("{}", b);

    println!("A * B:");
    println!("{}", a.multiply(&b));

    println!("Transpose of A:");
    println!("{}", a.transpose());

    println!("Is B symmetric? {}", b.is_symmetric());

    let id = Matrix::<f64>::identity(2);
    println!("Identity matrix:");
    println!("{}", id);

    // Show applications of vector spaces
    demonstrate_specialized_field();

    // Note on the relationship to noether's algebraic traits:
    println!("\n=== Vector Spaces in Abstract Algebra ===");
    println!("In the noether library, vector spaces have the following structure:");
    println!("- A vector space is a module over a field");
    println!("- A module is an additive abelian group with scalar multiplication from a ring");
    println!("- A free module has a basis of linearly independent elements");
    println!(
        "- Fields are commutative rings where every non-zero element has a multiplicative inverse"
    );
    println!("- Inner product spaces add the concept of angles and orthogonality");

    println!("\nApplications of vector spaces include:");
    println!("1. Linear algebra and computational mathematics");
    println!("2. Quantum mechanics and quantum computing (Hilbert spaces)");
    println!("3. Signal processing and Fourier analysis");
    println!("4. Machine learning and data analysis");
    println!("5. Computer graphics (transformations, projections)");
    println!("6. Control theory and dynamical systems");

    println!("\nBy implementing vector spaces over arbitrary fields, Noether");
    println!("provides a framework for advanced mathematical computing across");
    println!("many different domains and applications.");
}