fix #230

Author: arnog

CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ### Bug Fixes
 
+- **([#230](https://github.com/cortex-js/compute-engine/issues/230))
+  Root Derivatives**: Fixed the `D` operator not differentiating expressions
+  containing the `Root` operator (n-th roots). Previously, `D(Root(x, 3), x)`
+  (derivative of ∛x) would return an unevaluated derivative expression instead
+  of computing the result. Now correctly returns `1/(3x^(2/3))`, equivalent to
+  the expected `(1/3)·x^(-2/3)`. The fix adds a special case in the `differentiate`
+  function to handle `Root(base, n)` by applying the power rule with exponent `1/n`.
+
 - **Sign Simplification**: Fixed `Sign(x).simplify()` returning `1` instead of
   `-1` when `x` is negative. The simplification rule incorrectly returned
   `ce.One` for both positive and negative cases.

src/compute-engine/symbolic/derivative.ts

@@ -219,6 +219,24 @@ export function differentiate(
     return simplifyDerivative(add(...(terms as BoxedExpression[])));
   }
 
+  // Root rule: Root(base, n) = base^(1/n)
+  // d/dx Root(base, n) = d/dx base^(1/n) = (1/n) * base^((1/n) - 1) * d/dx base
+  if (expr.operator === 'Root') {
+    const [base, n] = expr.ops!;
+    if (!base.has(v)) return ce.Zero;
+
+    // Compute derivative using the power rule
+    // d/dx base^(1/n) = (1/n) * base^((1/n) - 1) * base'
+    const exponent = ce.One.div(n);  // 1/n
+    const basePrime = differentiate(base, v) ?? ce._fn('D', [base, ce.symbol(v)]);
+    const newExponent = exponent.sub(ce.One);  // (1/n) - 1 = (1-n)/n
+
+    // Create Power expression directly without canonicalization to avoid Root conversion
+    const power = ce._fn('Power', [base, newExponent], { canonical: false });
+
+    return simplifyDerivative(exponent.mul(power).mul(basePrime));
+  }
+
   // Power rule
   if (expr.operator === 'Power') {
     const [base, exponent] = expr.ops!;

test/compute-engine/calculus.test.ts

@@ -21,6 +21,25 @@ describe('DERIVATION', () => {
 
   test('no variable', () =>
     expect(evaluate('\\frac{d}{dx} 3t')).toMatchInlineSnapshot(`0`));
+
+  // Issue #230: Root operator should be differentiated correctly
+  test('cube root derivative', () =>
+    expect(evaluate('\\frac{d}{dx} \\sqrt[3]{x}')).toMatchInlineSnapshot(
+      `(3x^(2/3))^-1`
+    ));
+
+  test('fifth root derivative', () =>
+    expect(evaluate('\\frac{d}{dx} \\sqrt[5]{x}')).toMatchInlineSnapshot(
+      `(5x^(4/5))^-1`
+    ));
+
+  test('root with chain rule', () =>
+    expect(evaluate('\\frac{d}{dx} \\sqrt[3]{x^2 + 1}')).toMatchInlineSnapshot(
+      `(2x) / (3(x^2 + 1)^(2/3))`
+    ));
+
+  test('root of constant', () =>
+    expect(evaluate('\\frac{d}{dx} \\sqrt[3]{5}')).toMatchInlineSnapshot(`0`));
 });
 
 describe('INDEFINITE INTEGRATION', () => {

test/compute-engine/latex-syntax/logic.test.ts

@@ -825,3 +825,183 @@ describe('Iverson Bracket', () => {
     `);
   });
 });
+
+describe('Predicate', () => {
+  // Serialization tests
+  it('should serialize Predicate with one argument', () => {
+    expect(ce.box(['Predicate', 'P', 'x']).latex).toBe('P(x)');
+  });
+
+  it('should serialize Predicate with multiple arguments', () => {
+    expect(ce.box(['Predicate', 'Q', 'a', 'b']).latex).toBe('Q(a, b)');
+    expect(ce.box(['Predicate', 'R', 'x', 'y', 'z']).latex).toBe('R(x, y, z)');
+  });
+
+  // Round-trip tests: parse -> serialize -> parse should give same result
+  it('should round-trip predicates inside ForAll', () => {
+    const expr1 = ce.parse('\\forall x, P(x)');
+    // Verify it contains Predicate
+    expect(expr1.json).toMatchInlineSnapshot(`
+      [
+        ForAll,
+        x,
+        [
+          Predicate,
+          P,
+          x,
+        ],
+      ]
+    `);
+    // Serialize and re-parse
+    const latex = expr1.latex;
+    const expr2 = ce.parse(latex);
+    expect(expr2.json).toEqual(expr1.json);
+  });
+
+  it('should round-trip predicates inside Exists', () => {
+    const expr1 = ce.parse('\\exists x, Q(x, y)');
+    expect(expr1.json).toMatchInlineSnapshot(`
+      [
+        Exists,
+        x,
+        [
+          Predicate,
+          Q,
+          x,
+          y,
+        ],
+      ]
+    `);
+    const expr2 = ce.parse(expr1.latex);
+    expect(expr2.json).toEqual(expr1.json);
+  });
+
+  it('should round-trip nested quantifiers with predicates', () => {
+    const expr1 = ce.parse('\\forall x, \\exists y, R(x, y)');
+    expect(expr1.json).toMatchInlineSnapshot(`
+      [
+        ForAll,
+        x,
+        [
+          Exists,
+          y,
+          [
+            Predicate,
+            R,
+            x,
+            y,
+          ],
+        ],
+      ]
+    `);
+    const expr2 = ce.parse(expr1.latex);
+    expect(expr2.json).toEqual(expr1.json);
+  });
+
+  // Type inference tests
+  it('should infer boolean type for Predicate', () => {
+    const pred = ce.box(['Predicate', 'P', 'x']);
+    expect(pred.type.toString()).toBe('boolean');
+  });
+
+  it('should allow Predicate in boolean contexts', () => {
+    // Predicate should work as argument to And, Or, Not, etc.
+    const expr1 = ce.box(['And', ['Predicate', 'P', 'x'], ['Predicate', 'Q', 'x']]);
+    expect(expr1.type.toString()).toBe('boolean');
+
+    const expr2 = ce.box(['Not', ['Predicate', 'P', 'x']]);
+    expect(expr2.type.toString()).toBe('boolean');
+
+    const expr3 = ce.box(['Implies', ['Predicate', 'P', 'x'], ['Predicate', 'Q', 'x']]);
+    expect(expr3.type.toString()).toBe('boolean');
+  });
+
+  // D(f, x) should parse as Predicate, not derivative
+  it('should parse D(f, x) as Predicate, not derivative', () => {
+    // Outside quantifier scope - D is special-cased to always be Predicate
+    expect(ce.parse('D(f, x)').json).toMatchInlineSnapshot(`
+      [
+        Predicate,
+        D,
+        f,
+        x,
+      ]
+    `);
+
+    // Inside quantifier scope
+    expect(ce.parse('\\forall x, D(x)').json).toMatchInlineSnapshot(`
+      [
+        ForAll,
+        x,
+        [
+          Predicate,
+          D,
+          x,
+        ],
+      ]
+    `);
+  });
+
+  // Predicates outside quantifier scope should be regular function applications
+  it('should parse predicates outside quantifier scope as function applications', () => {
+    // P(x) outside quantifier scope is a regular function application
+    expect(ce.parse('P(x)').json).toMatchInlineSnapshot(`
+      [
+        P,
+        x,
+      ]
+    `);
+    expect(ce.parse('Q(a, b)').json).toMatchInlineSnapshot(`
+      [
+        Q,
+        a,
+        b,
+      ]
+    `);
+  });
+});
+
+describe('Single-letter library functions', () => {
+  // N is a library function for numeric evaluation, but N(x) in LaTeX
+  // is not standard math notation. Like D, N is excluded from automatic
+  // function recognition so it can be used as a variable.
+  it('should parse N(x) as Predicate, not as numeric function', () => {
+    // N(x) should NOT be parsed as the numeric evaluation function
+    // Instead, it's parsed as a Predicate (like D)
+    const expr = ce.parse('N(\\pi)');
+    expect(expr.json).toMatchInlineSnapshot(`
+      [
+        Predicate,
+        N,
+        Pi,
+      ]
+    `);
+  });
+
+  it('should allow N function via MathJSON', () => {
+    // N function can be constructed directly in MathJSON
+    const expr = ce.box(['N', 'Pi']);
+    expect(expr.operator).toBe('N');
+    expect(expr.op1?.symbol).toBe('Pi');
+
+    // Direct .N() on Pi gives numeric value (preferred way to get numeric values)
+    const piNumeric = ce.box('Pi').N();
+    expect(piNumeric.numericValue).not.toBeNull();
+  });
+
+  // e and i are constants, not functions
+  it('should parse e as Euler constant', () => {
+    expect(ce.parse('e').json).toMatchInlineSnapshot(`ExponentialE`);
+  });
+
+  it('should parse i as imaginary unit', () => {
+    // i is canonicalized to Complex representation
+    expect(ce.parse('i').json).toMatchInlineSnapshot(`
+      [
+        Complex,
+        0,
+        1,
+      ]
+    `);
+  });
+});