Apply Issue #26 fix to Rust implementation

- Added remove_duplicate_before_states() function to handle duplicate
  before states with conflicting transitions (null vs non-null)
- When a before state has both a null transition (0: 0 0) and non-null
  transitions, prefer the non-null transitions as they represent the
  actual final transformations
- Added comprehensive tests for Issue #26 scenarios:
  - test_simplify_issue26_update_operation
  - test_simplify_issue26_alternative_scenario
  - test_simplify_multiple_branches_from_same_initial
  - test_simplify_specific_example_removes_intermediate_states
  - test_simplify_keeps_unchanged_states
- Both C# and Rust implementations now have symmetric logic

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: konard

rust/src/changes_simplifier.rs

@@ -16,6 +16,10 @@ pub fn simplify_changes(changes: Vec<(Link, Link)>) -> Vec<(Link, Link)> {
         return vec![];
     }
 
+    // **FIX for Issue #26**: Remove duplicate before states by keeping the non-null transitions
+    // This handles cases where the same link is reported with multiple different transformations
+    let changes = remove_duplicate_before_states(changes);
+
     // First, handle unchanged states directly
     let mut unchanged_states = Vec::new();
     let mut changed_states = Vec::new();
@@ -106,6 +110,54 @@ pub fn simplify_changes(changes: Vec<(Link, Link)>) -> Vec<(Link, Link)> {
     results
 }
 
