@teachinglab/omd 0.1.0

package/omd/simplification/rules/functionRules.js

@@ -0,0 +1,111 @@
+import { omdSqrtNode } from '../../nodes/omdSqrtNode.js';
+import { SimplificationEngine } from '../omdSimplificationEngine.js';
+import * as utils from '../simplificationUtils.js';
+
+// ===== FUNCTION INVERSE PAIRS =====
+// Bidirectional inverse function pairs - each pair only needs to be defined once
+const FUNCTION_INVERSE_PAIRS = [
+    // Trigonometric functions
+    ['sin', 'arcsin'],
+    ['cos', 'arccos'], 
+    ['tan', 'arctan'],
+    
+    // Logarithmic/exponential functions
+    ['ln', 'exp'],
+    ['log', 'pow10'], // log base 10 and 10^x
+    
+    // Square root and square (for function nodes, not sqrt/power nodes)
+    ['sqrt', 'square'],
+    
+    // Hyperbolic functions
+    ['sinh', 'asinh'],
+    ['cosh', 'acosh'], 
+    ['tanh', 'atanh'],
+];
+
+/**
+ * Gets the inverse of a function (works bidirectionally)
+ * @param {string} functionName - The function name to find the inverse for
+ * @returns {string|null} The inverse function name, or null if not found
+ */
+function getInverse(functionName) {
+    for (const [func1, func2] of FUNCTION_INVERSE_PAIRS) {
+        if (func1 === functionName) return func2;
+        if (func2 === functionName) return func1;
+    }
+    return null;
+}
+
+// ===== FUNCTION NODE RULES =====
+export const functionRules = [
+    // General inverse function rule - handles all f(g(x)) = x where f and g are inverses
+    SimplificationEngine.createRule("Function Inverse Simplification",
+        (node) => {
+            // Check if this is a function node with exactly one argument
+            if (node.type !== 'omdFunctionNode' || !node.functionName || !node.argNodes || node.argNodes.length !== 1) {
+                return false;
+            }
+            
+            const outerFunction = node.functionName;
+            const arg = node.argNodes[0];
+            
+            // Check if the argument is also a function node with one argument
+            if (arg.type !== 'omdFunctionNode' || !arg.functionName || !arg.argNodes || arg.argNodes.length !== 1) {
+                return false;
+            }
+            
+            const innerFunction = arg.functionName;
+            
+            // Check if these are inverse functions
+            const expectedInverse = getInverse(outerFunction);
+            if (expectedInverse === innerFunction) {
+                return { 
+                    outerFunction,
+                    innerFunction, 
+                    innerArg: arg.argNodes[0]
+                };
+            }
+            
+            return false;
+        },
+        (node, data) => {
+            const newNode = data.innerArg.clone();
+            newNode.provenance.push(node.id, node.argNodes[0].id);
+            return newNode;
+        },
+        (originalNode, ruleData, newNode) => {
+            const { outerFunction, innerFunction } = ruleData;
+            const argStr = utils.nodeToString(ruleData.innerArg);
+            return `Simplified inverse functions: ${outerFunction}(${innerFunction}(${argStr})) = ${argStr}`;
+        }
+    ),
+
+    // Square root function to sqrt node conversion: sqrt(x) → √x
+    SimplificationEngine.createRule("Function to Sqrt Node",
+        (node) => {
+            if (node.type !== 'omdFunctionNode' || node.functionName !== 'sqrt' || !node.argNodes || node.argNodes.length !== 1) {
+                return false;
+            }
+            
+            return { argument: node.argNodes[0] };
+        },
+        (node, data) => {
+            // Create sqrt AST
+            const sqrtAst = {
+                type: 'FunctionNode',
+                fn: { type: 'SymbolNode', name: 'sqrt' },
+                args: [data.argument.toMathJSNode()]
+            };
+            
+            const newNode = new omdSqrtNode(sqrtAst);
+            newNode.setFontSize(node.getFontSize());
+            newNode.initialize();
+            newNode.provenance.push(node.id);
+            return newNode;
+        },
+        (originalNode, ruleData, newNode) => {
+            const argStr = utils.nodeToString(ruleData.argument);
+            return `Converted function to sqrt node: sqrt(${argStr}) = √${argStr}`;
+        }
+    )
+];

