Fix island initialization to use copies of best program

When initializing an empty island, a new copy of the best program is now created with a unique ID, rather than reusing the same program instance. This prevents a program from being assigned to multiple islands and ensures correct lineage tracking. Additional tests were added to verify correct migration behavior, unique program assignment per island, and proper handling of empty island initialization.

Author: codelion

openevolve/database.py

@@ -8,6 +8,7 @@
 import os
 import random
 import time
+import uuid
 from dataclasses import asdict, dataclass, field, fields
 
 # FileLock removed - no longer needed with threaded parallel processing
@@ -998,12 +999,29 @@ def _sample_exploration_parent(self) -> Program:
         if not current_island_programs:
             # If current island is empty, initialize with best program or random program
             if self.best_program_id and self.best_program_id in self.programs:
-                # Clone best program to current island
+                # Create a copy of best program for the empty island (don't reuse same ID)
                 best_program = self.programs[self.best_program_id]
-                self.islands[self.current_island].add(self.best_program_id)
-                best_program.metadata["island"] = self.current_island
-                logger.debug(f"Initialized empty island {self.current_island} with best program")
-                return best_program
+                copy_program = Program(
+                    id=str(uuid.uuid4()),
+                    code=best_program.code,
+                    language=best_program.language,
+                    parent_id=best_program.id,
+                    generation=best_program.generation,
+                    timestamp=time.time(),
+                    iteration_found=self.last_iteration,
+                    metrics=best_program.metrics.copy(),
+                    complexity=best_program.complexity,
+                    diversity=best_program.diversity,
+                    metadata={"island": self.current_island},
+                    artifacts_json=best_program.artifacts_json,
+                    artifact_dir=best_program.artifact_dir,
+                )
+                self.programs[copy_program.id] = copy_program
+                self.islands[self.current_island].add(copy_program.id)
+                logger.debug(
+                    f"Initialized empty island {self.current_island} with copy of best program"
+                )
+                return copy_program
             else:
                 # Use any available program
                 return next(iter(self.programs.values()))
@@ -1026,10 +1044,29 @@ def _sample_exploration_parent(self) -> Program:
                 f"Island {self.current_island} has no valid programs after cleanup, reinitializing"
             )
             if self.best_program_id and self.best_program_id in self.programs:
+                # Create a copy of best program for the empty island (don't reuse same ID)
                 best_program = self.programs[self.best_program_id]
-                self.islands[self.current_island].add(self.best_program_id)
-                best_program.metadata["island"] = self.current_island
-                return best_program
+                copy_program = Program(
+                    id=str(uuid.uuid4()),
+                    code=best_program.code,
+                    language=best_program.language,
+                    parent_id=best_program.id,
+                    generation=best_program.generation,
+                    timestamp=time.time(),
+                    iteration_found=self.last_iteration,
+                    metrics=best_program.metrics.copy(),
+                    complexity=best_program.complexity,
+                    diversity=best_program.diversity,
+                    metadata={"island": self.current_island},
+                    artifacts_json=best_program.artifacts_json,
+                    artifact_dir=best_program.artifact_dir,
+                )
+                self.programs[copy_program.id] = copy_program
+                self.islands[self.current_island].add(copy_program.id)
+                logger.debug(
+                    f"Reinitialized empty island {self.current_island} with copy of best program"
+                )
+                return copy_program
             else:
                 return next(iter(self.programs.values()))
 

tests/test_database.py

