feat: fallback to numeric comparison for symbolic exponents in equations comparison, added test cases PD-4890

Author: CarlaCostea

src/fixtures/latex-equal/symbolic/exponentials-PD-4649.ts

@@ -0,0 +1,59 @@
+export default {
+  mode: "symbolic",
+  tests: [
+    // Cases where symbolic validation failed before
+
+    {
+      target: "B=500(\\frac{3}{4})^n",
+      ne: ["B=500(\\frac{1}{4})^{n-1}"],
+    },
+    {
+      target: "y=500(\\frac{3}{4})^n",
+      ne: ["y=500(\\frac{1}{4})^{n-1}"],
+    },
+    {
+      target: "a=500(\\frac{3}{4})^d",
+      ne: ["a=(\\frac{1}{4})^{d-1}"],
+    },
+    {
+      target: "b=500(\\frac{3}{4})^d",
+      ne: ["b=(\\frac{1}{4})^{d-1}"],
+    },
+    {
+      target: "f=4^g",
+      ne: ["f=4^{g-1}"],
+    },
+    {
+      target: "h=4^g",
+      ne: ["h=4^{g-1}"],
+    },
+
+    // Control test — should NOT be equal when using multiplication instead of exponentiation
+    {
+      target: "a=4*g",
+      ne: ["a=4*(g-1)"],
+    },
+
+    // Valid symbolic equivalence (should return true)
+    {
+      target: "x=3^n",
+      eq: ["x=3^n"],
+    },
+    {
+      target: "z=2^y",
+      eq: ["z=2^y"],
+    },
+    {
+      target: "v=(\\frac{5}{2})^x",
+      eq: ["v=(\\frac{5}{2})^x"],
+    },
+    {
+      target: "m=(\\frac{3}{4})^a",
+      eq: ["m=(\\frac{3}{4})^a"],
+    },
+    {
+      target: "k=(1.5)^p",
+      eq: ["k=(1.5)^p"],
+    },
+  ],
+};

src/fixtures/latex-equal/symbolic/exponentials-PD-4896.ts