+/// Removes problematic duplicate before states that lead to simplification issues.
+/// This fixes Issue #26 where multiple transformations from the same before state
+/// to conflicting after states (including null states) would cause the simplifier to fail.
+///
+/// The key insight: If we have multiple transitions from the same before state,
+/// and one of them is to a "null" state (0: 0 0), we should prefer the non-null transition
+/// as it represents the actual final transformation.
+fn remove_duplicate_before_states(changes: Vec<(Link, Link)>) -> Vec<(Link, Link)> {
+    // Group changes by their before state
+    let mut grouped: HashMap<Link, Vec<(Link, Link)>> = HashMap::new();
+    for change in changes {
+        grouped.entry(change.0).or_default().push(change);
+    }
+
+    let mut result = Vec::new();
+
+    for (_before, changes_for_this_before) in grouped {
+        if changes_for_this_before.len() == 1 {
+            // No duplicates, keep as is
+            result.extend(changes_for_this_before);
+        } else {
+            // Multiple changes from the same before state
+            // Check if any of them is to a null state (0: 0 0)
+            let null_link = Link::new(0, 0, 0);
+            let has_null_transition = changes_for_this_before
+                .iter()
+                .any(|(_, after)| *after == null_link);
+            let non_null_transitions: Vec<_> = changes_for_this_before
+                .iter()
+                .filter(|(_, after)| *after != null_link)
+                .cloned()
+                .collect();
+
+            if has_null_transition && !non_null_transitions.is_empty() {
+                // Issue #26 scenario: We have both null and non-null transitions
+                // Prefer the non-null transitions as they represent the actual final states
+                result.extend(non_null_transitions);
+            } else {
+                // No null transitions involved, this is a legitimate multiple-branch scenario
+                // Keep all transitions
+                result.extend(changes_for_this_before);
+            }
+        }
+    }
+
+    result
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -150,4 +202,110 @@ mod tests {
 
         assert_eq!(result.len(), 2);
     }
+
+    #[test]
+    fn test_simplify_issue26_update_operation() {
+        // This represents the scenario described in GitHub issue #26
+        // Where links (1: 1 2) and (2: 2 1) are being updated to swap source and target
+        // The issue was that intermediate steps were being shown instead of the final transformation
+        let changes = vec![
+            // Step 1: Link (1: 1 2) is first deleted (becomes null/empty)
+            (Link::new(1, 1, 2), Link::new(0, 0, 0)),
+            // Step 2: New link (1: 2 1) is created (swapped source and target)
+            (Link::new(0, 0, 0), Link::new(1, 2, 1)),
+            // Step 3: Link (2: 2 1) is directly updated to (2: 1 2)
+            (Link::new(2, 2, 1), Link::new(2, 1, 2)),
+        ];
+
+        let result = simplify_changes(changes);
+
+        // Expected - The simplification should show only the initial-to-final transformations
+        assert_eq!(result.len(), 2);
+        assert!(result.contains(&(Link::new(1, 1, 2), Link::new(1, 2, 1))));
+        assert!(result.contains(&(Link::new(2, 2, 1), Link::new(2, 1, 2))));
+    }
+
+    #[test]
+    fn test_simplify_issue26_alternative_scenario() {
+        // This tests the scenario where the same before state has multiple transitions:
+        // one to null (deletion) and one to a non-null state (update)
+        let changes = vec![
+            // Let's say we get these individual changes that don't form a proper chain
+            (Link::new(1, 1, 2), Link::new(0, 0, 0)), // delete
+            (Link::new(1, 1, 2), Link::new(1, 2, 1)), // direct update (this is what should be kept)
+            (Link::new(2, 2, 1), Link::new(2, 1, 2)), // direct update
+        ];
+
+        let result = simplify_changes(changes);
+
+        // After the fix, we should prefer the non-null transition
+        // So we should get only 2 changes: the two direct updates
+        assert_eq!(result.len(), 2);
+        assert!(result.contains(&(Link::new(1, 1, 2), Link::new(1, 2, 1))));
+        assert!(result.contains(&(Link::new(2, 2, 1), Link::new(2, 1, 2))));
+    }
+
+    #[test]
+    fn test_simplify_multiple_branches_from_same_initial() {
+        // Original transitions (Before -> After):
+        // (0: 0 0) -> (1: 0 0)
+        // (1: 0 0) -> (1: 1 1)
+        // (0: 0 0) -> (2: 0 0)
+        // (2: 0 0) -> (2: 2 2)
+        let changes = vec![
+            (Link::new(0, 0, 0), Link::new(1, 0, 0)),
+            (Link::new(1, 0, 0), Link::new(1, 1, 1)),
+            (Link::new(0, 0, 0), Link::new(2, 0, 0)),
+            (Link::new(2, 0, 0), Link::new(2, 2, 2)),
+        ];
+
+        let result = simplify_changes(changes);
+
+        // Expected final transitions (After simplification):
+        // (0: 0 0) -> (1: 1 1)
+        // (0: 0 0) -> (2: 2 2)
+        assert_eq!(result.len(), 2);
+        assert!(result.contains(&(Link::new(0, 0, 0), Link::new(1, 1, 1))));
+        assert!(result.contains(&(Link::new(0, 0, 0), Link::new(2, 2, 2))));
+    }
+
+    #[test]
+    fn test_simplify_specific_example_removes_intermediate_states() {
+        // (1: 2 1) ↦ (1: 0 0)
+        // (2: 1 2) ↦ (2: 0 0)
+        // (2: 0 0) ↦ (0: 0 0)
+        // (1: 0 0) ↦ (0: 0 0)
+        let changes = vec![
+            (Link::new(1, 2, 1), Link::new(1, 0, 0)),
+            (Link::new(2, 1, 2), Link::new(2, 0, 0)),
+            (Link::new(2, 0, 0), Link::new(0, 0, 0)),
+            (Link::new(1, 0, 0), Link::new(0, 0, 0)),
+        ];
+
+        let result = simplify_changes(changes);
+
+        // Expected simplified changes:
+        // (1: 2 1) ↦ (0: 0 0)
+        // (2: 1 2) ↦ (0: 0 0)
+        assert_eq!(result.len(), 2);
+        assert!(result.contains(&(Link::new(1, 2, 1), Link::new(0, 0, 0))));
+        assert!(result.contains(&(Link::new(2, 1, 2), Link::new(0, 0, 0))));
+    }
+
+    #[test]
+    fn test_simplify_keeps_unchanged_states() {
+        // (1: 1 2) ↦ (1: 2 1)
+        // (2: 2 2) ↦ (2: 2 2) (unchanged)
+        let changes = vec![
+            (Link::new(1, 1, 2), Link::new(1, 2, 1)),
+            (Link::new(2, 2, 2), Link::new(2, 2, 2)),
+        ];
+
+        let result = simplify_changes(changes);
+
+        // Expected simplified changes still have (2: 2 2):
+        assert_eq!(result.len(), 2);
+        assert!(result.contains(&(Link::new(1, 1, 2), Link::new(1, 2, 1))));
+        assert!(result.contains(&(Link::new(2, 2, 2), Link::new(2, 2, 2))));
+    }
 }