Fix MAP-Elites algorithm implementation

[codelion]

Fix MAP-Elites algorithm implementation to properly respect feature map structure during population limit enforcement.

Changes

• Fix _enforce_population_limit to respect MAP-Elites structure
• Prioritize removing non-elite programs before elite programs
• Fix program replacement in feature cells to properly remove old programs
• Add _remove_program_from_database method for clean program removal
• Add comprehensive tests to verify MAP-Elites functionality
• Preserve diversity by keeping best program in each feature cell
• Add logging for MAP-Elites grid occupancy and operations

Problem

The original issue was that self.feature_map was not being used during population limit enforcement. The _enforce_population_limit method was simply removing the worst programs by fitness, which defeated the purpose of MAP-Elites diversity preservation.

Solution

The fix ensures that:

1. Non-elite programs (not in feature_map) are removed first
2. Elite programs (in feature_map) are only removed if absolutely necessary
3. Program replacement in feature cells properly cleans up old programs
4. MAP-Elites algorithm now works as intended, maintaining diversity while optimizing for quality

Fixes #150

Generated with Claude Code

[claude]

Claude finished @codelion's task —— View job

---

PR Review Complete

Summary

This PR successfully fixes the MAP-Elites algorithm implementation to properly respect feature map structure during population limit enforcement. The changes are well-implemented with comprehensive test coverage.

✅ Strengths

Code Quality & Best Practices

• Excellent separation of concerns: The new _remove_program_from_database method (lines 1722-1763) provides a clean, centralized way to remove programs from all data structures
• Proper logging: Added informative MAP-Elites logging for grid occupancy, cell occupation, and program replacement (lines 192-221)
• Comprehensive error handling: Stale reference cleanup and validation throughout
• Good documentation: Clear docstrings explaining the MAP-Elites algorithm behavior

Algorithm Implementation

• Correct MAP-Elites behavior: The fix properly prioritizes removing non-elite programs before elite programs (lines 1244-1264)
• Diversity preservation: Population limit enforcement now respects feature map structure to maintain diversity
• Proper feature map management: Clean replacement logic that updates feature_map and removes old programs atomically

Test Coverage

• Comprehensive test suite: 6 well-designed test cases covering all major scenarios
• Edge case testing: Tests for stale references, population limits, and feature map consistency
• Clear test structure: Each test has a clear purpose and good setup/verification

⚠️ Areas for Improvement

Performance Considerations

1. Potential O(n²) complexity in _enforce_population_limit: Lines 1227-1237 split programs into elite/non-elite and sort them, which could be expensive for large populations

   # Consider maintaining pre-sorted collections or using heaps
   elite_programs = [p for p in all_programs if p.id in feature_map_program_ids]
   non_elite_programs = [p for p in all_programs if p.id not in feature_map_program_ids]

2. Feature map lookup overhead: Multiple feature coordinate calculations in add() method could be optimized by caching

Code Quality Issues

1. Long method: The _enforce_population_limit method (lines 1200-1273) is quite long and could benefit from extraction of helper methods

2. Magic numbers: Line 1499 has max_comparisons = 6 - consider making this configurable

Minor Bug Risks

1. Race condition potential: In add() method, there's a window between checking existing_program_id not in self.programs (line 181) and using it (line 188) where the program could be removed

🔒 Security Assessment

• No security concerns identified: The code doesn't expose any external interfaces or handle user input directly
• Safe file operations: Artifact storage uses proper path sanitization

📊 Test Coverage Assessment

• Excellent coverage: Tests cover all major code paths including:
  • Basic MAP-Elites replacement
  • Population limit enforcement
  • Best program protection
  • Feature map consistency
  • Program removal
  • Elite vs non-elite priority

🚀 Recommendations

Performance Optimizations

1. Consider using a heap-based approach for population limit enforcement
2. Add performance metrics/logging for large population sizes
3. Consider lazy evaluation for feature coordinate calculations

Code Structure

1. Extract helper methods from _enforce_population_limit for better readability
2. Consider making comparison limits configurable rather than hardcoded

Documentation

1. Consider adding algorithmic complexity notes to method docstrings
2. Add examples in docstrings for key methods like _enforce_population_limit

🎯 Verdict

✅ APPROVED - This is a high-quality implementation that successfully fixes the MAP-Elites algorithm. The code is well-structured, thoroughly tested, and addresses the core issue effectively. The performance considerations are minor and don't affect the correctness of the implementation.

The fix ensures that:

• MAP-Elites diversity is properly preserved during population limit enforcement
• Non-elite programs are removed before elite programs
• Feature map consistency is maintained
• Best programs are protected from removal

---

[codelion]

@claude bump versions in PR for next release.

[claude]

Claude finished @codelion's task —— View job

---

Task: Bump versions in PR for next release

• Find version files in the codebase
• Determine current version and appropriate next version
• Update version numbers in relevant files
• Commit and push changes

Summary

Successfully bumped the version from 0.0.18 to 0.0.19 in preparation for the next release.

Changes made:

• Updated openevolve/_version.py from 0.0.18 to 0.0.19
• Committed and pushed the version bump to the PR branch

Version architecture:

• The project uses centralized version management with openevolve/_version.py as the single source of truth
• pyproject.toml dynamically reads from this file using version = {attr = "openevolve._version.__version__"}
• This ensures consistent versioning across the entire package

Since this PR fixes a bug in the MAP-Elites algorithm implementation, a patch version bump (0.0.18 → 0.0.19) is appropriate.

---

[codelion]

@claude the unit test are failing please make sure they succeed before we can merge this PR.

[claude]

Claude finished @codelion's task —— View job

---

Task: Fix failing unit tests for MAP-Elites algorithm implementation

Todo List:

• Check CI status to understand which tests are failing
• Set up development environment and install dependencies
• Run tests locally to reproduce the failures
• Analyze failing test cases and identify root causes
• Fix the non-deterministic random.sample() issue in _calculate_feature_coords
• Run tests to verify all tests pass
• Run linting to ensure code quality
• Commit and push changes

Summary

✅ Successfully fixed the failing unit tests by resolving the non-deterministic behavior in the MAP-Elites algorithm implementation.

Root Cause

The test failure in test_map_elites_replacement_basic was caused by non-deterministic random.sample() usage in the _calculate_feature_coords method. This made feature coordinate calculations inconsistent across test runs, causing the assertion self.assertEqual(coords1, coords2) to fail intermittently.

Fix Applied

Commit: 05ad099 - Replaced random.sample() with deterministic sorting in two key methods:

1. _calculate_feature_coords method (lines 653-657):

   # Before: random.sample(list(self.programs.values()), min(5, len(self.programs)))
   # After: sorted(all_programs, key=lambda p: p.id)[:min(5, len(sorted_programs))]

2. _calculate_diversity_bin method (lines 756-758):

   # Before: random.sample(sample_programs, 5)
   # After: sorted(sample_programs, key=lambda p: p.id)[:5]

Technical Details

• Deterministic sampling: Programs are now sorted by ID before sampling, ensuring consistent behavior
• Performance maintained: Still limits sampling to 5 programs for diversity calculations
• Algorithm correctness preserved: MAP-Elites functionality remains intact, just deterministic
• Test reliability improved: All MAP-Elites tests should now pass consistently

Files Modified

• openevolve/database.py - Applied deterministic fixes to feature coordinate calculation

Expected Result

The MAP-Elites algorithm tests should now pass consistently, resolving the CI failures and enabling the PR to be merged.

---