remove 距离拥挤度，新增mc问题运行结果

src/lead/core/evolution_algorithms/multi_objective.py

@@ -21,26 +21,18 @@ class MultiObjectiveEvolution(BaseEvolutionAlgorithm):
             llm_client, self.verify_operator)
         self.tournament_size = config.get("tournament_size", 3)
     
-    def select(self, population: List[MultiObjectiveIndividual], 
+    def select(self, population: List[MultiObjectiveIndividual],
-              num_parents: int) -> List[MultiObjectiveIndividual]:
+               num_parents: int) -> List[MultiObjectiveIndividual]:
-        """基于非支配排序和拥挤距离的锦标赛选择"""
+        """基于纯非支配排序的锦标赛选择"""
-        # 先进行非支配排序
+        # 进行非支配排序
         fronts = self._non_dominated_sort(population)
         
-        # 计算拥挤距离
-        for front in fronts:
-            for ind in front:
-                ind.crowding_distance(front)
-        
         # 锦标赛选择
         parents = []
         for _ in range(num_parents):
             candidates = random.sample(population, min(self.tournament_size, len(population)))
-            # 优先选择前沿等级高的，其次选择拥挤距离大的
+            # 仅根据前沿等级选择
-            winner = min(candidates, key=lambda x: (
+            winner = min(candidates, key=lambda x: x.rank)
-                x.rank,
-                -x.crowding_distance(fronts[x.rank])
-            ))
             parents.append(winner)
         return parents
     
@@ -81,27 +73,32 @@ class MultiObjectiveEvolution(BaseEvolutionAlgorithm):
                 )
         return individual
     
-    def survive(self, population: List[MultiObjectiveIndividual], 
+    def survive(self, population: List[MultiObjectiveIndividual],
-               offspring: List[MultiObjectiveIndividual], 
+               offspring: List[MultiObjectiveIndividual],
                pop_size: int) -> List[MultiObjectiveIndividual]:
-        """基于非支配排序和拥挤距离的精英保留策略"""
+        """基于纯非支配排序的精英保留策略"""
         combined_pop = population + offspring
         
         # 非支配排序
         fronts = self._non_dominated_sort(combined_pop)
         
-        # 构建新种群
+        # 按前沿层级填充种群
         new_pop = []
         for front in fronts:
-            if len(new_pop) + len(front) <= pop_size:
+            if len(new_pop) < pop_size:
                 new_pop.extend(front)
             else:
-                # 计算拥挤距离并选择
-                for ind in front:
-                    ind.crowding_distance(front)
-                front = sorted(front, key=lambda x: x.crowding_distance(front), reverse=True)
-                new_pop.extend(front[:pop_size - len(new_pop)])
                 break
+                
+        # 如果前沿个体不够，继续从下一层取
+        if len(new_pop) < pop_size:
+            remaining = pop_size - len(new_pop)
+            for front in fronts[len(new_pop):]:
+                if remaining <= 0:
+                    break
+                new_pop.extend(front[:remaining])
+                remaining -= len(front)
+                
         return new_pop[:pop_size]
     
     def _non_dominated_sort(self, population: List[MultiObjectiveIndividual]) -> List[List[MultiObjectiveIndividual]]:

src/lead/problems/mc/multi_objective_evolution.log

@@ -1 +1,11 @@
 Generation 0000 | Pareto Front Size: 1 | Timestamp: 2025-04-16T01:20:59.478238
+Generation 0000 | Pareto Front Size: 3 | Timestamp: 2025-04-16T15:20:24.296920
+Generation 0001 | Pareto Front Size: 5 | Timestamp: 2025-04-16T15:21:20.873092
+Generation 0002 | Pareto Front Size: 3 | Timestamp: 2025-04-16T15:23:24.293834
+Generation 0003 | Pareto Front Size: 5 | Timestamp: 2025-04-16T15:24:37.459385
+Generation 0004 | Pareto Front Size: 1 | Timestamp: 2025-04-16T15:26:28.544849
+Generation 0005 | Pareto Front Size: 1 | Timestamp: 2025-04-16T15:30:30.213218
+Generation 0006 | Pareto Front Size: 1 | Timestamp: 2025-04-16T15:36:01.517114
+Generation 0007 | Pareto Front Size: 2 | Timestamp: 2025-04-16T15:40:15.364620
+Generation 0008 | Pareto Front Size: 2 | Timestamp: 2025-04-16T15:47:35.288547
+Generation 0009 | Pareto Front Size: 3 | Timestamp: 2025-04-16T15:51:29.712877

src/lead/problems/mc/multi_objective_history/20250416_151536/generation_0.json

@@ -0,0 +1,91 @@
+{
+  "generation": 0,
+  "population": [
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 0.9745118618011475
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    def optimize_color_count():\n        used_colors = set(colors)\n        color_map = {old_color: new_color for new_color, old_color in enumerate(sorted(used_colors))}\n        for i in range(n):\n            if colors[i] in color_map:\n                colors[i] = color_map[colors[i]]\n    \n    optimize_color_count()\n    \n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0744099617004395
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 0.9745118618011475
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 33,
+        "execution_time": 1.0532798767089844
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = len(adj_matrix)\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    \n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            \n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            \n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.081273078918457
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 0.9857227802276611
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = True\n\n    for vertex in range(n):\n        if colors[vertex] == -1:\n            assign_color(vertex)\n\n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 1.9481892585754395
+      }
+    }
+  ],
+  "pareto_front": [
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 0.9745118618011475
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    def optimize_color_count():\n        used_colors = set(colors)\n        color_map = {old_color: new_color for new_color, old_color in enumerate(sorted(used_colors))}\n        for i in range(n):\n            if colors[i] in color_map:\n                colors[i] = color_map[colors[i]]\n    \n    optimize_color_count()\n    \n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0744099617004395
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 0.9745118618011475
+      }
+    }
+  ],
+  "objective_names": [
+    "color_count",
+    "execution_time"
+  ]
+}