package/omd/simplification/rules/index.js

@@ -0,0 +1,48 @@
+// Import all rule categories
+import { binaryRules } from './binaryRules.js';
+import { rationalRules } from './rationalRules.js';
+import { parenthesisRules } from './parenthesisRules.js';
+import { unaryRules } from './unaryRules.js';
+import { powerRules } from './powerRules.js';
+import { sqrtRules } from './sqrtRules.js';
+import { functionRules } from './functionRules.js';
+
+// ===== RULES ORGANIZED BY NODE TYPE =====
+export const rules = {
+    // ===== BINARY EXPRESSION RULES =====
+    binary: binaryRules,
+
+    // ===== RATIONAL NODE RULES =====
+    rational: rationalRules,
+
+    // ===== PARENTHESIS NODE RULES =====
+    parenthesis: parenthesisRules,
+
+    // ===== UNARY EXPRESSION RULES =====
+    unary: unaryRules,
+
+    // ===== POWER NODE RULES =====
+    power: powerRules,
+
+    // ===== SQRT NODE RULES =====
+    sqrt: sqrtRules,
+
+    // ===== FUNCTION NODE RULES =====
+    function: functionRules
+};
+
+// ===== RULE LOOKUP MAP =====
+export const ruleMap = {
+    'omdBinaryExpressionNode': rules.binary,
+    'omdRationalNode': rules.rational,
+    'omdParenthesisNode': rules.parenthesis,
+    'omdUnaryExpressionNode': rules.unary,
+    'omdPowerNode': rules.power,
+    'omdSqrtNode': rules.sqrt,
+    'omdFunctionNode': rules.function
+};
+
+// ===== HELPER FUNCTION =====
+export function getRulesForNode(node) {
+    return ruleMap[node.type] || [];
+}

package/omd/simplification/rules/parenthesisRules.js

@@ -0,0 +1,19 @@
+import { SimplificationEngine } from '../omdSimplificationEngine.js';
+import * as utils from '../simplificationUtils.js';
+
+// ===== PARENTHESIS NODE RULES =====
+export const parenthesisRules = [
+    // Remove redundant parentheses (e.g., ((x))) → (x)
+    SimplificationEngine.createRule("Remove Redundant Parentheses",
+        (node) => SimplificationEngine.isType(node.expression, 'omdParenthesisNode'),
+        (node) => {
+            const newNode = node.expression.clone();
+            newNode.provenance.push(node.id);
+            return newNode;
+        },
+        (originalNode, ruleData, newNode) => {
+            const childStr = utils.nodeToString(originalNode.content);
+            return `Removed redundant parentheses around "${childStr}"`;
+        }
+    )
+];

package/omd/simplification/rules/powerRules.js

