1{
2  "op": "replace",
3  "filename": "deap/custom_evolution.py",
4  "start_line": 87,
5  "end_line": 225,
6  "content": "def custom_select(population: list, k: int, toolbox=None) -> list:\n    \"\"\"Tournament selection with tournament size 3.\"\"\"\n    return tools.selTournament(population, k, tournsize=3)\n\n\ndef custom_crossover(ind1: list, ind2: list) -> Tuple[list, list]:\n    \"\"\"Binomial crossover with adaptive CR (not used directly).\"\"\"\n    # This function is kept for interface compatibility but not used in our custom run_evolution\n    return ind1, ind2\n\n\ndef custom_mutate(individual: list, lo: float, hi: float) -> Tuple[list]:\n    \"\"\"Polynomial mutation (not used directly).\"\"\"\n    # This function is kept for interface compatibility but not used in our custom run_evolution\n    tools.mutPolynomialBounded(\n        individual, eta=20.0, low=lo, up=hi,\n        indpb=1.0 / len(individual)\n    )\n    return (individual,)\n\n\ndef run_evolution(\n    evaluate_func: Callable,\n    dim: int,\n    lo: float,\n    hi: float,\n    pop_size: int,\n    n_generations: int,\n    cx_prob: float,\n    mut_prob: float,\n    seed: int,\n) -> Tuple[list, list]:\n    \"\"\"Adaptive Strategy Selection Differential Evolution with Covariance-guided Mutation (ASS-DE-CM).\n\n    Features:\n    1. Multiple mutation strategies with adaptive selection probability:\n        - DE/rand/1 (exploration)\n        - DE/current-to-pbest/1 (exploitation)  \n        - Covariance-guided mutation (direction learning)\n    2. Success-history adaptation of F and CR (like L-SHADE)\n    3. Covariance matrix learning from successful mutations\n    4. Linear population size reduction\n    5. Elitism and restart when stagnation detected\n    \"\"\"\n    random.seed(seed)\n    np.random.seed(seed)\n\n    # --- Hyperparameters ---\n    H = 5  # History size for F and CR\n    N_init = pop_size\n    N_min = max(4, dim)  # Minimum population size\n    p_min = 2.0 / N_init  # Minimum p for pbest\n    p_max = 0.2  # Maximum p for pbest\n    STRATEGIES = ['rand', 'pbest', 'cov']  # Mutation strategies\n    strategy_probs = [0.33, 0.33, 0.34]  # Initial selection probabilities\n    strategy_success = [0.0, 0.0, 0.0]  # Success counts for each strategy\n    strategy_attempts = [0.0, 0.0, 0.0]\n    cov_learning_rate = 0.1  # Learning rate for covariance matrix update\n    restart_threshold = 50  # Generations without improvement to trigger restart\n    diversity_threshold = 1e-6  # Minimum population diversity\n\n    toolbox = base.Toolbox()\n    toolbox.register(\"individual\", make_individual, toolbox, dim, lo, hi)\n    toolbox.register(\"population\", tools.initRepeat, list, toolbox.individual)\n    toolbox.register(\"evaluate\", evaluate_func)\n\n    # Initialize population\n    pop = toolbox.population(n=N_init)\n    fitnesses = list(map(toolbox.evaluate, pop))\n    for ind, fit in zip(pop, fitnesses):\n        ind.fitness.values = fit\n\n    # Success history for F and CR\n    M_F = [0.5] * H\n    M_CR = [0.5] * H\n    k = 0  # History index\n\n    # Covariance matrix initialization (identity)\n    C = np.eye(dim)\n    mean = np.array([(lo + hi) / 2.0] * dim)  # Initial mean\n\n    # External archive of inferior solutions\n    archive = []\n\n    fitness_history = []\n    best_ever = min(pop, key=lambda ind: ind.fitness.values[0])\n    best_fitness = best_ever.fitness.values[0]\n    no_improve_count = 0\n\n    for gen in range(n_generations):\n        N_current = len(pop)\n        \n        # Linear population reduction\n        if N_current > N_min:\n            target_N = int(N_init - (N_init - N_min) * (gen / n_generations))\n            if target_N < N_current:\n                # Remove worst individuals\n                pop.sort(key=lambda ind: ind.fitness.values[0])\n                pop = pop[:target_N]\n\n        # Collect successful F and CR values and their fitness improvements\n        S_F = []\n        S_CR = []\n        delta_f = []  # fitness improvement for weighting\n\n        trial_list = []\n        F_list = []\n        CR_list = []\n        strategy_list = []\n\n        for i in range(N_current):\n            # Sample F from Cauchy(M_F[r], 0.1), truncate to (0, 1]\n            r = random.randint(0, H - 1)\n            while True:\n                F_i = M_F[r] + 0.1 * np.random.standard_cauchy()\n                if F_i > 0:\n                    break\n            F_i = min(F_i, 1.0)\n\n            # Sample CR from Normal(M_CR[r], 0.1), clamp to [0, 1]\n            CR_i = np.random.normal(M_CR[r], 0.1)\n            CR_i = max(0.0, min(1.0, CR_i))\n\n            F_list.append(F_i)\n            CR_list.append(CR_i)\n\n            # Select mutation strategy based on adaptive probabilities\n            strategy_idx = np.random.choice(len(STRATEGIES), p=strategy_probs)\n            strategy = STRATEGIES[strategy_idx]\n            strategy_list.append(strategy_idx)\n\n            # DE/rand/1 mutation\n            if strategy == 'rand':\n                # Select three distinct random individuals (not i)\n                candidates = list(range(N_current))\n                candidates.remove(i)\n                r1, r2, r3 = random.sample(candidates, 3)\n                mutant = creator.Individual([\n                    pop[r1][j] + F_i * (pop[r2][j] - pop[r3][j])\n                    for j in range(dim)\n                ])\n\n            # DE/current-to-pbest/1 mutation\n            elif strategy == 'pbest':\n                # Choose p_i uniformly from [p_min, p_max]\n                p_i = random.uniform(p_min, p_max)\n                n_pbest = max(1, int(round(p_i * N_current)))\n                sorted_pop = sorted(pop, key=lambda ind: ind.fitness.values[0])\n                pbest = random.choice(sorted_pop[:n_pbest])\n\n                # Select r1 from pop (r1 != i)\n                candidates = list(range(N_current))\n                candidates.remove(i)\n                r1 = random.choice(candidates)\n\n                # Select r2 from pop + archive (r2 != i and r2 != r1)\n                union = list(range(N_current + len(archive)))\n                union_exclude = {i, r1}\n                union_avail = [x for x in union if x not in union_exclude]\n                if not union_avail:\n                    union_avail = [x for x in union if x != i]\n                r2_idx = random.choice(union_avail)\n                if r2_idx < N_current:\n                    x_r2 = pop[r2_idx]\n                else:\n                    x_r2 = archive[r2_idx - N_current]\n\n                # Mutation: v = x_i + F * (pbest - x_i) + F * (x_r1 - x_r2)\n                mutant = creator.Individual([\n                    pop[i][j] + F_i * (pbest[j] - pop[i][j]) + F_i * (pop[r1][j] - x_r2[j])\n                    for j in range(dim)\n                ])\n\n            # Covariance-guided mutation\n            else:  # strategy == 'cov'\n                # Generate mutation vector using covariance matrix\n                try:\n                    # Add small regularization for numerical stability\n                    C_reg = C + 1e-6 * np.eye(dim)\n                    L = np.linalg.cholesky(C_reg)\n                    z = np.random.randn(dim)\n                    mutation = L @ z\n                    # Scale by F_i and add to current individual\n                    mutant = creator.Individual([\n                        pop[i][j] + F_i * mutation[j]\n                        for j in range(dim)\n                    ])\n                except np.linalg.LinAlgError:\n                    # Fallback to DE/rand/1 if Cholesky fails\n                    candidates = list(range(N_current))\n                    candidates.remove(i)\n                    r1, r2, r3 = random.sample(candidates, 3)\n                    mutant = creator.Individual([\n                        pop[r1][j] + F_i * (pop[r2][j] - pop[r3][j])\n                        for j in range(dim)\n                    ])\n\n            # Binomial crossover\n            j_rand = random.randint(0, dim - 1)\n            trial = creator.Individual([\n                mutant[j] if (random.random() < CR_i or j == j_rand) else pop[i][j]\n                for j in range(dim)\n            ])\n\n            # Clip to bounds\n            for j in range(dim):\n                trial[j] = max(lo, min(hi, trial[j]))\n\n            trial.fitness.values = toolbox.evaluate(trial)\n            trial_list.append(trial)\n\n        # Selection and success history update\n        new_pop = []\n        for i in range(N_current):\n            trial = trial_list[i]\n            if trial.fitness.values[0] <= pop[i].fitness.values[0]:\n                # Success: archive old individual\n                if len(archive) < N_current:\n                    archive.append(toolbox.clone(pop[i]))\n                else:\n                    # Random replacement if archive full\n                    archive[random.randint(0, len(archive) - 1)] = toolbox.clone(pop[i])\n                \n                # Record successful F, CR, and strategy\n                if trial.fitness.values[0] < pop[i].fitness.values[0]:\n                    S_F.append(F_list[i])\n                    S_CR.append(CR_list[i])\n                    delta_f.append(pop[i].fitness.values[0] - trial.fitness.values[0])\n                \n                # Update strategy success counts\n                strategy_idx = strategy_list[i]\n                strategy_attempts[strategy_idx] += 1\n                if trial.fitness.values[0] < pop[i].fitness.values[0]:\n                    strategy_success[strategy_idx] += 1\n                \n                # Update covariance matrix with successful direction\n                if strategy_list[i] == 2:  # cov strategy\n                    diff = np.array(trial) - np.array(pop[i])\n                    if np.linalg.norm(diff) > 1e-10:\n                        # Update mean and covariance\n                        new_mean = (1 - cov_learning_rate) * mean + cov_learning_rate * np.array(trial)\n                        diff_mean = np.array(trial) - mean\n                        C = (1 - cov_learning_rate) * C + cov_learning_rate * np.outer(diff_mean, diff_mean)\n                        mean = new_mean\n                \n                new_pop.append(trial)\n            else:\n                new_pop.append(pop[i])\n        \n      \n... (truncated)"
7}