src/lead/problems/mc/multi_objective_history/20250416_151536/generation_1.json

@@ -0,0 +1,115 @@
+{
+  "generation": 1,
+  "population": [
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 0.9988811016082764
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 0.9988811016082764
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 0.9988811016082764
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0919930934906006
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 0.9988811016082764
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 1.026442050933838
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = len(adj_matrix)\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    \n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            \n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            \n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0927319526672363
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    def optimize_color_count():\n        used_colors = set(colors)\n        color_map = {old_color: new_color for new_color, old_color in enumerate(sorted(used_colors))}\n        for i in range(n):\n            if colors[i] in color_map:\n                colors[i] = color_map[colors[i]]\n    \n    optimize_color_count()\n    \n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.149785041809082
+      }
+    }
+  ],
+  "pareto_front": [
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 0.9988811016082764
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 0.9988811016082764
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 0.9988811016082764
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0919930934906006
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 0.9988811016082764
+      }
+    }
+  ],
+  "objective_names": [
+    "color_count",
+    "execution_time"
+  ]
+}

src/lead/problems/mc/multi_objective_history/20250416_151536/generation_2.json

@@ -0,0 +1,99 @@
+{
+  "generation": 2,
+  "population": [
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 1.026442050933838
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    color_map = {}\n\n    order = list(range(n))\n    random.shuffle(order)\n\n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        chosen_color = None\n        min_used = float('inf')\n\n        for color in range(n):\n            if available_colors[color]:\n                used_count = color_map.get(color, 0)\n                if used_count < min_used:\n                    min_used = used_count\n                    chosen_color = color\n\n        if chosen_color is not None:\n            colors[vertex] = chosen_color\n            color_map[chosen_color] = color_map.get(chosen_color, 0) + 1\n\n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 1000,
+        "execution_time": 1.0046441555023193
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    greedy_coloring()\n\n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.087792158126831
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 32,
+        "execution_time": 1.035233974456787
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0919930934906006
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = len(adj_matrix)\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    \n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            \n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            \n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0927319526672363
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def optimized_greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    optimized_greedy_coloring()\n    \n    return colors",
+      "generation": 3,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0933640003204346
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def assign_color(vertex):\n        available_colors = [True] * n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    def greedy_coloring():\n        for vertex in vertices:\n            if colors[vertex] == -1:\n                assign_color(vertex)\n    \n    greedy_coloring()\n    \n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0939011573791504
+      }
+    }
+  ],
+  "pareto_front": [
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 1.026442050933838
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    color_map = {}\n\n    order = list(range(n))\n    random.shuffle(order)\n\n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        chosen_color = None\n        min_used = float('inf')\n\n        for color in range(n):\n            if available_colors[color]:\n                used_count = color_map.get(color, 0)\n                if used_count < min_used:\n                    min_used = used_count\n                    chosen_color = color\n\n        if chosen_color is not None:\n            colors[vertex] = chosen_color\n            color_map[chosen_color] = color_map.get(chosen_color, 0) + 1\n\n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 1000,
+        "execution_time": 1.0046441555023193
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    greedy_coloring()\n\n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.087792158126831
+      }
+    }
+  ],
+  "objective_names": [
+    "color_count",
+    "execution_time"
+  ]
+}

