Add PossibleZeroQ function for zero-testing expressions

Author: ad-si

functions.csv

@@ -4307,7 +4307,7 @@ PositiveQ,Tests if a number is positive,✅,pure,,
 PositiveRationals,,,,12,4479
 PositiveReals,,,,12,1388
 PositiveSemidefiniteMatrixQ,,,,10,2837
-PossibleZeroQ,,,,6,1369
+PossibleZeroQ,Tests if an expression is possibly zero,✅,pure,6,1369
 Postfix,Symbol for postfix display formatting,✅,pure,1,3070
 Power,Raises a number to a power,✅,pure,1,4
 PowerDistribution,,,,8,3224

src/evaluator/dispatch/predicate_functions.rs

@@ -333,6 +333,9 @@ pub fn dispatch_predicate_functions(
     "SubsetQ" if args.len() == 2 => {
       return Some(crate::functions::predicate_ast::subset_q_ast(args));
     }
+    "PossibleZeroQ" => {
+      return Some(crate::functions::predicate_ast::possible_zero_q_ast(args));
+    }
     "OptionQ" if args.len() == 1 => {
       return Some(crate::functions::predicate_ast::option_q_ast(args));
     }

src/functions/predicate_ast.rs

@@ -1316,6 +1316,99 @@ pub fn subset_q_ast(args: &[Expr]) -> Result<Expr, InterpreterError> {
   }
 }
 