1{
2  "op": "replace",
3  "filename": "deap/custom_evolution.py",
4  "start_line": 87,
5  "end_line": 225,
6  "content": "def custom_select(population: list, k: int, toolbox=None) -> list:\n    \"\"\"Tournament selection with tournament size 3.\"\"\"\n    return tools.selTournament(population, k, tournsize=3)\n\n\ndef custom_crossover(ind1: list, ind2: list) -> Tuple[list, list]:\n    \"\"\"Binomial crossover with adaptive CR (not used directly).\"\"\"\n    # This function is kept for interface compatibility but not used in our custom run_evolution\n    return ind1, ind2\n\n\ndef custom_mutate(individual: list, lo: float, hi: float) -> Tuple[list]:\n    \"\"\"Polynomial mutation (not used directly).\"\"\"\n    # This function is kept for interface compatibility but not used in our custom run_evolution\n    tools.mutPolynomialBounded(\n        individual, eta=20.0, low=lo, up=hi,\n        indpb=1.0 / len(individual)\n    )\n    return (individual,)\n\n\ndef run_evolution(\n    evaluate_func: Callable,\n    dim: int,\n    lo: float,\n    hi: float,\n    pop_size: int,\n    n_generations: int,\n    cx_prob: float,\n    mut_prob: float,\n    seed: int,\n) -> Tuple[list, list]:\n    \"\"\"Adaptive Strategy Selection L-SHADE (ASS-L-SHADE).\n\n    Features:\n    1. Multiple mutation strategies with adaptive selection probability:\n        - DE/rand/1 (exploration)\n        - DE/current-to-pbest/1 (balanced)\n        - DE/best/1 (exploitation)\n    2. Success-history adaptation of F and CR (like L-SHADE)\n    3. Linear population size reduction\n    4. Elitism (keep best individual)\n    5. Restart when stagnation detected\n    \"\"\"\n    random.seed(seed)\n    np.random.seed(seed)\n\n    # --- Hyperparameters ---\n    H = 5  # History size for F and CR\n    N_init = pop_size\n    N_min = max(4, dim)  # Minimum population size\n    p_min = 2.0 / N_init  # Minimum p for pbest\n    p_max = 0.2  # Maximum p for pbest\n    STRATEGIES = ['rand', 'pbest', 'best']  # Mutation strategies\n    strategy_probs = [0.33, 0.33, 0.34]  # Initial selection probabilities\n    strategy_success = [0.0, 0.0, 0.0]  # Success counts for each strategy\n    strategy_attempts = [0.0, 0.0, 0.0]\n    restart_threshold = 100  # Generations without improvement to trigger restart\n    diversity_threshold = 1e-6  # Minimum population diversity\n\n    toolbox = base.Toolbox()\n    toolbox.register(\"individual\", make_individual, toolbox, dim, lo, hi)\n    toolbox.register(\"population\", tools.initRepeat, list, toolbox.individual)\n    toolbox.register(\"evaluate\", evaluate_func)\n\n    # Initialize population\n    pop = toolbox.population(n=N_init)\n    fitnesses = list(map(toolbox.evaluate, pop))\n    for ind, fit in zip(pop, fitnesses):\n        ind.fitness.values = fit\n\n    # Success history for F and CR\n    M_F = [0.5] * H\n    M_CR = [0.5] * H\n    k = 0  # History index\n\n    # External archive of inferior solutions\n    archive = []\n\n    fitness_history = []\n    best_ever = min(pop, key=lambda ind: ind.fitness.values[0])\n    best_fitness = best_ever.fitness.values[0]\n    no_improve_count = 0\n\n    for gen in range(n_generations):\n        N_current = len(pop)\n        \n        # Linear population reduction (L-SHADE style)\n        if N_current > N_min:\n            target_N = int(round(N_init - (N_init - N_min) * (gen / n_generations)))\n            if target_N < N_current:\n                # Remove worst individuals\n                pop.sort(key=lambda ind: ind.fitness.values[0])\n                pop = pop[:target_N]\n                # Also reduce archive size if needed\n                if len(archive) > target_N:\n                    archive = archive[:target_N]\n\n        # Collect successful F and CR values and their fitness improvements\n        S_F = []\n        S_CR = []\n        delta_f = []  # fitness improvement for weighting\n\n        trial_list = []\n        F_list = []\n        CR_list = []\n        strategy_list = []\n\n        for i in range(N_current):\n            # Sample F from Cauchy(M_F[r], 0.1), truncate to (0, 1]\n            r = random.randint(0, H - 1)\n            while True:\n                F_i = M_F[r] + 0.1 * np.random.standard_cauchy()\n                if F_i > 0:\n                    break\n            F_i = min(F_i, 1.0)\n\n            # Sample CR from Normal(M_CR[r], 0.1), clamp to [0, 1]\n            CR_i = np.random.normal(M_CR[r], 0.1)\n            CR_i = max(0.0, min(1.0, CR_i))\n\n            F_list.append(F_i)\n            CR_list.append(CR_i)\n\n            # Select mutation strategy based on adaptive probabilities\n            # Ensure probabilities sum to 1\n            probs = np.array(strategy_probs)\n            probs = probs / probs.sum() if probs.sum() > 0 else np.ones(len(STRATEGIES)) / len(STRATEGIES)\n            strategy_idx = np.random.choice(len(STRATEGIES), p=probs)\n            strategy = STRATEGIES[strategy_idx]\n            strategy_list.append(strategy_idx)\n\n            # DE/rand/1 mutation\n            if strategy == 'rand':\n                # Select three distinct random individuals (not i)\n                candidates = list(range(N_current))\n                candidates.remove(i)\n                r1, r2, r3 = random.sample(candidates, 3)\n                mutant = creator.Individual([\n                    pop[r1][j] + F_i * (pop[r2][j] - pop[r3][j])\n                    for j in range(dim)\n                ])\n\n            # DE/current-to-pbest/1 mutation\n            elif strategy == 'pbest':\n                # Choose p_i uniformly from [p_min, p_max]\n                p_i = random.uniform(p_min, p_max)\n                n_pbest = max(1, int(round(p_i * N_current)))\n                sorted_pop = sorted(pop, key=lambda ind: ind.fitness.values[0])\n                pbest = random.choice(sorted_pop[:n_pbest])\n\n                # Select r1 from pop (r1 != i)\n                candidates = list(range(N_current))\n                candidates.remove(i)\n                r1 = random.choice(candidates)\n\n                # Select r2 from pop + archive (r2 != i and r2 != r1)\n                union = list(range(N_current + len(archive)))\n                union_exclude = {i, r1}\n                union_avail = [x for x in union if x not in union_exclude]\n                if not union_avail:\n                    union_avail = [x for x in union if x != i]\n                r2_idx = random.choice(union_avail)\n                if r2_idx < N_current:\n                    x_r2 = pop[r2_idx]\n                else:\n                    x_r2 = archive[r2_idx - N_current]\n\n                # Mutation: v = x_i + F * (pbest - x_i) + F * (x_r1 - x_r2)\n                mutant = creator.Individual([\n                    pop[i][j] + F_i * (pbest[j] - pop[i][j]) + F_i * (pop[r1][j] - x_r2[j])\n                    for j in range(dim)\n                ])\n\n            # DE/best/1 mutation\n            else:  # strategy == 'best'\n                # Select best individual\n                sorted_pop = sorted(pop, key=lambda ind: ind.fitness.values[0])\n                best = sorted_pop[0]\n                \n                # Select two distinct random individuals (not i and not best)\n                candidates = list(range(N_current))\n                candidates.remove(i)\n                # Ensure best index is not in candidates if best is not i\n                best_idx = pop.index(best) if best in pop else -1\n                if best_idx in candidates:\n                    candidates.remove(best_idx)\n                r1, r2 = random.sample(candidates, 2)\n                \n                mutant = creator.Individual([\n                    best[j] + F_i * (pop[r1][j] - pop[r2][j])\n                    for j in range(dim)\n                ])\n\n            # Binomial crossover\n            j_rand = random.randint(0, dim - 1)\n            trial = creator.Individual([\n                mutant[j] if (random.random() < CR_i or j == j_rand) else pop[i][j]\n                for j in range(dim)\n            ])\n\n            # Clip to bounds\n            for j in range(dim):\n                trial[j] = max(lo, min(hi, trial[j]))\n\n            trial.fitness.values = toolbox.evaluate(trial)\n            trial_list.append(trial)\n\n        # Selection and success history update\n        new_pop = []\n        for i in range(N_current):\n            trial = trial_list[i]\n            if trial.fitness.values[0] <= pop[i].fitness.values[0]:\n                # Success: archive old individual\n                if len(archive) < N_current:\n                    archive.append(toolbox.clone(pop[i]))\n                else:\n                    # Random replacement if archive full\n                    archive[random.randint(0, len(archive) - 1)] = toolbox.clone(pop[i])\n                \n                # Record successful F, CR, and strategy\n                if trial.fitness.values[0] < pop[i].fitness.values[0]:\n                    S_F.append(F_list[i])\n                    S_CR.append(CR_list[i])\n                    delta_f.append(pop[i].fitness.values[0] - trial.fitness.values[0])\n                \n                # Update strategy success counts\n                strategy_idx = strategy_list[i]\n                strategy_attempts[strategy_idx] += 1\n                if trial.fitness.values[0] < pop[i].fitness.values[0]:\n                    strategy_success[strategy_idx] += 1\n                \n                new_pop.append(trial)\n            else:\n                new_pop.append(pop[i])\n        \n        pop = new_pop\n        \n        # Update success history M_F and M_CR\n        if S_F:\n            # Weighted average by fitness improvement\n            weights = np.array(delta_f) / sum(delta_f) if sum(delta_f) > 0 else np.ones(len(S_F)) / len(S_F)\n            M_F[k] = np.sum(weights * np.array(S_F))\n            M_CR[k] = np.sum(weights * np.array(S_CR))\n            k = (k + 1) % H\n        \n        # Update strategy selection probabilities\n        total_attempts = sum(strategy_attempts)\n        if total_attempts > 0:\n            for s_idx in range(len(STRATEGIES)):\n                if strategy_attempts[s_idx] > 0:\n                    success_rate = strategy_success[s_idx] / strategy_attempts[s_idx]\n                    # Update probability with learning rate 0.1\n                    strategy_probs[\n... (truncated)"
7}