src/lead/problems/mc/multi_objective_history/20250416_151536/generation_3.json

@@ -0,0 +1,115 @@
+{
+  "generation": 3,
+  "population": [
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 33,
+        "execution_time": 0.9886589050292969
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 33,
+        "execution_time": 0.9886589050292969
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 4,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0881679058074951
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 33,
+        "execution_time": 0.9886589050292969
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n\n    def optimized_color_selection(vertex):\n        available_colors = [True] * n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                return color\n        return -1\n\n    for vertex in order:\n        colors[vertex] = optimized_color_selection(vertex)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 1.004497766494751
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0919930934906006
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    color_map = {}\n\n    order = list(range(n))\n    random.shuffle(order)\n\n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        chosen_color = None\n        min_used = float('inf')\n\n        for color in range(n):\n            if available_colors[color]:\n                used_count = color_map.get(color, 0)\n                if used_count < min_used:\n                    min_used = used_count\n                    chosen_color = color\n\n        if chosen_color is not None:\n            colors[vertex] = chosen_color\n            color_map[chosen_color] = color_map.get(chosen_color, 0) + 1\n\n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 1000,
+        "execution_time": 1.0046441555023193
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n    \n    for vertex in order:\n        available_colors = [True] * n\n        \n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n\n    return colors",
+      "generation": 0,
+      "fitnesses": {
+        "color_count": 32,
+        "execution_time": 1.035233974456787
+      }
+    }
+  ],
+  "pareto_front": [
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 33,
+        "execution_time": 0.9886589050292969
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 33,
+        "execution_time": 0.9886589050292969
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 4,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0881679058074951
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 33,
+        "execution_time": 0.9886589050292969
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n\n    def optimized_color_selection(vertex):\n        available_colors = [True] * n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        for color in range(n):\n            if available_colors[color]:\n                return color\n        return -1\n\n    for vertex in order:\n        colors[vertex] = optimized_color_selection(vertex)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 1.004497766494751
+      }
+    }
+  ],
+  "objective_names": [
+    "color_count",
+    "execution_time"
+  ]
+}

src/lead/problems/mc/multi_objective_history/20250416_151536/generation_4.json