+/// PossibleZeroQ[expr] - Tests if expr is possibly zero
+/// Uses symbolic simplification and numeric evaluation to determine
+/// whether an expression could be zero.
+pub fn possible_zero_q_ast(args: &[Expr]) -> Result<Expr, InterpreterError> {
+  if args.len() != 1 {
+    return Ok(Expr::FunctionCall {
+      name: "PossibleZeroQ".to_string(),
+      args: args.to_vec(),
+    });
+  }
+  let expr = &args[0];
+
+  // 1. Structural zero check
+  if is_structural_zero(expr) {
+    return Ok(bool_expr(true));
+  }
+
+  // 2. Non-numeric atoms that can never be zero
+  match expr {
+    Expr::String(_) => return Ok(bool_expr(false)),
+    Expr::Identifier(name) => match name.as_str() {
+      "True" | "False" | "Infinity" | "ComplexInfinity" | "Indeterminate" => {
+        return Ok(bool_expr(false));
+      }
+      _ => {}
+    },
+    _ => {}
+  }
+
+  // 3. Known nonzero constants
+  if let Expr::Constant(c) = expr {
+    match c.as_str() {
+      "Pi" | "E" | "Degree" | "EulerGamma" | "Catalan" | "GoldenRatio"
+      | "Glaisher" | "Khinchin" => {
+        return Ok(bool_expr(false));
+      }
+      _ => {}
+    }
+  }
+
+  // 4. Known positive/negative numbers are not zero
+  if let Some(true) = is_known_positive(expr) {
+    return Ok(bool_expr(false));
+  }
+  if let Some(true) = is_known_negative(expr) {
+    return Ok(bool_expr(false));
+  }
+
+  // 5. Simplify the expression and check
+  let simplified = crate::functions::polynomial_ast::simplify_expr(expr);
+  if is_structural_zero(&simplified) {
+    return Ok(bool_expr(true));
+  }
+
+  // 6. Try numeric evaluation on the simplified expression
+  if let Some(val) = crate::functions::math_ast::try_eval_to_f64(&simplified) {
+    return Ok(bool_expr(val.abs() < 1e-10));
+  }
+
+  // 7. Try numeric evaluation on the original expression
+  if let Some(val) = crate::functions::math_ast::try_eval_to_f64(expr) {
+    return Ok(bool_expr(val.abs() < 1e-10));
+  }
+
+  // 8. For expressions we can't evaluate numerically, return False
+  // (matches Wolfram behavior for symbolic unknowns like x)
+  Ok(bool_expr(false))
+}
+
+/// Check if an expression is structurally zero (literal 0, 0.0, 0/1, Complex[0,0], etc.)
+fn is_structural_zero(expr: &Expr) -> bool {
+  match expr {
+    Expr::Integer(0) => true,
+    Expr::Real(f) => *f == 0.0,
+    Expr::BigInteger(n) => {
+      use num_traits::Zero;
+      n.is_zero()
+    }
+    Expr::BigFloat(digits, _) => digits.parse::<f64>().is_ok_and(|f| f == 0.0),
+    Expr::FunctionCall { name, args }
+      if name == "Rational" && args.len() == 2 =>
+    {
+      is_structural_zero(&args[0])
+    }
+    Expr::FunctionCall { name, args }
+      if name == "Complex" && args.len() == 2 =>
+    {
+      is_structural_zero(&args[0]) && is_structural_zero(&args[1])
+    }
+    _ => false,
+  }
+}
+
 /// OptionQ[expr] - Tests if expr is a Rule or RuleDelayed or a list thereof
 pub fn option_q_ast(args: &[Expr]) -> Result<Expr, InterpreterError> {
   if args.len() != 1 {

tests/interpreter_tests/math/predicates.rs

@@ -679,3 +679,167 @@ mod abs_infinity {
     assert_eq!(interpret("Abs[ComplexInfinity]").unwrap(), "Infinity");
   }
 }
+
+mod possible_zero_q {
+  use super::*;
+
+  #[test]
+  fn literal_zero() {
+    assert_eq!(interpret("PossibleZeroQ[0]").unwrap(), "True");
+  }
+
+  #[test]
+  fn real_zero() {
+    assert_eq!(interpret("PossibleZeroQ[0.0]").unwrap(), "True");
+  }
+
+  #[test]
+  fn nonzero_integer() {
+    assert_eq!(interpret("PossibleZeroQ[1]").unwrap(), "False");
+  }
+
+  #[test]
+  fn nonzero_negative() {
+    assert_eq!(interpret("PossibleZeroQ[-3]").unwrap(), "False");
+  }
+
+  #[test]
+  fn nonzero_real() {
+    assert_eq!(interpret("PossibleZeroQ[1.5]").unwrap(), "False");
+  }
+
+  #[test]
+  fn nonzero_rational() {
+    assert_eq!(interpret("PossibleZeroQ[1/2]").unwrap(), "False");
+  }
+
+  #[test]
+  fn rational_cancel_to_zero() {
+    assert_eq!(interpret("PossibleZeroQ[3/4 - 3/4]").unwrap(), "True");
+  }
+
+  #[test]
+  fn symbolic_cancel() {
+    assert_eq!(interpret("PossibleZeroQ[x - x]").unwrap(), "True");
+  }
+
+  #[test]
+  fn symbolic_cancel_with_coeff() {
+    assert_eq!(interpret("PossibleZeroQ[2*a - 2*a]").unwrap(), "True");
+  }
+
+  #[test]
+  fn symbolic_cancel_power() {
+    assert_eq!(interpret("PossibleZeroQ[a^2 - a^2]").unwrap(), "True");
+  }
+
+  #[test]
+  fn symbolic_unknown_false() {
+    assert_eq!(interpret("PossibleZeroQ[x]").unwrap(), "False");
+  }
+
+  #[test]
+  fn sin_zero() {
+    assert_eq!(interpret("PossibleZeroQ[Sin[0]]").unwrap(), "True");
+  }
+
+  #[test]
+  fn sin_pi() {
+    assert_eq!(interpret("PossibleZeroQ[Sin[Pi]]").unwrap(), "True");
+  }
+
+  #[test]
+  fn cos_pi_half() {
+    assert_eq!(interpret("PossibleZeroQ[Cos[Pi/2]]").unwrap(), "True");
+  }
+
+  #[test]
+  fn cos_zero_minus_one() {
+    assert_eq!(interpret("PossibleZeroQ[Cos[0] - 1]").unwrap(), "True");
+  }
+
+  #[test]
+  fn log_one() {
+    assert_eq!(interpret("PossibleZeroQ[Log[1]]").unwrap(), "True");
+  }
+
+  #[test]
+  fn sqrt_cancel() {
+    assert_eq!(
+      interpret("PossibleZeroQ[Sqrt[2] - Sqrt[2]]").unwrap(),
+      "True"
+    );
+  }
+
+  #[test]
+  fn constant_subtract() {
+    assert_eq!(interpret("PossibleZeroQ[E - E]").unwrap(), "True");
+  }
+
+  #[test]
+  fn nonzero_constant_pi() {
+    assert_eq!(interpret("PossibleZeroQ[Pi]").unwrap(), "False");
+  }
+
+  #[test]
+  fn nonzero_sum() {
+    assert_eq!(interpret("PossibleZeroQ[2 + 3]").unwrap(), "False");
+  }
+
+  #[test]
+  fn complex_i_false() {
+    assert_eq!(interpret("PossibleZeroQ[I]").unwrap(), "False");
+  }
+
+  #[test]
+  fn complex_zero() {
+    assert_eq!(interpret("PossibleZeroQ[0 + 0*I]").unwrap(), "True");
+  }
+
+  #[test]
+  fn zero_times_i() {
+    assert_eq!(interpret("PossibleZeroQ[0*I]").unwrap(), "True");
+  }
+
+  #[test]
+  fn infinity_false() {
+    assert_eq!(interpret("PossibleZeroQ[Infinity]").unwrap(), "False");
+  }
+
+  #[test]
+  fn neg_infinity_false() {
+    assert_eq!(interpret("PossibleZeroQ[-Infinity]").unwrap(), "False");
+  }
+
+  #[test]
+  fn complex_infinity_false() {
+    assert_eq!(
+      interpret("PossibleZeroQ[ComplexInfinity]").unwrap(),
+      "False"
+    );
+  }
+
+  #[test]
+  fn boolean_false() {
+    assert_eq!(interpret("PossibleZeroQ[True]").unwrap(), "False");
+  }
+
+  #[test]
+  fn string_false() {
+    assert_eq!(interpret("PossibleZeroQ[\"hello\"]").unwrap(), "False");
+  }
+
+  #[test]
+  fn x_squared_plus_one_false() {
+    assert_eq!(interpret("PossibleZeroQ[x^2 + 1]").unwrap(), "False");
+  }
+
+  #[test]
+  fn wrong_arg_count_unevaluated() {
+    assert_eq!(interpret("PossibleZeroQ[]").unwrap(), "PossibleZeroQ[]");
+    assert_eq!(
+      interpret("PossibleZeroQ[1, 2]").unwrap(),
+      "PossibleZeroQ[1, 2]"
+    );
+  }
+}