Fix migration to use MAP-Elites deduplication logic

Refactors the migration process to use the add() method for adding migrants, ensuring MAP-Elites deduplication, feature map updates, and proper island tracking. Updates logging to reflect the new process. Adds a test to verify that migrants are deduplicated correctly in the MAP-Elites feature map during migration.

Author: codelion

openevolve/database.py

@@ -1670,23 +1670,15 @@ def migrate_programs(self) -> None:
                         metadata={**migrant.metadata, "island": target_island, "migrant": True},
                     )
 
-                    # Add to target island
-                    self.islands[target_island].add(migrant_copy.id)
-                    self.programs[migrant_copy.id] = migrant_copy
-
-                    # Update island-specific best program if migrant is better
-                    self._update_island_best_program(migrant_copy, target_island)
-
-                    # Log migration with MAP-Elites coordinates
-                    feature_coords = self._calculate_feature_coords(migrant_copy)
-                    coords_dict = {
-                        self.config.feature_dimensions[j]: feature_coords[j]
-                        for j in range(len(feature_coords))
-                    }
+                    # Use add() method to properly handle MAP-Elites deduplication,
+                    # feature map updates, and island tracking
+                    self.add(migrant_copy, target_island=target_island)
+
+                    # Log migration
                     logger.info(
-                        "Program migrated to island %d at MAP-Elites coords: %s",
+                        "Program %s migrated to island %d",
+                        migrant_copy.id[:8],
                         target_island,
-                        coords_dict,
                     )
 
         # Update last migration generation

tests/test_migration_no_duplicates.py

@@ -250,9 +250,90 @@ def test_migration_with_feature_map_conflicts_resolved_cleanly(self):
 
         # No _migrant suffixes should exist
         migrant_programs = [pid for pid in all_program_ids if '_migrant' in pid]
-        self.assertEqual(len(migrant_programs), 0, 
+        self.assertEqual(len(migrant_programs), 0,
                         f"Found programs with _migrant suffix: {migrant_programs}")
 
+    def test_migration_uses_map_elites_deduplication(self):
+        """Test that migrants go through MAP-Elites deduplication (same cell = keep better)"""
+        # Create two programs that will map to the EXACT SAME feature coordinates
+        # Use custom complexity/diversity metrics to control the coordinates explicitly
+        prog_low = Program(
+            id="low_score",
+            code="def low_func(): return 1",
+            language="python",
+            metrics={
+                "complexity": 50.0,  # Custom complexity (overrides built-in)
+                "diversity": 30.0,   # Custom diversity (overrides built-in)
+                "score": 0.3,
+                "combined_score": 0.3
+            },
+            metadata={"island": 0, "generation": 3},
+        )
+
+        prog_high = Program(
+            id="high_score",
+            code="def high_func(): return 2",
+            language="python",
+            metrics={
+                "complexity": 50.0,  # Same as prog_low
+                "diversity": 30.0,   # Same as prog_low
+                "score": 0.9,        # Better score
+                "combined_score": 0.9
+            },
+            metadata={"island": 0, "generation": 3},
+        )
+
+        # Add both to island 0
+        # MAP-Elites should keep only the better one (high_score) in the feature map
+        self.db.add(prog_low)
+
+        # Get the feature coords for prog_low
+        coords_low = self.db._calculate_feature_coords(prog_low)
+
+        # Add high score - should replace low score in same cell
+        self.db.add(prog_high)
+
+        # Get the feature coords for prog_high (should be identical due to same custom metrics)
+        coords_high = self.db._calculate_feature_coords(prog_high)
+
+        # Verify they map to the same cell
+        self.assertEqual(coords_low, coords_high, "Programs with same custom metrics should map to same cell")
+
+        # Verify MAP-Elites deduplication worked on island 0
+        # Check the feature map (not self.islands which contains all programs)
+        island_0_feature_map = self.db.island_feature_maps[0]
+        feature_key = self.db._feature_coords_to_key(coords_high)
+
+        # This cell should have exactly one program
+        self.assertIn(feature_key, island_0_feature_map, "Cell should be occupied")
+        cell_program_id = island_0_feature_map[feature_key]
+        self.assertEqual(cell_program_id, "high_score", "Better program should be kept in MAP-Elites cell")
+
+        # Set generation to trigger migration
+        self.db.island_generations[0] = 3
+
+        # Force migration - high_score will migrate to island 1
+        self.db.migrate_programs()
+
+        # CRITICAL TEST: Check that migrant was added to island 1 feature map
+        # (Current implementation bypasses add() so this will FAIL)
+        island_1_feature_map = self.db.island_feature_maps[1]
+
+        # The migrant should be in the feature map at the same coordinates
+        migrant_in_feature_map = feature_key in island_1_feature_map
+
+        self.assertTrue(migrant_in_feature_map,
+                       "Migrant should be added to target island's feature map (currently bypasses add())")
+
+        # If migrant is in feature map, verify it's the high-score version
+        if migrant_in_feature_map:
+            migrant_id = island_1_feature_map[feature_key]
+            migrant_program = self.db.programs[migrant_id]
+            # The migrant is a copy, so code should match high_score's code
+            self.assertEqual(migrant_program.code, "def high_func(): return 2", "Migrant should have high_score's code")
+            self.assertEqual(migrant_program.metrics["combined_score"], 0.9,
+                           "Migrant should preserve high score")
+
 
 if __name__ == '__main__':
     unittest.main()