1{
2  "n": 1
3}

1{
2  "op": "replace",
3  "filename": "deap/custom_evolution.py",
4  "start_line": 87,
5  "end_line": 405,
6  "content": "def custom_select(population: list, k: int, toolbox=None) -> list:\n    \"\"\"Tournament selection with tournament size 3.\"\"\"\n    return tools.selTournament(population, k, tournsize=3)\n\n\ndef custom_crossover(ind1: list, ind2: list) -> Tuple[list, list]:\n    \"\"\"Binomial crossover with adaptive CR (not used directly).\"\"\"\n    # This function is kept for interface compatibility but not used in our custom run_evolution\n    return ind1, ind2\n\n\ndef custom_mutate(individual: list, lo: float, hi: float) -> Tuple[list]:\n    \"\"\"Polynomial mutation (not used directly).\"\"\"\n    # This function is kept for interface compatibility but not used in our custom run_evolution\n    tools.mutPolynomialBounded(\n        individual, eta=20.0, low=lo, up=hi,\n        indpb=1.0 / len(individual)\n    )\n    return (individual,)\n\n\ndef run_evolution(\n    evaluate_func: Callable,\n    dim: int,\n    lo: float,\n    hi: float,\n    pop_size: int,\n    n_generations: int,\n    cx_prob: float,\n    mut_prob: float,\n    seed: int,\n) -> Tuple[list, list]:\n    \"\"\"Adaptive Strategy Selection L-SHADE (ASS-L-SHADE).\n\n    Features:\n    1. Multiple mutation strategies with adaptive selection probability:\n        - DE/rand/1 (exploration)\n        - DE/current-to-pbest/1 (balanced)\n        - DE/best/1 (exploitation)\n    2. Success-history adaptation of F and CR (like L-SHADE)\n    3. Linear population size reduction\n    4. Elitism (keep best individual)\n    5. Restart when stagnation detected\n    \"\"\"\n    random.seed(seed)\n    np.random.seed(seed)\n\n    # --- Hyperparameters ---\n    H = 5  # History size for F and CR\n    N_init = pop_size\n    N_min = max(4, dim)  # Minimum population size\n    p_min = 2.0 / N_init  # Minimum p for pbest\n    p_max = 0.2  # Maximum p for pbest\n    STRATEGIES = ['rand', 'pbest', 'best']  # Mutation strategies\n    strategy_probs = [0.33, 0.33, 0.34]  # Initial selection probabilities\n    strategy_success = [0.0, 0.0, 0.0]  # Success counts for each strategy\n    strategy_attempts = [0.0, 0.0, 0.0]\n    restart_threshold = 100  # Generations without improvement to trigger restart\n    diversity_threshold = 1e-6  # Minimum population diversity\n\n    toolbox = base.Toolbox()\n    toolbox.register(\"individual\", make_individual, toolbox, dim, lo, hi)\n    toolbox.register(\"population\", tools.initRepeat, list, toolbox.individual)\n    toolbox.register(\"evaluate\", evaluate_func)\n\n    # Initialize population\n    pop = toolbox.population(n=N_init)\n    fitnesses = list(map(toolbox.evaluate, pop))\n    for ind, fit in zip(pop, fitnesses):\n        ind.fitness.values = fit\n\n    # Success history for F and CR\n    M_F = [0.5] * H\n    M_CR = [0.5] * H\n    k = 0  # History index\n\n    # External archive of inferior solutions\n    archive = []\n\n    fitness_history = []\n    best_ever = min(pop, key=lambda ind: ind.fitness.values[0])\n    best_fitness = best_ever.fitness.values[0]\n    no_improve_count = 0\n\n    for gen in range(n_generations):\n        N_current = len(pop)\n        \n        # Linear population reduction (L-SHADE style)\n        if N_current > N_min:\n            target_N = int(round(N_init - (N_init - N_min) * (gen / n_generations)))\n            if target_N < N_current:\n                # Remove worst individuals\n                pop.sort(key=lambda ind: ind.fitness.values[0])\n                pop = pop[:target_N]\n                # Also reduce archive size if needed\n                if len(archive) > target_N:\n                    archive = archive[:target_N]\n\n        # Collect successful F and CR values and their fitness improvements\n        S_F = []\n        S_CR = []\n        delta_f = []  # fitness improvement for weighting\n\n        trial_list = []\n        F_list = []\n        CR_list = []\n        strategy_list = []\n\n        for i in range(N_current):\n            # Sample F from Cauchy(M_F[r], 0.1), truncate to (0, 1]\n            r = random.randint(0, H - 1)\n            while True:\n                F_i = M_F[r] + 0.1 * np.random.standard_cauchy()\n                if F_i > 0:\n                    break\n            F_i = min(F_i, 1.0)\n\n            # Sample CR from Normal(M_CR[r], 0.1), clamp to [0, 1]\n            CR_i = np.random.normal(M_CR[r], 0.1)\n            CR_i = max(0.0, min(1.0, CR_i))\n\n            F_list.append(F_i)\n            CR_list.append(CR_i)\n\n            # Select mutation strategy based on adaptive probabilities\n            # Ensure probabilities sum to 1\n            probs = np.array(strategy_probs)\n            probs = probs / probs.sum() if probs.sum() > 0 else np.ones(len(STRATEGIES)) / len(STRATEGIES)\n            strategy_idx = np.random.choice(len(STRATEGIES), p=probs)\n            strategy = STRATEGIES[strategy_idx]\n            strategy_list.append(strategy_idx)\n\n            # DE/rand/1 mutation\n            if strategy == 'rand':\n                # Select three distinct random individuals (not i)\n                candidates = list(range(N_current))\n                candidates.remove(i)\n                r1, r2, r3 = random.sample(candidates, 3)\n                mutant = creator.Individual([\n                    pop[r1][j] + F_i * (pop[r2][j] - pop[r3][j])\n                    for j in range(dim)\n                ])\n\n            # DE/current-to-pbest/1 mutation\n            elif strategy == 'pbest':\n                # Choose p_i uniformly from [p_min, p_max]\n                p_i = random.uniform(p_min, p_max)\n                n_pbest = max(1, int(round(p_i * N_current)))\n                sorted_pop = sorted(pop, key=lambda ind: ind.fitness.values[0])\n                pbest = random.choice(sorted_pop[:n_pbest])\n\n                # Select r1 from pop (r1 != i)\n                candidates = list(range(N_current))\n                candidates.remove(i)\n                r1 = random.choice(candidates)\n\n                # Select r2 from pop + archive (r2 != i and r2 != r1)\n                union = list(range(N_current + len(archive)))\n                union_exclude = {i, r1}\n                union_avail = [x for x in union if x not in union_exclude]\n                if not union_avail:\n                    union_avail = [x for x in union if x != i]\n                r2_idx = random.choice(union_avail)\n                if r2_idx < N_current:\n                    x_r2 = pop[r2_idx]\n                else:\n                    x_r2 = archive[r2_idx - N_current]\n\n                # Mutation: v = x_i + F * (pbest - x_i) + F * (x_r1 - x_r2)\n                mutant = creator.Individual([\n                    pop[i][j] + F_i * (pbest[j] - pop[i][j]) + F_i * (pop[r1][j] - x_r2[j])\n                    for j in range(dim)\n                ])\n\n            # DE/best/1 mutation\n            else:  # strategy == 'best'\n                # Select best individual\n                sorted_pop = sorted(pop, key=lambda ind: ind.fitness.values[0])\n                best = sorted_pop[0]\n                \n                # Select two distinct random individuals (not i and not best)\n                candidates = list(range(N_current))\n                candidates.remove(i)\n                # Ensure best index is not in candidates if best is not i\n                best_idx = pop.index(best) if best in pop else -1\n                if best_idx in candidates:\n                    candidates.remove(best_idx)\n                r1, r2 = random.sample(candidates, 2)\n                \n                mutant = creator.Individual([\n                    best[j] + F_i * (pop[r1][j] - pop[r2][j])\n                    for j in range(dim)\n                ])\n\n            # Binomial crossover\n            j_rand = random.randint(0, dim - 1)\n            trial = creator.Individual([\n                mutant[j] if (random.random() < CR_i or j == j_rand) else pop[i][j]\n                for j in range(dim)\n            ])\n\n            # Clip to bounds\n            for j in range(dim):\n                trial[j] = max(lo, min(hi, trial[j]))\n\n            trial.fitness.values = toolbox.evaluate(trial)\n            trial_list.append(trial)\n\n        # Selection and success history update\n        new_pop = []\n        for i in range(N_current):\n            trial = trial_list[i]\n            if trial.fitness.values[0] <= pop[i].fitness.values[0]:\n                # Success: archive old individual\n                if len(archive) < N_current:\n                    archive.append(toolbox.clone(pop[i]))\n                else:\n                    # Random replacement if archive full\n                    archive[random.randint(0, len(archive) - 1)] = toolbox.clone(pop[i])\n                \n                # Record successful F, CR, and strategy\n                if trial.fitness.values[0] < pop[i].fitness.values[0]:\n                    S_F.append(F_list[i])\n                    S_CR.append(CR_list[i])\n                    delta_f.append(pop[i].fitness.values[0] - trial.fitness.values[0])\n                \n                # Update strategy success counts\n                strategy_idx = strategy_list[i]\n                strategy_attempts[strategy_idx] += 1\n                if trial.fitness.values[0] < pop[i].fitness.values[0]:\n                    strategy_success[strategy_idx] += 1\n                \n                new_pop.append(trial)\n            else:\n                new_pop.append(pop[i])\n        \n        pop = new_pop\n        \n        # Update success history M_F and M_CR\n        if S_F:\n            # Weighted average by fitness improvement\n            weights = np.array(delta_f) / sum(delta_f) if sum(delta_f) > 0 else np.ones(len(S_F)) / len(S_F)\n            M_F[k] = np.sum(weights * np.array(S_F))\n            M_CR[k] = np.sum(weights * np.array(S_CR))\n            k = (k + 1) % H\n        \n        # Update strategy selection probabilities\n        total_attempts = sum(strategy_attempts)\n        if total_attempts > 0:\n            for s_idx in range(len(STRATEGIES)):\n                if strategy_attempts[s_idx] > 0:\n                    success_rate = strategy_success[s_idx] / strategy_attempts[s_idx]\n                    # Update probability with learning rate 0.1\n                    strategy_probs[\n... (truncated)"
7}