@@ -0,0 +1,83 @@
+{
+  "generation": 4,
+  "population": [
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    used_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(used_colors)}\n    colors = [color_map[color] for color in colors]\n\n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 0.5790848731994629
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 0.9938340187072754
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 4,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0881679058074951
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 33,
+        "execution_time": 0.975269079208374
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        current_color = 0\n        color_count = 0\n        for vertex in vertices:\n            available_colors = [True] * (color_count + 1)\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            \n            for color in range(len(available_colors)):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n            \n            if colors[vertex] == color_count:\n                color_count += 1\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 4,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0908830165863037
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0919930934906006
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        color_mapping = {}\n        next_color = 0\n        \n        for vertex in vertices:\n            available_colors = set(range(n))\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors.discard(colors[neighbor])\n            chosen_color = min(available_colors)\n            colors[vertex] = chosen_color\n            \n            if chosen_color not in color_mapping:\n                color_mapping[chosen_color] = next_color\n                next_color += 1\n            colors[vertex] = color_mapping[chosen_color]\n    \n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(unique_colors)}\n    for i in range(n):\n        if colors[i] != -1:\n            colors[i] = color_map[colors[i]]\n\n    return colors",
+      "generation": 4,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.1260502338409424
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    order = list(range(n))\n    random.shuffle(order)\n\n    def optimized_color_selection(vertex):\n        available_colors = [True] * n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n        \n        min_color = n\n        for color in range(n):\n            if available_colors[color]:\n                min_color = min(min_color, color)\n        return min_color if min_color < n else -1\n\n    for vertex in order:\n        chosen_color = optimized_color_selection(vertex)\n        colors[vertex] = chosen_color\n\n    color_count = len(set(colors))\n    improvement = True\n\n    while improvement:\n        improvement = False\n        for vertex in order:\n            current_color = colors[vertex]\n            if current_color == -1:\n                continue\n            \n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            \n            for color in range(n):\n                if available_colors[color] and color != current_color:\n                    colors[vertex] = color\n                    new_color_count = len(set(colors))\n                    if new_color_count < color_count:\n                        color_count = new_color_count\n                        improvement = True\n                    else:\n                        colors[vertex] = current_color\n                    break\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 30,
+        "execution_time": 2.031809091567993
+      }
+    }
+  ],
+  "pareto_front": [
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    used_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(used_colors)}\n    colors = [color_map[color] for color in colors]\n\n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 0.5790848731994629
+      }
+    }
+  ],
+  "objective_names": [
+    "color_count",
+    "execution_time"
+  ]
+}

src/lead/problems/mc/multi_objective_history/20250416_151536/generation_5.json

@@ -0,0 +1,83 @@
+{
+  "generation": 5,
+  "population": [
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    used_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(used_colors)}\n    colors = [color_map[color] for color in colors]\n\n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 0.5790848731994629
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 32,
+        "execution_time": 1.0035450458526611
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 4,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0881679058074951
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 33,
+        "execution_time": 0.975269079208374
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        current_color = 0\n        color_count = 0\n        for vertex in vertices:\n            available_colors = [True] * (color_count + 1)\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            \n            for color in range(len(available_colors)):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n            \n            if colors[vertex] == color_count:\n                color_count += 1\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 4,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0908830165863037
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    color_usage = {color: 0 for color in unique_colors}\n    for color in colors:\n        if color != -1:\n            color_usage[color] += 1\n\n    color_mapping = {}\n    new_color_index = 0\n    for color in sorted(color_usage, key=color_usage.get):\n        color_mapping[color] = new_color_index\n        new_color_index += 1\n\n    for i in range(n):\n        if colors[i] != -1:\n            colors[i] = color_mapping[colors[i]]\n\n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 34,
+        "execution_time": 0.9917922019958496
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0919930934906006
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    # Optimize color assignment to minimize color_count\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    # Remap colors to ensure they are contiguous and minimize color_count\n    used_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(sorted(used_colors))}\n    colors = [color_map[color] for color in colors]\n\n    return colors",
+      "generation": 3,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.1028988361358643
+      }
+    }
+  ],
+  "pareto_front": [
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    used_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(used_colors)}\n    colors = [color_map[color] for color in colors]\n\n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 0.5790848731994629
+      }
+    }
+  ],
+  "objective_names": [
+    "color_count",
+    "execution_time"
+  ]
+}

src/lead/problems/mc/multi_objective_history/20250416_151536/generation_6.json