@@ -0,0 +1,132 @@
+export default {
+  mode: "symbolic",
+  tests: [
+     {
+      target: "\\left(\\frac{1}{2}\\right)^n",
+      eq: ["\\left(\\frac{10}{20}\\right)^n"],
+    },
+    {
+      target: "\\left(\\frac{1}{2}\\right)^n",
+      eq: ["\\left(0.5\\right)^n"],
+    },
+    {
+      target: "\\left(\\frac{1}{2}\\right)^n",
+      eq: ["\\left(\\frac{2}{4}\\right)^n"],
+    },
+    {
+      target: "\\left(\\frac{10}{20}\\right)^n",
+      eq: ["\\left(\\frac{1}{2}\\right)^n"],
+    },
+    {
+      target: "\\left(0.5\\right)^n",
+      eq: ["\\left(\\frac{1}{2}\\right)^n"],
+    },
+    {
+      target: "\\left(\\frac{3}{2}\\right)^a",
+      eq: ["\\left(\\frac{6}{4}\\right)^a"],
+    },
+    {
+      target: "\\left(\\frac{3}{2}\\right)^a",
+      eq: ["\\left(1.5\\right)^a"],
+    },
+    {
+      target: "\\left(\\frac{1}{2}\\right)^n",
+      eq: ["\\left(1\\div2\\right)^n"],
+    },
+
+    // Division written with \left and \right — also should be equivalent
+
+    {
+      target: "\\left(1\\div2\\right)^n",
+      eq: ["\\left(10\\div20\\right)^n"],
+    },
+    {
+      target: "\\left(1\\div2\\right)^n",
+      eq: ["\\left(0.5\\right)^n"],
+    },
+    {
+      target: "\\left(1\\div2\\right)^n",
+      eq: ["\\left(2\\div4\\right)^n"],
+    },
+    {
+      target: "\\left(10\\div20\\right)^n",
+      eq: ["\\left(1\\div2\\right)^n"],
+    },
+    {
+      target: "\\left(0.5\\right)^n",
+      eq: ["\\left(1\\div2\\right)^n"],
+    },
+    {
+      target: "\\left(3\\div2\\right)^n",
+      eq: ["\\left(6\\div4\\right)^n"],
+    },
+    {
+      target: "\\left(3\\div2\\right)^n",
+      eq: ["\\left(1.5\\right)^n"],
+    },
+    // All of the following SHOULD be considered equivalent (eq)
+
+    {
+      target: "(\\frac{1}{2})^n",
+      eq: ["(\\frac{10}{20})^n"],
+    },
+    {
+      target: "(\\frac{1}{2})^n",
+      eq: ["(0.5)^n"],
+    },
+    {
+      target: "(\\frac{1}{2})^n",
+      eq: ["(\\frac{2}{4})^n"],
+    },
+    {
+      target: "(\\frac{10}{20})^n",
+      eq: ["(\\frac{1}{2})^n"],
+    },
+    {
+      target: "(0.5)^n",
+      eq: ["(\\frac{1}{2})^n"],
+    },
+    {
+      target: "(\\frac{3}{2})^a",
+      eq: ["(\\frac{6}{4})^a"],
+    },
+    {
+      target: "(\\frac{3}{2})^a",
+      eq: ["(1.5)^a"],
+    },
+    {
+      target: "(\\frac{1}{2})^n",
+      eq: ["(1\\div2)^n"],
+    },
+
+    // Control set – same expressions using division
+    {
+      target: "(1\\div2)^n",
+      eq: ["(10\\div20)^n"],
+    },
+    {
+      target: "(1\\div2)^n",
+      eq: ["(0.5)^n"],
+    },
+    {
+      target: "(1\\div2)^n",
+      eq: ["(2\\div4)^n"],
+    },
+    {
+      target: "(10\\div20)^n",
+      eq: ["(1\\div2)^n"],
+    },
+    {
+      target: "(0.5)^n",
+      eq: ["(1\\div2)^n"],
+    },
+    {
+      target: "(3\\div2)^n",
+      eq: ["(6\\div4)^n"],
+    },
+    {
+      target: "(3\\div2)^n",
+      eq: ["(1.5)^n"],
+    },
+  ],
+};

src/symbolic/compare-equations.ts

@@ -49,6 +49,68 @@ export const compareEquations = (
     let firstEquationCoefficients: number[];
     let secondEquationCoefficients: number[];
 
+    const hasSymbolicExponent = (node: MathNode): boolean => {
+      let found = false;
+
+      node.traverse((n) => {
+        if (
+          n.isOperatorNode &&
+          n.op === "^" &&
+          !n.args[1]?.isConstantNode // Exponent is symbolic or compound
+        ) {
+          found = true;
+        }
+      });
+
+      return found;
+    };
+
+    const areNumericallyEquivalent = (
+      exprA: MathNode,
+      exprB: MathNode,
+      variables: string[],
+      tolerance: number = 1e-10
+    ): boolean => {
+      const compiledA = m.compile(exprA.toString());
+      const compiledB = m.compile(exprB.toString());
+
+      const testValues = [1, 2, 3, 4, 5];
+
+      return testValues.every((val) => {
+        const scope = variables.reduce((acc, v) => {
+          acc[v] = val;
+          return acc;
+        }, {} as Record<string, number>);
+
+        try {
+          const resultA = compiledA.evaluate(scope);
+          const resultB = compiledB.evaluate(scope);
+          return Math.abs(resultA - resultB) < tolerance;
+        } catch {
+          return false;
+        }
+      });
+    };
+
+    if (
+      hasSymbolicExponent(firstExpression) ||
+      hasSymbolicExponent(secondExpression)
+    ) {
+      const isEquivalent = areNumericallyEquivalent(
+        firstExpression,
+        secondExpression,
+        firstEquationVariablesName
+      );
+      console.log(
+        "Symbolic exponent detected, fallback to numeric equivalence:",
+        firstExpression.toString(),
+        secondExpression.toString(),
+        "=>",
+        isEquivalent
+      );
+      return isEquivalent;
+    }
+
     if (firstEquationVariablesName.length === 1) {
       firstEquationCoefficients = getCoefficients(
         firstExpression,