Trait Simplify 

pub trait Simplify {
    // Required method
    fn simplify(&self) -> Self;
}

Trait for simplifying expressions

Simplification transforms expressions into equivalent but simpler symbolic forms through algebraic reduction. Unlike evaluation, simplification:

• Does NOT substitute variables
• Does NOT check domain restrictions
• Does NOT compute numerical values (except constant folding)
• DOES preserve mathematical equivalence

Simplification vs Evaluation

Use simplify() when: You need algebraic reduction while keeping expressions symbolic Use evaluate() when: You need numerical values with domain checking Use evaluate_with_context() when: You need to substitute variables and compute

Examples

use mathhook_core::{expr, symbol};
use mathhook_core::simplify::Simplify;
use mathhook_core::Expression;

// Combine like terms
let x = symbol!(x);
let x_expr = Expression::symbol(x.clone());
let sum = Expression::add(vec![x_expr.clone(), x_expr.clone()]);
assert_eq!(sum.simplify(), Expression::mul(vec![expr!(2), x_expr.clone()]));

// Apply identities
assert_eq!(Expression::mul(vec![x_expr.clone(), expr!(1)]).simplify(), x_expr.clone());
assert_eq!(Expression::add(vec![x_expr.clone(), expr!(0)]).simplify(), x_expr.clone());
assert_eq!(Expression::mul(vec![expr!(0), x_expr.clone()]).simplify(), expr!(0));

// Constant folding (algebraic, not "evaluation")
assert_eq!(Expression::add(vec![expr!(2), expr!(3)]).simplify(), expr!(5));

Domain Safety

Simplification does NOT validate mathematical domains:

use mathhook_core::{symbol, Expression};
use mathhook_core::simplify::Simplify;

// No error - stays symbolic or simplifies to i (complex domain)
let sqrt_neg = Expression::function("sqrt".to_string(), vec![Expression::integer(-1)]);
let result = sqrt_neg.simplify();
// For domain checking, use evaluate() instead

Idempotency

Simplification is idempotent (applying twice yields same result):

use mathhook_core::{symbol, Expression};
use mathhook_core::simplify::Simplify;

let x = symbol!(x);
let x_expr = Expression::symbol(x.clone());
let expr = Expression::add(vec![x_expr.clone(), x_expr.clone(), x_expr.clone()]);
assert_eq!(expr.simplify().simplify(), expr.simplify());

Required Methods

fn simplify(&self) -> Self

Simplify expression using algebraic reduction rules

Returns a mathematically equivalent expression in canonical simplified form. Never fails (always returns Expression, not Result).

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl Simplify for Expression