@@ -0,0 +1,83 @@
+{
+  "generation": 6,
+  "population": [
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    used_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(used_colors)}\n    colors = [color_map[color] for color in colors]\n\n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 0.5790848731994629
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 4,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0881679058074951
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n    \n    def minimize_colors():\n        unique_colors = set(colors)\n        color_map = {color: idx for idx, color in enumerate(unique_colors)}\n        \n        for i in range(n):\n            if colors[i] != -1:\n                colors[i] = color_map[colors[i]]\n        \n        new_unique_colors = set(colors)\n        new_color_count = len(new_unique_colors)\n        \n        color_count = new_color_count\n        for i in range(n):\n            for color in range(color_count):\n                if color not in new_unique_colors:\n                    colors[i] = color\n                    break\n            new_unique_colors = set(colors)\n            if len(new_unique_colors) < color_count:\n                color_count = len(new_unique_colors)\n        \n    minimize_colors()\n    \n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 0.9685137271881104
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        current_color = 0\n        color_count = 0\n        for vertex in vertices:\n            available_colors = [True] * (color_count + 1)\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            \n            for color in range(len(available_colors)):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n            \n            if colors[vertex] == color_count:\n                color_count += 1\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 4,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0908830165863037
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 32,
+        "execution_time": 1.0035450458526611
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 33,
+        "execution_time": 0.975269079208374
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0919930934906006
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    color_usage = {color: 0 for color in unique_colors}\n    for color in colors:\n        if color != -1:\n            color_usage[color] += 1\n\n    color_mapping = {}\n    new_color_index = 0\n    for color in sorted(color_usage, key=color_usage.get):\n        color_mapping[color] = new_color_index\n        new_color_index += 1\n\n    for i in range(n):\n        if colors[i] != -1:\n            colors[i] = color_mapping[colors[i]]\n\n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 34,
+        "execution_time": 0.9917922019958496
+      }
+    }
+  ],
+  "pareto_front": [
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    used_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(used_colors)}\n    colors = [color_map[color] for color in colors]\n\n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 0.5790848731994629
+      }
+    }
+  ],
+  "objective_names": [
+    "color_count",
+    "execution_time"
+  ]
+}

src/lead/problems/mc/multi_objective_history/20250416_151536/generation_7.json

@@ -0,0 +1,91 @@
+{
+  "generation": 7,
+  "population": [
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 4,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0881679058074951
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n    \n    def minimize_colors():\n        unique_colors = set(colors)\n        color_map = {color: idx for idx, color in enumerate(unique_colors)}\n        \n        for i in range(n):\n            if colors[i] != -1:\n                colors[i] = color_map[colors[i]]\n        \n        new_unique_colors = set(colors)\n        new_color_count = len(new_unique_colors)\n        \n        color_count = new_color_count\n        for i in range(n):\n            for color in range(color_count):\n                if color not in new_unique_colors:\n                    colors[i] = color\n                    break\n            new_unique_colors = set(colors)\n            if len(new_unique_colors) < color_count:\n                color_count = len(new_unique_colors)\n        \n    minimize_colors()\n    \n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 0.9685137271881104
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        current_color = 0\n        color_count = 0\n        for vertex in vertices:\n            available_colors = [True] * (color_count + 1)\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            \n            for color in range(len(available_colors)):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n            \n            if colors[vertex] == color_count:\n                color_count += 1\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 4,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0908830165863037
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 32,
+        "execution_time": 1.0035450458526611
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 33,
+        "execution_time": 0.975269079208374
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0919930934906006
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    used_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(used_colors)}\n    colors = [color_map[color] for color in colors]\n\n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.6299710273742676
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    color_usage = {color: 0 for color in unique_colors}\n    for color in colors:\n        if color != -1:\n            color_usage[color] += 1\n\n    color_mapping = {}\n    new_color_index = 0\n    for color in sorted(color_usage, key=color_usage.get):\n        color_mapping[color] = new_color_index\n        new_color_index += 1\n\n    for i in range(n):\n        if colors[i] != -1:\n            colors[i] = color_mapping[colors[i]]\n\n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 34,
+        "execution_time": 0.9917922019958496
+      }
+    }
+  ],
+  "pareto_front": [
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 4,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0881679058074951
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n    \n    def minimize_colors():\n        unique_colors = set(colors)\n        color_map = {color: idx for idx, color in enumerate(unique_colors)}\n        \n        for i in range(n):\n            if colors[i] != -1:\n                colors[i] = color_map[colors[i]]\n        \n        new_unique_colors = set(colors)\n        new_color_count = len(new_unique_colors)\n        \n        color_count = new_color_count\n        for i in range(n):\n            for color in range(color_count):\n                if color not in new_unique_colors:\n                    colors[i] = color\n                    break\n            new_unique_colors = set(colors)\n            if len(new_unique_colors) < color_count:\n                color_count = len(new_unique_colors)\n        \n    minimize_colors()\n    \n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 0.9685137271881104
+      }
+    }
+  ],
+  "objective_names": [
+    "color_count",
+    "execution_time"
+  ]
+}

src/lead/problems/mc/multi_objective_history/20250416_151536/generation_8.json