1{
2  "op": "replace",
3  "filename": "deap/custom_evolution.py",
4  "start_line": 108,
5  "end_line": 395,
6  "content": "def run_evolution(\n    evaluate_func: Callable,\n    dim: int,\n    lo: float,\n    hi: float,\n    pop_size: int,\n    n_generations: int,\n    cx_prob: float,\n    mut_prob: float,\n    seed: int,\n) -> Tuple[list, list]:\n    \"\"\"Multi-Strategy L-SHADE (MS-L-SHADE).\n\n    Features:\n    1. Three mutation strategies with equal probability:\n        - DE/rand/1 (exploration)\n        - DE/current-to-pbest/1 (balanced)\n        - DE/best/1 (exploitation)\n    2. Success-history adaptation of F and CR (L-SHADE)\n    3. Linear population size reduction\n    4. Elitism (keep best individual)\n    5. Restart when stagnation detected\n    \"\"\"\n    random.seed(seed)\n    np.random.seed(seed)\n\n    # --- Hyperparameters ---\n    H = 5  # History size for F and CR\n    N_init = pop_size\n    N_min = max(4, dim)  # Minimum population size\n    p_min = 2.0 / N_init  # Minimum p for pbest\n    p_max = 0.2  # Maximum p for pbest\n    restart_threshold = 100  # Generations without improvement to trigger restart\n    diversity_threshold = 1e-6  # Minimum population diversity\n\n    toolbox = base.Toolbox()\n    toolbox.register(\"individual\", make_individual, toolbox, dim, lo, hi)\n    toolbox.register(\"population\", tools.initRepeat, list, toolbox.individual)\n    toolbox.register(\"evaluate\", evaluate_func)\n\n    # Initialize population\n    pop = toolbox.population(n=N_init)\n    fitnesses = list(map(toolbox.evaluate, pop))\n    for ind, fit in zip(pop, fitnesses):\n        ind.fitness.values = fit\n\n    # Success history for F and CR\n    M_F = [0.5] * H\n    M_CR = [0.5] * H\n    k = 0  # History index\n\n    # External archive of inferior solutions\n    archive = []\n\n    fitness_history = []\n    best_ever = min(pop, key=lambda ind: ind.fitness.values[0])\n    best_fitness = best_ever.fitness.values[0]\n    no_improve_count = 0\n\n    for gen in range(n_generations):\n        N_current = len(pop)\n        \n        # Linear population reduction (L-SHADE style)\n        if N_current > N_min:\n            target_N = int(round(N_init - (N_init - N_min) * (gen / n_generations)))\n            if target_N < N_current:\n                # Remove worst individuals\n                pop.sort(key=lambda ind: ind.fitness.values[0])\n                pop = pop[:target_N]\n                # Also reduce archive size if needed\n                if len(archive) > target_N:\n                    archive = archive[:target_N]\n\n        # Collect successful F and CR values and their fitness improvements\n        S_F = []\n        S_CR = []\n        delta_f = []  # fitness improvement for weighting\n\n        trial_list = []\n        F_list = []\n        CR_list = []\n\n        for i in range(N_current):\n            # Sample F from Cauchy(M_F[r], 0.1), truncate to (0, 1]\n            r = random.randint(0, H - 1)\n            while True:\n                F_i = M_F[r] + 0.1 * np.random.standard_cauchy()\n                if F_i > 0:\n                    break\n            F_i = min(F_i, 1.0)\n\n            # Sample CR from Normal(M_CR[r], 0.1), clamp to [0, 1]\n            CR_i = np.random.normal(M_CR[r], 0.1)\n            CR_i = max(0.0, min(1.0, CR_i))\n\n            F_list.append(F_i)\n            CR_list.append(CR_i)\n\n            # Select mutation strategy with equal probability\n            strategy = random.choice(['rand', 'pbest', 'best'])\n\n            # DE/rand/1 mutation\n            if strategy == 'rand':\n                # Select three distinct random individuals (not i)\n                candidates = list(range(N_current))\n                candidates.remove(i)\n                if len(candidates) < 3:\n                    # Fallback to rand/1 with replacement? Use rand/1 with duplicates\n                    r1 = random.choice(candidates)\n                    r2 = random.choice(candidates)\n                    r3 = random.choice(candidates)\n                else:\n                    r1, r2, r3 = random.sample(candidates, 3)\n                mutant = creator.Individual([\n                    pop[r1][j] + F_i * (pop[r2][j] - pop[r3][j])\n                    for j in range(dim)\n                ])\n\n            # DE/current-to-pbest/1 mutation\n            elif strategy == 'pbest':\n                # Choose p_i uniformly from [p_min, p_max]\n                p_i = random.uniform(p_min, p_max)\n                n_pbest = max(1, int(round(p_i * N_current)))\n                sorted_pop = sorted(pop, key=lambda ind: ind.fitness.values[0])\n                pbest = random.choice(sorted_pop[:n_pbest])\n\n                # Select r1 from pop (r1 != i)\n                candidates = list(range(N_current))\n                candidates.remove(i)\n                r1 = random.choice(candidates)\n\n                # Select r2 from pop + archive (r2 != i and r2 != r1)\n                union = list(range(N_current + len(archive)))\n                union_exclude = {i, r1}\n                union_avail = [x for x in union if x not in union_exclude]\n                if not union_avail:\n                    union_avail = [x for x in union if x != i]\n                r2_idx = random.choice(union_avail)\n                if r2_idx < N_current:\n                    x_r2 = pop[r2_idx]\n                else:\n                    x_r2 = archive[r2_idx - N_current]\n\n                # Mutation: v = x_i + F * (pbest - x_i) + F * (x_r1 - x_r2)\n                mutant = creator.Individual([\n                    pop[i][j] + F_i * (pbest[j] - pop[i][j]) + F_i * (pop[r1][j] - x_r2[j])\n                    for j in range(dim)\n                ])\n\n            # DE/best/1 mutation\n            else:  # strategy == 'best'\n                # Select best individual\n                sorted_pop = sorted(pop, key=lambda ind: ind.fitness.values[0])\n                best = sorted_pop[0]\n                \n                # Select two distinct random individuals (not i and not best)\n                candidates = list(range(N_current))\n                candidates.remove(i)\n                # Ensure best index is not in candidates if best is not i\n                best_idx = pop.index(best) if best in pop else -1\n                if best_idx in candidates:\n                    candidates.remove(best_idx)\n                if len(candidates) < 2:\n                    # Fallback: use any two distinct (allow duplicates?)\n                    r1 = random.choice(candidates) if candidates else i\n                    r2 = random.choice(candidates) if candidates else i\n                else:\n                    r1, r2 = random.sample(candidates, 2)\n                \n                mutant = creator.Individual([\n                    best[j] + F_i * (pop[r1][j] - pop[r2][j])\n                    for j in range(dim)\n                ])\n\n            # Binomial crossover\n            j_rand = random.randint(0, dim - 1)\n            trial = creator.Individual([\n                mutant[j] if (random.random() < CR_i or j == j_rand) else pop[i][j]\n                for j in range(dim)\n            ])\n\n            # Clip to bounds\n            for j in range(dim):\n                trial[j] = max(lo, min(hi, trial[j]))\n\n            trial.fitness.values = toolbox.evaluate(trial)\n            trial_list.append(trial)\n\n        # Selection and success history update\n        new_pop = []\n        for i in range(N_current):\n            trial = trial_list[i]\n            if trial.fitness.values[0] <= pop[i].fitness.values[0]:\n                # Success: archive old individual\n                if len(archive) < N_current:\n                    archive.append(toolbox.clone(pop[i]))\n                else:\n                    # Random replacement if archive full\n                    archive[random.randint(0, len(archive) - 1)] = toolbox.clone(pop[i])\n                \n                # Record successful F and CR\n                if trial.fitness.values[0] < pop[i].fitness.values[0]:\n                    S_F.append(F_list[i])\n                    S_CR.append(CR_list[i])\n                    delta_f.append(pop[i].fitness.values[0] - trial.fitness.values[0])\n                \n                new_pop.append(trial)\n            else:\n                new_pop.append(pop[i])\n        \n        pop = new_pop\n        \n        # Update success history M_F and M_CR\n        if S_F:\n            # Weighted average by fitness improvement\n            weights = np.array(delta_f) / sum(delta_f) if sum(delta_f) > 0 else np.ones(len(S_F)) / len(S_F)\n            M_F[k] = np.sum(weights * np.array(S_F))\n            M_CR[k] = np.sum(weights * np.array(S_CR))\n            k = (k + 1) % H\n        \n        # Track best fitness\n        gen_best = min(pop, key=lambda ind: ind.fitness.values[0])\n        gen_best_fit = gen_best.fitness.values[0]\n        if gen_best_fit < best_fitness:\n            best_fitness = gen_best_fit\n            best_ever = toolbox.clone(gen_best)\n            no_improve_count = 0\n        else:\n            no_improve_count += 1\n        \n        fitness_history.append(best_fitness)\n        \n        # Check for restart\n        if no_improve_count >= restart_threshold:\n            # Calculate population diversity\n            positions = np.array(pop)\n            centroid = np.mean(positions, axis=0)\n            diversity = np.mean(np.linalg.norm(positions - centroid, axis=1))\n            if diversity < diversity_threshold:\n                # Restart: reinitialize 80% of population, keep 20% best\n                pop.sort(key=lambda ind: ind.fitness.values[0])\n                keep_n = max(2, N_current // 5)\n                survivors = pop[:keep_n]\n                new_individuals = toolbox.population(n=N_current - keep_n)\n                fitnesses = list(map(toolbox.evaluate, new_individuals))\n                for ind, fit in zip(new_individuals, fitnesses):\n                    ind.fitness.values = fit\n                pop = survivors + new_individuals\n                # Reset success history\n                M_F = [0.5] * H\n                M_CR = [0.5] * H\n                # Clear archive\n                archive = []\n                no_improve_count = 0\n                print(f\"RESTART at generation {gen+1}\", flush=True)\n... (truncated)"
7}

