fixed #290

Author: arnog

CHANGELOG.md

@@ -1,5 +1,21 @@
 ## [Unreleased]
 
+### Bug Fixes
+
+- **Derivatives of user-defined functions** (#290): `\frac{d}{dx} f` and `f'(x)`
+  now correctly evaluate when `f` is a user-defined function (e.g.,
+  `f(x) := 2x`). Previously `\frac{d}{dx} f` returned `0` and `f'(x)` returned
+  a symbolic `Apply(Derivative(...))`.
+- **Stack overflow with same-name arguments**: Evaluating `f(x)` no longer
+  causes a stack overflow when the argument name matches the parameter name.
+- **Cleaner `D` canonical form**: `f'(x)` now canonicalizes to
+  `["D", ["f", "x"], "x"]` instead of the verbose
+  `["D", ["Function", ["Block", ["f", "x"]], "x"], "x"]`. Function calls are
+  no longer redundantly wrapped in `Function(Block(...))`. Similarly,
+  `\frac{d}{dx} f` where `f` is a known function symbol canonicalizes to
+  `["D", ["f", "x"], "x"]` by applying the function to the differentiation
+  variable.
+
 ### Free Functions
 
 - Free functions (`simplify`, `evaluate`, `N`, `expand`, `expandAll`, `factor`,

src/compute-engine/boxed-expression/boxed-symbol.ts

@@ -402,7 +402,14 @@ export class BoxedSymbol extends _BoxedExpression implements SymbolInterface {
     if (this._def.value.isConstant) return this._def.value.value;
 
     // Lookup the value in the current evaluation context
-    return this.engine._getSymbolValue(this._id);
+    const result = this.engine._getSymbolValue(this._id);
+
+    // Guard: when a function parameter is bound to an argument with the same
+    // name (e.g., f(x) called with argument x), the eval context maps x → x,
+    // creating an infinite loop. Return undefined to treat as a free variable.
+    if (result !== undefined && result.symbol === this._id) return undefined;
+
+    return result;
   }
 
   get value(): Expression | undefined {

src/compute-engine/library/calculus.ts

@@ -2,7 +2,7 @@ import type { Expression, SymbolDefinitions } from '../global-types';
 
 import { checkType } from '../boxed-expression/validate';
 import { hasSymbolicTranscendental } from '../boxed-expression/utils';
-import { isFunction, sym } from '../boxed-expression/type-guards';
+import { isFunction, isSymbol, sym } from '../boxed-expression/type-guards';
 
 import {
   applicableN1,
@@ -140,14 +140,39 @@ volumes
       signature:
         '(expression, variable:symbol, variables:symbol+) -> expression',
       canonical: (ops, { engine: ce, scope }) => {
+        // If the first argument is a function symbol (e.g., f where f(x):=2x),
+        // apply it to the differentiation variables to produce a function call.
+        // e.g., ['D', 'f', 'x'] → ['D', ['f', 'x'], 'x']
+        if (isSymbol(ops[0]) && ops[0].canonical.operatorDefinition) {
+          const vars = ops.slice(1);
+          const fCall = ce.function(ops[0].symbol, vars);
+          return ce._fn('D', [fCall, ...vars], { scope });
+        }
+
+        // If the first argument is already a function call (e.g., f'(x)
+        // parsed as ['D', ['f', 'x'], 'x']), use it directly rather than
+        // wrapping in Function(Block(...)).
+        const op0 = ops[0].canonical;
+        if (isFunction(op0) && op0.operator) {
+          return ce._fn('D', [op0, ...ops.slice(1)], { scope });
+        }
+
         const f = canonicalFunctionLiteralArguments(ce, ops);
         if (!f) return null;
 
         return ce._fn('D', [f, ...ops!.slice(1)], { scope });
       },
       evaluate: (ops, { engine: _engine }) => {
         let f: Expression | undefined = ops[0].canonical;
-        f = f.evaluate();
+
+        // Unwrap Function literals to get the body for differentiation.
+        // For non-Function expressions (e.g., ['f', 'x']), do NOT call
+        // .evaluate() before differentiating — that would prematurely
+        // substitute variable values (e.g., x=5) and lose structural info.
+        if (f.operator === 'Function' && isFunction(f)) {
+          f = f.op1;
+        }
+
         const params = ops.slice(1);
         if (params.length === 0) f = undefined;
         for (const param of params) {
@@ -156,7 +181,6 @@ volumes
             f = undefined;
             break;
           }
-          if (f && f.operator === 'Function' && isFunction(f)) f = f.op1;
           f = differentiate(f!, paramSym);
           if (f === undefined) break;
         }

src/compute-engine/symbolic/derivative.ts

@@ -233,6 +233,19 @@ export function differentiate(
   if (isNumber(expr)) return expr.engine.Zero;
   if (isSymbol(expr)) {
     if (expr.symbol === v) return expr.engine.One;
+
+    // Resolve user-defined functions: e.g. f where f(x) := 2x
+    if (expr.operatorDefinition) {
+      const ce = expr.engine;
+      const wildcard = ce.symbol('_');
+      const body = ce.function(expr.symbol, [wildcard]).evaluate();
+      // If the body resolved (is not just the same function call), differentiate it
+      if (body.operator !== expr.symbol) {
+        const bodyWithV = body.subs({ _: ce.symbol(v) });
+        return differentiate(bodyWithV, v, depth + 1);
+      }
+    }
+
     return expr.engine.Zero;
   }
   if (!expr.operator || !isFunction(expr)) return undefined;
@@ -450,6 +463,27 @@ export function differentiate(
 
   const h = DERIVATIVES_TABLE[expr.operator];
   if (h === undefined) {
+    // Try resolving user-defined function calls before falling back to
+    // symbolic chain rule. Apply the function to wildcards, evaluate to
+    // get the body, substitute actual arguments, and differentiate.
+    const opSym = ce.symbol(expr.operator);
+    if (opSym.operatorDefinition) {
+      const args = expr.ops;
+      const wildcards =
+        args.length === 1
+          ? [ce.symbol('_')]
+          : args.map((_, i) => ce.symbol(`_${i + 1}`));
+      const body = ce.function(expr.operator, wildcards).evaluate();
+      if (body.operator !== expr.operator) {
+        const subsMap: Record<string, Expression> = {};
+        wildcards.forEach((w, i) => {
+          subsMap[sym(w)!] = args[i];
+        });
+        const bodyWithArgs = body.subs(subsMap);
+        return differentiate(bodyWithArgs, v, depth + 1);
+      }
+    }
+
     if (expr.nops > 1) return undefined;
 
     // If we don't know how to differentiate this function, assume it's a

test/compute-engine/derivatives.test.ts

@@ -541,6 +541,46 @@ describe('Multi-argument function derivatives', () => {
   });
 });
 
+describe('User-defined function derivatives', () => {
+  // Use a local engine so f(x) := 2x doesn't affect other tests
+  let ce: InstanceType<typeof import('../../src/compute-engine').ComputeEngine>;
+
+  beforeAll(async () => {
+    const { ComputeEngine } = await import('../../src/compute-engine');
+    ce = new ComputeEngine();
+    ce.parse('f(x) := 2x').evaluate();
+  });
+
+  it('f(x) should evaluate to 2x without stack overflow', () => {
+    const result = ce.parse('f(x)').evaluate();
+    expect(result.toString()).toMatchInlineSnapshot(`2x`);
+  });
+
+  it('d/dx f(x) where f(x) := 2x should be 2', () => {
+    const expr = ce.box(['D', ['f', 'x'], 'x']);
+    const result = expr.evaluate();
+    expect(result.toString()).toMatchInlineSnapshot(`2`);
+  });
+
+  it('d/dx f as a function symbol where f(x) := 2x should be 2', () => {
+    // D(Function(Block(f), x)) — Leibniz notation parses f as a function symbol
+    const expr = ce.parse('\\frac{d}{dx} f');
+    const result = expr.evaluate();
+    expect(result.toString()).toMatchInlineSnapshot(`2`);
+  });
+
+  it('d/dx f(x^2) where f(x) := 2x should be 4x', () => {
+    const expr = ce.box(['D', ['f', ['Square', 'x']], 'x']);
+    const result = expr.evaluate();
+    expect(result.toString()).toMatchInlineSnapshot(`4x`);
+  });
+
+  it('f(3) should evaluate to 6', () => {
+    const result = ce.parse('f(3)').evaluate();
+    expect(result.toString()).toMatchInlineSnapshot(`6`);
+  });
+});
+
 describe('ND', () => {
   it('should compute the numerical approximation of the derivative of a polynomial', () => {
     const expr = parse('\\mathrm{ND}(x \\mapsto x^3 + 2x - 4, 2)');

test/compute-engine/latex-syntax/__snapshots__/calculus.test.ts.snap

@@ -73,9 +73,9 @@ D
 `;
 
 exports[`EULER DERIVATIVE NOTATION D^2_x f - second derivative 1`] = `
-\\frac{\\mathrm{d}}{\\mathrm{d}x}\\frac{\\mathrm{d}}{\\mathrm{d}x}f
-D((x) |-> D((x) |-> f, x), x)
-["D", ["Function", ["D", ["Function", "f", "x"], "x"], "x"], "x"]
+\\frac{\\mathrm{d}^{2}}{\\mathrm{d}x^{2}}f
+D(D((x) |-> f, x), x)
+["D", ["D", ["Function", "f", "x"], "x"], "x"]
 `;
 
 exports[`EULER DERIVATIVE NOTATION D_t x - different variable 1`] = `
@@ -86,8 +86,8 @@ D((t) |-> x, t)
 
 exports[`EULER DERIVATIVE NOTATION D_x (x^2 + 1) - derivative of expression 1`] = `
 \\frac{\\mathrm{d}}{\\mathrm{d}x}x^2+1
-D((x) |-> x^2 + 1, x)
-["D", ["Function", ["Add", ["Square", "x"], 1], "x"], "x"]
+D(x^2 + 1, x)
+["D", ["Add", ["Square", "x"], 1], "x"]
 `;
 
 exports[`EULER DERIVATIVE NOTATION D_x f - first derivative 1`] = `
@@ -418,8 +418,8 @@ int(sin(x) dx) + 1 === 2
 
 exports[`LAGRANGE PRIME NOTATION WITH ARGUMENTS \\sin'(x) - known function with prime 1`] = `
 \\frac{\\mathrm{d}}{\\mathrm{d}x}\\sin(x)
-D((x) |-> sin(x), x)
-["D", ["Function", ["Sin", "x"], "x"], "x"]
+D(sin(x), x)
+["D", ["Sin", "x"], "x"]
 `;
 
 exports[`LAGRANGE PRIME NOTATION WITH ARGUMENTS f' without arguments - returns Derivative 1`] = `
@@ -429,49 +429,33 @@ Derivative(f)
 `;
 
 exports[`LAGRANGE PRIME NOTATION WITH ARGUMENTS f'''(x) - triple prime with argument 1`] = `
-\\frac{\\mathrm{d}}{\\mathrm{d}x}\\frac{\\mathrm{d}}{\\mathrm{d}x}\\frac{\\mathrm{d}}{\\mathrm{d}x}f(x)
-D((x) |-> D((x) |-> D((x) |-> f(x), x), x), x)
-[
-  "D",
-  [
-    "Function",
-    [
-      "D",
-      ["Function", ["D", ["Function", ["f", "x"], "x"], "x"], "x"],
-      "x"
-    ],
-    "x"
-  ],
-  "x"
-]
+\\frac{\\mathrm{d}^{3}}{\\mathrm{d}x^{3}}f(x)
+D(D(D(f(x), x), x), x)
+["D", ["D", ["D", ["f", "x"], "x"], "x"], "x"]
 `;
 
 exports[`LAGRANGE PRIME NOTATION WITH ARGUMENTS f''(x) - double prime with argument 1`] = `
-\\frac{\\mathrm{d}}{\\mathrm{d}x}\\frac{\\mathrm{d}}{\\mathrm{d}x}f(x)
-D((x) |-> D((x) |-> f(x), x), x)
-[
-  "D",
-  ["Function", ["D", ["Function", ["f", "x"], "x"], "x"], "x"],
-  "x"
-]
+\\frac{\\mathrm{d}^{2}}{\\mathrm{d}x^{2}}f(x)
+D(D(f(x), x), x)
+["D", ["D", ["f", "x"], "x"], "x"]
 `;
 
 exports[`LAGRANGE PRIME NOTATION WITH ARGUMENTS f'(x) - single prime with argument 1`] = `
 \\frac{\\mathrm{d}}{\\mathrm{d}x}f(x)
-D((x) |-> f(x), x)
-["D", ["Function", ["f", "x"], "x"], "x"]
+D(f(x), x)
+["D", ["f", "x"], "x"]
 `;
 
 exports[`LAGRANGE PRIME NOTATION WITH ARGUMENTS f'(x, y) - multiple arguments uses first as variable 1`] = `
 \\frac{\\mathrm{d}}{\\mathrm{d}x}f(x, y)
-D((x) |-> f(x, y), x)
-["D", ["Function", ["f", "x", "y"], "x"], "x"]
+D(f(x, y), x)
+["D", ["f", "x", "y"], "x"]
 `;
 
 exports[`LAGRANGE PRIME NOTATION WITH ARGUMENTS g'(t) - different variable 1`] = `
 \\frac{\\mathrm{d}}{\\mathrm{d}t}g(t)
-D((t) |-> g(t), t)
-["D", ["Function", ["g", "t"], "t"], "t"]
+D(g(t), t)
+["D", ["g", "t"], "t"]
 `;
 
 exports[`MULTIPLE INTEGRALS Double integral 1`] = `
@@ -612,49 +596,21 @@ D((t) |-> x, t)
 `;
 
 exports[`NEWTON DOT NOTATION Fourth derivative \\ddddot{z} 1`] = `
-\\frac{\\mathrm{d}}{\\mathrm{d}t}\\frac{\\mathrm{d}}{\\mathrm{d}t}\\frac{\\mathrm{d}}{\\mathrm{d}t}\\frac{\\mathrm{d}}{\\mathrm{d}t}z
-D((t) |-> D((t) |-> D((t) |-> D((t) |-> z, t), t), t), t)
-[
-  "D",
-  [
-    "Function",
-    [
-      "D",
-      [
-        "Function",
-        [
-          "D",
-          ["Function", ["D", ["Function", "z", "t"], "t"], "t"],
-          "t"
-        ],
-        "t"
-      ],
-      "t"
-    ],
-    "t"
-  ],
-  "t"
-]
+\\frac{\\mathrm{d}^{4}}{\\mathrm{d}t^{4}}z
+D(D(D(D((t) |-> z, t), t), t), t)
+["D", ["D", ["D", ["D", ["Function", "z", "t"], "t"], "t"], "t"], "t"]
 `;
 
 exports[`NEWTON DOT NOTATION Second derivative \\ddot{x} 1`] = `
-\\frac{\\mathrm{d}}{\\mathrm{d}t}\\frac{\\mathrm{d}}{\\mathrm{d}t}x
-D((t) |-> D((t) |-> x, t), t)
-["D", ["Function", ["D", ["Function", "x", "t"], "t"], "t"], "t"]
+\\frac{\\mathrm{d}^{2}}{\\mathrm{d}t^{2}}x
+D(D((t) |-> x, t), t)
+["D", ["D", ["Function", "x", "t"], "t"], "t"]
 `;
 
 exports[`NEWTON DOT NOTATION Third derivative \\dddot{y} 1`] = `
-\\frac{\\mathrm{d}}{\\mathrm{d}t}\\frac{\\mathrm{d}}{\\mathrm{d}t}\\frac{\\mathrm{d}}{\\mathrm{d}t}y
-D((t) |-> D((t) |-> D((t) |-> y, t), t), t)
-[
-  "D",
-  [
-    "Function",
-    ["D", ["Function", ["D", ["Function", "y", "t"], "t"], "t"], "t"],
-    "t"
-  ],
-  "t"
-]
+\\frac{\\mathrm{d}^{3}}{\\mathrm{d}t^{3}}y
+D(D(D((t) |-> y, t), t), t)
+["D", ["D", ["D", ["Function", "y", "t"], "t"], "t"], "t"]
 `;
 
 exports[`REAL WORLD INTEGRALS Integral with non standard typesetting 1`] = `

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

@@ -26,17 +26,13 @@ describe('TRIGONOMETRIC FUNCTIONS inverse, prime', () => {
   test(`\\sin^{-1}'(x)`, () =>
     expect(check("\\sin^{-1}'(x)")).toMatchInlineSnapshot(`
       box       = ["D", ["Apply", ["InverseFunction", "Sin"], "x"], "x"]
-      canonical = ["D", ["Function", ["Arcsin", "x"], "x"], "x"]
+      canonical = ["D", ["Arcsin", "x"], "x"]
       eval-auto = 1 / sqrt(1 - x^2)
     `));
   test(`\\sin^{-1}''(x)`, () =>
     expect(check("\\sin^{-1}''(x)")).toMatchInlineSnapshot(`
       box       = ["D", ["D", ["Apply", ["InverseFunction", "Sin"], "x"], "x"], "x"]
-      canonical = [
-        "D",
-        ["Function", ["D", ["Function", ["Arcsin", "x"], "x"], "x"], "x"],
-        "x"
-      ]
+      canonical = ["D", ["D", ["Arcsin", "x"], "x"], "x"]
       eval-auto = x / (1 - x^2)^(3/2)
     `));
   test(`\\cos^{-1\\doubleprime}(x)`, () =>
@@ -48,11 +44,7 @@ describe('TRIGONOMETRIC FUNCTIONS inverse, prime', () => {
   test(`\\cos^{-1}\\doubleprime(x)`, () =>
     expect(check('\\cos^{-1}\\doubleprime(x)')).toMatchInlineSnapshot(`
       box       = ["D", ["D", ["Apply", ["InverseFunction", "Cos"], "x"], "x"], "x"]
-      canonical = [
-        "D",
-        ["Function", ["D", ["Function", ["Arccos", "x"], "x"], "x"], "x"],
-        "x"
-      ]
+      canonical = ["D", ["D", ["Arccos", "x"], "x"], "x"]
       eval-auto = -x / (1 - x^2)^(3/2)
     `));
 });

test/playground.ts

@@ -12,9 +12,16 @@ import { expand } from '../src/compute-engine/boxed-expression/expand';
 const ce = new ComputeEngine();
 const engine = ce;
 
-console.log(parse('3 \\mathrm{cm} + 5\\mathrm{m}').evaluate().json);
-
-console.log(evaluate('\\frac{123 \\mathrm{J}}{10\\mathrm{m}}').latex);
+ce.parse('f(x):=2x').evaluate();
+console.log(ce.parse('\\frac{d}{dx}f').json);
+console.log(ce.parse('D_x f').json);
+console.log(JSON.stringify(ce.parse("f'(x)").json));
+// -> ["D",["Function",["Block",["f","x"]],"x"],"x"]
+console.log(ce.parse('\\dot{x}').json);
+// -> [ 'D', [ 'Function', [ 'Block', 'x' ], 't' ], 't' ]
+
+ce.parse('f(x):=2x').evaluate();
+ce.parse('\\frac{d}{dx} f').evaluate().print(); // evaluates to 0
 
 // 1. sin(theta)**2 + cos(theta)**2 → 1 — Clean trig identity, but too simple.
 // 2. (alpha**2 - beta**2) / (alpha - beta) → didn't simplify. Engine doesn't cancel the