@teachinglab/omd/omd/simplification/rules/binaryRules.js

omd

import { SimplificationEngine } from '../omdSimplificationEngine.js';
import * as utils from '../simplificationUtils.js';
import { getMultiplicationSymbol } from '../../config/omdConfigManager.js';
import { omdRationalNode } from '../../nodes/omdRationalNode.js';

// ===== BINARY EXPRESSION RULES =====
export const binaryRules = [
    // Handle addition cases like a + (-a) = 0 
    SimplificationEngine.createRule("Opposite Term Cancellation",
        (node) => {
            // Only handle addition for now
            if (!SimplificationEngine.isBinaryOp(node, 'add')) {
                return false;
            }

            // Check for constant + (-constant) patterns (2 + (-2) = 0)
            if (node.left.isConstant()) {
                const leftVal = node.left.getValue();
                
                // Check if right side is a unary minus of a constant
                if (SimplificationEngine.isType(node.right, 'omdUnaryExpressionNode') && 
                    node.right.operation === 'unaryMinus' &&
                    node.right.argument.isConstant()) {
                    const rightVal = node.right.argument.getValue();
                    if (leftVal === rightVal) {
                        return {
                            leftTerm: node.left,
                            rightTerm: node.right,
                            termType: 'constant',
                            leftValue: leftVal,
                            rightValue: -rightVal,
                            isNegatedRight: true
                        };
                    }
                }
                
                // Check for direct opposite constants (rare case)
                if (node.right.isConstant()) {
                    const rightVal = node.right.getValue();
                    if (leftVal === -rightVal) {
                        return {
                            leftTerm: node.left,
                            rightTerm: node.right,
                            termType: 'constant',
                            leftValue: leftVal,
                            rightValue: rightVal,
                            isNegatedRight: false
                        };
                    }
                }
            }

            // Check if we have a + (-a) pattern for monomials
            const leftMonomial = SimplificationEngine.isMonomial(node.left);
            let rightMonomial = null;
            let isNegatedRight = false;

            // Check if right side is a unary minus
            if (SimplificationEngine.isType(node.right, 'omdUnaryExpressionNode') && 
                node.right.operation === 'unaryMinus') {
                rightMonomial = SimplificationEngine.isMonomial(node.right.argument);
                isNegatedRight = true;
            } else {
                rightMonomial = SimplificationEngine.isMonomial(node.right);
            }

            if (leftMonomial && rightMonomial) {
                // For a + (-a), check if left coefficient equals right coefficient 
                // For a + (-2a), check if left coefficient equals negative of right coefficient
                let leftCoeff = leftMonomial.coefficient;
                let rightCoeff = rightMonomial.coefficient;
                
                if (isNegatedRight) {
                    rightCoeff = -rightCoeff; // Since it's wrapped in unary minus
                }

                // Check if they are the same variable with same power and opposite coefficients
                if (leftMonomial.variable === rightMonomial.variable &&
                    leftMonomial.power === rightMonomial.power &&
                    leftCoeff === -rightCoeff) {
                    return {
                        leftTerm: node.left,
                        rightTerm: node.right,
                        termType: 'monomial',
                        variable: leftMonomial.variable,
                        power: leftMonomial.power,
                        leftCoeff: leftCoeff,
                        rightCoeff: rightCoeff,
                        isNegatedRight: isNegatedRight
                    };
                }
            }

            return false;
        },
        (node, data) => {
            const { leftTerm, rightTerm } = data;
            const zeroNode = SimplificationEngine.createConstant(0, node.getFontSize());
            
            // Preserve provenance from both terms
            zeroNode.provenance.push(leftTerm.id);
            zeroNode.provenance.push(rightTerm.id);
            zeroNode.provenance.push(node.id);
            
            return zeroNode;
        },
        (originalNode, ruleData, newNode) => {
            const { termType } = ruleData;
            
            if (termType === 'constant') {
                const { leftValue, rightValue, isNegatedRight } = ruleData;
                if (isNegatedRight) {
                    return `Cancelled opposite terms: ${leftValue} + (-${leftValue}) = 0`;
                } else {
                    return `Cancelled opposite terms: ${leftValue} + ${rightValue} = 0`;
                }
            } else {
                const { variable, power, leftCoeff, rightCoeff, isNegatedRight } = ruleData;
                const powerStr = power !== 1 ? `^${power}` : '';
                
                // Format the left term
                const leftCoeffStr = leftCoeff === 1 ? '' : leftCoeff === -1 ? '-' : `${leftCoeff}`;
                const leftTermStr = `${leftCoeffStr}${variable}${powerStr}`;
                
                // Format the right term 
                let rightTermStr;
                if (isNegatedRight) {
                    const innerCoeff = Math.abs(rightCoeff);
                    const innerCoeffStr = innerCoeff === 1 ? '' : `${innerCoeff}`;
                    rightTermStr = `(-${innerCoeffStr}${variable}${powerStr})`;
                } else {
                    const rightCoeffStr = rightCoeff === 1 ? '' : rightCoeff === -1 ? '-' : `${rightCoeff}`;
                    rightTermStr = `${rightCoeffStr}${variable}${powerStr}`;
                }
                
                return `Cancelled opposite terms: ${leftTermStr} + ${rightTermStr} = 0`;
            }
        }
    ),

    // Handle constant cancellation in multi-term sums (3x + 2 - 2 → 3x + 0)
    SimplificationEngine.createRule("Cancel Constants in Sums",
        (node) => {
            if (!SimplificationEngine.isBinaryOp(node) ||
                (node.operation !== 'add' && node.operation !== 'subtract')) return false;

            // Flatten the sum to get all terms
            const terms = [];
            utils.flattenSum(node, terms);

            // Only proceed if we have at least 3 terms (need non-constants + constants that cancel)
            if (terms.length < 3) return false;

            const constantTerms = terms.filter(t => t.node.isConstant());
            const nonConstantTerms = terms.filter(t => !t.node.isConstant());

            // Need at least one non-constant term and at least 2 constants
            if (nonConstantTerms.length === 0 || constantTerms.length < 2) return false;

            // Check if any constants cancel out exactly
            const cancellingPairs = [];
            const usedIndices = new Set();

            for (let i = 0; i < constantTerms.length; i++) {
                if (usedIndices.has(i)) continue;
                
                const term1 = constantTerms[i];
                const val1 = term1.node.getValue() * term1.sign;

                for (let j = i + 1; j < constantTerms.length; j++) {
                    if (usedIndices.has(j)) continue;
                    
                    const term2 = constantTerms[j];
                    const val2 = term2.node.getValue() * term2.sign;

                    // Check if they cancel exactly
                    if (val1 + val2 === 0) {
                        cancellingPairs.push([term1, term2]);
                        usedIndices.add(i);
                        usedIndices.add(j);
                        break;
                    }
                }
            }

            if (cancellingPairs.length > 0) {
                return {
                    terms: terms,
                    cancellingPairs: cancellingPairs,
                    constantTerms: constantTerms,
                    nonConstantTerms: nonConstantTerms
                };
            }

            return false;
        },
        (node, data) => {
            const { terms, cancellingPairs, constantTerms, nonConstantTerms } = data;

            // Start with non-constant terms
            const finalTerms = [...nonConstantTerms];

            // Keep track of which constant terms were cancelled
            const cancelledTerms = new Set();
            cancellingPairs.forEach(pair => {
                pair.forEach(term => cancelledTerms.add(term));
            });

            // Add back any constant terms that weren't cancelled
            constantTerms.forEach(term => {
                if (!cancelledTerms.has(term)) {
                    finalTerms.push(term);
                }
            });

            // Collect detailed provenance from all cancelled terms
            let cancelledNodeIds = [];
            if (cancellingPairs.length > 0) {
                const zeroNode = SimplificationEngine.createConstant(0, node.getFontSize());
                
                // Add provenance from all cancelled terms and their operators
                cancellingPairs.forEach(pair => {
                    // Find the operator node between the pair
                    const [term1, term2] = pair;
                    const parent = terms.find(t => 
                        t.node.type === 'omdBinaryExpressionNode' &&
                        ((t.node.left === term1.node && t.node.right === term2.node) ||
                         (t.node.left === term2.node && t.node.right === term1.node))
                    );

                    // Add provenance from the constants and the operator
                    pair.forEach(term => {
                        zeroNode.provenance.push(term.node.id);
                        cancelledNodeIds.push(term.node.id);
                        
                        // If this term has an operator (e.g. the minus sign), include it
                        if (term.node.operation) {
                            zeroNode.provenance.push(term.node.operation.id);
                            cancelledNodeIds.push(term.node.operation.id);
                        }
                    });

                    // Add provenance from the binary operation's operator
                    if (parent && parent.node.operation) {
                        zeroNode.provenance.push(parent.node.operation.id);
                        cancelledNodeIds.push(parent.node.operation.id);
                    }
                });
                
                finalTerms.push({ node: zeroNode, sign: 1 });
            }

            // Build the result tree
            const result = utils.buildSumTree(finalTerms, node.getFontSize());
            
            if (result) {
                // Only preserve provenance from the cancelled terms
                cancelledNodeIds.forEach(id => {
                    if (!result.provenance.includes(id)) {
                        result.provenance.push(id);
                    }
                });
            }

            return result;
        },
        (originalNode, ruleData, newNode) => {
            const { cancellingPairs } = ruleData;
            
            const cancellationDescriptions = cancellingPairs.map(pair => {
                const [term1, term2] = pair;
                const val1 = term1.node.getValue();
                const val2 = term2.node.getValue();
                const sign1 = term1.sign === 1 ? '+' : '-';
                const sign2 = term2.sign === 1 ? '+' : '-';
                
                return `${sign1} ${val1} ${sign2} ${val2} = 0`;
            });

            return `Cancelled constants in sum: ${cancellationDescriptions.join(', ')}`;
        }
    ),

    // Basic constant folding (works for both regular and rational constants)
    SimplificationEngine.createConstantFoldRule("Add Constants", "add"),
    SimplificationEngine.createConstantFoldRule("Subtract Constants", "subtract"), 
    SimplificationEngine.createConstantFoldRule("Multiply Constants", "multiply"),
    SimplificationEngine.createConstantFoldRule("Divide Constants", "divide"),

    // Identity operations
    SimplificationEngine.createIdentityRule("Add Zero", "add", 0),           // x + 0 → x, 0 + x → x
    SimplificationEngine.createIdentityRule("Subtract Zero", "subtract", 0, 'right'), // x - 0 → x
    SimplificationEngine.createIdentityRule("Multiply One", "multiply", 1),  // x * 1 → x, 1 * x → x  
    SimplificationEngine.createIdentityRule("Divide One", "divide", 1, 'right'),     // x / 1 → x

    // Zero multiplication (anything times zero equals zero)
    SimplificationEngine.createZeroMultiplicationRule(),

    // Coefficient multiplication (2 * 3x → 6x)
    SimplificationEngine.createRule("Combine Coefficients",
        (node) => {
            if (!SimplificationEngine.isBinaryOp(node, 'multiply')) return false;

            const constOp = SimplificationEngine.hasConstantOperand(node);
            if (!constOp) return false;

            const otherNode = constOp.other;
            if (!SimplificationEngine.isBinaryOp(otherNode, 'multiply')) return false;

            const innerConstOp = SimplificationEngine.hasConstantOperand(otherNode);
            if (!innerConstOp) return false;

            const outerConstant = constOp.constant.getValue();
            const innerConstant = innerConstOp.constant.getValue();
            const expression = innerConstOp.other;

            return {
                coefficient: outerConstant * innerConstant,
                expression
            };
        },
        (node, data) => {
            const { coefficient, expression } = data;
            const newNode = SimplificationEngine.createMultiplication(
                SimplificationEngine.createConstant(coefficient, node.getFontSize()),
                expression.clone(),
                node.getFontSize()
            );
            
            // Preserve provenance from both operands
            newNode.provenance.push(node.id);
            if (newNode.left) {
                newNode.left.provenance.push(node.left.id, node.right.id);
            }
            if (newNode.right) {
                newNode.right.provenance.push(expression.id);
            }
            
            return newNode;
        },
        (originalNode, ruleData, newNode) => {
            const { coefficient, expression } = ruleData;
            const constOp = SimplificationEngine.hasConstantOperand(originalNode);
            const innerConstOp = SimplificationEngine.hasConstantOperand(constOp.other);
            const outerVal = constOp.constant.getValue();
            const innerVal = innerConstOp.constant.getValue();
            
            return `Combined coefficients: ${outerVal} ${getMultiplicationSymbol()} ${innerVal} = ${coefficient}`;
        }
    ),

    // Distributive property (2*(x+3) → 2x + 6)
    SimplificationEngine.createRule("Distributive Property",
        (node) => {
            if (!SimplificationEngine.isBinaryOp(node, 'multiply')) return false;

            const constOp = SimplificationEngine.hasConstantOperand(node);
            if (!constOp) return false;

            const otherNode = constOp.other;
            
            // Check if the other operand is a parenthesized sum/difference
            let innerExpr = otherNode;
            if (SimplificationEngine.isType(otherNode, 'omdParenthesisNode')) {
                innerExpr = otherNode.expression;
            }

            if (!SimplificationEngine.isBinaryOp(innerExpr, 'add') && 
                !SimplificationEngine.isBinaryOp(innerExpr, 'subtract')) {
                return false;
            }

            return {
                constantNode: constOp.constant,
                innerExpr: innerExpr,
                originalInnerNode: otherNode
            };
        },
        (node, data) => {
            const { constantNode, innerExpr } = data;
            const multiplier = constantNode.getValue();
            const fontSize = node.getFontSize();

            // Distribute the constant across the terms
            const terms = [];
            utils.flattenSum(innerExpr, terms);

            const distributedTerms = terms.map(term => {
                const newCoeff = multiplier * term.sign;
                const distributedNode = SimplificationEngine.createBinaryOp(
                    SimplificationEngine.createConstant(Math.abs(newCoeff), fontSize),
                    'multiply',
                    term.node.clone(),
                    fontSize
                );
                
                // Preserve provenance
                distributedNode.provenance.push(node.id, constantNode.id, term.node.id);
                
                return {
                    node: distributedNode,
                    sign: newCoeff >= 0 ? 1 : -1
                };
            });

            return utils.buildSumTree(distributedTerms, fontSize);
        },
        (originalNode, ruleData, newNode) => {
            const { constantNode, innerExpr } = ruleData;
            const multiplierStr = constantNode.toString();
            const expressionStr = innerExpr.toString();

            return `Applied distributive property: ${multiplierStr} ${getMultiplicationSymbol()} (${expressionStr})`;
        }
    ),

    // Expand polynomial multiplication like (3x+3)(2x+2) using FOIL/distributive property
    SimplificationEngine.createRule("Expand Polynomial Multiplication",
        (node) => {
            if (!SimplificationEngine.isBinaryOp(node, 'multiply')) return false;

            // Both operands should be sums or differences (optionally parenthesized)
            let leftExpr = SimplificationEngine.unwrapParentheses(node.left);
            let rightExpr = SimplificationEngine.unwrapParentheses(node.right);

            // Check if both sides are sums or differences
            const leftIsSum = SimplificationEngine.isBinaryOp(leftExpr, 'add') || 
                              SimplificationEngine.isBinaryOp(leftExpr, 'subtract');
            const rightIsSum = SimplificationEngine.isBinaryOp(rightExpr, 'add') || 
                               SimplificationEngine.isBinaryOp(rightExpr, 'subtract');

            if (!leftIsSum || !rightIsSum) return false;

            // Extract terms from both expressions
            const leftTerms = [];
            const rightTerms = [];
            utils.flattenSum(leftExpr, leftTerms);
            utils.flattenSum(rightExpr, rightTerms);

            // Limit to reasonable number of terms to avoid explosion
            if (leftTerms.length > 4 || rightTerms.length > 4) return false;

            return {
                leftExpression: leftExpr,
                rightExpression: rightExpr,
                leftTerms: leftTerms,
                rightTerms: rightTerms
            };
        },
        (node, data) => {
            const { leftTerms, rightTerms } = data;
            const fontSize = node.getFontSize();

            // Apply distributive property: each term in left multiplied by each term in right
            const expandedTerms = [];
            
            for (const leftTerm of leftTerms) {
                for (const rightTerm of rightTerms) {
                    const productSign = leftTerm.sign * rightTerm.sign;
                    const productNode = SimplificationEngine.createBinaryOp(
                        leftTerm.node.clone(),
                        'multiply',
                        rightTerm.node.clone(),
                        fontSize
                    );
                    
                    // Use granular provenance
                    const allLeafNodes = [...(leftTerm.leafNodes || []), ...(rightTerm.leafNodes || [])];
                    allLeafNodes.forEach(leafNode => {
                        [productNode.left, productNode.right, productNode].forEach(part => {
                            if (part && !part.provenance.includes(leafNode.id)) {
                                part.provenance.push(leafNode.id);
                            }
                        });
                    });
                    
                    expandedTerms.push({
                        node: productNode,
                        sign: productSign,
                        leafNodes: allLeafNodes
                    });
                }
            }

            return utils.buildSumTree(expandedTerms, fontSize);
        },
        (originalNode, ruleData, newNode) => {
            const { leftExpression, rightExpression } = ruleData;
            const leftStr = utils.nodeToString(leftExpression);
            const rightStr = utils.nodeToString(rightExpression);
            return `Expanded polynomial multiplication: (${leftStr})(${rightStr})`;
        }
    ),

    // Multiply monomials (2x * 3x -> 6x^2, 3y^2 * 4y -> 12y^3)
    SimplificationEngine.createRule("Multiply Monomials",
        (node) => {
            if (!SimplificationEngine.isBinaryOp(node, 'multiply')) return false;

            // Check if both operands are monomials
            const leftMonomial = SimplificationEngine.isMonomial(node.left);
            const rightMonomial = SimplificationEngine.isMonomial(node.right);

            if (!leftMonomial || !rightMonomial) return false;

            // Check if they have the same variable
            if (leftMonomial.variable !== rightMonomial.variable) return false;

            return {
                variable: leftMonomial.variable,
                leftCoeff: leftMonomial.coefficient,
                rightCoeff: rightMonomial.coefficient,
                leftPower: leftMonomial.power,
                rightPower: rightMonomial.power,
                leftNode: node.left,
                rightNode: node.right
            };
        },
        (node, data) => {
            const { variable, leftCoeff, rightCoeff, leftPower, rightPower, leftNode, rightNode } = data;
            const fontSize = node.getFontSize();

            // Calculate new coefficient and power
            const newCoeff = leftCoeff * rightCoeff;
            const newPower = leftPower + rightPower;

            // Extract granular provenance
            const leftProvenance = utils.extractMonomialProvenance(leftNode);
            const rightProvenance = utils.extractMonomialProvenance(rightNode);
            
            const coefficientProvenance = [
                ...leftProvenance.coefficientNodes.map(n => n.id),
                ...rightProvenance.coefficientNodes.map(n => n.id)
            ];
            
            const variableProvenance = [
                ...leftProvenance.variableNodes.map(n => n.id),
                ...rightProvenance.variableNodes.map(n => n.id)
            ];

            // Create the result with granular provenance
            const result = utils.createMonomialWithGranularProvenance(
                newCoeff,
                variable,
                newPower,
                fontSize,
                coefficientProvenance,
                variableProvenance
            );

            result.provenance.push(node.id);

            return result;
        },
        (originalNode, ruleData, newNode) => {
            const { leftCoeff, rightCoeff, variable, leftPower, rightPower } = ruleData;
            const newCoeff = leftCoeff * rightCoeff;
            const newPower = leftPower + rightPower;
            const leftStr = utils.nodeToString(ruleData.leftNode);
            const rightStr = utils.nodeToString(ruleData.rightNode);
            
            return `Multiplied monomials: ${leftStr} ${getMultiplicationSymbol()} ${rightStr} = ${newCoeff}${variable}${newPower > 1 ? `^${newPower}` : ''}`;
        }
    ),

    // Combine identical terms in multiplication to create powers (x*x -> x^2, y*y*y -> y^3)
    SimplificationEngine.createRule("Combine Like Factors",
        (node) => {
            if (!SimplificationEngine.isBinaryOp(node, 'multiply')) return false;

            // Check if both operands are identical variables or simple expressions
            if (SimplificationEngine.isType(node.left, 'omdVariableNode') && 
                SimplificationEngine.isType(node.right, 'omdVariableNode') &&
                node.left.name === node.right.name) {
                return {
                    variable: node.left.name,
                    leftNode: node.left,
                    rightNode: node.right,
                    power: 2
                };
            }

            // Check for more complex patterns like x^2 * x -> x^3
            let baseVar = null;
            let leftPower = 1;
            let rightPower = 1;
            let leftNode = node.left;
            let rightNode = node.right;

            // Analyze left operand
            if (SimplificationEngine.isType(node.left, 'omdVariableNode')) {
                baseVar = node.left.name;
                leftPower = 1;
            } else if (SimplificationEngine.isType(node.left, 'omdPowerNode') &&
                      SimplificationEngine.isType(node.left.base, 'omdVariableNode') &&
                      node.left.exponent.isConstant()) {
                baseVar = node.left.base.name;
                leftPower = node.left.exponent.getValue();
            }

            // Analyze right operand
            if (SimplificationEngine.isType(node.right, 'omdVariableNode')) {
                if (baseVar === node.right.name) {
                    rightPower = 1;
                } else {
                    return false;
                }
            } else if (SimplificationEngine.isType(node.right, 'omdPowerNode') &&
                      SimplificationEngine.isType(node.right.base, 'omdVariableNode') &&
                      node.right.exponent.isConstant()) {
                if (baseVar === node.right.base.name) {
                    rightPower = node.right.exponent.getValue();
                } else {
                    return false;
                }
            } else {
                return false;
            }

            if (baseVar && Number.isInteger(leftPower) && Number.isInteger(rightPower)) {
                return {
                    variable: baseVar,
                    leftNode: leftNode,
                    rightNode: rightNode,
                    power: leftPower + rightPower
                };
            }

            return false;
        },
        (node, data) => {
            const { variable, power, leftNode, rightNode } = data;
            const fontSize = node.getFontSize();

            let result;
            if (power === 1) {
                result = SimplificationEngine.createMonomial(1, variable, 1, fontSize);
            } else {
                const variableNode = SimplificationEngine.createMonomial(1, variable, 1, fontSize);
                result = utils.createPowerTerm(variableNode, power, fontSize);
            }

            // Preserve provenance from both original factors
            result.provenance.push(leftNode.id, rightNode.id, node.id);
            
            return result;
        },
        (originalNode, ruleData, newNode) => {
            const { variable, power } = ruleData;
            const leftStr = utils.nodeToString(ruleData.leftNode);
            const rightStr = utils.nodeToString(ruleData.rightNode);
            
            return `Combined like factors: ${leftStr} ${getMultiplicationSymbol()} ${rightStr} = ${variable}${power > 1 ? `^${power}` : ''}`;
        }
    ),

    // Complex sum folding (x + 2 + 3 → x + 5)
    SimplificationEngine.createRule("Combine Multiple Constants in Sums",
        (node) => {
            if (!SimplificationEngine.isBinaryOp(node) ||
                (node.operation !== 'add' && node.operation !== 'subtract')) return false;

            // Flatten the sum
            const terms = [];
            utils.flattenSum(node, terms);

            const constantCount = terms.filter(t => t.node.isConstant()).length;
            if (constantCount <= 1) return false;

            // Calculate what the combined constant would be
            const constantTerms = terms.filter(t => t.node.isConstant());
            let totalNum = 0, totalDen = 1;
            for (const term of constantTerms) {
                const { num, den } = term.node.getRationalValue();
                const newTotalNum = (totalNum * den) + (num * term.sign * totalDen);
                const newTotalDen = totalDen * den;
                totalNum = newTotalNum;
                totalDen = newTotalDen;
                const commonDivisor = utils.gcd(Math.abs(totalNum), Math.abs(totalDen));
                totalNum /= commonDivisor;
                totalDen /= commonDivisor;
            }

            // Don't handle cases where the result would be zero - let cancellation rules handle those
            if (totalNum === 0) return false;

            return { terms };
        },
        (node, data) => {
            const { terms } = data;

            const constantTerms = terms.filter(t => t.node.isConstant());
            const otherTerms = terms.filter(t => !t.node.isConstant());

            // Get the actual constant nodes for provenance
            const constantNodes = constantTerms.map(t => t.node);

            // Combine all constants using rational arithmetic
            let totalNum = 0, totalDen = 1;
            for (const term of constantTerms) {
                const { num, den } = term.node.getRationalValue();
                const newTotalNum = (totalNum * den) + (num * term.sign * totalDen);
                const newTotalDen = totalDen * den;
                totalNum = newTotalNum;
                totalDen = newTotalDen;
                const commonDivisor = utils.gcd(Math.abs(totalNum), Math.abs(totalDen));
                totalNum /= commonDivisor;
                totalDen /= commonDivisor;
            }

            // Add combined constant back to terms if non-zero
            let finalTerms = [...otherTerms];

            if (totalNum !== 0 || finalTerms.length === 0) {
                if (totalDen < 0) { totalNum = -totalNum; totalDen = -totalDen; }
                const sign = totalNum >= 0 ? 1 : -1;
                const absNum = Math.abs(totalNum);

                let newNode;
                if (totalDen === 1) {
                    // Create a simple constant with automatic provenance tracking
                    newNode = SimplificationEngine.createConstant(absNum, node.getFontSize(), ...constantNodes);
                } else {
                    // Create a rational node
                    newNode = new omdRationalNode({
                        type: 'OperatorNode',
                        fn: 'divide',
                        args: [
                            { type: 'ConstantNode', value: absNum },
                            { type: 'ConstantNode', value: totalDen }
                        ]
                    });
                    newNode.setFontSize(node.getFontSize());
                    // Apply provenance for rational nodes manually using the same approach
                    constantNodes.forEach(sourceNode => {
                        if (sourceNode.id && !newNode.provenance.includes(sourceNode.id)) {
                            newNode.provenance.push(sourceNode.id);
                        }
                    });
                }

                finalTerms.push({ node: newNode, sign: sign });
            }

            if (finalTerms.length === 0) {
                const zeroNode = SimplificationEngine.createConstant(0, node.getFontSize(), ...constantNodes);
                return zeroNode;
            }

            const result = utils.buildSumTree(finalTerms, node.getFontSize());
            
            if(result) {
                constantNodes.forEach(sourceNode => {
                    if (sourceNode.id && !result.provenance.includes(sourceNode.id)) {
                        result.provenance.push(sourceNode.id);
                    }
                });
                result.provenance.push(node.id);
            }

            return result;
        },
        (originalNode, ruleData, newNode) => {
            const { terms } = ruleData;
            const constantTerms = terms.filter(t => t.node.isConstant());
        
            // Calculate the combined value
            let totalNum = 0, totalDen = 1;
            for (const term of constantTerms) {
                const { num, den } = term.node.getRationalValue();
                const newTotalNum = (totalNum * den) + (num * term.sign * totalDen);
                const newTotalDen = totalDen * den;
                totalNum = newTotalNum;
                totalDen = newTotalDen;
                const commonDivisor = utils.gcd(Math.abs(totalNum), Math.abs(totalDen));
                totalNum /= commonDivisor;
                totalDen /= commonDivisor;
            }
        
            const constantStrings = constantTerms.map(t => {
                const valueStr = utils.nodeToString(t.node);
                return t.sign === 1 ? `+ ${valueStr}` : `- ${valueStr}`;
            });
            // For the first term, if it's positive, remove the leading "+ ".
            if (constantStrings.length > 0 && constantStrings[0].startsWith('+ ')) {
                constantStrings[0] = constantStrings[0].substring(2);
            }
            
            const calculation = constantStrings.join(' ');
            const resultStr = totalDen === 1 ? `${totalNum}` : `${totalNum}/${totalDen}`;
        
            let message = `Combining the constant terms: ${calculation} = ${resultStr}. `;
            
            if (totalNum === 0) {
                message += `Since the constants sum to zero, they are replaced by 0.`;
            } else {
                message += `The constants are replaced by their sum.`;
            }
            
            return message;
        }
    ),

    // Combine like terms (monomials with same variable and power)
    SimplificationEngine.createRule("Combine Like Terms",
        (node) => {
            if (!SimplificationEngine.isBinaryOp(node, 'add') && !SimplificationEngine.isBinaryOp(node, 'subtract')) {
                return false;
            }

            const terms = [];
            utils.flattenSum(node, terms);

            const likeTermGroups = new Map();
            const otherTerms = [];
            
            for (const term of terms) {
                const monomialInfo = SimplificationEngine.isMonomial(term.node);
                
                if (monomialInfo) {
                    const key = `${monomialInfo.variable}^${monomialInfo.power}`;
                    if (!likeTermGroups.has(key)) {
                        likeTermGroups.set(key, []);
                    }
                    
                    likeTermGroups.get(key).push({
                        term,
                        monomialInfo,
                        originalNodeId: term.node.id
                    });
                } else {
                    otherTerms.push(term);
                }
            }

            // Check if we have like terms to combine
            const foundLikeTerms = Array.from(likeTermGroups.values()).some(group => group.length > 1);

            return foundLikeTerms ? { likeTermGroups, otherTerms } : false;
        },
        (node, data) => {
            const { likeTermGroups, otherTerms } = data;
            // Start with a copy of the original terms array (to preserve order)
            let allNewTerms = [...otherTerms];
            // We'll build a map from node id to its index in the original terms array
            const originalTerms = [];
            utils.flattenSum(node, originalTerms);

            // For each group of like terms
            for (const [key, termGroup] of likeTermGroups) {
                if (termGroup.length === 1) {
                    // Find the index of this term in the original terms array
                    const idx = originalTerms.findIndex(t => t.node.id === termGroup[0].term.node.id);
                    if (idx !== -1) {
                        allNewTerms.splice(idx, 0, termGroup[0].term);
                    } else {
                        allNewTerms.push(termGroup[0].term);
                    }
                } else {
                    // Combine multiple like terms
                    let totalCoeff = 0;
                    const coefficientProvenance = [];
                    const variableProvenance = [];
                    const likeTermIds = termGroup.map(t => t.term.node.id);
                    for (const termData of termGroup) {
                        const coeff = termData.monomialInfo.coefficient * termData.term.sign;
                        totalCoeff += coeff;
                        // Extract granular provenance
                        const monomialProvenance = utils.extractMonomialProvenance(termData.term.node);
                        monomialProvenance.coefficientNodes.forEach(coeffNode => {
                            if (!coefficientProvenance.includes(coeffNode.id)) {
                                coefficientProvenance.push(coeffNode.id);
                            }
                        });
                        monomialProvenance.variableNodes.forEach(varNode => {
                            if (!variableProvenance.includes(varNode.id)) {
                                variableProvenance.push(varNode.id);
                            }
                        });
                    }
                    // Create combined term if coefficient is non-zero
                    if (totalCoeff !== 0) {
                        const firstTerm = termGroup[0];
                        const newMonomial = utils.createMonomialWithGranularProvenance(
                            totalCoeff,
                            firstTerm.monomialInfo.variable,
                            firstTerm.monomialInfo.power,
                            node.getFontSize(),
                            coefficientProvenance,
                            variableProvenance
                        );
                        // Find the leftmost index of any like term in the original terms array
                        const leftmostIdx = originalTerms.findIndex(t => likeTermIds.includes(t.node.id));
                        // Remove all like terms from allNewTerms (by node id)
                        allNewTerms = allNewTerms.filter(t => !likeTermIds.includes(t.node.id));
                        // Insert the new combined term at the leftmost index
                        if (leftmostIdx !== -1) {
                            allNewTerms.splice(leftmostIdx, 0, { node: newMonomial, sign: 1 });
                        } else {
                            allNewTerms.push({ node: newMonomial, sign: 1 });
                        }
                    } else {
                        // If the sum is zero, just remove all like terms
                        allNewTerms = allNewTerms.filter(t => !likeTermIds.includes(t.node.id));
                    }
                }
            }

            // Handle zero case
            if (allNewTerms.length === 0) {
                return SimplificationEngine.createConstant(0, node.getFontSize());
            }

            return utils.buildSumTree(allNewTerms, node.getFontSize());
        },
        (originalNode, ruleData, newNode) => {
            const { likeTermGroups } = ruleData;
            const combinations = [];

            for (const [key, termGroup] of likeTermGroups) {
                if (termGroup.length > 1) {
                    let totalCoeff = 0;
                    const termDetails = [];
                    
                    for (const termData of termGroup) {
                        const coeff = termData.monomialInfo.coefficient * termData.term.sign;
                        totalCoeff += coeff;
                        
                        // Format individual terms for the explanation
                        const variable = termData.monomialInfo.variable;
                        const power = termData.monomialInfo.power;
                        const powerStr = power !== 1 ? `^${power}` : '';
                        
                        if (coeff === 1) {
                            termDetails.push(`${variable}${powerStr}`);
                        } else if (coeff === -1) {
                            termDetails.push(`-${variable}${powerStr}`);
                        } else {
                            termDetails.push(`${coeff}${variable}${powerStr}`);
                        }
                    }
                    
                    const variable = termGroup[0].monomialInfo.variable;
                    const power = termGroup[0].monomialInfo.power;
                    const powerStr = power !== 1 ? `^${power}` : '';
                    
                    if (totalCoeff === 0) {
                        combinations.push(`${termDetails.join(' + ').replace('+ -', '- ')} = 0 (like terms cancelled)`);
                    } else {
                        const resultStr = totalCoeff === 1 ? `${variable}${powerStr}` :
                                         totalCoeff === -1 ? `-${variable}${powerStr}` :
                                         `${totalCoeff}${variable}${powerStr}`;
                        combinations.push(`${termDetails.join(' + ').replace('+ -', '- ')} = ${resultStr}`);
                    }
                }
            }

            if (combinations.length === 0) {
                return "No like terms were found to combine";
            } else if (combinations.length === 1) {
                return `Combined like terms: ${combinations[0]}`;
            } else {
                return `Combined like terms: ${combinations.join('; ')}`;
            }
        }
    ),

    // Multiply then divide by same factor: (a*x)/a → x or a*(x/a) → x
    SimplificationEngine.createRule("Multiply Divide Same Factor",
        (node) => {
            // Check for (a*x)/a pattern (rational node with multiplication in numerator)
            if (SimplificationEngine.isType(node, 'omdRationalNode')) {
                const numerator = SimplificationEngine.unwrapParentheses(node.numerator);
                const denominator = SimplificationEngine.unwrapParentheses(node.denominator);
                
                if (SimplificationEngine.isBinaryOp(numerator, 'multiply') && 
                    SimplificationEngine.isType(denominator, 'omdConstantNode')) {
                    
                    const constOp = SimplificationEngine.hasConstantOperand(numerator);
                    if (constOp && constOp.constant.getValue() === denominator.getValue()) {
                        return {
                            pattern: 'rational',
                            factor: constOp.constant.getValue(),
                            expression: constOp.other,
                            factorNode: constOp.constant,
                            denominatorNode: denominator
                        };
                    }
                }
            }
            
            // Check for a*(x/a) pattern (multiplication with rational)
            if (SimplificationEngine.isBinaryOp(node, 'multiply')) {
                const constOp = SimplificationEngine.hasConstantOperand(node);
                if (!constOp) return false;
                
                const otherNode = constOp.other;
                if (SimplificationEngine.isType(otherNode, 'omdRationalNode')) {
                    const denominator = SimplificationEngine.unwrapParentheses(otherNode.denominator);
                    
                    if (SimplificationEngine.isType(denominator, 'omdConstantNode') &&
                        constOp.constant.getValue() === denominator.getValue()) {
                        
                        return {
                            pattern: 'multiply',
                            factor: constOp.constant.getValue(),
                            expression: SimplificationEngine.unwrapParentheses(otherNode.numerator),
                            factorNode: constOp.constant,
                            denominatorNode: denominator
                        };
                    }
                }
            }
            
            return false;
        },
        (node, data) => {
            const { expression, factorNode, denominatorNode } = data;
            const newNode = expression.clone();
            
            // Preserve provenance
            newNode.provenance.push(factorNode.id);
            newNode.provenance.push(denominatorNode.id);
            newNode.provenance.push(node.id);
            
            return newNode;
        },
        (originalNode, ruleData, newNode) => {
            const { pattern, factor } = ruleData;
            if (pattern === 'rational') {
                return `Simplified multiplication and division: (${factor} × expression)/${factor} = expression`;
            } else {
                return `Simplified multiplication and division: ${factor} × (expression/${factor}) = expression`;
            }
        }
    )
];