1{
2  "op": "replace",
3  "filename": "deap/custom_evolution.py",
4  "start_line": 190,
5  "end_line": 294,
6  "content": "          for i in range(N_current):\n              try:\n                  # Sample F from Cauchy(M_F[r], 0.1), truncate to (0, 1]\n                  r = random.randint(0, H - 1)\n                  while True:\n                      F_i = M_F[r] + 0.1 * np.random.standard_cauchy()\n                      if F_i > 0:\n                          break\n                  F_i = min(F_i, 1.0)\n\n                  # Sample CR from Normal(M_CR[r], 0.1), clamp to [0, 1]\n                  CR_i = np.random.normal(M_CR[r], 0.1)\n                  CR_i = max(0.0, min(1.0, CR_i))\n\n                  F_list.append(F_i)\n                  CR_list.append(CR_i)\n\n                  # Select mutation strategy with equal probability\n                  strategy = random.choice(['rand', 'pbest', 'best'])\n\n                  # DE/rand/1 mutation\n                  if strategy == 'rand':\n                      # Select three distinct random individuals (not i)\n                      candidates = list(range(N_current))\n                      candidates.remove(i)\n                      if len(candidates) < 3:\n                          # Fallback to rand/1 with replacement? Use rand/1 with duplicates\n                          r1 = random.choice(candidates)\n                          r2 = random.choice(candidates)\n                          r3 = random.choice(candidates)\n                      else:\n                          r1, r2, r3 = random.sample(candidates, 3)\n                      mutant = creator.Individual([\n                          pop[r1][j] + F_i * (pop[r2][j] - pop[r3][j])\n                          for j in range(dim)\n                      ])\n\n                  # DE/current-to-pbest/1 mutation\n                  elif strategy == 'pbest':\n                      # Choose p_i uniformly from [p_min, p_max]\n                      p_i = random.uniform(p_min, p_max)\n                      n_pbest = max(1, int(round(p_i * N_current)))\n                      sorted_pop = sorted(pop, key=lambda ind: ind.fitness.values[0])\n                      pbest = random.choice(sorted_pop[:n_pbest])\n\n                      # Select r1 from pop (r1 != i)\n                      candidates = list(range(N_current))\n                      candidates.remove(i)\n                      r1 = random.choice(candidates)\n\n                      # Select r2 from pop + archive (r2 != i and r2 != r1)\n                      union = list(range(N_current + len(archive)))\n                      union_exclude = {i, r1}\n                      union_avail = [x for x in union if x not in union_exclude]\n                      if not union_avail:\n                          union_avail = [x for x in union if x != i]\n                      r2_idx = random.choice(union_avail)\n                      if r2_idx < N_current:\n                          x_r2 = pop[r2_idx]\n                      else:\n                          x_r2 = archive[r2_idx - N_current]\n\n                      # Mutation: v = x_i + F * (pbest - x_i) + F * (x_r1 - x_r2)\n                      mutant = creator.Individual([\n                          pop[i][j] + F_i * (pbest[j] - pop[i][j]) + F_i * (pop[r1][j] - x_r2[j])\n                          for j in range(dim)\n                      ])\n\n                  # DE/best/1 mutation\n                  else:  # strategy == 'best'\n                      # Select best individual\n                      sorted_pop = sorted(pop, key=lambda ind: ind.fitness.values[0])\n                      best = sorted_pop[0]\n                      \n                      # Select two distinct random individuals (not i and not best)\n                      candidates = list(range(N_current))\n                      candidates.remove(i)\n                      # Ensure best index is not in candidates if best is not i\n                      best_idx = pop.index(best) if best in pop else -1\n                      if best_idx in candidates:\n                          candidates.remove(best_idx)\n                      if len(candidates) < 2:\n                          # Fallback: use any two distinct (allow duplicates?)\n                          r1 = random.choice(candidates) if candidates else i\n                          r2 = random.choice(candidates) if candidates else i\n                      else:\n                          r1, r2 = random.sample(candidates, 2)\n                      \n                      mutant = creator.Individual([\n                          best[j] + F_i * (pop[r1][j] - pop[r2][j])\n                          for j in range(dim)\n                      ])\n\n                  # Binomial crossover\n                  j_rand = random.randint(0, dim - 1)\n                  trial = creator.Individual([\n                      mutant[j] if (random.random() < CR_i or j == j_rand) else pop[i][j]\n                      for j in range(dim)\n                  ])\n\n                  # Clip to bounds\n                  for j in range(dim):\n                      trial[j] = max(lo, min(hi, trial[j]))\n\n                  trial.fitness.values = toolbox.evaluate(trial)\n                  trial_list.append(trial)\n              except Exception as e:\n                  # If any error occurs, keep the original individual\n                  trial_list.append(pop[i])"
7}

