Reglas de derivación con JavaScript

01 · De fórmula a estructura

Un programa necesita comprender la expresión

Una cadena como "sin(x*x)" no revela directamente qué operación es exterior. Un derivador simbólico separa análisis, transformación, simplificación y presentación.

02 · Árbol de sintaxis

Las expresiones como objetos

El polinomio x²+3x puede representarse sin ambigüedad:

const expression = {
  type: "add",
  left: { type: "power", base: { type: "variable", name: "x" }, exponent: 2 },
  right: {
    type: "multiply",
    left: { type: "constant", value: 3 },
    right: { type: "variable", name: "x" }
  }
};

Cada nodo contiene solo los operandos necesarios. El árbol conserva precedencia y facilita recorridos recursivos.

03 · Reglas mínimas

Constantes y variables detienen la recursión

function derive(node, variable = "x") {
  switch (node.type) {
    case "constant": return constant(0);
    case "variable": return constant(node.name === variable ? 1 : 0);
    default: throw new Error(`Nodo no soportado: ${node.type}`);
  }
}

04 · Sumas y restas

Conservar el operador y derivar los hijos

case "add":
  return add(derive(node.left, variable), derive(node.right, variable));
case "subtract":
  return subtract(derive(node.left, variable), derive(node.right, variable));

La recursión refleja exactamente la linealidad: el derivador no necesita saber cuántos términos contiene la expresión completa.

05 · Operaciones binarias

Producto y cociente construyen nuevos árboles

case "multiply":
  return add(
    multiply(derive(node.left, variable), node.right),
    multiply(node.left, derive(node.right, variable))
  );
case "divide":
  return divide(
    subtract(
      multiply(derive(node.top, variable), node.bottom),
      multiply(node.top, derive(node.bottom, variable))
    ),
    power(node.bottom, 2)
  );

En una implementación inmutable conviene clonar o tratar los nodos como valores para evitar modificaciones accidentales compartidas.

06 · Potencias

Distinguir exponente constante y variable

Para uⁿ con n constante:

case "power": {
  const { base, exponent } = node;
  if (typeof exponent === "number") {
    return multiply(
      multiply(constant(exponent), power(base, exponent - 1)),
      derive(base, variable)
    );
  }
  return deriveVariablePower(base, exponent, variable);
}

La potencia variable necesita la regla logarítmica del tema 27.

07 · Regla de la cadena

Funciones elementales como nodos unarios

Todos los casos derivan recursivamente el argumento, lo que implementa la cadena.

08 · Simplificación

Una derivada correcta puede ser ilegible

Derivar 3x produce inicialmente 0·x+3·1. Reglas locales mejoran el resultado:

function simplifyMultiply(left, right) {
  if (isZero(left) || isZero(right)) return constant(0);
  if (isOne(left)) return right;
  if (isOne(right)) return left;
  if (isConstant(left) && isConstant(right)) {
    return constant(left.value * right.value);
  }
  return multiply(left, right);
}

09 · Evaluación segura

Recorrer el árbol sin eval

function evaluate(node, scope) {
  switch (node.type) {
    case "constant": return node.value;
    case "variable": return scope[node.name];
    case "add": return evaluate(node.left, scope) + evaluate(node.right, scope);
    case "multiply": return evaluate(node.left, scope) * evaluate(node.right, scope);
    case "sin": return Math.sin(evaluate(node.argument, scope));
    default: throw new Error(`No se puede evaluar ${node.type}`);
  }
}

eval mezcla datos con código, dificulta validar entradas y abre riesgos de seguridad. Un intérprete explícito admite solo las operaciones declaradas.

10 · Flujo completo

Separar responsabilidades

El lexer reconoce números y símbolos; el parser aplica gramática y precedencia; el derivador transforma el AST; el simplificador normaliza; el impresor genera una representación legible. Esta separación hace que cada etapa pueda probarse de manera independiente.

11 · Exploración interactiva

Laboratorio: derivada simbólica y numérica

Seleccioná una expresión, mové el punto y reducí h. La curva amarilla es la función y la coral su derivada.

12 · Estrategia de pruebas

Probar estructura y significado

Un derivador requiere varios niveles:

• Pruebas unitarias para cada regla.
• Pruebas estructurales del AST resultante.
• Evaluaciones en puntos conocidos.
• Comparación con diferencias centrales.
• Casos de dominio inválido y errores esperados.

La verificación numérica detecta muchos fallos, pero no demuestra equivalencia simbólica en todo el dominio.

13 · Alcance del prototipo

Qué falta para un sistema algebraico completo

Un derivador real debe manejar análisis sintáctico, supuestos de dominio, simplificación canónica, expresiones equivalentes, funciones por partes, números complejos y crecimiento del árbol. También debe impedir recursión excesiva y validar tamaños de entrada.

La diferenciación automática usada en aprendizaje automático es distinta: calcula derivadas de un programa evaluado, no necesariamente una fórmula simbólica legible.

14 · Comprensión

Confusiones frecuentes

15 · Práctica guiada

Ejercicios de aplicación

Ejercicio 1: nodo constante

Implementá la derivada de una constante.

Ejercicio 2: regla de suma

Construí el AST derivado de x²+sin x.

Ejercicio 3: producto

Derivá simbólicamente x·eˣ.

Ejercicio 4: cadena

Indicá los nodos de la derivada de sin(x²).

Ejercicio 5: simplificación

Simplificá 0·x+3·1.

Ejercicio 6: evaluación

Evaluá el AST de x²+1 con x=3.

Ejercicio 7: prueba numérica

¿Cómo comprobarías la derivada implementada de ln(x)?

Ejercicio 8: seguridad

¿Por qué un conjunto cerrado de nodos es preferible a eval?

16 · Síntesis

Ideas para recordar

Con este tema se integran las reglas matemáticas del curso en una arquitectura de software extensible.