@@ -3,6 +3,7 @@
 """
 
 import unittest
+import uuid
 from openevolve.config import Config
 from openevolve.database import Program, ProgramDatabase
 
@@ -457,6 +458,183 @@ def test_diversity_feature_integration(self):
             self.assertGreaterEqual(coord, 0)
             self.assertLess(coord, self.db.feature_bins)
 
+    def test_migration_prevents_re_migration(self):
+        """Test that programs marked as migrants don't migrate again"""
+        # Create database with multiple islands
+        config = Config()
+        config.database.in_memory = True
+        config.database.num_islands = 3
+        config.database.migration_interval = 1  # Migrate every generation
+        multi_db = ProgramDatabase(config.database)
+
+        # Add programs to each island (avoid "migrant" in original IDs)
+        for i in range(3):
+            program = Program(
+                id=f"test_prog_{i}",
+                code=f"def test_{i}(): return {i}",
+                language="python",
+                metrics={"score": 0.5 + i * 0.1},
+            )
+            multi_db.add(program, target_island=i)
+
+        # Manually mark one as a migrant
+        migrant_program = multi_db.get("test_prog_0")
+        migrant_program.metadata["migrant"] = True
+
+        # Store original ID
+        original_id = migrant_program.id
+
+        # Count initial programs with "_migrant_" pattern (created by migration)
+        initial_migrant_count = sum(1 for pid in multi_db.programs if "_migrant_" in pid)
+        self.assertEqual(initial_migrant_count, 0)  # Should be none initially
+
+        # Run migration
+        multi_db.island_generations[0] = config.database.migration_interval
+        multi_db.island_generations[1] = config.database.migration_interval
+        multi_db.island_generations[2] = config.database.migration_interval
+        multi_db.migrate_programs()
+
+        # Check that the migrant program wasn't re-migrated
+        # It should still exist with the same ID (not a new migrant ID)
+        still_exists = multi_db.get(original_id)
+        self.assertIsNotNone(still_exists)
+        
+        # Count new programs created by migration (identified by "_migrant_" pattern)
+        new_migrant_ids = [pid for pid in multi_db.programs if "_migrant_" in pid]
+        
+        # Each non-migrant program (2 of them) migrates to 2 adjacent islands
+        # So we expect 2 * 2 = 4 new migrant programs
+        # The already-marked migrant (test_prog_0) should NOT create any new copies
+        self.assertEqual(len(new_migrant_ids), 4)
+        
+        # Verify the already-migrant program didn't create new copies
+        migrant_descendants = [pid for pid in new_migrant_ids if original_id in pid]
+        self.assertEqual(len(migrant_descendants), 0, 
+                        f"Program {original_id} should not have created migrant copies")
+
+    def test_empty_island_initialization_creates_copies(self):
+        """Test that empty islands are initialized with copies, not shared references"""
+        # Create database with multiple islands
+        config = Config()
+        config.database.in_memory = True
+        config.database.num_islands = 3
+        # Force exploration mode to test empty island handling
+        config.database.exploration_ratio = 1.0
+        config.database.exploitation_ratio = 0.0
+        multi_db = ProgramDatabase(config.database)
+
+        # Add a single program to island 1
+        program = Program(
+            id="original_program",
+            code="def original(): return 42",
+            language="python",
+            metrics={"score": 0.9, "combined_score": 0.9},
+        )
+        multi_db.add(program, target_island=1)
+        
+        # Make it the best program
+        multi_db.best_program_id = "original_program"
+
+        # Switch to empty island 0 and sample
+        multi_db.set_current_island(0)
+        sampled_parent, _ = multi_db.sample()
+
+        # The sampled program should be a copy, not the original
+        self.assertNotEqual(sampled_parent.id, "original_program")
+        self.assertEqual(sampled_parent.code, program.code)  # Same code
+        self.assertEqual(sampled_parent.parent_id, "original_program")  # Parent is the original
+        
+        # Check island membership
+        self.assertIn("original_program", multi_db.islands[1])
+        self.assertNotIn("original_program", multi_db.islands[0])
+        self.assertIn(sampled_parent.id, multi_db.islands[0])
+        
+        # Run validation - should not raise any errors
+        multi_db._validate_migration_results()
+
+    def test_no_program_assigned_to_multiple_islands(self):
+        """Test that programs are never assigned to multiple islands"""
+        # Create database with multiple islands
+        config = Config()
+        config.database.in_memory = True
+        config.database.num_islands = 4
+        multi_db = ProgramDatabase(config.database)
+
+        # Add programs to different islands
+        program_ids = []
+        for i in range(4):
+            program = Program(
+                id=f"island_test_{i}",
+                code=f"def test_{i}(): return {i}",
+                language="python",
+                metrics={"score": 0.5 + i * 0.1, "combined_score": 0.5 + i * 0.1},
+            )
+            multi_db.add(program, target_island=i)
+            program_ids.append(program.id)
+
+        # Make the best program from island 3
+        multi_db.best_program_id = "island_test_3"
+
+        # Sample from empty islands - this should create copies
+        for empty_island in range(4):
+            if len(multi_db.islands[empty_island]) == 0:
+                multi_db.set_current_island(empty_island)
+                parent, _ = multi_db.sample()
+
+        # Check that no program ID appears in multiple islands
+        all_island_programs = {}
+        for island_idx, island_programs in enumerate(multi_db.islands):
+            for program_id in island_programs:
+                if program_id in all_island_programs:
+                    self.fail(
+                        f"Program {program_id} found in both island {all_island_programs[program_id]} "
+                        f"and island {island_idx}"
+                    )
+                all_island_programs[program_id] = island_idx
+
+        # Run validation - should not raise any errors
+        multi_db._validate_migration_results()
+
+    def test_migration_validation_passes(self):
+        """Test that migration validation passes after our fixes"""
+        # Create database with multiple islands
+        config = Config()
+        config.database.in_memory = True
+        config.database.num_islands = 3
+        config.database.migration_interval = 1
+        multi_db = ProgramDatabase(config.database)
+
+        # Add programs and run several migration cycles
+        for i in range(6):
+            program = Program(
+                id=f"test_program_{i}",
+                code=f"def test_{i}(): return {i * 2}",
+                language="python",
+                metrics={"score": 0.4 + i * 0.1, "combined_score": 0.4 + i * 0.1},
+            )
+            multi_db.add(program, target_island=i % 3)
+
+        # Run multiple migration cycles
+        for cycle in range(3):
+            # Increment generations to trigger migration
+            for island in range(3):
+                multi_db.island_generations[island] += 1
+            
+            # Migrate programs
+            multi_db.migrate_programs()
+            
+            # Validation should pass without warnings
+            multi_db._validate_migration_results()
+            
+            # Verify no program has exponential ID growth
+            for program_id in multi_db.programs:
+                # Count occurrences of "migrant" in ID
+                migrant_count = program_id.count("migrant")
+                self.assertLessEqual(
+                    migrant_count, 1, 
+                    f"Program ID {program_id} has been migrated multiple times"
+                )
+
 
 if __name__ == "__main__":
     unittest.main()