1{
2  "op": "replace",
3  "filename": "deap/custom_evolution.py",
4  "start_line": 87,
5  "end_line": 225,
6  "content": "def custom_select(population: list, k: int, toolbox=None) -> list:\n    \"\"\"Select k individuals from the population using crowding distance tournament.\n\n    Maintains diversity by preferring individuals in less crowded regions of the fitness landscape.\n    \n    Args:\n        population: List of individuals (each has a .fitness.values attribute).\n        k: Number of individuals to select.\n        toolbox: The DEAP toolbox (optional, for access to other operators).\n\n    Returns:\n        List of k selected individuals (deep copies recommended).\n    \"\"\"\n    import math\n    \n    # Compute crowding distances\n    n = len(population)\n    if n == 0:\n        return []\n    \n    # Initialize crowding distances to zero\n    for ind in population:\n        ind.crowding_distance = 0.0\n    \n    # For each objective dimension (single objective here)\n    # Sort by fitness\n    sorted_pop = sorted(population, key=lambda ind: ind.fitness.values[0])\n    \n    # Boundary individuals get infinite distance\n    sorted_pop[0].crowding_distance = float('inf')\n    sorted_pop[-1].crowding_distance = float('inf')\n    \n    # For interior points, compute distance based on neighbors\n    if n > 2:\n        fitness_range = sorted_pop[-1].fitness.values[0] - sorted_pop[0].fitness.values[0]\n        if fitness_range > 1e-12:\n            for i in range(1, n-1):\n                sorted_pop[i].crowding_distance = (\n                    sorted_pop[i+1].fitness.values[0] - sorted_pop[i-1].fitness.values[0]\n                ) / fitness_range\n        else:\n            # All fitnesses equal, assign uniform distance\n            for i in range(1, n-1):\n                sorted_pop[i].crowding_distance = 1.0\n    \n    # Tournament selection using crowding distance\n    selected = []\n    for _ in range(k):\n        # Randomly pick tournament size 4\n        tournament = random.sample(population, min(4, len(population)))\n        # Winner is the one with highest crowding distance (most diverse)\n        winner = max(tournament, key=lambda ind: ind.crowding_distance)\n        selected.append(winner)\n    \n    return selected\n\n\ndef custom_crossover(ind1: list, ind2: list) -> Tuple[list, list]:\n    \"\"\"Apply hybrid crossover: SBX for exploitation, DE-like for exploration.\n\n    Randomly chooses between SBX and DE/rand/1 crossover based on a probability.\n    \n    Args:\n        ind1, ind2: Parent individuals (lists of floats).\n\n    Returns:\n        Tuple of two offspring individuals (modified in-place).\n    \"\"\"\n    # Use DE-like crossover with probability 0.3 for exploration\n    if random.random() < 0.3:\n        # DE/rand/1 style: ind1 + F*(ind2 - ind1) where F=0.5\n        # Actually for two parents, create a differential vector\n        F = 0.5\n        dim = len(ind1)\n        # Create trial vector: parent1 + F*(parent2 - parent1)\n        trial = [ind1[i] + F * (ind2[i] - ind1[i]) for i in range(dim)]\n        # Create second trial: parent2 + F*(parent1 - parent2)\n        trial2 = [ind2[i] + F * (ind1[i] - ind2[i]) for i in range(dim)]\n        # Replace parents with trials\n        for i in range(dim):\n            ind1[i] = trial[i]\n            ind2[i] = trial2[i]\n    else:\n        # Default: simulated binary crossover (SBX), eta=20 for exploitation\n        tools.cxSimulatedBinary(ind1, ind2, eta=20.0)\n    \n    return ind1, ind2\n\n\ndef custom_mutate(individual: list, lo: float, hi: float) -> Tuple[list]:\n    \"\"\"Apply adaptive mutation based on population diversity.\n\n    Mutation rate adapts: higher when population converges, lower when diverse.\n    Uses Gaussian mutation with adaptive sigma.\n    \n    Args:\n        individual: The individual to mutate (list of floats).\n        lo: Lower bound for genes.\n        hi: Upper bound for genes.\n\n    Returns:\n        Tuple containing the mutated individual.\n    \"\"\"\n    dim = len(individual)\n    \n    # Adaptive mutation probability: base 0.2, can increase up to 0.5\n    # This will be controlled in run_evolution via mut_prob parameter\n    \n    # Use polynomial mutation with adaptive eta based on generation\n    # Not directly available, so we implement Gaussian mutation with adaptive sigma\n    sigma = (hi - lo) * 0.1  # Initial sigma as 10% of domain width\n    \n    for i in range(dim):\n        if random.random() < 1.0/dim:  # per-gene mutation probability\n            # Gaussian mutation with clipping\n            new_val = individual[i] + random.gauss(0, sigma)\n            individual[i] = max(lo, min(hi, new_val))\n    \n    return (individual,)\n\n\ndef run_evolution(\n    evaluate_func: Callable,\n    dim: int,\n    lo: float,\n    hi: float,\n    pop_size: int,\n    n_generations: int,\n    cx_prob: float,\n    mut_prob: float,\n    seed: int,\n) -> Tuple[list, list]:\n    \"\"\"Run Hybrid Adaptive Evolutionary Strategy (HAES).\n\n    Features:\n    1. Elitism: preserve best solutions\n    2. Adaptive mutation based on population diversity\n    3. Multiple crossover operators (SBX + DE-like)\n    4. Restart mechanism when diversity drops too low\n    5. Crowding distance selection for diversity maintenance\n    \n    Args:\n        evaluate_func: Fitness function mapping individual -> (fitness_value,).\n        dim: Dimensionality of the search space.\n        lo: Lower bound for each dimension.\n        hi: Upper bound for each dimension.\n        pop_size: Population size.\n        n_generations: Number of generations.\n        cx_prob: Crossover probability.\n        mut_prob: Mutation probability.\n        seed: Random seed.\n\n    Returns:\n        best_individual: The best individual found.\n        fitness_history: List of best fitness per generation.\n    \"\"\"\n    random.seed(seed)\n    np.random.seed(seed)\n\n    # Setup toolbox\n    toolbox = base.Toolbox()\n    toolbox.register(\"individual\", make_individual, toolbox, dim, lo, hi)\n    toolbox.register(\"population\", tools.initRepeat, list, toolbox.individual)\n    toolbox.register(\"evaluate\", evaluate_func)\n\n    # Initialize population\n    pop = toolbox.population(n=pop_size)\n    fitnesses = list(map(toolbox.evaluate, pop))\n    for ind, fit in zip(pop, fitnesses):\n        ind.fitness.values = fit\n\n    # Archive for elitism\n    archive_size = max(10, pop_size // 10)\n    archive = []\n    \n    # For adaptive mutation\n    base_mut_prob = mut_prob\n    min_diversity_threshold = 1e-6\n    \n    fitness_history = []\n    best_ever = None\n    best_ever_fit = float('inf')\n\n    for gen in range(n_generations):\n        # Compute population diversity\n        if len(pop) > 1:\n            # Diversity measure: average pairwise Euclidean distance\n            diversity = 0.0\n            count = 0\n            for i in range(len(pop)):\n                for j in range(i+1, len(pop)):\n                    dist = math.sqrt(sum((pop[i][k] - pop[j][k])**2 for k in range(dim)))\n                    diversity += dist\n                    count += 1\n            if count > 0:\n                diversity /= count\n        else:\n            diversity = 0.0\n        \n        # Adaptive mutation: increase if diversity is low\n        if diversity < min_diversity_threshold and gen > 0:\n            # Population converged, increase mutation\n            adaptive_mut_prob = min(base_mut_prob * 2.0, 0.5)\n        else:\n            adaptive_mut_prob = base_mut_prob\n        \n        # Restart mechanism if diversity is extremely low (population converged)\n        if diversity < min_diversity_threshold and gen > 0 and gen % 100 == 0:\n            # Keep only the best 10% and regenerate the rest\n            pop.sort(key=lambda ind: ind.fitness.values[0])\n            keep = max(2, pop_size // 10)\n            new_pop = pop[:keep]\n            # Generate new random individuals\n            while len(new_pop) < pop_size:\n                ind = make_individual(toolbox, dim, lo, hi)\n                ind.fitness.values = toolbox.evaluate(ind)\n                new_pop.append(ind)\n            pop = new_pop\n            print(f\"RESTART at generation {gen+1} due to low diversity\")\n        \n        # Update archive with best individuals\n        all_individuals = pop + archive\n        all_individuals.sort(key=lambda ind: ind.fitness.values[0])\n        archive = all_individuals[:archive_size]\n        \n        # Selection with crowding distance\n        offspring = custom_select(pop, len(pop), toolbox)\n        offspring = [toolbox.clone(ind) for ind in offspring]\n        \n        # Add some elite individuals from archive (10%)\n        n_elite = max(1, len(offspring) // 10)\n        elite = archive[:n_elite]\n        for elite_ind in elite:\n            # Replace random offspring with elite\n            if len(offspring) > 0:\n                idx = random.randint(0, len(offspring)-1)\n                offspring[idx] = toolbox.clone(elite_ind)\n\n        # Crossover\n        for i in range(0, len(offspring) - 1, 2):\n            if random.random() < cx_prob:\n                custom_crossover(offspring[i], offspring[i + 1])\n                del offspring[i].fitness.values\n                del offspring[i + 1].fitness.values\n\n        # Mutation with adaptive probability\n        for i in range(len(offspring)):\n            if random.random() < adaptive_mut_prob:\n                # Use polynomial mutation with bounds\n                tools.mutPolynomialBounded(\n                    offspring[i], eta=20.0, low=lo, up=hi,\n                    indpb=1.0 / dim  # Per-gene mutation probability\n                )\n                del offspring[i].fitness.values\n\n        # Clip to bounds\n        for ind in offspring:\n            clip_individual(ind, lo, hi)\n\n        # Evaluate individuals with invalid fitness\n        invalid_ind = [ind for ind in offspring if not ind.fitness.valid]\n        fitnesses = list(map(toolbox.evaluate, invalid_ind))\n        for ind, fit in zip(invalid_ind, fitnesses):\n            ind.fitness.values = fit\n\n        # Replace population\n        pop[:] = offspring\n        \n        # Track best ever\n        gen_best = min(pop, key=lambda ind: ind.fitness.values[0])\n        gen_best_fit = gen_best.fitness.values[0]\n        if ge\n... (truncated)"
7}