@teachinglab/omd 0.6.0 → 0.6.2

package/omd/simplification/simplificationUtils.js

@@ -1,1056 +1,1056 @@
-import { omdConstantNode } from "../nodes/omdConstantNode.js";
-import { omdBinaryExpressionNode } from "../nodes/omdBinaryExpressionNode.js";
-import { omdNode } from "../nodes/omdNode.js";
-import { omdRationalNode } from "../nodes/omdRationalNode.js";
-import { omdUnaryExpressionNode } from "../nodes/omdUnaryExpressionNode.js";
-import { omdPowerNode } from "../nodes/omdPowerNode.js";
-import { omdVariableNode } from "../nodes/omdVariableNode.js";
-import { SimplificationEngine } from "./omdSimplificationEngine.js";
-import { getMultiplicationSymbol } from '../config/omdConfigManager.js';
-
-// ===== MANUAL PROVENANCE HELPER FUNCTIONS =====
-
-/**
- * Manually applies provenance from source nodes to a target node
- * @param {omdNode} targetNode - The node to apply provenance to
- * @param {...omdNode} sourceNodes - The source nodes to collect provenance from
- * @returns {omdNode} The target node with applied provenance
- */
-export function applyProvenance(targetNode, ...sourceNodes) {
-    if (!targetNode) return targetNode;
-    
-    targetNode.provenance = targetNode.provenance || [];
-    
-    for (const sourceNode of sourceNodes) {
-        if (!sourceNode) continue;
-        
-        // Add the source node's ID
-        if (sourceNode.id && !targetNode.provenance.includes(sourceNode.id)) {
-            targetNode.provenance.push(sourceNode.id);
-        }
-        
-        // Add all of the source node's provenance
-        if (sourceNode.provenance && Array.isArray(sourceNode.provenance)) {
-            sourceNode.provenance.forEach(id => {
-                if (id && !targetNode.provenance.includes(id)) {
-                    targetNode.provenance.push(id);
-                }
-            });
-        }
-        
-        // Recursively collect from children
-        collectChildIds(sourceNode, targetNode.provenance);
-    }
-    
-    return targetNode;
-}
-
-/**
- * Recursively collects IDs from child nodes
- * @param {omdNode} node - The node to collect from
- * @param {Array} idSet - The array to add IDs to
- */
-function collectChildIds(node, idSet) {
-    if (!node || !idSet) return;
-    
-    // Visit common child properties
-    const childProps = ['left', 'right', 'base', 'exponent', 'argument', 'expression', 
-                       'numerator', 'denominator', 'content'];
-    
-    for (const prop of childProps) {
-        const child = node[prop];
-        if (child && child.id && !idSet.includes(child.id)) {
-            idSet.push(child.id);
-            // Recursively collect from grandchildren
-            collectChildIds(child, idSet);
-        }
-    }
-    
-    // Handle array properties like args
-    if (node.args && Array.isArray(node.args)) {
-        node.args.forEach(arg => {
-            if (arg && arg.id && !idSet.includes(arg.id)) {
-                idSet.push(arg.id);
-                collectChildIds(arg, idSet);
-            }
-        });
-    }
-}
-
-/**
- * Calculates the greatest common divisor of two numbers.
- * @param {number} a
- * @param {number} b
- * @returns {number} The GCD of a and b.
- */
-export function gcd(a, b) {
-    a = Math.abs(a);
-    b = Math.abs(b);
-    while(b) {
-        [a, b] = [b, a % b];
-    }
-    return a;
-}
-
-/**
- * Applies a mathematical operation to two numbers.
- * @param {string} op - The operator ('add', 'subtract', 'multiply', 'divide', or symbolic representation).
- * @param {number} left - The left operand.
- * @param {number} right - The right operand.
- * @returns {number|null} The result of the operation, or null if the operation is invalid (e.g., division by zero).
- */
-export function _applyOperator(op, left, right) {
-    switch (op) {
-        case 'add':
-            return left + right;
-        case 'subtract':
-            return left - right;
-        case 'multiply':
-            return left * right;
-        case 'divide':
-            return right !== 0 ? left / right : null;
-        default:
-            return null;
-    }
-}
-
-/**
- * Creates a new, fully initialized `omdConstantNode`.
- * @param {number} value - The numerical value for the constant.
- * @param {number} fontSize - The font size to render the node with.
- * @returns {omdConstantNode} The newly created constant node.
- */
-export function createConstantNode(value, fontSize) {
-    const newConstantAST = { type: 'ConstantNode', value: value, clone: function () { return { ...this }; } };
-    const newConstantNode = new omdConstantNode(newConstantAST);
-    newConstantNode.setFontSize(fontSize);
-    newConstantNode.initialize();
-    return newConstantNode;
-}
-
-/**
- * Helper to safely replace an old node with a new node in the tree.
- * Handles both root node replacement and child node replacement.
- * @param {omdNode} oldNode - The node to be replaced.
- * @param {omdNode} newNode - The new node to insert.
- * @param {omdNode} currentRoot - The current root of the entire expression tree.
- * @returns {{success: boolean, newRoot: omdNode}} The result of the operation.
- */
-export function _replaceNodeInTree(oldNode, newNode, currentRoot) {
-    if (oldNode === currentRoot) {
-        return { success: true, newRoot: newNode };
-    }
-    
-    // This ensures layout updates are triggered during the replacement itself to maintain visual consistency.
-    const success = oldNode.replaceWith(newNode, { updateLayout: true });
-
-    // Update the astNodeData for the new node and propagate changes upwards
-    if (success) {
-        newNode.astNodeData = newNode.toMathJSNode();
-        let current = newNode.parent;
-        while (current) {
-            // Only update astNodeData for actual omdNodes
-            if (current instanceof omdNode) {
-                current.astNodeData = current.toMathJSNode();
-            } else {
-                // Stop traversing if we encounter a non-omdNode parent (like jsvgContainer)
-                break;
-            }
-            current = current.parent;
-        }
-    }
-
-    return { success: success, newRoot: currentRoot };
-}
-
-/**
- * Extracts all leaf nodes (constants and variables) from an expression tree
- * for granular provenance tracking
- */
-export function extractLeafNodes(node) {
-    const leafNodes = [];
-    
-    function traverse(n) {
-        if (!n) return;
-        
-        // If it's a leaf node (constant or variable), add it
-        if (n.type === 'omdConstantNode' || 
-            n.type === 'omdVariableNode') {
-            leafNodes.push(n);
-            return;
-        }
-        
-        // Recursively traverse child nodes
-        if (n.left) traverse(n.left);
-        if (n.right) traverse(n.right);
-        if (n.base) traverse(n.base);
-        if (n.exponent) traverse(n.exponent);
-        if (n.argument) traverse(n.argument);
-        if (n.expression) traverse(n.expression);
-        if (n.numerator) traverse(n.numerator);
-        if (n.denominator) traverse(n.denominator);
-    }
-    
-    traverse(node);
-    return leafNodes;
-}
-
-/**
- * Recursively flattens a tree of additions and subtractions into a single list of terms.
- * Each term is an object containing the node and its sign (1 for addition, -1 for subtraction).
- * For example, `a - (b + c)` becomes `[{node: a, sign: 1}, {node: b, sign: -1}, {node: c, sign: -1}]`.
- * @param {omdNode} node - The current node in the expression tree to process.
- * @param {Array<Object>} terms - An array to accumulate the flattened terms. This array is modified by the function.
- */
-export function flattenSum(node, terms) {
-    const op = node.operation;
-    if (node.type === 'omdBinaryExpressionNode' && (op === 'add' || op === '+')) {
-        flattenSum(node.left, terms);
-        flattenSum(node.right, terms);
-    } else if (node.type === 'omdBinaryExpressionNode' && (op === 'subtract' || op === '-')) {
-        flattenSum(node.left, terms);
-        const rightTerms = [];
-        flattenSum(node.right, rightTerms);
-        rightTerms.forEach(t => { t.sign *= -1; }); // Invert the sign for all terms on the right of a minus.
-        terms.push(...rightTerms);
-    } else {
-        // This is a leaf node in the sum (could be a variable, a multiplication, etc.)
-        // Extract leaf nodes for granular provenance tracking
-        const leafNodes = extractLeafNodes(node);
-        terms.push({ 
-            node: node, 
-            sign: 1,
-            leafNodes: leafNodes // Add leaf nodes for provenance
-        });
-    }
-}
-
-export function buildSumTree(terms, fontSize) {
-    if (terms.length === 0) return createConstantNode(0, fontSize);
-
-    // Sort terms to handle subtractions gracefully
-    terms.sort((a, b) => b.sign - a.sign);
-    
-    // If the expression starts with a negative term (e.g., -a + b), we prepend a '0'
-    if (terms.length > 1 && terms[0].sign === -1) {
-        if (terms[0].node.type === 'omdConstantNode') {
-            const first = terms.shift();
-            first.sign = 1; 
-            terms.push(first);
-        } else {
-            terms.unshift({node: createConstantNode(0, fontSize), sign: 1});
-        }
-    }
-
-    // Build the tree from left to right
-    let firstTerm = terms.shift();
-    let currentTree = firstTerm.node;
-    
-    // Ensure the first node is properly formed - clone it if needed
-    if (!currentTree || typeof currentTree.updateLayoutUpwards !== 'function') {
-        const originalId = currentTree.id;
-        currentTree = currentTree.clone();
-        currentTree.provenance = currentTree.provenance || [];
-        if (originalId && !currentTree.provenance.includes(originalId)) {
-            currentTree.provenance.push(originalId);
-        }
-        currentTree.setFontSize(fontSize);
-        currentTree.initialize();
-    }
-    
-    // If there's only one term, return it directly (it should already have correct provenance)
-    if (terms.length === 0) {
-        return currentTree;
-    }
-    
-    while (terms.length > 0) {
-        const term = terms.shift();
-        const opSymbol = term.sign === 1 ? '+' : '-';
-        const opFn = term.sign === 1 ? 'add' : 'subtract';
-
-        let termNode = term.node;
-        
-        if (!termNode || typeof termNode.updateLayoutUpwards !== 'function') {
-            const originalId = termNode.id;
-            termNode = termNode.clone();
-            termNode.provenance = termNode.provenance || [];
-            if (originalId && !termNode.provenance.includes(originalId)) {
-                termNode.provenance.push(originalId);
-            }
-            termNode.setFontSize(fontSize);
-            termNode.initialize();
-        }
-
-        // Preserve expansion provenance metadata if it exists
-        if (term.expansionProvenance) {
-            // Add expansion metadata to the term node for later reference
-            termNode.expansionProvenance = termNode.expansionProvenance || [];
-            termNode.expansionProvenance.push(term.expansionProvenance);
-            
-            // Ensure all expansion source IDs are in the term's provenance
-            [term.expansionProvenance.leftSource, term.expansionProvenance.rightSource, term.expansionProvenance.originalMultiplication].forEach(id => {
-                if (id && !termNode.provenance.includes(id)) {
-                    termNode.provenance.push(id);
-                }
-            });
-        }
-
-        // Create new binary expression
-        const newAST = {
-            type: 'OperatorNode',
-            op: opSymbol,
-            fn: opFn,
-            args: [currentTree.toMathJSNode(), termNode.toMathJSNode()],
-            clone: function () { return { ...this, args: this.args.map(arg => arg.clone()) }; }
-        };
-        
-        const newNode = new omdBinaryExpressionNode(newAST);
-        newNode.setFontSize(fontSize);
-        newNode.initialize();
-        
-        // Binary operation nodes should inherit provenance from their operands
-        // This allows tracking which terms contributed to the final expression
-        const leftProvenance = currentTree.provenance || [];
-        const rightProvenance = termNode.provenance || [];
-        
-        // Add provenance from both left and right operands
-        [...leftProvenance, ...rightProvenance, currentTree.id, termNode.id].forEach(id => {
-            if (id && !newNode.provenance.includes(id)) {
-                newNode.provenance.push(id);
-            }
-        });
-        
-        // Preserve expansion provenance metadata in the binary expression
-        if (termNode.expansionProvenance || currentTree.expansionProvenance) {
-            newNode.expansionProvenance = newNode.expansionProvenance || [];
-            if (termNode.expansionProvenance) {
-                newNode.expansionProvenance.push(...termNode.expansionProvenance);
-            }
-            if (currentTree.expansionProvenance) {
-                newNode.expansionProvenance.push(...currentTree.expansionProvenance);
-            }
-        }
-        
-        currentTree = newNode;
-    }
-    
-    return currentTree;
-}
-
-/**
- * Creates a rational node (fraction) safely with proper initialization
- * @param {number} numerator - The numerator value
- * @param {number} denominator - The denominator value  
- * @param {number} fontSize - The font size for the node
- * @returns {omdNode} A properly initialized rational or constant node
- */
-export function createRationalNode(numerator, denominator, fontSize) {
-    // If denominator is 1, just return a constant
-    if (denominator === 1) {
-        return createConstantNode(numerator, fontSize);
-    }
-    
-    // Create AST for the rational node
-    const ast = {
-        type: 'OperatorNode', 
-        op: '/', 
-        fn: 'divide',
-        args: [
-            { type: 'ConstantNode', value: Math.abs(numerator), clone: function() { return {...this}; } },
-            { type: 'ConstantNode', value: denominator, clone: function() { return {...this}; } }
-        ],
-        clone: function() { return { ...this, args: this.args.map(arg => arg.clone()) }; }
-    };
-    
-    let node = new omdRationalNode(ast);
-    
-    // Handle negative fractions by wrapping in unary minus
-    if (numerator < 0) {
-        const unaryAST = {
-            type: 'OperatorNode', 
-            op: '-', 
-            fn: 'unaryMinus',
-            args: [node.toMathJSNode()],
-            clone: function() { return { ...this, args: this.args.map(arg => arg.clone()) }; }
-        };
-        node = new omdUnaryExpressionNode(unaryAST);
-    }
-    
-    node.setFontSize(fontSize);
-    node.initialize();
-    
-    return node;
-}
-
-/**
- * Converts any omdNode into a human-readable string representation.
- * @param {omdNode} node - The node to convert.
- * @returns {string} A string representation of the node.
- */
-export function nodeToString(node) {
-    if (!node) return '';
-
-    // Operation name to symbol mapping
-    const operationSymbols = {
-        'add': '+',
-        'subtract': '-',
-        'multiply': getMultiplicationSymbol(),
-        'divide': '÷',
-        'unaryMinus': '-',
-        'unaryPlus': '+',
-        'pow': '^'
-    };
-
-    // Check for a getValue method (constants) - but only if actually constant
-    if (typeof node.getValue === 'function' && node.isConstant && node.isConstant()) {
-        return node.getValue().toString();
-    }
-
-    // Check for a name property (variables)
-    if (node.name) {
-        return node.name;
-    }
-
-    // Handle binary expressions recursively
-    if (node.type === 'omdBinaryExpressionNode') {
-        const left = nodeToString(node.left);
-        const right = nodeToString(node.right);
-        // Handle cases where node.op might be null (implicit multiplication)
-        let op;
-        if (node.op && node.op.opName) {
-            op = operationSymbols[node.op.opName] || node.op.opName;
-        } else if (node.operation) {
-            op = operationSymbols[node.operation] || node.operation;
-        } else {
-            // For implicit multiplication, use empty string
-            op = ''; // This handles cases like "2x" where it's implicit multiplication
-        }
-        // Only add parentheses for explicit operations, not implicit multiplication
-        return op ? `${left} ${op} ${right}` : `${left}${right}`;
-    }
-
-    // Handle unary expressions
-    if (node.type === 'omdUnaryExpressionNode') {
-        const arg = nodeToString(node.argument);
-        let op;
-        if (node.op && node.op.opName) {
-            op = operationSymbols[node.op.opName] || node.op.opName;
-        } else if (node.operation) {
-            op = operationSymbols[node.operation] || node.operation;
-        } else {
-            op = '-'; // Default for unary
-        }
-        // Only add parentheses around the argument if it's a complex expression
-        if (arg.includes(' ') || arg.includes('+') || arg.includes('-') || arg.includes(getMultiplicationSymbol()) || arg.includes('÷')) {
-            return `${op}(${arg})`;
-        }
-        return `${op}${arg}`;
-    }
-    
-    // Handle rational nodes
-    if (node.type === 'omdRationalNode') {
-        const num = nodeToString(node.numerator);
-        const den = nodeToString(node.denominator);
-        return `(${num}/${den})`;
-    }
-
-    // Handle parenthesis nodes
-    if (node.type === 'omdParenthesisNode') {
-        const content = nodeToString(node.content || node.expression);
-        // Only add parentheses if the content doesn't already start and end with them
-        if (content.startsWith('(') && content.endsWith(')')) {
-            return content;
-        }
-        return `(${content})`;
-    }
-
-    // Handle power nodes
-    if (node.type === 'omdPowerNode') {
-        const base = nodeToString(node.base);
-        const exp = nodeToString(node.exponent);
-        return `${base}^${exp}`;
-    }
-
-    // Handle sqrt nodes
-    if (node.type === 'omdSqrtNode') {
-        const arg = nodeToString(node.argument);
-        return `√(${arg})`;
-    }
-
-    // Handle function nodes
-    if (node.type === 'omdFunctionNode') {
-        const functionName = node.functionName || node.name || 'f';
-        if (node.argNodes && node.argNodes.length > 0) {
-            const args = node.argNodes.map(arg => nodeToString(arg)).join(', ');
-            return `${functionName}(${args})`;
-        } else if (node.args && node.args.length > 0) {
-            const args = node.args.map(arg => nodeToString(arg)).join(', ');
-            return `${functionName}(${args})`;
-        }
-        return `${functionName}()`;
-    }
-
-    // Handle equation nodes
-    if (node.type === 'omdEquationNode') {
-        const left = nodeToString(node.left);
-        const right = nodeToString(node.right);
-        return `${left} = ${right}`;
-    }
-
-    // Fallback for other node types - try toString method first
-    if (typeof node.toString === 'function') {
-        try {
-            return node.toString();
-        } catch (e) {
-            // Continue to next fallback
-        }
-    }
-
-    // Use math.js as final fallback
-    if (node.toMathJSNode) {
-        try {
-            return math.parse(node.toMathJSNode()).toString();
-        } catch (e) {
-            // Continue to final fallback
-        }
-    }
-
-    // Use node name if available, otherwise use constructor name as last resort
-    return node.name || node.type || '[unknown]';
-}
-
-// ===== POLYNOMIAL EXPANSION HELPER FUNCTIONS =====
-
-/**
- * Expands a polynomial power using multinomial expansion
- * For example: (a + b)^2 = a^2 + 2ab + b^2
- * @param {Array} terms - Array of {node, sign} objects representing the polynomial terms
- * @param {number} exponent - The power to expand to
- * @param {number} fontSize - Font size for new nodes
- * @returns {Array} Array of {node, sign} objects representing the expanded terms
- */
-export function expandPolynomialPower(terms, exponent, fontSize) {
-    if (exponent === 1) {
-        return terms;
-    }
-    
-    if (exponent === 2) {
-        return expandBinomialSquare(terms, fontSize);
-    }
-    
-    if (exponent === 3) {
-        return expandBinomialCube(terms, fontSize);
-    }
-    
-    if (exponent === 4) {
-        return expandBinomialFourth(terms, fontSize);
-    }
-    
-    // For higher powers, use recursive multiplication
-    let result = terms;
-    for (let i = 1; i < exponent; i++) {
-        result = multiplyTermArrays(result, terms, fontSize);
-    }
-    
-    return result;
-}
-
-/**
- * Expands (a + b + ...)^2 using the multinomial theorem
- */
-export function expandBinomialSquare(terms, fontSize) {
-    const expandedTerms = [];
-    
-    // Square terms: a^2, b^2, ...
-    for (const term of terms) {
-        const squaredNode = SimplificationEngine.createBinaryOp(
-            term.node.clone(),
-            'multiply',
-            term.node.clone(),
-            fontSize
-        );
-        
-        // Use granular provenance from leaf nodes
-        const leafNodes = term.leafNodes || [];
-        leafNodes.forEach(leafNode => {
-            [squaredNode.left, squaredNode.right, squaredNode].forEach(part => {
-                if (part && !part.provenance.includes(leafNode.id)) {
-                    part.provenance.push(leafNode.id);
-                }
-            });
-        });
-        
-        expandedTerms.push({
-            node: squaredNode,
-            sign: term.sign * term.sign // Always positive since we're squaring
-        });
-    }
-    
-    // Cross terms: 2ab, 2ac, 2bc, ...
-    for (let i = 0; i < terms.length; i++) {
-        for (let j = i + 1; j < terms.length; j++) {
-            const term1 = terms[i];
-            const term2 = terms[j];
-            
-            // Create 2 * term1 * term2
-            const coefficient2 = SimplificationEngine.createConstant(2, fontSize);
-            const product1 = SimplificationEngine.createBinaryOp(
-                coefficient2,
-                'multiply',
-                term1.node.clone(),
-                fontSize
-            );
-            const finalProduct = SimplificationEngine.createBinaryOp(
-                product1,
-                'multiply',
-                term2.node.clone(),
-                fontSize
-            );
-            
-            // Use granular provenance from both terms
-            const allLeafNodes = [...(term1.leafNodes || []), ...(term2.leafNodes || [])];
-            allLeafNodes.forEach(leafNode => {
-                [product1.right, finalProduct.right, finalProduct].forEach(part => {
-                    if (part && !part.provenance.includes(leafNode.id)) {
-                        part.provenance.push(leafNode.id);
-                    }
-                });
-            });
-            
-            expandedTerms.push({
-                node: finalProduct,
-                sign: term1.sign * term2.sign
-            });
-        }
-    }
-    
-    return expandedTerms;
-}
-
-/**
- * Expands (a + b + ...)^3 for binomial/trinomial cases
- */
-export function expandBinomialCube(terms, fontSize) {
-    if (terms.length === 2) {
-        const [term1, term2] = terms;
-        const expandedTerms = [];
-        
-        // Use the efficient helper functions with provenance
-        expandedTerms.push({ 
-            node: createPowerTermWithProvenance(term1.node, 3, fontSize, term1.leafNodes), 
-            sign: Math.pow(term1.sign, 3) 
-        });
-        expandedTerms.push({ 
-            node: createCoefficientProductTermWithProvenance(3, term1.node, 2, term2.node, 1, fontSize, term1.leafNodes, term2.leafNodes), 
-            sign: Math.pow(term1.sign, 2) * term2.sign 
-        });
-        expandedTerms.push({ 
-            node: createCoefficientProductTermWithProvenance(3, term1.node, 1, term2.node, 2, fontSize, term1.leafNodes, term2.leafNodes), 
-            sign: term1.sign * Math.pow(term2.sign, 2) 
-        });
-        expandedTerms.push({ 
-            node: createPowerTermWithProvenance(term2.node, 3, fontSize, term2.leafNodes), 
-            sign: Math.pow(term2.sign, 3) 
-        });
-        
-        return expandedTerms;
-    }
-    
-    // For more than 2 terms, use general multiplication
-    return multiplyTermArrays(expandBinomialSquare(terms, fontSize), terms, fontSize);
-}
-
-/**
- * Expands (a + b)^4 = a^4 + 4a^3b + 6a^2b^2 + 4ab^3 + b^4
- */
-export function expandBinomialFourth(terms, fontSize) {
-    if (terms.length === 2) {
-        const [term1, term2] = terms;
-        const expandedTerms = [];
-        
-        // Use the efficient helper functions with provenance
-        expandedTerms.push({ 
-            node: createPowerTermWithProvenance(term1.node, 4, fontSize, term1.leafNodes), 
-            sign: Math.pow(term1.sign, 4) 
-        });
-        expandedTerms.push({ 
-            node: createCoefficientProductTermWithProvenance(4, term1.node, 3, term2.node, 1, fontSize, term1.leafNodes, term2.leafNodes), 
-            sign: Math.pow(term1.sign, 3) * term2.sign 
-        });
-        expandedTerms.push({ 
-            node: createCoefficientProductTermWithProvenance(6, term1.node, 2, term2.node, 2, fontSize, term1.leafNodes, term2.leafNodes), 
-            sign: Math.pow(term1.sign, 2) * Math.pow(term2.sign, 2) 
-        });
-        expandedTerms.push({ 
-            node: createCoefficientProductTermWithProvenance(4, term1.node, 1, term2.node, 3, fontSize, term1.leafNodes, term2.leafNodes), 
-            sign: term1.sign * Math.pow(term2.sign, 3) 
-        });
-        expandedTerms.push({ 
-            node: createPowerTermWithProvenance(term2.node, 4, fontSize, term2.leafNodes), 
-            sign: Math.pow(term2.sign, 4) 
-        });
-        
-        return expandedTerms;
-    }
-    
-    // For more than 2 terms, use general multiplication
-    const cubed = expandBinomialCube(terms, fontSize);
-    return multiplyTermArrays(cubed, terms, fontSize);
-}
-
-/**
- * Creates a term like x^n with granular provenance tracking
- */
-export function createPowerTermWithProvenance(baseNode, power, fontSize, leafNodes) {
-    if (power === 1) {
-        const cloned = baseNode.clone();
-        // Add leaf node provenance
-        if (leafNodes && leafNodes.length > 0) {
-            leafNodes.forEach(leafNode => {
-                if (!cloned.provenance.includes(leafNode.id)) {
-                    cloned.provenance.push(leafNode.id);
-                }
-            });
-        }
-        return cloned;
-    }
-    
-    const powerConstant = SimplificationEngine.createConstant(power, fontSize);
-    
-    // Create power node AST structure
-    const powerAST = {
-        type: 'OperatorNode',
-        op: '^',
-        fn: 'pow',
-        args: [baseNode.toMathJSNode(), powerConstant.toMathJSNode()],
-        clone: function() { 
-            return { 
-                ...this, 
-                args: this.args.map(arg => arg.clone()) 
-            }; 
-        }
-    };
-    
-    const powerNode = new omdPowerNode(powerAST);
-    powerNode.setFontSize(fontSize);
-    powerNode.initialize();
-    
-    // Add leaf node provenance
-    if (leafNodes && leafNodes.length > 0) {
-        leafNodes.forEach(leafNode => {
-            if (!powerNode.base.provenance.includes(leafNode.id)) {
-                powerNode.base.provenance.push(leafNode.id);
-            }
-            if (!powerNode.provenance.includes(leafNode.id)) {
-                powerNode.provenance.push(leafNode.id);
-            }
-        });
-    } else {
-        powerNode.base.provenance.push(baseNode.id);
-        powerNode.provenance.push(baseNode.id);
-    }
-    
-    return powerNode;
-}
-
-/**
- * Creates a term like c * a^p1 * b^p2 with granular provenance tracking
- */
-export function createCoefficientProductTermWithProvenance(coefficient, node1, power1, node2, power2, fontSize, leafNodes1, leafNodes2) {
-    let result = SimplificationEngine.createConstant(coefficient, fontSize);
-    
-    // Multiply by node1^power1
-    if (power1 > 0) {
-        const term1 = createPowerTermWithProvenance(node1, power1, fontSize, leafNodes1);
-        result = SimplificationEngine.createBinaryOp(result, 'multiply', term1, fontSize);
-        
-        // Add leaf node provenance to the result
-        if (leafNodes1 && leafNodes1.length > 0) {
-            leafNodes1.forEach(leafNode => {
-                if (!result.provenance.includes(leafNode.id)) {
-                    result.provenance.push(leafNode.id);
-                }
-            });
-        }
-    }
-    
-    // Multiply by node2^power2
-    if (power2 > 0) {
-        const term2 = createPowerTermWithProvenance(node2, power2, fontSize, leafNodes2);
-        result = SimplificationEngine.createBinaryOp(result, 'multiply', term2, fontSize);
-        
-        // Add leaf node provenance to the result
-        if (leafNodes2 && leafNodes2.length > 0) {
-            leafNodes2.forEach(leafNode => {
-                if (!result.provenance.includes(leafNode.id)) {
-                    result.provenance.push(leafNode.id);
-                }
-            });
-        }
-    }
-    
-    return result;
-}
-
-/**
- * Creates a term like x^n
- */
-export function createPowerTerm(baseNode, power, fontSize) {
-    if (power === 1) {
-        return baseNode.clone();
-    }
-    
-    const powerConstant = SimplificationEngine.createConstant(power, fontSize);
-    
-    // Create power node AST structure
-    const powerAST = {
-        type: 'OperatorNode',
-        op: '^',
-        fn: 'pow',
-        args: [baseNode.toMathJSNode(), powerConstant.toMathJSNode()],
-        clone: function() { 
-            return { 
-                ...this, 
-                args: this.args.map(arg => arg.clone()) 
-            }; 
-        }
-    };
-    
-    const powerNode = new omdPowerNode(powerAST);
-    powerNode.setFontSize(fontSize);
-    powerNode.initialize();
-    
-    return powerNode;
-}
-
-/**
- * Creates a term like c * a^p1 * b^p2
- */
-export function createCoefficientProductTerm(coefficient, node1, power1, node2, power2, fontSize) {
-    let result = SimplificationEngine.createConstant(coefficient, fontSize);
-    
-    // Multiply by node1^power1
-    if (power1 > 0) {
-        const term1 = createPowerTerm(node1, power1, fontSize);
-        result = SimplificationEngine.createBinaryOp(result, 'multiply', term1, fontSize);
-    }
-    
-    // Multiply by node2^power2
-    if (power2 > 0) {
-        const term2 = createPowerTerm(node2, power2, fontSize);
-        result = SimplificationEngine.createBinaryOp(result, 'multiply', term2, fontSize);
-    }
-    
-    return result;
-}
-
-/**
- * Multiplies two arrays of terms (for general polynomial multiplication)
- */
-export function multiplyTermArrays(terms1, terms2, fontSize) {
-    const result = [];
-    
-    for (const term1 of terms1) {
-        for (const term2 of terms2) {
-            const productNode = SimplificationEngine.createBinaryOp(
-                term1.node.clone(),
-                'multiply',
-                term2.node.clone(),
-                fontSize
-            );
-            
-            // Add granular provenance from leaf nodes of both terms
-            const allLeafNodes = [...(term1.leafNodes || []), ...(term2.leafNodes || [])];
-            allLeafNodes.forEach(leafNode => {
-                [productNode.left, productNode.right, productNode].forEach(part => {
-                    if (part && !part.provenance.includes(leafNode.id)) {
-                        part.provenance.push(leafNode.id);
-                    }
-                });
-            });
-            
-            result.push({
-                node: productNode,
-                sign: term1.sign * term2.sign,
-                leafNodes: allLeafNodes
-            });
-        }
-    }
-    
-    return result;
-}
-
-/**
- * Creates a monomial with granular provenance tracking for coefficients and variables separately
- */
-export function createMonomialWithGranularProvenance(coefficient, variable, power, fontSize, coefficientProvenance = [], variableProvenance = []) {
-    // Create variable node
-    const variableAST = { type: 'SymbolNode', name: variable, clone: function() { return {...this}; } };
-    const variableNode = new (SimplificationEngine.getNodeClass('omdVariableNode'))(variableAST);
-    variableNode.setFontSize(fontSize);
-    variableNode.initialize();
-    
-    // Set variable-specific provenance
-    if (variableProvenance && variableProvenance.length > 0) {
-        variableNode.provenance = [...variableProvenance];
-    }
-    
-    let termNode = variableNode;
-    
-    // Add power if not 1
-    if (power !== 1) {
-        const powerAST = {
-            type: 'OperatorNode',
-            op: '^',
-            fn: 'pow',
-            args: [variableAST, { type: 'ConstantNode', value: power, clone: function() { return {...this}; } }],
-            clone: function() { return { ...this, args: this.args.map(arg => arg.clone()) }; }
-        };
-        termNode = new (SimplificationEngine.getNodeClass('omdPowerNode'))(powerAST);
-        termNode.setFontSize(fontSize);
-        termNode.initialize();
-        
-        // Set variable provenance on the base, power gets no special provenance
-        if (termNode.base && variableProvenance && variableProvenance.length > 0) {
-            termNode.base.provenance = [...variableProvenance];
-        }
-    }
-    
-    let result;
-    if (coefficient === 1) {
-        result = termNode;
-    } else if (coefficient === -1) {
-        // Create unary minus
-        const unaryAST = {
-            type: 'OperatorNode',
-            op: '-',
-            fn: 'unaryMinus',
-            args: [termNode.toMathJSNode()],
-            clone: function() { return { ...this, args: this.args.map(arg => arg.clone()) }; }
-        };
-        result = new (SimplificationEngine.getNodeClass('omdUnaryExpressionNode'))(unaryAST);
-        result.setFontSize(fontSize);
-        result.initialize();
-        
-        // The argument preserves variable provenance
-        if (result.argument && variableProvenance && variableProvenance.length > 0) {
-            result.argument.provenance = [...variableProvenance];
-        }
-    } else {
-        // Create coefficient * term
-        const coeffNode = SimplificationEngine.createConstant(Math.abs(coefficient), fontSize);
-        
-        // Set coefficient-specific provenance
-        if (coefficientProvenance && coefficientProvenance.length > 0) {
-            coeffNode.provenance = [...coefficientProvenance];
-        }
-        
-        const multiplicationNode = SimplificationEngine.createBinaryOp(coeffNode, 'multiply', termNode, fontSize);
-        
-        // Apply granular provenance: coefficient to left, variable to right
-        if (multiplicationNode.left && coefficientProvenance && coefficientProvenance.length > 0) {
-            multiplicationNode.left.provenance = [...coefficientProvenance];
-        }
-        if (multiplicationNode.right && variableProvenance && variableProvenance.length > 0) {
-            multiplicationNode.right.provenance = [...variableProvenance];
-        }
-        
-        // Wrap in unary minus if coefficient is negative
-        if (coefficient < 0) {
-            const unaryAST = {
-                type: 'OperatorNode',
-                op: '-',
-                fn: 'unaryMinus',
-                args: [multiplicationNode.toMathJSNode()],
-                clone: function() { return { ...this, args: this.args.map(arg => arg.clone()) }; }
-            };
-            result = new (SimplificationEngine.getNodeClass('omdUnaryExpressionNode'))(unaryAST);
-            result.setFontSize(fontSize);
-            result.initialize();
-            
-            // Preserve granular provenance within the unary minus
-            if (result.argument) {
-                if (result.argument.left && coefficientProvenance && coefficientProvenance.length > 0) {
-                    result.argument.left.provenance = [...coefficientProvenance];
-                }
-                if (result.argument.right && variableProvenance && variableProvenance.length > 0) {
-                    result.argument.right.provenance = [...variableProvenance];
-                }
-            }
-        } else {
-            result = multiplicationNode;
-        }
-    }
-    
-    return result;
-}
-
-/**
- * Extracts coefficient and variable leaf nodes separately from a monomial term
- * for granular provenance tracking in like term combination
- */
-export function extractMonomialProvenance(termNode) {
-    const coefficientNodes = [];
-    const variableNodes = [];
-    
-    function traverse(node, isInCoefficient = false) {
-        if (!node) return;
-        
-        // If we find a variable node, it goes to variables
-        if (node.type === 'omdVariableNode') {
-            variableNodes.push(node);
-            return;
-        }
-        
-        // If we find a constant node
-        if (node.type === 'omdConstantNode') {
-            // If we're in a power expression, this is likely an exponent, not a coefficient
-            if (node.parent && node.parent.type === 'omdPowerNode' && node.parent.exponent === node) {
-                // Skip exponents for provenance purposes
-                return;
-            }
-            // Otherwise, it's a coefficient
-            coefficientNodes.push(node);
-            return;
-        }
-        
-        // For power nodes, traverse base for variables
-        if (node.type === 'omdPowerNode') {
-            if (node.base) traverse(node.base, false);
-            // Don't traverse exponent for provenance
-            return;
-        }
-        
-        // For binary operations, determine what we're looking at
-        if (node.type === 'omdBinaryExpressionNode') {
-            if (node.operation === 'multiply') {
-                // In multiplication, left is often coefficient, right is often variable
-                if (node.left) traverse(node.left, true);
-                if (node.right) traverse(node.right, false);
-            } else {
-                // For other operations, traverse both sides
-                if (node.left) traverse(node.left, isInCoefficient);
-                if (node.right) traverse(node.right, isInCoefficient);
-            }
-            return;
-        }
-        
-        // For unary operations, traverse the argument
-        if (node.type === 'omdUnaryExpressionNode') {
-            if (node.argument) traverse(node.argument, isInCoefficient);
-            return;
-        }
-        
-        // For other node types, try to traverse child properties
-        ['left', 'right', 'base', 'exponent', 'argument', 'expression', 'numerator', 'denominator'].forEach(prop => {
-            if (node[prop]) traverse(node[prop], isInCoefficient);
-        });
-    }
-    
-    traverse(termNode);
-    
-    return {
-        coefficientNodes,
-        variableNodes
-    };
+import { omdConstantNode } from "../nodes/omdConstantNode.js";
+import { omdBinaryExpressionNode } from "../nodes/omdBinaryExpressionNode.js";
+import { omdNode } from "../nodes/omdNode.js";
+import { omdRationalNode } from "../nodes/omdRationalNode.js";
+import { omdUnaryExpressionNode } from "../nodes/omdUnaryExpressionNode.js";
+import { omdPowerNode } from "../nodes/omdPowerNode.js";
+import { omdVariableNode } from "../nodes/omdVariableNode.js";
+import { SimplificationEngine } from "./omdSimplificationEngine.js";
+import { getMultiplicationSymbol } from '../config/omdConfigManager.js';
+
+// ===== MANUAL PROVENANCE HELPER FUNCTIONS =====
+
+/**
+ * Manually applies provenance from source nodes to a target node
+ * @param {omdNode} targetNode - The node to apply provenance to
+ * @param {...omdNode} sourceNodes - The source nodes to collect provenance from
+ * @returns {omdNode} The target node with applied provenance
+ */
+export function applyProvenance(targetNode, ...sourceNodes) {
+    if (!targetNode) return targetNode;
+    
+    targetNode.provenance = targetNode.provenance || [];
+    
+    for (const sourceNode of sourceNodes) {
+        if (!sourceNode) continue;
+        
+        // Add the source node's ID
+        if (sourceNode.id && !targetNode.provenance.includes(sourceNode.id)) {
+            targetNode.provenance.push(sourceNode.id);
+        }
+        
+        // Add all of the source node's provenance
+        if (sourceNode.provenance && Array.isArray(sourceNode.provenance)) {
+            sourceNode.provenance.forEach(id => {
+                if (id && !targetNode.provenance.includes(id)) {
+                    targetNode.provenance.push(id);
+                }
+            });
+        }
+        
+        // Recursively collect from children
+        collectChildIds(sourceNode, targetNode.provenance);
+    }
+    
+    return targetNode;
+}
+
+/**
+ * Recursively collects IDs from child nodes
+ * @param {omdNode} node - The node to collect from
+ * @param {Array} idSet - The array to add IDs to
+ */
+function collectChildIds(node, idSet) {
+    if (!node || !idSet) return;
+    
+    // Visit common child properties
+    const childProps = ['left', 'right', 'base', 'exponent', 'argument', 'expression', 
+                       'numerator', 'denominator', 'content'];
+    
+    for (const prop of childProps) {
+        const child = node[prop];
+        if (child && child.id && !idSet.includes(child.id)) {
+            idSet.push(child.id);
+            // Recursively collect from grandchildren
+            collectChildIds(child, idSet);
+        }
+    }
+    
+    // Handle array properties like args
+    if (node.args && Array.isArray(node.args)) {
+        node.args.forEach(arg => {
+            if (arg && arg.id && !idSet.includes(arg.id)) {
+                idSet.push(arg.id);
+                collectChildIds(arg, idSet);
+            }
+        });
+    }
+}
+
+/**
+ * Calculates the greatest common divisor of two numbers.
+ * @param {number} a
+ * @param {number} b
+ * @returns {number} The GCD of a and b.
+ */
+export function gcd(a, b) {
+    a = Math.abs(a);
+    b = Math.abs(b);
+    while(b) {
+        [a, b] = [b, a % b];
+    }
+    return a;
+}
+
+/**
+ * Applies a mathematical operation to two numbers.
+ * @param {string} op - The operator ('add', 'subtract', 'multiply', 'divide', or symbolic representation).
+ * @param {number} left - The left operand.
+ * @param {number} right - The right operand.
+ * @returns {number|null} The result of the operation, or null if the operation is invalid (e.g., division by zero).
+ */
+export function _applyOperator(op, left, right) {
+    switch (op) {
+        case 'add':
+            return left + right;
+        case 'subtract':
+            return left - right;
+        case 'multiply':
+            return left * right;
+        case 'divide':
+            return right !== 0 ? left / right : null;
+        default:
+            return null;
+    }
+}
+
+/**
+ * Creates a new, fully initialized `omdConstantNode`.
+ * @param {number} value - The numerical value for the constant.
+ * @param {number} fontSize - The font size to render the node with.
+ * @returns {omdConstantNode} The newly created constant node.
+ */
+export function createConstantNode(value, fontSize) {
+    const newConstantAST = { type: 'ConstantNode', value: value, clone: function () { return { ...this }; } };
+    const newConstantNode = new omdConstantNode(newConstantAST);
+    newConstantNode.setFontSize(fontSize);
+    newConstantNode.initialize();
+    return newConstantNode;
+}
+
+/**
+ * Helper to safely replace an old node with a new node in the tree.
+ * Handles both root node replacement and child node replacement.
+ * @param {omdNode} oldNode - The node to be replaced.
+ * @param {omdNode} newNode - The new node to insert.
+ * @param {omdNode} currentRoot - The current root of the entire expression tree.
+ * @returns {{success: boolean, newRoot: omdNode}} The result of the operation.
+ */
+export function _replaceNodeInTree(oldNode, newNode, currentRoot) {
+    if (oldNode === currentRoot) {
+        return { success: true, newRoot: newNode };
+    }
+    
+    // This ensures layout updates are triggered during the replacement itself to maintain visual consistency.
+    const success = oldNode.replaceWith(newNode, { updateLayout: true });
+
+    // Update the astNodeData for the new node and propagate changes upwards
+    if (success) {
+        newNode.astNodeData = newNode.toMathJSNode();
+        let current = newNode.parent;
+        while (current) {
+            // Only update astNodeData for actual omdNodes
+            if (current instanceof omdNode) {
+                current.astNodeData = current.toMathJSNode();
+            } else {
+                // Stop traversing if we encounter a non-omdNode parent (like jsvgContainer)
+                break;
+            }
+            current = current.parent;
+        }
+    }
+
+    return { success: success, newRoot: currentRoot };
+}
+
+/**
+ * Extracts all leaf nodes (constants and variables) from an expression tree
+ * for granular provenance tracking
+ */
+export function extractLeafNodes(node) {
+    const leafNodes = [];
+    
+    function traverse(n) {
+        if (!n) return;
+        
+        // If it's a leaf node (constant or variable), add it
+        if (n.type === 'omdConstantNode' || 
+            n.type === 'omdVariableNode') {
+            leafNodes.push(n);
+            return;
+        }
+        
+        // Recursively traverse child nodes
+        if (n.left) traverse(n.left);
+        if (n.right) traverse(n.right);
+        if (n.base) traverse(n.base);
+        if (n.exponent) traverse(n.exponent);
+        if (n.argument) traverse(n.argument);
+        if (n.expression) traverse(n.expression);
+        if (n.numerator) traverse(n.numerator);
+        if (n.denominator) traverse(n.denominator);
+    }
+    
+    traverse(node);
+    return leafNodes;
+}
+
+/**
+ * Recursively flattens a tree of additions and subtractions into a single list of terms.
+ * Each term is an object containing the node and its sign (1 for addition, -1 for subtraction).
+ * For example, `a - (b + c)` becomes `[{node: a, sign: 1}, {node: b, sign: -1}, {node: c, sign: -1}]`.
+ * @param {omdNode} node - The current node in the expression tree to process.
+ * @param {Array<Object>} terms - An array to accumulate the flattened terms. This array is modified by the function.
+ */
+export function flattenSum(node, terms) {
+    const op = node.operation;
+    if (node.type === 'omdBinaryExpressionNode' && (op === 'add' || op === '+')) {
+        flattenSum(node.left, terms);
+        flattenSum(node.right, terms);
+    } else if (node.type === 'omdBinaryExpressionNode' && (op === 'subtract' || op === '-')) {
+        flattenSum(node.left, terms);
+        const rightTerms = [];
+        flattenSum(node.right, rightTerms);
+        rightTerms.forEach(t => { t.sign *= -1; }); // Invert the sign for all terms on the right of a minus.
+        terms.push(...rightTerms);
+    } else {
+        // This is a leaf node in the sum (could be a variable, a multiplication, etc.)
+        // Extract leaf nodes for granular provenance tracking
+        const leafNodes = extractLeafNodes(node);
+        terms.push({ 
+            node: node, 
+            sign: 1,
+            leafNodes: leafNodes // Add leaf nodes for provenance
+        });
+    }
+}
+
+export function buildSumTree(terms, fontSize) {
+    if (terms.length === 0) return createConstantNode(0, fontSize);
+
+    // Sort terms to handle subtractions gracefully
+    terms.sort((a, b) => b.sign - a.sign);
+    
+    // If the expression starts with a negative term (e.g., -a + b), we prepend a '0'
+    if (terms.length > 1 && terms[0].sign === -1) {
+        if (terms[0].node.type === 'omdConstantNode') {
+            const first = terms.shift();
+            first.sign = 1; 
+            terms.push(first);
+        } else {
+            terms.unshift({node: createConstantNode(0, fontSize), sign: 1});
+        }
+    }
+
+    // Build the tree from left to right
+    let firstTerm = terms.shift();
+    let currentTree = firstTerm.node;
+    
+    // Ensure the first node is properly formed - clone it if needed
+    if (!currentTree || typeof currentTree.updateLayoutUpwards !== 'function') {
+        const originalId = currentTree.id;
+        currentTree = currentTree.clone();
+        currentTree.provenance = currentTree.provenance || [];
+        if (originalId && !currentTree.provenance.includes(originalId)) {
+            currentTree.provenance.push(originalId);
+        }
+        currentTree.setFontSize(fontSize);
+        currentTree.initialize();
+    }
+    
+    // If there's only one term, return it directly (it should already have correct provenance)
+    if (terms.length === 0) {
+        return currentTree;
+    }
+    
+    while (terms.length > 0) {
+        const term = terms.shift();
+        const opSymbol = term.sign === 1 ? '+' : '-';
+        const opFn = term.sign === 1 ? 'add' : 'subtract';
+
+        let termNode = term.node;
+        
+        if (!termNode || typeof termNode.updateLayoutUpwards !== 'function') {
+            const originalId = termNode.id;
+            termNode = termNode.clone();
+            termNode.provenance = termNode.provenance || [];
+            if (originalId && !termNode.provenance.includes(originalId)) {
+                termNode.provenance.push(originalId);
+            }
+            termNode.setFontSize(fontSize);
+            termNode.initialize();
+        }
+
+        // Preserve expansion provenance metadata if it exists
+        if (term.expansionProvenance) {
+            // Add expansion metadata to the term node for later reference
+            termNode.expansionProvenance = termNode.expansionProvenance || [];
+            termNode.expansionProvenance.push(term.expansionProvenance);
+            
+            // Ensure all expansion source IDs are in the term's provenance
+            [term.expansionProvenance.leftSource, term.expansionProvenance.rightSource, term.expansionProvenance.originalMultiplication].forEach(id => {
+                if (id && !termNode.provenance.includes(id)) {
+                    termNode.provenance.push(id);
+                }
+            });
+        }
+
+        // Create new binary expression
+        const newAST = {
+            type: 'OperatorNode',
+            op: opSymbol,
+            fn: opFn,
+            args: [currentTree.toMathJSNode(), termNode.toMathJSNode()],
+            clone: function () { return { ...this, args: this.args.map(arg => arg.clone()) }; }
+        };
+        
+        const newNode = new omdBinaryExpressionNode(newAST);
+        newNode.setFontSize(fontSize);
+        newNode.initialize();
+        
+        // Binary operation nodes should inherit provenance from their operands
+        // This allows tracking which terms contributed to the final expression
+        const leftProvenance = currentTree.provenance || [];
+        const rightProvenance = termNode.provenance || [];
+        
+        // Add provenance from both left and right operands
+        [...leftProvenance, ...rightProvenance, currentTree.id, termNode.id].forEach(id => {
+            if (id && !newNode.provenance.includes(id)) {
+                newNode.provenance.push(id);
+            }
+        });
+        
+        // Preserve expansion provenance metadata in the binary expression
+        if (termNode.expansionProvenance || currentTree.expansionProvenance) {
+            newNode.expansionProvenance = newNode.expansionProvenance || [];
+            if (termNode.expansionProvenance) {
+                newNode.expansionProvenance.push(...termNode.expansionProvenance);
+            }
+            if (currentTree.expansionProvenance) {
+                newNode.expansionProvenance.push(...currentTree.expansionProvenance);
+            }
+        }
+        
+        currentTree = newNode;
+    }
+    
+    return currentTree;
+}
+
+/**
+ * Creates a rational node (fraction) safely with proper initialization
+ * @param {number} numerator - The numerator value
+ * @param {number} denominator - The denominator value  
+ * @param {number} fontSize - The font size for the node
+ * @returns {omdNode} A properly initialized rational or constant node
+ */
+export function createRationalNode(numerator, denominator, fontSize) {
+    // If denominator is 1, just return a constant
+    if (denominator === 1) {
+        return createConstantNode(numerator, fontSize);
+    }
+    
+    // Create AST for the rational node
+    const ast = {
+        type: 'OperatorNode', 
+        op: '/', 
+        fn: 'divide',
+        args: [
+            { type: 'ConstantNode', value: Math.abs(numerator), clone: function() { return {...this}; } },
+            { type: 'ConstantNode', value: denominator, clone: function() { return {...this}; } }
+        ],
+        clone: function() { return { ...this, args: this.args.map(arg => arg.clone()) }; }
+    };
+    
+    let node = new omdRationalNode(ast);
+    
+    // Handle negative fractions by wrapping in unary minus
+    if (numerator < 0) {
+        const unaryAST = {
+            type: 'OperatorNode', 
+            op: '-', 
+            fn: 'unaryMinus',
+            args: [node.toMathJSNode()],
+            clone: function() { return { ...this, args: this.args.map(arg => arg.clone()) }; }
+        };
+        node = new omdUnaryExpressionNode(unaryAST);
+    }
+    
+    node.setFontSize(fontSize);
+    node.initialize();
+    
+    return node;
+}
+
+/**
+ * Converts any omdNode into a human-readable string representation.
+ * @param {omdNode} node - The node to convert.
+ * @returns {string} A string representation of the node.
+ */
+export function nodeToString(node) {
+    if (!node) return '';
+
+    // Operation name to symbol mapping
+    const operationSymbols = {
+        'add': '+',
+        'subtract': '-',
+        'multiply': getMultiplicationSymbol(),
+        'divide': '÷',
+        'unaryMinus': '-',
+        'unaryPlus': '+',
+        'pow': '^'
+    };
+
+    // Check for a getValue method (constants) - but only if actually constant
+    if (typeof node.getValue === 'function' && node.isConstant && node.isConstant()) {
+        return node.getValue().toString();
+    }
+
+    // Check for a name property (variables)
+    if (node.name) {
+        return node.name;
+    }
+
+    // Handle binary expressions recursively
+    if (node.type === 'omdBinaryExpressionNode') {
+        const left = nodeToString(node.left);
+        const right = nodeToString(node.right);
+        // Handle cases where node.op might be null (implicit multiplication)
+        let op;
+        if (node.op && node.op.opName) {
+            op = operationSymbols[node.op.opName] || node.op.opName;
+        } else if (node.operation) {
+            op = operationSymbols[node.operation] || node.operation;
+        } else {
+            // For implicit multiplication, use empty string
+            op = ''; // This handles cases like "2x" where it's implicit multiplication
+        }
+        // Only add parentheses for explicit operations, not implicit multiplication
+        return op ? `${left} ${op} ${right}` : `${left}${right}`;
+    }
+
+    // Handle unary expressions
+    if (node.type === 'omdUnaryExpressionNode') {
+        const arg = nodeToString(node.argument);
+        let op;
+        if (node.op && node.op.opName) {
+            op = operationSymbols[node.op.opName] || node.op.opName;
+        } else if (node.operation) {
+            op = operationSymbols[node.operation] || node.operation;
+        } else {
+            op = '-'; // Default for unary
+        }
+        // Only add parentheses around the argument if it's a complex expression
+        if (arg.includes(' ') || arg.includes('+') || arg.includes('-') || arg.includes(getMultiplicationSymbol()) || arg.includes('÷')) {
+            return `${op}(${arg})`;
+        }
+        return `${op}${arg}`;
+    }
+    
+    // Handle rational nodes
+    if (node.type === 'omdRationalNode') {
+        const num = nodeToString(node.numerator);
+        const den = nodeToString(node.denominator);
+        return `(${num}/${den})`;
+    }
+
+    // Handle parenthesis nodes
+    if (node.type === 'omdParenthesisNode') {
+        const content = nodeToString(node.content || node.expression);
+        // Only add parentheses if the content doesn't already start and end with them
+        if (content.startsWith('(') && content.endsWith(')')) {
+            return content;
+        }
+        return `(${content})`;
+    }
+
+    // Handle power nodes
+    if (node.type === 'omdPowerNode') {
+        const base = nodeToString(node.base);
+        const exp = nodeToString(node.exponent);
+        return `${base}^${exp}`;
+    }
+
+    // Handle sqrt nodes
+    if (node.type === 'omdSqrtNode') {
+        const arg = nodeToString(node.argument);
+        return `√(${arg})`;
+    }
+
+    // Handle function nodes
+    if (node.type === 'omdFunctionNode') {
+        const functionName = node.functionName || node.name || 'f';
+        if (node.argNodes && node.argNodes.length > 0) {
+            const args = node.argNodes.map(arg => nodeToString(arg)).join(', ');
+            return `${functionName}(${args})`;
+        } else if (node.args && node.args.length > 0) {
+            const args = node.args.map(arg => nodeToString(arg)).join(', ');
+            return `${functionName}(${args})`;
+        }
+        return `${functionName}()`;
+    }
+
+    // Handle equation nodes
+    if (node.type === 'omdEquationNode') {
+        const left = nodeToString(node.left);
+        const right = nodeToString(node.right);
+        return `${left} = ${right}`;
+    }
+
+    // Fallback for other node types - try toString method first
+    if (typeof node.toString === 'function') {
+        try {
+            return node.toString();
+        } catch (e) {
+            // Continue to next fallback
+        }
+    }
+
+    // Use math.js as final fallback
+    if (node.toMathJSNode) {
+        try {
+            return math.parse(node.toMathJSNode()).toString();
+        } catch (e) {
+            // Continue to final fallback
+        }
+    }
+
+    // Use node name if available, otherwise use constructor name as last resort
+    return node.name || node.type || '[unknown]';
+}
+
+// ===== POLYNOMIAL EXPANSION HELPER FUNCTIONS =====
+
+/**
+ * Expands a polynomial power using multinomial expansion
+ * For example: (a + b)^2 = a^2 + 2ab + b^2
+ * @param {Array} terms - Array of {node, sign} objects representing the polynomial terms
+ * @param {number} exponent - The power to expand to
+ * @param {number} fontSize - Font size for new nodes
+ * @returns {Array} Array of {node, sign} objects representing the expanded terms
+ */
+export function expandPolynomialPower(terms, exponent, fontSize) {
+    if (exponent === 1) {
+        return terms;
+    }
+    
+    if (exponent === 2) {
+        return expandBinomialSquare(terms, fontSize);
+    }
+    
+    if (exponent === 3) {
+        return expandBinomialCube(terms, fontSize);
+    }
+    
+    if (exponent === 4) {
+        return expandBinomialFourth(terms, fontSize);
+    }
+    
+    // For higher powers, use recursive multiplication
+    let result = terms;
+    for (let i = 1; i < exponent; i++) {
+        result = multiplyTermArrays(result, terms, fontSize);
+    }
+    
+    return result;
+}
+
+/**
+ * Expands (a + b + ...)^2 using the multinomial theorem
+ */
+export function expandBinomialSquare(terms, fontSize) {
+    const expandedTerms = [];
+    
+    // Square terms: a^2, b^2, ...
+    for (const term of terms) {
+        const squaredNode = SimplificationEngine.createBinaryOp(
+            term.node.clone(),
+            'multiply',
+            term.node.clone(),
+            fontSize
+        );
+        
+        // Use granular provenance from leaf nodes
+        const leafNodes = term.leafNodes || [];
+        leafNodes.forEach(leafNode => {
+            [squaredNode.left, squaredNode.right, squaredNode].forEach(part => {
+                if (part && !part.provenance.includes(leafNode.id)) {
+                    part.provenance.push(leafNode.id);
+                }
+            });
+        });
+        
+        expandedTerms.push({
+            node: squaredNode,
+            sign: term.sign * term.sign // Always positive since we're squaring
+        });
+    }
+    
+    // Cross terms: 2ab, 2ac, 2bc, ...
+    for (let i = 0; i < terms.length; i++) {
+        for (let j = i + 1; j < terms.length; j++) {
+            const term1 = terms[i];
+            const term2 = terms[j];
+            
+            // Create 2 * term1 * term2
+            const coefficient2 = SimplificationEngine.createConstant(2, fontSize);
+            const product1 = SimplificationEngine.createBinaryOp(
+                coefficient2,
+                'multiply',
+                term1.node.clone(),
+                fontSize
+            );
+            const finalProduct = SimplificationEngine.createBinaryOp(
+                product1,
+                'multiply',
+                term2.node.clone(),
+                fontSize
+            );
+            
+            // Use granular provenance from both terms
+            const allLeafNodes = [...(term1.leafNodes || []), ...(term2.leafNodes || [])];
+            allLeafNodes.forEach(leafNode => {
+                [product1.right, finalProduct.right, finalProduct].forEach(part => {
+                    if (part && !part.provenance.includes(leafNode.id)) {
+                        part.provenance.push(leafNode.id);
+                    }
+                });
+            });
+            
+            expandedTerms.push({
+                node: finalProduct,
+                sign: term1.sign * term2.sign
+            });
+        }
+    }
+    
+    return expandedTerms;
+}
+
+/**
+ * Expands (a + b + ...)^3 for binomial/trinomial cases
+ */
+export function expandBinomialCube(terms, fontSize) {
+    if (terms.length === 2) {
+        const [term1, term2] = terms;
+        const expandedTerms = [];
+        
+        // Use the efficient helper functions with provenance
+        expandedTerms.push({ 
+            node: createPowerTermWithProvenance(term1.node, 3, fontSize, term1.leafNodes), 
+            sign: Math.pow(term1.sign, 3) 
+        });
+        expandedTerms.push({ 
+            node: createCoefficientProductTermWithProvenance(3, term1.node, 2, term2.node, 1, fontSize, term1.leafNodes, term2.leafNodes), 
+            sign: Math.pow(term1.sign, 2) * term2.sign 
+        });
+        expandedTerms.push({ 
+            node: createCoefficientProductTermWithProvenance(3, term1.node, 1, term2.node, 2, fontSize, term1.leafNodes, term2.leafNodes), 
+            sign: term1.sign * Math.pow(term2.sign, 2) 
+        });
+        expandedTerms.push({ 
+            node: createPowerTermWithProvenance(term2.node, 3, fontSize, term2.leafNodes), 
+            sign: Math.pow(term2.sign, 3) 
+        });
+        
+        return expandedTerms;
+    }
+    
+    // For more than 2 terms, use general multiplication
+    return multiplyTermArrays(expandBinomialSquare(terms, fontSize), terms, fontSize);
+}
+
+/**
+ * Expands (a + b)^4 = a^4 + 4a^3b + 6a^2b^2 + 4ab^3 + b^4
+ */
+export function expandBinomialFourth(terms, fontSize) {
+    if (terms.length === 2) {
+        const [term1, term2] = terms;
+        const expandedTerms = [];
+        
+        // Use the efficient helper functions with provenance
+        expandedTerms.push({ 
+            node: createPowerTermWithProvenance(term1.node, 4, fontSize, term1.leafNodes), 
+            sign: Math.pow(term1.sign, 4) 
+        });
+        expandedTerms.push({ 
+            node: createCoefficientProductTermWithProvenance(4, term1.node, 3, term2.node, 1, fontSize, term1.leafNodes, term2.leafNodes), 
+            sign: Math.pow(term1.sign, 3) * term2.sign 
+        });
+        expandedTerms.push({ 
+            node: createCoefficientProductTermWithProvenance(6, term1.node, 2, term2.node, 2, fontSize, term1.leafNodes, term2.leafNodes), 
+            sign: Math.pow(term1.sign, 2) * Math.pow(term2.sign, 2) 
+        });
+        expandedTerms.push({ 
+            node: createCoefficientProductTermWithProvenance(4, term1.node, 1, term2.node, 3, fontSize, term1.leafNodes, term2.leafNodes), 
+            sign: term1.sign * Math.pow(term2.sign, 3) 
+        });
+        expandedTerms.push({ 
+            node: createPowerTermWithProvenance(term2.node, 4, fontSize, term2.leafNodes), 
+            sign: Math.pow(term2.sign, 4) 
+        });
+        
+        return expandedTerms;
+    }
+    
+    // For more than 2 terms, use general multiplication
+    const cubed = expandBinomialCube(terms, fontSize);
+    return multiplyTermArrays(cubed, terms, fontSize);
+}
+
+/**
+ * Creates a term like x^n with granular provenance tracking
+ */
+export function createPowerTermWithProvenance(baseNode, power, fontSize, leafNodes) {
+    if (power === 1) {
+        const cloned = baseNode.clone();
+        // Add leaf node provenance
+        if (leafNodes && leafNodes.length > 0) {
+            leafNodes.forEach(leafNode => {
+                if (!cloned.provenance.includes(leafNode.id)) {
+                    cloned.provenance.push(leafNode.id);
+                }
+            });
+        }
+        return cloned;
+    }
+    
+    const powerConstant = SimplificationEngine.createConstant(power, fontSize);
+    
+    // Create power node AST structure
+    const powerAST = {
+        type: 'OperatorNode',
+        op: '^',
+        fn: 'pow',
+        args: [baseNode.toMathJSNode(), powerConstant.toMathJSNode()],
+        clone: function() { 
+            return { 
+                ...this, 
+                args: this.args.map(arg => arg.clone()) 
+            }; 
+        }
+    };
+    
+    const powerNode = new omdPowerNode(powerAST);
+    powerNode.setFontSize(fontSize);
+    powerNode.initialize();
+    
+    // Add leaf node provenance
+    if (leafNodes && leafNodes.length > 0) {
+        leafNodes.forEach(leafNode => {
+            if (!powerNode.base.provenance.includes(leafNode.id)) {
+                powerNode.base.provenance.push(leafNode.id);
+            }
+            if (!powerNode.provenance.includes(leafNode.id)) {
+                powerNode.provenance.push(leafNode.id);
+            }
+        });
+    } else {
+        powerNode.base.provenance.push(baseNode.id);
+        powerNode.provenance.push(baseNode.id);
+    }
+    
+    return powerNode;
+}
+
+/**
+ * Creates a term like c * a^p1 * b^p2 with granular provenance tracking
+ */
+export function createCoefficientProductTermWithProvenance(coefficient, node1, power1, node2, power2, fontSize, leafNodes1, leafNodes2) {
+    let result = SimplificationEngine.createConstant(coefficient, fontSize);
+    
+    // Multiply by node1^power1
+    if (power1 > 0) {
+        const term1 = createPowerTermWithProvenance(node1, power1, fontSize, leafNodes1);
+        result = SimplificationEngine.createBinaryOp(result, 'multiply', term1, fontSize);
+        
+        // Add leaf node provenance to the result
+        if (leafNodes1 && leafNodes1.length > 0) {
+            leafNodes1.forEach(leafNode => {
+                if (!result.provenance.includes(leafNode.id)) {
+                    result.provenance.push(leafNode.id);
+                }
+            });
+        }
+    }
+    
+    // Multiply by node2^power2
+    if (power2 > 0) {
+        const term2 = createPowerTermWithProvenance(node2, power2, fontSize, leafNodes2);
+        result = SimplificationEngine.createBinaryOp(result, 'multiply', term2, fontSize);
+        
+        // Add leaf node provenance to the result
+        if (leafNodes2 && leafNodes2.length > 0) {
+            leafNodes2.forEach(leafNode => {
+                if (!result.provenance.includes(leafNode.id)) {
+                    result.provenance.push(leafNode.id);
+                }
+            });
+        }
+    }
+    
+    return result;
+}
+
+/**
+ * Creates a term like x^n
+ */
+export function createPowerTerm(baseNode, power, fontSize) {
+    if (power === 1) {
+        return baseNode.clone();
+    }
+    
+    const powerConstant = SimplificationEngine.createConstant(power, fontSize);
+    
+    // Create power node AST structure
+    const powerAST = {
+        type: 'OperatorNode',
+        op: '^',
+        fn: 'pow',
+        args: [baseNode.toMathJSNode(), powerConstant.toMathJSNode()],
+        clone: function() { 
+            return { 
+                ...this, 
+                args: this.args.map(arg => arg.clone()) 
+            }; 
+        }
+    };
+    
+    const powerNode = new omdPowerNode(powerAST);
+    powerNode.setFontSize(fontSize);
+    powerNode.initialize();
+    
+    return powerNode;
+}
+
+/**
+ * Creates a term like c * a^p1 * b^p2
+ */
+export function createCoefficientProductTerm(coefficient, node1, power1, node2, power2, fontSize) {
+    let result = SimplificationEngine.createConstant(coefficient, fontSize);
+    
+    // Multiply by node1^power1
+    if (power1 > 0) {
+        const term1 = createPowerTerm(node1, power1, fontSize);
+        result = SimplificationEngine.createBinaryOp(result, 'multiply', term1, fontSize);
+    }
+    
+    // Multiply by node2^power2
+    if (power2 > 0) {
+        const term2 = createPowerTerm(node2, power2, fontSize);
+        result = SimplificationEngine.createBinaryOp(result, 'multiply', term2, fontSize);
+    }
+    
+    return result;
+}
+
+/**
+ * Multiplies two arrays of terms (for general polynomial multiplication)
+ */
+export function multiplyTermArrays(terms1, terms2, fontSize) {
+    const result = [];
+    
+    for (const term1 of terms1) {
+        for (const term2 of terms2) {
+            const productNode = SimplificationEngine.createBinaryOp(
+                term1.node.clone(),
+                'multiply',
+                term2.node.clone(),
+                fontSize
+            );
+            
+            // Add granular provenance from leaf nodes of both terms
+            const allLeafNodes = [...(term1.leafNodes || []), ...(term2.leafNodes || [])];
+            allLeafNodes.forEach(leafNode => {
+                [productNode.left, productNode.right, productNode].forEach(part => {
+                    if (part && !part.provenance.includes(leafNode.id)) {
+                        part.provenance.push(leafNode.id);
+                    }
+                });
+            });
+            
+            result.push({
+                node: productNode,
+                sign: term1.sign * term2.sign,
+                leafNodes: allLeafNodes
+            });
+        }
+    }
+    
+    return result;
+}
+
+/**
+ * Creates a monomial with granular provenance tracking for coefficients and variables separately
+ */
+export function createMonomialWithGranularProvenance(coefficient, variable, power, fontSize, coefficientProvenance = [], variableProvenance = []) {
+    // Create variable node
+    const variableAST = { type: 'SymbolNode', name: variable, clone: function() { return {...this}; } };
+    const variableNode = new (SimplificationEngine.getNodeClass('omdVariableNode'))(variableAST);
+    variableNode.setFontSize(fontSize);
+    variableNode.initialize();
+    
+    // Set variable-specific provenance
+    if (variableProvenance && variableProvenance.length > 0) {
+        variableNode.provenance = [...variableProvenance];
+    }
+    
+    let termNode = variableNode;
+    
+    // Add power if not 1
+    if (power !== 1) {
+        const powerAST = {
+            type: 'OperatorNode',
+            op: '^',
+            fn: 'pow',
+            args: [variableAST, { type: 'ConstantNode', value: power, clone: function() { return {...this}; } }],
+            clone: function() { return { ...this, args: this.args.map(arg => arg.clone()) }; }
+        };
+        termNode = new (SimplificationEngine.getNodeClass('omdPowerNode'))(powerAST);
+        termNode.setFontSize(fontSize);
+        termNode.initialize();
+        
+        // Set variable provenance on the base, power gets no special provenance
+        if (termNode.base && variableProvenance && variableProvenance.length > 0) {
+            termNode.base.provenance = [...variableProvenance];
+        }
+    }
+    
+    let result;
+    if (coefficient === 1) {
+        result = termNode;
+    } else if (coefficient === -1) {
+        // Create unary minus
+        const unaryAST = {
+            type: 'OperatorNode',
+            op: '-',
+            fn: 'unaryMinus',
+            args: [termNode.toMathJSNode()],
+            clone: function() { return { ...this, args: this.args.map(arg => arg.clone()) }; }
+        };
+        result = new (SimplificationEngine.getNodeClass('omdUnaryExpressionNode'))(unaryAST);
+        result.setFontSize(fontSize);
+        result.initialize();
+        
+        // The argument preserves variable provenance
+        if (result.argument && variableProvenance && variableProvenance.length > 0) {
+            result.argument.provenance = [...variableProvenance];
+        }
+    } else {
+        // Create coefficient * term
+        const coeffNode = SimplificationEngine.createConstant(Math.abs(coefficient), fontSize);
+        
+        // Set coefficient-specific provenance
+        if (coefficientProvenance && coefficientProvenance.length > 0) {
+            coeffNode.provenance = [...coefficientProvenance];
+        }
+        
+        const multiplicationNode = SimplificationEngine.createBinaryOp(coeffNode, 'multiply', termNode, fontSize);
+        
+        // Apply granular provenance: coefficient to left, variable to right
+        if (multiplicationNode.left && coefficientProvenance && coefficientProvenance.length > 0) {
+            multiplicationNode.left.provenance = [...coefficientProvenance];
+        }
+        if (multiplicationNode.right && variableProvenance && variableProvenance.length > 0) {
+            multiplicationNode.right.provenance = [...variableProvenance];
+        }
+        
+        // Wrap in unary minus if coefficient is negative
+        if (coefficient < 0) {
+            const unaryAST = {
+                type: 'OperatorNode',
+                op: '-',
+                fn: 'unaryMinus',
+                args: [multiplicationNode.toMathJSNode()],
+                clone: function() { return { ...this, args: this.args.map(arg => arg.clone()) }; }
+            };
+            result = new (SimplificationEngine.getNodeClass('omdUnaryExpressionNode'))(unaryAST);
+            result.setFontSize(fontSize);
+            result.initialize();
+            
+            // Preserve granular provenance within the unary minus
+            if (result.argument) {
+                if (result.argument.left && coefficientProvenance && coefficientProvenance.length > 0) {
+                    result.argument.left.provenance = [...coefficientProvenance];
+                }
+                if (result.argument.right && variableProvenance && variableProvenance.length > 0) {
+                    result.argument.right.provenance = [...variableProvenance];
+                }
+            }
+        } else {
+            result = multiplicationNode;
+        }
+    }
+    
+    return result;
+}
+
+/**
+ * Extracts coefficient and variable leaf nodes separately from a monomial term
+ * for granular provenance tracking in like term combination
+ */
+export function extractMonomialProvenance(termNode) {
+    const coefficientNodes = [];
+    const variableNodes = [];
+    
+    function traverse(node, isInCoefficient = false) {
+        if (!node) return;
+        
+        // If we find a variable node, it goes to variables
+        if (node.type === 'omdVariableNode') {
+            variableNodes.push(node);
+            return;
+        }
+        
+        // If we find a constant node
+        if (node.type === 'omdConstantNode') {
+            // If we're in a power expression, this is likely an exponent, not a coefficient
+            if (node.parent && node.parent.type === 'omdPowerNode' && node.parent.exponent === node) {
+                // Skip exponents for provenance purposes
+                return;
+            }
+            // Otherwise, it's a coefficient
+            coefficientNodes.push(node);
+            return;
+        }
+        
+        // For power nodes, traverse base for variables
+        if (node.type === 'omdPowerNode') {
+            if (node.base) traverse(node.base, false);
+            // Don't traverse exponent for provenance
+            return;
+        }
+        
+        // For binary operations, determine what we're looking at
+        if (node.type === 'omdBinaryExpressionNode') {
+            if (node.operation === 'multiply') {
+                // In multiplication, left is often coefficient, right is often variable
+                if (node.left) traverse(node.left, true);
+                if (node.right) traverse(node.right, false);
+            } else {
+                // For other operations, traverse both sides
+                if (node.left) traverse(node.left, isInCoefficient);
+                if (node.right) traverse(node.right, isInCoefficient);
+            }
+            return;
+        }
+        
+        // For unary operations, traverse the argument
+        if (node.type === 'omdUnaryExpressionNode') {
+            if (node.argument) traverse(node.argument, isInCoefficient);
+            return;
+        }
+        
+        // For other node types, try to traverse child properties
+        ['left', 'right', 'base', 'exponent', 'argument', 'expression', 'numerator', 'denominator'].forEach(prop => {
+            if (node[prop]) traverse(node[prop], isInCoefficient);
+        });
+    }
+    
+    traverse(termNode);
+    
+    return {
+        coefficientNodes,
+        variableNodes
+    };
 }