@teachinglab/omd 0.6.1 → 0.6.2

package/omd/utils/omdTreeDiff.js

@@ -1,734 +1,734 @@
-import { omdStepVisualizerNodeUtils } from '../utils/omdStepVisualizerNodeUtils.js';
-
-/**
- * Robust tree diff algorithm using optimal substructure matching
- * This replaces the special-case-heavy approach with a systematic algorithm
- */
-export class omdTreeDiff {
-    
-    /**
-     * Main entry point - finds changed nodes between two equations
-     * @param {omdEquationNode} oldEquation - Previous equation
-     * @param {omdEquationNode} newEquation - Current equation
-     * @param {Object} options - Configuration options
-     * @param {boolean} options.educationalMode - If true, highlights mathematically neutral changes for learning
-     * @returns {Array} Array of changed nodes to highlight
-     */
-    static findChangedNodes(oldEquation, newEquation, options = {}) {
-        const { educationalMode = false } = options;
-        
-
-        
-        // === SPECIAL CASE: Same operation added to both sides ===
-        const specialCaseNodes = this.findEquationSpecialCases(oldEquation, newEquation);
-        if (specialCaseNodes.length > 0) {
-            return specialCaseNodes;
-        }
-        
-        const changedNodes = [];
-        
-        // Compare left sides if they differ
-        if (oldEquation.left.toString() !== newEquation.left.toString()) {
-            const leftChanges = this.diffSubtrees(oldEquation.left, newEquation.left, educationalMode);
-            changedNodes.push(...leftChanges);
-        }
-        
-        // Compare right sides if they differ
-        if (oldEquation.right.toString() !== newEquation.right.toString()) {
-            const rightChanges = this.diffSubtrees(oldEquation.right, newEquation.right, educationalMode);
-            changedNodes.push(...rightChanges);
-        }
-        
-        return changedNodes;
-    }
-    
-    /**
-     * Find equation-level special cases (like adding same operation to both sides)
-     * @param {omdEquationNode} oldEquation - Previous equation
-     * @param {omdEquationNode} newEquation - Current equation
-     * @returns {Array} Nodes to highlight for equation special cases
-     */
-    static findEquationSpecialCases(oldEquation, newEquation) {
-        const oldLeftStr = oldEquation.left.toString();
-        const newLeftStr = newEquation.left.toString();
-        const oldRightStr = oldEquation.right.toString();
-        const newRightStr = newEquation.right.toString();
-        
-        // Check if we're adding the same operation to both sides
-        if (newLeftStr.startsWith(oldLeftStr) && newRightStr.startsWith(oldRightStr)) {
-            const leftSuffix = newLeftStr.substring(oldLeftStr.length).trim();
-            const rightSuffix = newRightStr.substring(oldRightStr.length).trim();
-            
-            // Case 1: Adding subtraction to both sides (e.g., "x + 2 = 5" → "x + 2 - 2 = 5 - 2")
-            if (leftSuffix.startsWith("-") && rightSuffix.startsWith("-") && 
-                leftSuffix.substring(1).trim() === rightSuffix.substring(1).trim()) {
-                
-                const subtractedValue = leftSuffix.substring(1).trim();
-                
-                const nodesToHighlight = [];
-                
-                // Find rightmost occurrence of the subtracted value on left side
-                const leftSubtractedNode = omdStepVisualizerNodeUtils.findRightmostNodeWithValue(newEquation.left, subtractedValue);
-                if (leftSubtractedNode) {
-                    // If it's a leaf node, add it directly; otherwise find its leaf nodes
-                    if (omdStepVisualizerNodeUtils.isLeafNode(leftSubtractedNode)) {
-                        nodesToHighlight.push(leftSubtractedNode);
-                    } else {
-                        const leftLeaves = omdStepVisualizerNodeUtils.findLeafNodes(leftSubtractedNode);
-                        nodesToHighlight.push(...leftLeaves);
-                    }
-                }
-                
-                // Find rightmost occurrence of the subtracted value on right side
-                const rightSubtractedNode = omdStepVisualizerNodeUtils.findRightmostNodeWithValue(newEquation.right, subtractedValue);
-                if (rightSubtractedNode) {
-                    // If it's a leaf node, add it directly; otherwise find its leaf nodes
-                    if (omdStepVisualizerNodeUtils.isLeafNode(rightSubtractedNode)) {
-                        nodesToHighlight.push(rightSubtractedNode);
-                    } else {
-                        const rightLeaves = omdStepVisualizerNodeUtils.findLeafNodes(rightSubtractedNode);
-                        nodesToHighlight.push(...rightLeaves);
-                    }
-                }
-                
-                return nodesToHighlight;
-            }
-            
-            // Case 2: Adding addition to both sides (e.g., "x - 2 = 3" → "x - 2 + 2 = 3 + 2")
-            if (leftSuffix.startsWith("+") && rightSuffix.startsWith("+") && 
-                leftSuffix.substring(1).trim() === rightSuffix.substring(1).trim()) {
-                
-                const addedValue = leftSuffix.substring(1).trim();
-                
-                const nodesToHighlight = [];
-                
-                // Find rightmost occurrence of the added value on left side
-                const leftAddedNode = omdStepVisualizerNodeUtils.findRightmostNodeWithValue(newEquation.left, addedValue);
-                if (leftAddedNode) {
-                    // If it's a leaf node, add it directly; otherwise find its leaf nodes
-                    if (omdStepVisualizerNodeUtils.isLeafNode(leftAddedNode)) {
-                        nodesToHighlight.push(leftAddedNode);
-                    } else {
-                        const leftLeaves = omdStepVisualizerNodeUtils.findLeafNodes(leftAddedNode);
-                        nodesToHighlight.push(...leftLeaves);
-                    }
-                }
-                
-                // Find rightmost occurrence of the added value on right side  
-                const rightAddedNode = omdStepVisualizerNodeUtils.findRightmostNodeWithValue(newEquation.right, addedValue);
-                if (rightAddedNode) {
-                    // If it's a leaf node, add it directly; otherwise find its leaf nodes
-                    if (omdStepVisualizerNodeUtils.isLeafNode(rightAddedNode)) {
-                        nodesToHighlight.push(rightAddedNode);
-                    } else {
-                        const rightLeaves = omdStepVisualizerNodeUtils.findLeafNodes(rightAddedNode);
-                        nodesToHighlight.push(...rightLeaves);
-                    }
-                }
-                
-                return nodesToHighlight;
-            }
-        }
-        
-        return [];
-    }
-    
-    /**
-     * Core algorithm: find optimal subtree matching and return unmatched nodes
-     * @param {omdNode} oldTree - Old tree root
-     * @param {omdNode} newTree - New tree root
-     * @param {boolean} educationalMode - Whether to highlight pedagogical changes
-     * @returns {Array} Array of unmatched leaf nodes in new tree
-     */
-    static diffSubtrees(oldTree, newTree, educationalMode = false) {
-        // === STEP 1: CHECK FOR EDUCATIONAL PATTERNS FIRST ===
-        // These patterns from the old system worked really well for highlighting
-        
-        // Check for common prefix patterns (like "2x + 4" → "2x + 4 - 4")
-        const prefixHighlights = this.findCommonPrefixHighlights(oldTree, newTree);
-        if (prefixHighlights.length > 0) {
-            return prefixHighlights;
-        }
-        
-        // Check for variable preservation patterns (when variables stay same but constants change)
-        const variableHighlights = this.findVariablePreservationHighlights(oldTree, newTree);
-        if (variableHighlights.length > 0) {
-            return variableHighlights;
-        }
-        
-        // Check for type difference patterns (constant becoming binary expression, etc.)
-        const typeHighlights = this.findTypeDifferenceHighlights(oldTree, newTree);
-        if (typeHighlights.length > 0) {
-            return typeHighlights;
-        }
-        
-        // Check for subtraction patterns (when one part matches and other is subtracted)
-        const subtractionHighlights = this.findSubtractionPatternHighlights(oldTree, newTree);
-        if (subtractionHighlights.length > 0) {
-            return subtractionHighlights;
-        }
-        
-        // === STEP 2: FALLBACK TO OPTIMAL MATCHING ALGORITHM ===
-        
-        // Find all possible subtree matches
-        const allMatches = this.findAllSubtreeMatches(oldTree, newTree);
-        
-        // Select optimal non-overlapping set of matches
-        const optimalMatches = this.selectOptimalMatching(allMatches);
-        
-        // Find unmatched nodes (these are the changes)
-        let unmatchedNodes = this.findUnmatchedLeafNodes(newTree, optimalMatches);
-        
-        // Educational mode - highlight simplifications
-        if (educationalMode && unmatchedNodes.length === 0) {
-            const educationalHighlights = this.findEducationalHighlights(oldTree, newTree, optimalMatches);
-            unmatchedNodes.push(...educationalHighlights);
-        }
-        
-        return unmatchedNodes;
-    }
-    
-    /**
-     * Find educational highlights for cases where mathematical content didn't change
-     * but pedagogical highlighting is desired (e.g., removing + 0)
-     * @param {omdNode} oldTree - Old tree root
-     * @param {omdNode} newTree - New tree root  
-     * @param {Array} optimalMatches - The matches already found
-     * @returns {Array} Additional nodes to highlight for educational purposes
-     */
-    static findEducationalHighlights(oldTree, newTree, optimalMatches) {
-        const educationalNodes = [];
-        
-        // Case 1: Additive identity removal (+ 0 or - 0)
-        const identityHighlights = this.findAdditiveIdentityChanges(oldTree, newTree);
-        educationalNodes.push(...identityHighlights);
-        
-        // Case 2: Multiplicative identity removal (* 1 or / 1)  
-        const multiplicativeHighlights = this.findMultiplicativeIdentityChanges(oldTree, newTree);
-        educationalNodes.push(...multiplicativeHighlights);
-        
-        // Case 3: Double negative simplification (--x → x)
-        const doubleNegativeHighlights = this.findDoubleNegativeChanges(oldTree, newTree);
-        educationalNodes.push(...doubleNegativeHighlights);
-        
-        return educationalNodes;
-    }
-    
-    /**
-     * Find additive identity changes (removal of + 0 or - 0)
-     * @param {omdNode} oldTree - Old tree
-     * @param {omdNode} newTree - New tree
-     * @returns {Array} Nodes to highlight for additive identity
-     */
-    static findAdditiveIdentityChanges(oldTree, newTree) {
-        // Check if old tree has + 0 or - 0 that's not in new tree
-        const oldStr = oldTree.toString();
-        const newStr = newTree.toString();
-        
-        // Pattern: "expression + 0" → "expression" or "expression - 0" → "expression"
-        if ((oldStr.includes(" + 0") || oldStr.includes(" - 0")) && 
-            !newStr.includes(" + 0") && !newStr.includes(" - 0")) {
-            
-            // Highlight ALL leaf nodes of the remaining expression to show the complete term
-            const allLeafNodes = omdStepVisualizerNodeUtils.findLeafNodes(newTree);
-            
-            if (allLeafNodes.length > 0) {
-                return allLeafNodes; // Highlight all leaf nodes in the remaining expression
-            }
-        }
-        
-        return [];
-    }
-    
-    /**
-     * Find multiplicative identity changes (removal of * 1 or / 1)
-     * @param {omdNode} oldTree - Old tree
-     * @param {omdNode} newTree - New tree
-     * @returns {Array} Nodes to highlight for multiplicative identity
-     */
-    static findMultiplicativeIdentityChanges(oldTree, newTree) {
-        const oldStr = oldTree.toString();
-        const newStr = newTree.toString();
-        
-        if ((oldStr.includes(" * 1") || oldStr.includes(" / 1")) && 
-            !newStr.includes(" * 1") && !newStr.includes(" / 1")) {
-            
-            const allLeafNodes = omdStepVisualizerNodeUtils.findLeafNodes(newTree);
-            if (allLeafNodes.length > 0) {
-                return allLeafNodes; // Highlight entire remaining expression
-            }
-        }
-        
-        return [];
-    }
-    
-    /**
-     * Find double negative changes (--x → x)
-     * @param {omdNode} oldTree - Old tree
-     * @param {omdNode} newTree - New tree
-     * @returns {Array} Nodes to highlight for double negative removal
-     */
-    static findDoubleNegativeChanges(oldTree, newTree) {
-        const oldStr = oldTree.toString();
-        const newStr = newTree.toString();
-        
-        if (oldStr.includes("--") && !newStr.includes("--")) {
-            const allLeafNodes = omdStepVisualizerNodeUtils.findLeafNodes(newTree);
-            if (allLeafNodes.length > 0) {
-                return allLeafNodes; // Highlight entire remaining expression
-            }
-        }
-        
-        return [];
-    }
-    
-    /**
-     * Find common prefix highlighting patterns
-     * Example: "2x + 4" → "2x + 4 - 4" should highlight only the "- 4" part
-     * @param {omdNode} oldTree - Old tree
-     * @param {omdNode} newTree - New tree
-     * @returns {Array} Nodes to highlight for common prefix patterns
-     */
-    static findCommonPrefixHighlights(oldTree, newTree) {
-        // Only apply to binary expressions
-        if (!omdStepVisualizerNodeUtils.isBinaryNode(newTree)) {
-            return [];
-        }
-        
-        const oldStr = oldTree.toString();
-        const newStr = newTree.toString();
-        
-        // Find common prefix
-        const commonPrefix = this._findCommonPrefix(oldStr, newStr);
-        if (!commonPrefix || commonPrefix.length <= 1) {
-            return [];
-        }
-        
-        const oldSuffix = oldStr.substring(commonPrefix.length).trim();
-        const newSuffix = newStr.substring(commonPrefix.length).trim();
-        
-        // Case 1: New suffix is "0" (simplification to zero)
-        if (newSuffix === "0") {
-            const zeroNodes = omdStepVisualizerNodeUtils.findLeafNodesWithValue(newTree, "0");
-            if (zeroNodes.length > 0) {
-                return zeroNodes;
-            }
-        }
-        
-        // Case 2: New suffix is a subtraction (adding negative term)
-        if (oldSuffix === "" && newSuffix.startsWith("- ")) {
-            const subtractedValue = newSuffix.substring(2).trim();
-            
-            const subtractedNodes = omdStepVisualizerNodeUtils.findLeafNodesWithValue(newTree, subtractedValue);
-            if (subtractedNodes.length > 0) {
-                return subtractedNodes;
-            }
-        }
-        
-        return [];
-    }
-    
-    /**
-     * Find variable preservation highlighting patterns  
-     * Example: "2x + 4" → "2x + 2" should highlight only the changed constant
-     * @param {omdNode} oldTree - Old tree
-     * @param {omdNode} newTree - New tree
-     * @returns {Array} Nodes to highlight for variable preservation patterns
-     */
-    static findVariablePreservationHighlights(oldTree, newTree) {
-        // Only apply to binary expressions
-        if (!omdStepVisualizerNodeUtils.isBinaryNode(oldTree) || 
-            !omdStepVisualizerNodeUtils.isBinaryNode(newTree)) {
-            return [];
-        }
-        
-        const oldStr = oldTree.toString();
-        const newStr = newTree.toString();
-        
-        // Check if both expressions contain the same variable term
-        const variablePattern = /(\d*[a-zA-Z])/;
-        const oldMatch = oldStr.match(variablePattern);
-        const newMatch = newStr.match(variablePattern);
-        
-        if (oldMatch && newMatch && oldMatch[0] === newMatch[0]) {
-            // Find constants that changed
-            const oldConstNodes = omdStepVisualizerNodeUtils.findConstantNodes(oldTree);
-            const newConstNodes = omdStepVisualizerNodeUtils.findConstantNodes(newTree);
-            
-            const changedConstNodes = newConstNodes.filter(newNode => {
-                return !oldConstNodes.some(oldNode => 
-                    oldNode.toString() === newNode.toString()
-                );
-            });
-            
-            return changedConstNodes;
-        }
-        
-        return [];
-    }
-    
-    /**
-     * Find type difference highlighting patterns
-     * Example: constant "3" → binary expression "x + 2" should highlight the new expression
-     * @param {omdNode} oldTree - Old tree
-     * @param {omdNode} newTree - New tree  
-     * @returns {Array} Nodes to highlight for type difference patterns
-     */
-    static findTypeDifferenceHighlights(oldTree, newTree) {
-        const oldType = oldTree.constructor ? oldTree.type : 'unknown';
-        const newType = newTree.constructor ? newTree.type : 'unknown';
-        
-        if (oldType === newType) {
-            return []; // Same type, not a type difference pattern
-        }
-        
-        // Case 1: New node is binary, check if old node is part of it
-        if (omdStepVisualizerNodeUtils.isBinaryNode(newTree)) {
-            const oldStr = oldTree.toString();
-            const newLeftStr = newTree.left ? newTree.left.toString() : '';
-            const newRightStr = newTree.right ? newTree.right.toString() : '';
-            
-            if (oldStr === newLeftStr) {
-                if (newTree.right) {
-                    const leafNodes = omdStepVisualizerNodeUtils.findLeafNodes(newTree.right);
-                    return leafNodes;
-                }
-            } else if (oldStr === newRightStr) {
-                if (newTree.left) {
-                    const leafNodes = omdStepVisualizerNodeUtils.findLeafNodes(newTree.left);
-                    return leafNodes;
-                }
-            }
-        }
-        
-        // Case 2: Complete change - highlight all leaf nodes in new tree
-        const leaves = omdStepVisualizerNodeUtils.findLeafNodes(newTree);
-        return leaves;
-    }
-    
-    /**
-     * Find subtraction pattern highlighting 
-     * Example: "x + 2" → "x + 2 - 2" should highlight only the "- 2" part
-     * @param {omdNode} oldTree - Old tree
-     * @param {omdNode} newTree - New tree
-     * @returns {Array} Nodes to highlight for subtraction patterns
-     */
-    static findSubtractionPatternHighlights(oldTree, newTree) {
-        // Check if new tree is a subtraction and old tree matches the left side
-        if (omdStepVisualizerNodeUtils.isBinaryNode(newTree) && 
-            newTree.operation === 'subtract') {
-            
-            const oldStr = oldTree.toString();
-            const newLeftStr = newTree.left?.toString();
-            
-            if (oldStr === newLeftStr) {
-                if (newTree.right) {
-                    const rightLeaves = omdStepVisualizerNodeUtils.findLeafNodes(newTree.right);
-                    return rightLeaves;
-                }
-            }
-        }
-        
-        return [];
-    }
-    
-    /**
-     * Helper: Find the longest common prefix between two strings
-     * @param {string} str1 - First string
-     * @param {string} str2 - Second string
-     * @returns {string} The common prefix
-     * @private
-     */
-    static _findCommonPrefix(str1, str2) {
-        let i = 0;
-        while (i < str1.length && i < str2.length && str1[i] === str2[i]) {
-            i++;
-        }
-        return str1.substring(0, i);
-    }
-    
-    /**
-     * Find all possible matches between subtrees of old and new trees
-     * @param {omdNode} oldTree - Old tree root
-     * @param {omdNode} newTree - New tree root
-     * @returns {Array} Array of match objects {oldNode, newNode, size, score}
-     */
-    static findAllSubtreeMatches(oldTree, newTree) {
-        const matches = [];
-        const oldSubtrees = this.getAllSubtrees(oldTree);
-        const newSubtrees = this.getAllSubtrees(newTree);
-        
-        for (const oldSub of oldSubtrees) {
-            for (const newSub of newSubtrees) {
-                const similarity = this.calculateSimilarity(oldSub, newSub);
-                if (similarity.isMatch) {
-                    matches.push({
-                        oldNode: oldSub,
-                        newNode: newSub,
-                        size: similarity.size,
-                        score: similarity.score,
-                        type: similarity.type
-                    });
-                }
-            }
-        }
-        
-        return matches;
-    }
-    
-    /**
-     * Get all subtrees (including single nodes) from a tree
-     * @param {omdNode} root - Root node
-     * @returns {Array} Array of all subtrees
-     */
-    static getAllSubtrees(root) {
-        if (!root) return [];
-        
-        const subtrees = [root];
-        
-        // Add all child subtrees recursively
-        if (omdStepVisualizerNodeUtils.isBinaryNode(root)) {
-            subtrees.push(...this.getAllSubtrees(root.left));
-            subtrees.push(...this.getAllSubtrees(root.right));
-        } else if (omdStepVisualizerNodeUtils.isUnaryNode(root)) {
-            subtrees.push(...this.getAllSubtrees(root.argument));
-        } else if (omdStepVisualizerNodeUtils.hasExpression(root)) {
-            subtrees.push(...this.getAllSubtrees(root.expression));
-        }
-        
-        return subtrees;
-    }
-    
-    /**
-     * Calculate similarity between two subtrees
-     * @param {omdNode} tree1 - First tree
-     * @param {omdNode} tree2 - Second tree
-     * @returns {Object} Similarity info {isMatch, size, score, type}
-     */
-    static calculateSimilarity(tree1, tree2) {
-        // Exact structural match
-        if (this.treesStructurallyEqual(tree1, tree2)) {
-            const size = this.getSubtreeSize(tree1);
-            return {
-                isMatch: true,
-                size: size,
-                score: size * 10, // High score for exact matches
-                type: 'exact'
-            };
-        }
-        
-        // Exact string match (different structure, same result)
-        if (tree1.toString() === tree2.toString()) {
-            const size = this.getSubtreeSize(tree1);
-            return {
-                isMatch: true,
-                size: size,
-                score: size * 8, // Slightly lower than structural match
-                type: 'equivalent'
-            };
-        }
-        
-        // Leaf node value match
-        if (omdStepVisualizerNodeUtils.isLeafNode(tree1) && 
-            omdStepVisualizerNodeUtils.isLeafNode(tree2)) {
-            const val1 = omdStepVisualizerNodeUtils.getNodeValue(tree1);
-            const val2 = omdStepVisualizerNodeUtils.getNodeValue(tree2);
-            
-            if (val1 === val2) {
-                return {
-                    isMatch: true,
-                    size: 1,
-                    score: 5, // Lower score for single nodes
-                    type: 'leaf'
-                };
-            }
-        }
-        
-        return { isMatch: false, size: 0, score: 0, type: 'none' };
-    }
-    
-    /**
-     * Check if two trees are structurally identical
-     * @param {omdNode} tree1 - First tree
-     * @param {omdNode} tree2 - Second tree
-     * @returns {boolean} True if structurally identical
-     */
-    static treesStructurallyEqual(tree1, tree2) {
-        if (!tree1 && !tree2) return true;
-        if (!tree1 || !tree2) return false;
-        
-        // Check node types
-        const type1 = tree1.constructor ? tree1.type : 'unknown';
-        const type2 = tree2.constructor ? tree2.type : 'unknown';
-        if (type1 !== type2) return false;
-        
-        // Check leaf nodes
-        if (omdStepVisualizerNodeUtils.isLeafNode(tree1)) {
-            const val1 = omdStepVisualizerNodeUtils.getNodeValue(tree1);
-            const val2 = omdStepVisualizerNodeUtils.getNodeValue(tree2);
-            return val1 === val2;
-        }
-        
-        // Check binary nodes
-        if (omdStepVisualizerNodeUtils.isBinaryNode(tree1)) {
-            if (tree1.operation !== tree2.operation) return false;
-            return this.treesStructurallyEqual(tree1.left, tree2.left) &&
-                   this.treesStructurallyEqual(tree1.right, tree2.right);
-        }
-        
-        // Check unary nodes
-        if (omdStepVisualizerNodeUtils.isUnaryNode(tree1)) {
-            if (tree1.operation !== tree2.operation) return false;
-            return this.treesStructurallyEqual(tree1.argument, tree2.argument);
-        }
-        
-        // Check expression nodes
-        if (omdStepVisualizerNodeUtils.hasExpression(tree1)) {
-            return this.treesStructurallyEqual(tree1.expression, tree2.expression);
-        }
-        
-        return false;
-    }
-    
-    /**
-     * Calculate the size (number of nodes) in a subtree
-     * @param {omdNode} root - Root of subtree
-     * @returns {number} Number of nodes in subtree
-     */
-    static getSubtreeSize(root) {
-        if (!root) return 0;
-        
-        let size = 1; // Count this node
-        
-        if (omdStepVisualizerNodeUtils.isBinaryNode(root)) {
-            size += this.getSubtreeSize(root.left);
-            size += this.getSubtreeSize(root.right);
-        } else if (omdStepVisualizerNodeUtils.isUnaryNode(root)) {
-            size += this.getSubtreeSize(root.argument);
-        } else if (omdStepVisualizerNodeUtils.hasExpression(root)) {
-            size += this.getSubtreeSize(root.expression);
-        }
-        
-        return size;
-    }
-    
-    /**
-     * Select optimal non-overlapping set of matches using greedy algorithm
-     * @param {Array} matches - Array of potential matches
-     * @returns {Array} Array of selected optimal matches
-     */
-    static selectOptimalMatching(matches) {
-        // Sort by score (descending) to prefer better matches
-        const sortedMatches = matches.slice().sort((a, b) => b.score - a.score);
-        
-        const selectedMatches = [];
-        const usedOldNodes = new Set();
-        const usedNewNodes = new Set();
-        
-        for (const match of sortedMatches) {
-            // Check if this match overlaps with already selected matches
-            if (!this.hasNodeOverlap(match.oldNode, usedOldNodes) &&
-                !this.hasNodeOverlap(match.newNode, usedNewNodes)) {
-                
-                selectedMatches.push(match);
-                this.markSubtreeAsUsed(match.oldNode, usedOldNodes);
-                this.markSubtreeAsUsed(match.newNode, usedNewNodes);
-            }
-        }
-        
-        return selectedMatches;
-    }
-    
-    /**
-     * Check if a node overlaps with any node in the used set
-     * @param {omdNode} node - Node to check
-     * @param {Set} usedNodes - Set of already used nodes
-     * @returns {boolean} True if there's overlap
-     */
-    static hasNodeOverlap(node, usedNodes) {
-        // Check if this node or any of its ancestors/descendants are used
-        const nodeSubtrees = this.getAllSubtrees(node);
-        return nodeSubtrees.some(subtree => usedNodes.has(subtree));
-    }
-    
-    /**
-     * Mark all nodes in a subtree as used
-     * @param {omdNode} root - Root of subtree to mark
-     * @param {Set} usedNodes - Set to add nodes to
-     */
-    static markSubtreeAsUsed(root, usedNodes) {
-        const allNodes = this.getAllSubtrees(root);
-        allNodes.forEach(node => usedNodes.add(node));
-    }
-    
-    /**
-     * Find leaf nodes in new tree that aren't covered by any match
-     * @param {omdNode} newTree - New tree root
-     * @param {Array} matches - Array of selected matches
-     * @returns {Array} Array of unmatched leaf nodes
-     */
-    static findUnmatchedLeafNodes(newTree, matches) {
-        const allLeafNodes = omdStepVisualizerNodeUtils.findLeafNodes(newTree);
-        const matchedNodes = new Set();
-        
-        // Mark all nodes covered by matches
-        for (const match of matches) {
-            const matchedSubtreeNodes = this.getAllSubtrees(match.newNode);
-            matchedSubtreeNodes.forEach(node => matchedNodes.add(node));
-        }
-        
-        // Return leaf nodes not covered by any match
-        const unmatchedLeaves = allLeafNodes.filter(leaf => !matchedNodes.has(leaf));
-        
-        return unmatchedLeaves;
-    }
-    
-    /**
-     * Find leaf nodes in old tree that aren't covered by any match (i.e., removed nodes)
-     * @param {omdNode} oldTree - Old tree root
-     * @param {Array} matches - Array of selected matches
-     * @returns {Array} Array of unmatched leaf nodes from old tree
-     */
-    static findUnmatchedOldNodes(oldTree, matches) {
-        const allOldLeafNodes = omdStepVisualizerNodeUtils.findLeafNodes(oldTree);
-        const matchedOldNodes = new Set();
-        
-        // Mark all old nodes covered by matches
-        for (const match of matches) {
-            const matchedSubtreeNodes = this.getAllSubtrees(match.oldNode);
-            matchedSubtreeNodes.forEach(node => matchedOldNodes.add(node));
-        }
-        
-        // Return old leaf nodes not covered by any match (these were removed)
-        const unmatchedOldLeaves = allOldLeafNodes.filter(leaf => !matchedOldNodes.has(leaf));
-        
-        return unmatchedOldLeaves;
-    }
-    
-    /**
-     * Debug helper: print tree structure
-     * @param {omdNode} node - Node to print
-     * @param {number} depth - Current depth for indentation
-     * @returns {string} String representation of tree structure
-     */
-    static debugPrintTree(node, depth = 0) {
-        if (!node) return '';
-        
-        const indent = '  '.repeat(depth);
-        const nodeType = node.constructor ? node.type : 'unknown';
-        const nodeValue = node.toString ? node.toString() : 'unknown';
-        
-        let result = `${indent}${nodeType}: "${nodeValue}"\n`;
-        
-        if (omdStepVisualizerNodeUtils.isBinaryNode(node)) {
-            result += `${indent}├─ left:\n${this.debugPrintTree(node.left, depth + 1)}`;
-            result += `${indent}└─ right:\n${this.debugPrintTree(node.right, depth + 1)}`;
-        } else if (omdStepVisualizerNodeUtils.isUnaryNode(node)) {
-            result += `${indent}└─ argument:\n${this.debugPrintTree(node.argument, depth + 1)}`;
-        } else if (omdStepVisualizerNodeUtils.hasExpression(node)) {
-            result += `${indent}└─ expression:\n${this.debugPrintTree(node.expression, depth + 1)}`;
-        }
-        
-        return result;
-    }
+import { omdStepVisualizerNodeUtils } from '../utils/omdStepVisualizerNodeUtils.js';
+
+/**
+ * Robust tree diff algorithm using optimal substructure matching
+ * This replaces the special-case-heavy approach with a systematic algorithm
+ */
+export class omdTreeDiff {
+    
+    /**
+     * Main entry point - finds changed nodes between two equations
+     * @param {omdEquationNode} oldEquation - Previous equation
+     * @param {omdEquationNode} newEquation - Current equation
+     * @param {Object} options - Configuration options
+     * @param {boolean} options.educationalMode - If true, highlights mathematically neutral changes for learning
+     * @returns {Array} Array of changed nodes to highlight
+     */
+    static findChangedNodes(oldEquation, newEquation, options = {}) {
+        const { educationalMode = false } = options;
+        
+
+        
+        // === SPECIAL CASE: Same operation added to both sides ===
+        const specialCaseNodes = this.findEquationSpecialCases(oldEquation, newEquation);
+        if (specialCaseNodes.length > 0) {
+            return specialCaseNodes;
+        }
+        
+        const changedNodes = [];
+        
+        // Compare left sides if they differ
+        if (oldEquation.left.toString() !== newEquation.left.toString()) {
+            const leftChanges = this.diffSubtrees(oldEquation.left, newEquation.left, educationalMode);
+            changedNodes.push(...leftChanges);
+        }
+        
+        // Compare right sides if they differ
+        if (oldEquation.right.toString() !== newEquation.right.toString()) {
+            const rightChanges = this.diffSubtrees(oldEquation.right, newEquation.right, educationalMode);
+            changedNodes.push(...rightChanges);
+        }
+        
+        return changedNodes;
+    }
+    
+    /**
+     * Find equation-level special cases (like adding same operation to both sides)
+     * @param {omdEquationNode} oldEquation - Previous equation
+     * @param {omdEquationNode} newEquation - Current equation
+     * @returns {Array} Nodes to highlight for equation special cases
+     */
+    static findEquationSpecialCases(oldEquation, newEquation) {
+        const oldLeftStr = oldEquation.left.toString();
+        const newLeftStr = newEquation.left.toString();
+        const oldRightStr = oldEquation.right.toString();
+        const newRightStr = newEquation.right.toString();
+        
+        // Check if we're adding the same operation to both sides
+        if (newLeftStr.startsWith(oldLeftStr) && newRightStr.startsWith(oldRightStr)) {
+            const leftSuffix = newLeftStr.substring(oldLeftStr.length).trim();
+            const rightSuffix = newRightStr.substring(oldRightStr.length).trim();
+            
+            // Case 1: Adding subtraction to both sides (e.g., "x + 2 = 5" → "x + 2 - 2 = 5 - 2")
+            if (leftSuffix.startsWith("-") && rightSuffix.startsWith("-") && 
+                leftSuffix.substring(1).trim() === rightSuffix.substring(1).trim()) {
+                
+                const subtractedValue = leftSuffix.substring(1).trim();
+                
+                const nodesToHighlight = [];
+                
+                // Find rightmost occurrence of the subtracted value on left side
+                const leftSubtractedNode = omdStepVisualizerNodeUtils.findRightmostNodeWithValue(newEquation.left, subtractedValue);
+                if (leftSubtractedNode) {
+                    // If it's a leaf node, add it directly; otherwise find its leaf nodes
+                    if (omdStepVisualizerNodeUtils.isLeafNode(leftSubtractedNode)) {
+                        nodesToHighlight.push(leftSubtractedNode);
+                    } else {
+                        const leftLeaves = omdStepVisualizerNodeUtils.findLeafNodes(leftSubtractedNode);
+                        nodesToHighlight.push(...leftLeaves);
+                    }
+                }
+                
+                // Find rightmost occurrence of the subtracted value on right side
+                const rightSubtractedNode = omdStepVisualizerNodeUtils.findRightmostNodeWithValue(newEquation.right, subtractedValue);
+                if (rightSubtractedNode) {
+                    // If it's a leaf node, add it directly; otherwise find its leaf nodes
+                    if (omdStepVisualizerNodeUtils.isLeafNode(rightSubtractedNode)) {
+                        nodesToHighlight.push(rightSubtractedNode);
+                    } else {
+                        const rightLeaves = omdStepVisualizerNodeUtils.findLeafNodes(rightSubtractedNode);
+                        nodesToHighlight.push(...rightLeaves);
+                    }
+                }
+                
+                return nodesToHighlight;
+            }
+            
+            // Case 2: Adding addition to both sides (e.g., "x - 2 = 3" → "x - 2 + 2 = 3 + 2")
+            if (leftSuffix.startsWith("+") && rightSuffix.startsWith("+") && 
+                leftSuffix.substring(1).trim() === rightSuffix.substring(1).trim()) {
+                
+                const addedValue = leftSuffix.substring(1).trim();
+                
+                const nodesToHighlight = [];
+                
+                // Find rightmost occurrence of the added value on left side
+                const leftAddedNode = omdStepVisualizerNodeUtils.findRightmostNodeWithValue(newEquation.left, addedValue);
+                if (leftAddedNode) {
+                    // If it's a leaf node, add it directly; otherwise find its leaf nodes
+                    if (omdStepVisualizerNodeUtils.isLeafNode(leftAddedNode)) {
+                        nodesToHighlight.push(leftAddedNode);
+                    } else {
+                        const leftLeaves = omdStepVisualizerNodeUtils.findLeafNodes(leftAddedNode);
+                        nodesToHighlight.push(...leftLeaves);
+                    }
+                }
+                
+                // Find rightmost occurrence of the added value on right side  
+                const rightAddedNode = omdStepVisualizerNodeUtils.findRightmostNodeWithValue(newEquation.right, addedValue);
+                if (rightAddedNode) {
+                    // If it's a leaf node, add it directly; otherwise find its leaf nodes
+                    if (omdStepVisualizerNodeUtils.isLeafNode(rightAddedNode)) {
+                        nodesToHighlight.push(rightAddedNode);
+                    } else {
+                        const rightLeaves = omdStepVisualizerNodeUtils.findLeafNodes(rightAddedNode);
+                        nodesToHighlight.push(...rightLeaves);
+                    }
+                }
+                
+                return nodesToHighlight;
+            }
+        }
+        
+        return [];
+    }
+    
+    /**
+     * Core algorithm: find optimal subtree matching and return unmatched nodes
+     * @param {omdNode} oldTree - Old tree root
+     * @param {omdNode} newTree - New tree root
+     * @param {boolean} educationalMode - Whether to highlight pedagogical changes
+     * @returns {Array} Array of unmatched leaf nodes in new tree
+     */
+    static diffSubtrees(oldTree, newTree, educationalMode = false) {
+        // === STEP 1: CHECK FOR EDUCATIONAL PATTERNS FIRST ===
+        // These patterns from the old system worked really well for highlighting
+        
+        // Check for common prefix patterns (like "2x + 4" → "2x + 4 - 4")
+        const prefixHighlights = this.findCommonPrefixHighlights(oldTree, newTree);
+        if (prefixHighlights.length > 0) {
+            return prefixHighlights;
+        }
+        
+        // Check for variable preservation patterns (when variables stay same but constants change)
+        const variableHighlights = this.findVariablePreservationHighlights(oldTree, newTree);
+        if (variableHighlights.length > 0) {
+            return variableHighlights;
+        }
+        
+        // Check for type difference patterns (constant becoming binary expression, etc.)
+        const typeHighlights = this.findTypeDifferenceHighlights(oldTree, newTree);
+        if (typeHighlights.length > 0) {
+            return typeHighlights;
+        }
+        
+        // Check for subtraction patterns (when one part matches and other is subtracted)
+        const subtractionHighlights = this.findSubtractionPatternHighlights(oldTree, newTree);
+        if (subtractionHighlights.length > 0) {
+            return subtractionHighlights;
+        }
+        
+        // === STEP 2: FALLBACK TO OPTIMAL MATCHING ALGORITHM ===
+        
+        // Find all possible subtree matches
+        const allMatches = this.findAllSubtreeMatches(oldTree, newTree);
+        
+        // Select optimal non-overlapping set of matches
+        const optimalMatches = this.selectOptimalMatching(allMatches);
+        
+        // Find unmatched nodes (these are the changes)
+        let unmatchedNodes = this.findUnmatchedLeafNodes(newTree, optimalMatches);
+        
+        // Educational mode - highlight simplifications
+        if (educationalMode && unmatchedNodes.length === 0) {
+            const educationalHighlights = this.findEducationalHighlights(oldTree, newTree, optimalMatches);
+            unmatchedNodes.push(...educationalHighlights);
+        }
+        
+        return unmatchedNodes;
+    }
+    
+    /**
+     * Find educational highlights for cases where mathematical content didn't change
+     * but pedagogical highlighting is desired (e.g., removing + 0)
+     * @param {omdNode} oldTree - Old tree root
+     * @param {omdNode} newTree - New tree root  
+     * @param {Array} optimalMatches - The matches already found
+     * @returns {Array} Additional nodes to highlight for educational purposes
+     */
+    static findEducationalHighlights(oldTree, newTree, optimalMatches) {
+        const educationalNodes = [];
+        
+        // Case 1: Additive identity removal (+ 0 or - 0)
+        const identityHighlights = this.findAdditiveIdentityChanges(oldTree, newTree);
+        educationalNodes.push(...identityHighlights);
+        
+        // Case 2: Multiplicative identity removal (* 1 or / 1)  
+        const multiplicativeHighlights = this.findMultiplicativeIdentityChanges(oldTree, newTree);
+        educationalNodes.push(...multiplicativeHighlights);
+        
+        // Case 3: Double negative simplification (--x → x)
+        const doubleNegativeHighlights = this.findDoubleNegativeChanges(oldTree, newTree);
+        educationalNodes.push(...doubleNegativeHighlights);
+        
+        return educationalNodes;
+    }
+    
+    /**
+     * Find additive identity changes (removal of + 0 or - 0)
+     * @param {omdNode} oldTree - Old tree
+     * @param {omdNode} newTree - New tree
+     * @returns {Array} Nodes to highlight for additive identity
+     */
+    static findAdditiveIdentityChanges(oldTree, newTree) {
+        // Check if old tree has + 0 or - 0 that's not in new tree
+        const oldStr = oldTree.toString();
+        const newStr = newTree.toString();
+        
+        // Pattern: "expression + 0" → "expression" or "expression - 0" → "expression"
+        if ((oldStr.includes(" + 0") || oldStr.includes(" - 0")) && 
+            !newStr.includes(" + 0") && !newStr.includes(" - 0")) {
+            
+            // Highlight ALL leaf nodes of the remaining expression to show the complete term
+            const allLeafNodes = omdStepVisualizerNodeUtils.findLeafNodes(newTree);
+            
+            if (allLeafNodes.length > 0) {
+                return allLeafNodes; // Highlight all leaf nodes in the remaining expression
+            }
+        }
+        
+        return [];
+    }
+    
+    /**
+     * Find multiplicative identity changes (removal of * 1 or / 1)
+     * @param {omdNode} oldTree - Old tree
+     * @param {omdNode} newTree - New tree
+     * @returns {Array} Nodes to highlight for multiplicative identity
+     */
+    static findMultiplicativeIdentityChanges(oldTree, newTree) {
+        const oldStr = oldTree.toString();
+        const newStr = newTree.toString();
+        
+        if ((oldStr.includes(" * 1") || oldStr.includes(" / 1")) && 
+            !newStr.includes(" * 1") && !newStr.includes(" / 1")) {
+            
+            const allLeafNodes = omdStepVisualizerNodeUtils.findLeafNodes(newTree);
+            if (allLeafNodes.length > 0) {
+                return allLeafNodes; // Highlight entire remaining expression
+            }
+        }
+        
+        return [];
+    }
+    
+    /**
+     * Find double negative changes (--x → x)
+     * @param {omdNode} oldTree - Old tree
+     * @param {omdNode} newTree - New tree
+     * @returns {Array} Nodes to highlight for double negative removal
+     */
+    static findDoubleNegativeChanges(oldTree, newTree) {
+        const oldStr = oldTree.toString();
+        const newStr = newTree.toString();
+        
+        if (oldStr.includes("--") && !newStr.includes("--")) {
+            const allLeafNodes = omdStepVisualizerNodeUtils.findLeafNodes(newTree);
+            if (allLeafNodes.length > 0) {
+                return allLeafNodes; // Highlight entire remaining expression
+            }
+        }
+        
+        return [];
+    }
+    
+    /**
+     * Find common prefix highlighting patterns
+     * Example: "2x + 4" → "2x + 4 - 4" should highlight only the "- 4" part
+     * @param {omdNode} oldTree - Old tree
+     * @param {omdNode} newTree - New tree
+     * @returns {Array} Nodes to highlight for common prefix patterns
+     */
+    static findCommonPrefixHighlights(oldTree, newTree) {
+        // Only apply to binary expressions
+        if (!omdStepVisualizerNodeUtils.isBinaryNode(newTree)) {
+            return [];
+        }
+        
+        const oldStr = oldTree.toString();
+        const newStr = newTree.toString();
+        
+        // Find common prefix
+        const commonPrefix = this._findCommonPrefix(oldStr, newStr);
+        if (!commonPrefix || commonPrefix.length <= 1) {
+            return [];
+        }
+        
+        const oldSuffix = oldStr.substring(commonPrefix.length).trim();
+        const newSuffix = newStr.substring(commonPrefix.length).trim();
+        
+        // Case 1: New suffix is "0" (simplification to zero)
+        if (newSuffix === "0") {
+            const zeroNodes = omdStepVisualizerNodeUtils.findLeafNodesWithValue(newTree, "0");
+            if (zeroNodes.length > 0) {
+                return zeroNodes;
+            }
+        }
+        
+        // Case 2: New suffix is a subtraction (adding negative term)
+        if (oldSuffix === "" && newSuffix.startsWith("- ")) {
+            const subtractedValue = newSuffix.substring(2).trim();
+            
+            const subtractedNodes = omdStepVisualizerNodeUtils.findLeafNodesWithValue(newTree, subtractedValue);
+            if (subtractedNodes.length > 0) {
+                return subtractedNodes;
+            }
+        }
+        
+        return [];
+    }
+    
+    /**
+     * Find variable preservation highlighting patterns  
+     * Example: "2x + 4" → "2x + 2" should highlight only the changed constant
+     * @param {omdNode} oldTree - Old tree
+     * @param {omdNode} newTree - New tree
+     * @returns {Array} Nodes to highlight for variable preservation patterns
+     */
+    static findVariablePreservationHighlights(oldTree, newTree) {
+        // Only apply to binary expressions
+        if (!omdStepVisualizerNodeUtils.isBinaryNode(oldTree) || 
+            !omdStepVisualizerNodeUtils.isBinaryNode(newTree)) {
+            return [];
+        }
+        
+        const oldStr = oldTree.toString();
+        const newStr = newTree.toString();
+        
+        // Check if both expressions contain the same variable term
+        const variablePattern = /(\d*[a-zA-Z])/;
+        const oldMatch = oldStr.match(variablePattern);
+        const newMatch = newStr.match(variablePattern);
+        
+        if (oldMatch && newMatch && oldMatch[0] === newMatch[0]) {
+            // Find constants that changed
+            const oldConstNodes = omdStepVisualizerNodeUtils.findConstantNodes(oldTree);
+            const newConstNodes = omdStepVisualizerNodeUtils.findConstantNodes(newTree);
+            
+            const changedConstNodes = newConstNodes.filter(newNode => {
+                return !oldConstNodes.some(oldNode => 
+                    oldNode.toString() === newNode.toString()
+                );
+            });
+            
+            return changedConstNodes;
+        }
+        
+        return [];
+    }
+    
+    /**
+     * Find type difference highlighting patterns
+     * Example: constant "3" → binary expression "x + 2" should highlight the new expression
+     * @param {omdNode} oldTree - Old tree
+     * @param {omdNode} newTree - New tree  
+     * @returns {Array} Nodes to highlight for type difference patterns
+     */
+    static findTypeDifferenceHighlights(oldTree, newTree) {
+        const oldType = oldTree.constructor ? oldTree.type : 'unknown';
+        const newType = newTree.constructor ? newTree.type : 'unknown';
+        
+        if (oldType === newType) {
+            return []; // Same type, not a type difference pattern
+        }
+        
+        // Case 1: New node is binary, check if old node is part of it
+        if (omdStepVisualizerNodeUtils.isBinaryNode(newTree)) {
+            const oldStr = oldTree.toString();
+            const newLeftStr = newTree.left ? newTree.left.toString() : '';
+            const newRightStr = newTree.right ? newTree.right.toString() : '';
+            
+            if (oldStr === newLeftStr) {
+                if (newTree.right) {
+                    const leafNodes = omdStepVisualizerNodeUtils.findLeafNodes(newTree.right);
+                    return leafNodes;
+                }
+            } else if (oldStr === newRightStr) {
+                if (newTree.left) {
+                    const leafNodes = omdStepVisualizerNodeUtils.findLeafNodes(newTree.left);
+                    return leafNodes;
+                }
+            }
+        }
+        
+        // Case 2: Complete change - highlight all leaf nodes in new tree
+        const leaves = omdStepVisualizerNodeUtils.findLeafNodes(newTree);
+        return leaves;
+    }
+    
+    /**
+     * Find subtraction pattern highlighting 
+     * Example: "x + 2" → "x + 2 - 2" should highlight only the "- 2" part
+     * @param {omdNode} oldTree - Old tree
+     * @param {omdNode} newTree - New tree
+     * @returns {Array} Nodes to highlight for subtraction patterns
+     */
+    static findSubtractionPatternHighlights(oldTree, newTree) {
+        // Check if new tree is a subtraction and old tree matches the left side
+        if (omdStepVisualizerNodeUtils.isBinaryNode(newTree) && 
+            newTree.operation === 'subtract') {
+            
+            const oldStr = oldTree.toString();
+            const newLeftStr = newTree.left?.toString();
+            
+            if (oldStr === newLeftStr) {
+                if (newTree.right) {
+                    const rightLeaves = omdStepVisualizerNodeUtils.findLeafNodes(newTree.right);
+                    return rightLeaves;
+                }
+            }
+        }
+        
+        return [];
+    }
+    
+    /**
+     * Helper: Find the longest common prefix between two strings
+     * @param {string} str1 - First string
+     * @param {string} str2 - Second string
+     * @returns {string} The common prefix
+     * @private
+     */
+    static _findCommonPrefix(str1, str2) {
+        let i = 0;
+        while (i < str1.length && i < str2.length && str1[i] === str2[i]) {
+            i++;
+        }
+        return str1.substring(0, i);
+    }
+    
+    /**
+     * Find all possible matches between subtrees of old and new trees
+     * @param {omdNode} oldTree - Old tree root
+     * @param {omdNode} newTree - New tree root
+     * @returns {Array} Array of match objects {oldNode, newNode, size, score}
+     */
+    static findAllSubtreeMatches(oldTree, newTree) {
+        const matches = [];
+        const oldSubtrees = this.getAllSubtrees(oldTree);
+        const newSubtrees = this.getAllSubtrees(newTree);
+        
+        for (const oldSub of oldSubtrees) {
+            for (const newSub of newSubtrees) {
+                const similarity = this.calculateSimilarity(oldSub, newSub);
+                if (similarity.isMatch) {
+                    matches.push({
+                        oldNode: oldSub,
+                        newNode: newSub,
+                        size: similarity.size,
+                        score: similarity.score,
+                        type: similarity.type
+                    });
+                }
+            }
+        }
+        
+        return matches;
+    }
+    
+    /**
+     * Get all subtrees (including single nodes) from a tree
+     * @param {omdNode} root - Root node
+     * @returns {Array} Array of all subtrees
+     */
+    static getAllSubtrees(root) {
+        if (!root) return [];
+        
+        const subtrees = [root];
+        
+        // Add all child subtrees recursively
+        if (omdStepVisualizerNodeUtils.isBinaryNode(root)) {
+            subtrees.push(...this.getAllSubtrees(root.left));
+            subtrees.push(...this.getAllSubtrees(root.right));
+        } else if (omdStepVisualizerNodeUtils.isUnaryNode(root)) {
+            subtrees.push(...this.getAllSubtrees(root.argument));
+        } else if (omdStepVisualizerNodeUtils.hasExpression(root)) {
+            subtrees.push(...this.getAllSubtrees(root.expression));
+        }
+        
+        return subtrees;
+    }
+    
+    /**
+     * Calculate similarity between two subtrees
+     * @param {omdNode} tree1 - First tree
+     * @param {omdNode} tree2 - Second tree
+     * @returns {Object} Similarity info {isMatch, size, score, type}
+     */
+    static calculateSimilarity(tree1, tree2) {
+        // Exact structural match
+        if (this.treesStructurallyEqual(tree1, tree2)) {
+            const size = this.getSubtreeSize(tree1);
+            return {
+                isMatch: true,
+                size: size,
+                score: size * 10, // High score for exact matches
+                type: 'exact'
+            };
+        }
+        
+        // Exact string match (different structure, same result)
+        if (tree1.toString() === tree2.toString()) {
+            const size = this.getSubtreeSize(tree1);
+            return {
+                isMatch: true,
+                size: size,
+                score: size * 8, // Slightly lower than structural match
+                type: 'equivalent'
+            };
+        }
+        
+        // Leaf node value match
+        if (omdStepVisualizerNodeUtils.isLeafNode(tree1) && 
+            omdStepVisualizerNodeUtils.isLeafNode(tree2)) {
+            const val1 = omdStepVisualizerNodeUtils.getNodeValue(tree1);
+            const val2 = omdStepVisualizerNodeUtils.getNodeValue(tree2);
+            
+            if (val1 === val2) {
+                return {
+                    isMatch: true,
+                    size: 1,
+                    score: 5, // Lower score for single nodes
+                    type: 'leaf'
+                };
+            }
+        }
+        
+        return { isMatch: false, size: 0, score: 0, type: 'none' };
+    }
+    
+    /**
+     * Check if two trees are structurally identical
+     * @param {omdNode} tree1 - First tree
+     * @param {omdNode} tree2 - Second tree
+     * @returns {boolean} True if structurally identical
+     */
+    static treesStructurallyEqual(tree1, tree2) {
+        if (!tree1 && !tree2) return true;
+        if (!tree1 || !tree2) return false;
+        
+        // Check node types
+        const type1 = tree1.constructor ? tree1.type : 'unknown';
+        const type2 = tree2.constructor ? tree2.type : 'unknown';
+        if (type1 !== type2) return false;
+        
+        // Check leaf nodes
+        if (omdStepVisualizerNodeUtils.isLeafNode(tree1)) {
+            const val1 = omdStepVisualizerNodeUtils.getNodeValue(tree1);
+            const val2 = omdStepVisualizerNodeUtils.getNodeValue(tree2);
+            return val1 === val2;
+        }
+        
+        // Check binary nodes
+        if (omdStepVisualizerNodeUtils.isBinaryNode(tree1)) {
+            if (tree1.operation !== tree2.operation) return false;
+            return this.treesStructurallyEqual(tree1.left, tree2.left) &&
+                   this.treesStructurallyEqual(tree1.right, tree2.right);
+        }
+        
+        // Check unary nodes
+        if (omdStepVisualizerNodeUtils.isUnaryNode(tree1)) {
+            if (tree1.operation !== tree2.operation) return false;
+            return this.treesStructurallyEqual(tree1.argument, tree2.argument);
+        }
+        
+        // Check expression nodes
+        if (omdStepVisualizerNodeUtils.hasExpression(tree1)) {
+            return this.treesStructurallyEqual(tree1.expression, tree2.expression);
+        }
+        
+        return false;
+    }
+    
+    /**
+     * Calculate the size (number of nodes) in a subtree
+     * @param {omdNode} root - Root of subtree
+     * @returns {number} Number of nodes in subtree
+     */
+    static getSubtreeSize(root) {
+        if (!root) return 0;
+        
+        let size = 1; // Count this node
+        
+        if (omdStepVisualizerNodeUtils.isBinaryNode(root)) {
+            size += this.getSubtreeSize(root.left);
+            size += this.getSubtreeSize(root.right);
+        } else if (omdStepVisualizerNodeUtils.isUnaryNode(root)) {
+            size += this.getSubtreeSize(root.argument);
+        } else if (omdStepVisualizerNodeUtils.hasExpression(root)) {
+            size += this.getSubtreeSize(root.expression);
+        }
+        
+        return size;
+    }
+    
+    /**
+     * Select optimal non-overlapping set of matches using greedy algorithm
+     * @param {Array} matches - Array of potential matches
+     * @returns {Array} Array of selected optimal matches
+     */
+    static selectOptimalMatching(matches) {
+        // Sort by score (descending) to prefer better matches
+        const sortedMatches = matches.slice().sort((a, b) => b.score - a.score);
+        
+        const selectedMatches = [];
+        const usedOldNodes = new Set();
+        const usedNewNodes = new Set();
+        
+        for (const match of sortedMatches) {
+            // Check if this match overlaps with already selected matches
+            if (!this.hasNodeOverlap(match.oldNode, usedOldNodes) &&
+                !this.hasNodeOverlap(match.newNode, usedNewNodes)) {
+                
+                selectedMatches.push(match);
+                this.markSubtreeAsUsed(match.oldNode, usedOldNodes);
+                this.markSubtreeAsUsed(match.newNode, usedNewNodes);
+            }
+        }
+        
+        return selectedMatches;
+    }
+    
+    /**
+     * Check if a node overlaps with any node in the used set
+     * @param {omdNode} node - Node to check
+     * @param {Set} usedNodes - Set of already used nodes
+     * @returns {boolean} True if there's overlap
+     */
+    static hasNodeOverlap(node, usedNodes) {
+        // Check if this node or any of its ancestors/descendants are used
+        const nodeSubtrees = this.getAllSubtrees(node);
+        return nodeSubtrees.some(subtree => usedNodes.has(subtree));
+    }
+    
+    /**
+     * Mark all nodes in a subtree as used
+     * @param {omdNode} root - Root of subtree to mark
+     * @param {Set} usedNodes - Set to add nodes to
+     */
+    static markSubtreeAsUsed(root, usedNodes) {
+        const allNodes = this.getAllSubtrees(root);
+        allNodes.forEach(node => usedNodes.add(node));
+    }
+    
+    /**
+     * Find leaf nodes in new tree that aren't covered by any match
+     * @param {omdNode} newTree - New tree root
+     * @param {Array} matches - Array of selected matches
+     * @returns {Array} Array of unmatched leaf nodes
+     */
+    static findUnmatchedLeafNodes(newTree, matches) {
+        const allLeafNodes = omdStepVisualizerNodeUtils.findLeafNodes(newTree);
+        const matchedNodes = new Set();
+        
+        // Mark all nodes covered by matches
+        for (const match of matches) {
+            const matchedSubtreeNodes = this.getAllSubtrees(match.newNode);
+            matchedSubtreeNodes.forEach(node => matchedNodes.add(node));
+        }
+        
+        // Return leaf nodes not covered by any match
+        const unmatchedLeaves = allLeafNodes.filter(leaf => !matchedNodes.has(leaf));
+        
+        return unmatchedLeaves;
+    }
+    
+    /**
+     * Find leaf nodes in old tree that aren't covered by any match (i.e., removed nodes)
+     * @param {omdNode} oldTree - Old tree root
+     * @param {Array} matches - Array of selected matches
+     * @returns {Array} Array of unmatched leaf nodes from old tree
+     */
+    static findUnmatchedOldNodes(oldTree, matches) {
+        const allOldLeafNodes = omdStepVisualizerNodeUtils.findLeafNodes(oldTree);
+        const matchedOldNodes = new Set();
+        
+        // Mark all old nodes covered by matches
+        for (const match of matches) {
+            const matchedSubtreeNodes = this.getAllSubtrees(match.oldNode);
+            matchedSubtreeNodes.forEach(node => matchedOldNodes.add(node));
+        }
+        
+        // Return old leaf nodes not covered by any match (these were removed)
+        const unmatchedOldLeaves = allOldLeafNodes.filter(leaf => !matchedOldNodes.has(leaf));
+        
+        return unmatchedOldLeaves;
+    }
+    
+    /**
+     * Debug helper: print tree structure
+     * @param {omdNode} node - Node to print
+     * @param {number} depth - Current depth for indentation
+     * @returns {string} String representation of tree structure
+     */
+    static debugPrintTree(node, depth = 0) {
+        if (!node) return '';
+        
+        const indent = '  '.repeat(depth);
+        const nodeType = node.constructor ? node.type : 'unknown';
+        const nodeValue = node.toString ? node.toString() : 'unknown';
+        
+        let result = `${indent}${nodeType}: "${nodeValue}"\n`;
+        
+        if (omdStepVisualizerNodeUtils.isBinaryNode(node)) {
+            result += `${indent}├─ left:\n${this.debugPrintTree(node.left, depth + 1)}`;
+            result += `${indent}└─ right:\n${this.debugPrintTree(node.right, depth + 1)}`;
+        } else if (omdStepVisualizerNodeUtils.isUnaryNode(node)) {
+            result += `${indent}└─ argument:\n${this.debugPrintTree(node.argument, depth + 1)}`;
+        } else if (omdStepVisualizerNodeUtils.hasExpression(node)) {
+            result += `${indent}└─ expression:\n${this.debugPrintTree(node.expression, depth + 1)}`;
+        }
+        
+        return result;
+    }
 }