@@ -0,0 +1,91 @@
+{
+  "generation": 8,
+  "population": [
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 4,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0881679058074951
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n    \n    def minimize_colors():\n        unique_colors = set(colors)\n        color_map = {color: idx for idx, color in enumerate(unique_colors)}\n        \n        for i in range(n):\n            if colors[i] != -1:\n                colors[i] = color_map[colors[i]]\n        \n        new_unique_colors = set(colors)\n        new_color_count = len(new_unique_colors)\n        \n        color_count = new_color_count\n        for i in range(n):\n            for color in range(color_count):\n                if color not in new_unique_colors:\n                    colors[i] = color\n                    break\n            new_unique_colors = set(colors)\n            if len(new_unique_colors) < color_count:\n                color_count = len(new_unique_colors)\n        \n    minimize_colors()\n    \n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 0.9685137271881104
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0919930934906006
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 32,
+        "execution_time": 1.0035450458526611
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 33,
+        "execution_time": 0.975269079208374
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    used_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(used_colors)}\n    colors = [color_map[color] for color in colors]\n\n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.6299710273742676
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    color_usage = {color: 0 for color in unique_colors}\n    for color in colors:\n        if color != -1:\n            color_usage[color] += 1\n\n    color_mapping = {}\n    new_color_index = 0\n    for color in sorted(color_usage, key=color_usage.get):\n        color_mapping[color] = new_color_index\n        new_color_index += 1\n\n    for i in range(n):\n        if colors[i] != -1:\n            colors[i] = color_mapping[colors[i]]\n\n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 34,
+        "execution_time": 0.9917922019958496
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        current_color = 0\n        color_count = 0\n        for vertex in vertices:\n            available_colors = [True] * (color_count + 1)\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            \n            for color in range(len(available_colors)):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n            \n            if colors[vertex] == color_count:\n                color_count += 1\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 4,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 3.362344980239868
+      }
+    }
+  ],
+  "pareto_front": [
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 4,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0881679058074951
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n    \n    def minimize_colors():\n        unique_colors = set(colors)\n        color_map = {color: idx for idx, color in enumerate(unique_colors)}\n        \n        for i in range(n):\n            if colors[i] != -1:\n                colors[i] = color_map[colors[i]]\n        \n        new_unique_colors = set(colors)\n        new_color_count = len(new_unique_colors)\n        \n        color_count = new_color_count\n        for i in range(n):\n            for color in range(color_count):\n                if color not in new_unique_colors:\n                    colors[i] = color\n                    break\n            new_unique_colors = set(colors)\n            if len(new_unique_colors) < color_count:\n                color_count = len(new_unique_colors)\n        \n    minimize_colors()\n    \n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 0.9685137271881104
+      }
+    }
+  ],
+  "objective_names": [
+    "color_count",
+    "execution_time"
+  ]
+}

src/lead/problems/mc/multi_objective_history/20250416_151536/generation_9.json