@@ -0,0 +1,143 @@
+import { omdSqrtNode } from '../../nodes/omdSqrtNode.js';
+import { SimplificationEngine } from '../omdSimplificationEngine.js';
+import * as utils from '../simplificationUtils.js';
+
+// ===== POWER NODE RULES =====
+export const powerRules = [
+    // Calculate constant powers (2^3 → 8)
+    SimplificationEngine.createRule("Calculate Powers",
+        (node) => {
+            if (!node.base.isConstant() || !node.exponent.isConstant()) return false;
+            const base = node.base.getValue();
+            const exp = node.exponent.getValue();
+            return { value: Math.pow(base, exp) };
+        },
+        (node, data) => {
+            const newNode = SimplificationEngine.createConstant(data.value, node.getFontSize());
+            newNode.provenance.push(node.id);
+            return newNode;
+        },
+        (originalNode, ruleData, newNode) => {
+            const { base, exponent } = originalNode;
+            const result = ruleData.value;
+            return `Calculated power: ${utils.nodeToString(base)}^${utils.nodeToString(exponent)} = ${result}`;
+        }
+    ),
+
+    // Power of zero (x^0 → 1)
+    SimplificationEngine.createRule("Power of Zero",
+        (node) => node.exponent.isConstant() && node.exponent.getValue() === 0,
+        (node) => {
+            const newNode = SimplificationEngine.createConstant(1, node.getFontSize());
+            newNode.provenance.push(node.id);
+            return newNode;
+        },
+        (originalNode, ruleData, newNode) => {
+            const { base } = originalNode;
+            return `Simplified power of zero: ${utils.nodeToString(base)}^0 = 1`;
+        }
+    ),
+
+    // Power of one (x^1 → x)
+    SimplificationEngine.createRule("Power of One",
+        (node) => node.exponent.isConstant() && node.exponent.getValue() === 1,
+        (node) => {
+            const newNode = node.base.clone();
+            newNode.provenance.push(node.id);
+            return newNode;
+        },
+        (originalNode, ruleData, newNode) => {
+            const { base } = originalNode;
+            return `Simplified power of one: ${utils.nodeToString(base)}^1 = ${utils.nodeToString(base)}`;
+        }
+    ),
+
+    // Expand polynomial powers like (x-2)^2 or (a+b)^3
+    SimplificationEngine.createRule("Expand Polynomial Power",
+        (node) => {
+            if (!node.exponent.isConstant()) return false;
+            const exp = node.exponent.getValue();
+            if (!Number.isInteger(exp) || exp < 2 || exp > 4) return false;
+
+            let baseExpr = SimplificationEngine.unwrapParentheses(node.base);
+
+            if (!SimplificationEngine.isBinaryOp(baseExpr, 'add') && 
+                !SimplificationEngine.isBinaryOp(baseExpr, 'subtract')) {
+                return false;
+            }
+
+            const terms = [];
+            utils.flattenSum(baseExpr, terms);
+            
+            if (terms.length > 5) return false;
+
+            return { baseExpression: baseExpr, terms, exponent: exp };
+        },
+        (node, data) => {
+            const { terms, exponent } = data;
+            const expandedTerms = utils.expandPolynomialPower(terms, exponent, node.getFontSize());
+            const result = utils.buildSumTree(expandedTerms, node.getFontSize());
+            
+            if (result) {
+                result.provenance.push(node.id);
+            }
+            
+            return result;
+        },
+        (originalNode, ruleData, newNode) => {
+            const { baseExpression, exponent } = ruleData;
+            const baseStr = utils.nodeToString(baseExpression);
+            return `Expanded polynomial power: (${baseStr})^${exponent}`;
+        }
+    ),
+
+    // Simplify (√x)² → x
+    SimplificationEngine.createRule("Square of Square Root",
+        (node) => {
+            if (!node.exponent.isConstant() || node.exponent.getValue() !== 2) return false;
+            if (node.base.type !== 'omdSqrtNode') return false;
+            
+            return { innerArg: node.base.argument };
+        },
+        (node, data) => {
+            const newNode = data.innerArg.clone();
+            newNode.provenance.push(node.id, node.base.id);
+            return newNode;
+        },
+        (originalNode, ruleData, newNode) => {
+            const argStr = utils.nodeToString(ruleData.innerArg);
+            return `Simplified square of square root: (√${argStr})² = ${argStr}`;
+        }
+    ),
+
+    // Simplify x^(1/2) → √x
+    SimplificationEngine.createRule("Fractional Exponent to Square Root",
+        (node) => {
+            if (!node.exponent.isConstant()) return false;
+            
+            // Check if exponent is 1/2 (0.5)
+            const exp = node.exponent.getValue();
+            if (Math.abs(exp - 0.5) > 0.0001) return false;
+            
+            return { base: node.base };
+        },
+        (node, data) => {
+            // Create sqrt AST
+            const sqrtAst = {
+                type: 'FunctionNode',
+                fn: { type: 'SymbolNode', name: 'sqrt' },
+                args: [data.base.toMathJSNode()]
+            };
+            
+            const newNode = new omdSqrtNode(sqrtAst);
+            newNode.setFontSize(node.getFontSize());
+            newNode.initialize();
+            newNode.provenance.push(node.id);
+            return newNode;
+        },
+        (originalNode, ruleData, newNode) => {
+            const baseStr = utils.nodeToString(ruleData.base);
+            return `Converted fractional exponent to square root: ${baseStr}^(1/2) = √${baseStr}`;
+        }
+    )
+];