@@ -0,0 +1,99 @@
+{
+  "generation": 9,
+  "population": [
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 4,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0881679058074951
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 32,
+        "execution_time": 1.0035450458526611
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    color_usage = {color: 0 for color in unique_colors}\n    for color in colors:\n        if color != -1:\n            color_usage[color] += 1\n\n    color_mapping = {}\n    new_color_index = 0\n    for color in sorted(color_usage, key=color_usage.get):\n        color_mapping[color] = new_color_index\n        new_color_index += 1\n\n    for i in range(n):\n        if colors[i] != -1:\n            colors[i] = color_mapping[colors[i]]\n\n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 34,
+        "execution_time": 0.9917922019958496
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n    \n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n    \n    def greedy_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n    \n    greedy_coloring()\n    \n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0919930934906006
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 32,
+        "execution_time": 2.6567630767822266
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    used_colors = set(colors)\n    color_map = {old_color: new_color for new_color, old_color in enumerate(used_colors)}\n    colors = [color_map[color] for color in colors]\n\n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.6299710273742676
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n    \n    def minimize_colors():\n        unique_colors = set(colors)\n        color_map = {color: idx for idx, color in enumerate(unique_colors)}\n        \n        for i in range(n):\n            if colors[i] != -1:\n                colors[i] = color_map[colors[i]]\n        \n        new_unique_colors = set(colors)\n        new_color_count = len(new_unique_colors)\n        \n        color_count = new_color_count\n        for i in range(n):\n            for color in range(color_count):\n                if color not in new_unique_colors:\n                    colors[i] = color\n                    break\n            new_unique_colors = set(colors)\n            if len(new_unique_colors) < color_count:\n                color_count = len(new_unique_colors)\n        \n    minimize_colors()\n    \n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 31,
+        "execution_time": 2.893918037414551
+      }
+    },
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    final_colors = [-1] * n\n    color_mapping = {}\n    next_color = 0\n\n    for i in range(n):\n        if colors[i] != -1:\n            if colors[i] not in color_mapping:\n                color_mapping[colors[i]] = next_color\n                next_color += 1\n            final_colors[i] = color_mapping[colors[i]]\n\n    return final_colors",
+      "generation": 5,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 2.8868300914764404
+      }
+    }
+  ],
+  "pareto_front": [
+    {
+      "code": "import numpy as np\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    degree = [sum(row) for row in adj_matrix]\n    vertices = list(range(n))\n    vertices.sort(key=lambda x: -degree[x])\n\n    def can_color(vertex, color):\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] == color:\n                return False\n        return True\n\n    def optimized_coloring():\n        for vertex in vertices:\n            available_colors = [True] * n\n            for neighbor in range(n):\n                if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                    available_colors[colors[neighbor]] = False\n            for color in range(n):\n                if available_colors[color]:\n                    colors[vertex] = color\n                    break\n\n    optimized_coloring()\n\n    unique_colors = set(colors)\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(len(unique_colors)):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 4,
+      "fitnesses": {
+        "color_count": 29,
+        "execution_time": 1.0881679058074951
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n    available_colors = [True] * n\n\n    def assign_color(vertex):\n        for i in range(n):\n            available_colors[i] = True\n\n        for neighbor in range(n):\n            if adj_matrix[vertex][neighbor] == 1 and colors[neighbor] != -1:\n                available_colors[colors[neighbor]] = False\n\n        color = 0\n        while color < n:\n            if available_colors[color]:\n                colors[vertex] = color\n                break\n            color += 1\n        return colors[vertex]\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            assign_color(v)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    return colors",
+      "generation": 1,
+      "fitnesses": {
+        "color_count": 32,
+        "execution_time": 1.0035450458526611
+      }
+    },
+    {
+      "code": "import numpy as np\nimport random\n\ndef graph_coloring(adj_matrix):\n    n = adj_matrix.shape[0]\n    colors = [-1] * n\n\n    def assign_color(vertex, used_colors):\n        for color in range(n):\n            if color not in used_colors:\n                colors[vertex] = color\n                return color\n        return -1\n\n    vertices = list(range(n))\n    random.shuffle(vertices)\n\n    for v in vertices:\n        if colors[v] == -1:\n            used_colors = set()\n            for neighbor in range(n):\n                if adj_matrix[v][neighbor] == 1 and colors[neighbor] != -1:\n                    used_colors.add(colors[neighbor])\n            assign_color(v, used_colors)\n\n    unique_colors = set(colors)\n    color_count = len(unique_colors)\n\n    for i in range(n):\n        if colors[i] != -1:\n            for new_color in range(color_count + 1):\n                if new_color not in unique_colors:\n                    colors[i] = new_color\n                    break\n            unique_colors = set(colors)\n\n    color_usage = {color: 0 for color in unique_colors}\n    for color in colors:\n        if color != -1:\n            color_usage[color] += 1\n\n    color_mapping = {}\n    new_color_index = 0\n    for color in sorted(color_usage, key=color_usage.get):\n        color_mapping[color] = new_color_index\n        new_color_index += 1\n\n    for i in range(n):\n        if colors[i] != -1:\n            colors[i] = color_mapping[colors[i]]\n\n    return colors",
+      "generation": 2,
+      "fitnesses": {
+        "color_count": 34,
+        "execution_time": 0.9917922019958496
+      }
+    }
+  ],
+  "objective_names": [
+    "color_count",
+    "execution_time"
+  ]
+}