Skip to content

Instantly share code, notes, and snippets.

@XMPPwocky

XMPPwocky/variant_demo.ipynb

Last active August 9, 2021 22:01
Show Gist options
  • Save XMPPwocky/28b77297371b12581c341281bfcfeed2 to your computer and use it in GitHub Desktop.
Save XMPPwocky/28b77297371b12581c341281bfcfeed2 to your computer and use it in GitHub Desktop.
Download ZIP
Display the source blob
Display the rendered blob
Raw
variant_demo.ipynb
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Some setup first..."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"# ye olde imports\n",
"import math, random\n",
"from statistics import mean, geometric_mean"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Imagine a virus which is, somehow, a single protein with only 3 \"amino acids\" (actually just uppercase letters here, oh well)\n",
"\n",
"Currently, only one type is circulating, which is \"XYZ\"."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"EXISTING_TYPE = \"XYZ\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"But there's a possible variant, the Super Nasty Variant, \"BAD\", which escapes antibodies and is hard to even create good antibodies against (meaning even a vaccine targeted specifically at it has trouble):"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"SUPER_NASTY_TYPE = \"BAD\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we'll run a comically oversimplified simulation of evolution: starting from a population of 100 copies of the existing virus (XYZ)..."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"POPULATION_SIZE = 100\n",
"\n",
"def make_starting_population(): return [EXISTING_TYPE] * POPULATION_SIZE"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Each generation, every virus makes a copy of itself (to form a population twice as big), possibly mutating in the process.\n",
"\n",
"Then, each virus may die (in this case, be neutralized by antibodies or whatever); the odds of survival each generation is the virus's fitness.\n",
"\n",
"Note that the steady-state here happens for viruses with fitness of 0.5 (they make a copy of themselves each generation, but on average the original or the copy dies). "
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"def evolve(starting_population, fitness):\n",
" population = starting_population\n",
"\n",
" new_population = [virus for virus in population] \n",
" \n",
" \n",
" # each virus makes a copy of itself, maybe mutating...\n",
" for virus in population:\n",
" new_population.append(maybe_mutate(virus))\n",
"\n",
" # but then some maybe die, based on their fitness:\n",
" population = []\n",
" \n",
" for virus in new_population:\n",
" if fitness(virus) > random.random():\n",
" # virus survived\n",
" population.append(virus)\n",
" \n",
" if not population:\n",
" population = [EXISTING_TYPE] # goofy hack so that the virus never completely dies out\n",
"\n",
" return population"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"MAX_GENERATIONS = 5000 # timeout to keep things sensible\n",
"def run_experiment(fitness_fn, quiet=True):\n",
" population = make_starting_population()\n",
"\n",
" if not quiet: print(\"Generation\\tPop. size\\tAvg. fitness\\tMax. fitness\")\n",
" for generation in range(MAX_GENERATIONS):\n",
" if generation % 100 == 0:\n",
" fitnesses = [fitness_fn(virus) for virus in population]\n",
" avg_fitness = geometric_mean(fitnesses)\n",
" max_fitness = max(fitnesses)\n",
" if not quiet: print(\"{:5}\\t\\t{:8}\\t{:5.4f}\\t\\t{:5.4f}\".format(generation, len(population), avg_fitness, max_fitness))\n",
"\n",
" population = evolve(population, fitness_fn)\n",
" if SUPER_NASTY_TYPE in population:\n",
" if not quiet: print(\"Super Nasty Variant evolved in {} generations!\".format(generation))\n",
" return generation\n",
" \n",
" return MAX_GENERATIONS # didn't evolve at all, time ran out\n",
"\n",
"def run_many_experiments(fitness_fn, num_experiments):\n",
" results = []\n",
" for experiment in range(num_experiments):\n",
" generations_to_nasty = run_experiment(fitness_fn, quiet=True)\n",
" results.append(generations_to_nasty)\n",
" if generations_to_nasty != MAX_GENERATIONS:\n",
" print(\"Experiment #{}: Super Nasty Variant evolved in {} generations\".format(experiment, generations_to_nasty))\n",
" else:\n",
" print(\"Experiment #{}: Super Nasty Variant never evolved\".format(experiment))\n",
" print(\"On average, the variant showed up at generation {}\".format(mean(filter(lambda r: r is not None, results))))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In this model, \"mutations\" are just random amino acid substitutions:"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"ERROR_RATE = 1e-3 # 1/1000 chance per amino acid to replace it with a random one\n",
"\n",
"def random_letter():\n",
" return chr(ord(\"A\")+random.randint(0, 26))\n",
"\n",
"def maybe_mutate(virus):\n",
" # random substitutions\n",
" newvirus = virus\n",
" \n",
" for i in range(len(newvirus)):\n",
" if random.random() < ERROR_RATE:\n",
" # mutate this position\n",
" newvirus = newvirus[:i] + random_letter() + newvirus[i+1:]\n",
" return newvirus"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If each of the individual 3 substitutions (X->B, Y->A, Z->D) required to get from the existing type to the Super Nasty Type confers a small advantage on its own..."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"SINGLE_SUBSTITUTION_FITNESS_GAIN = 1.05 # 5% advantage per substitution\n",
"\n",
"BASE_FITNESS = 0.50001 # just a biiit above steady state...\n",
"\n",
"def fitness_normal(virus):\n",
" num_mutations = 0\n",
" if virus[0] == \"B\": num_mutations += 1\n",
" if virus[1] == \"A\": num_mutations += 1\n",
" if virus[2] == \"D\": num_mutations += 1\n",
"\n",
" return BASE_FITNESS * pow(SINGLE_SUBSTITUTION_FITNESS_GAIN, num_mutations)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"then within a few thousand generations, the Super Nasty Variant usually shows up:"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Experiment #0: Super Nasty Variant evolved in 1241 generations\n",
"Experiment #1: Super Nasty Variant evolved in 442 generations\n",
"Experiment #2: Super Nasty Variant evolved in 2245 generations\n",
"Experiment #3: Super Nasty Variant evolved in 432 generations\n",
"Experiment #4: Super Nasty Variant evolved in 324 generations\n",
"Experiment #5: Super Nasty Variant evolved in 2128 generations\n",
"Experiment #6: Super Nasty Variant never evolved\n",
"Experiment #7: Super Nasty Variant never evolved\n",
"Experiment #8: Super Nasty Variant evolved in 437 generations\n",
"Experiment #9: Super Nasty Variant evolved in 435 generations\n",
"Experiment #10: Super Nasty Variant evolved in 2282 generations\n",
"Experiment #11: Super Nasty Variant evolved in 1179 generations\n",
"Experiment #12: Super Nasty Variant evolved in 2802 generations\n",
"Experiment #13: Super Nasty Variant never evolved\n",
"Experiment #14: Super Nasty Variant evolved in 1586 generations\n",
"Experiment #15: Super Nasty Variant evolved in 180 generations\n",
"Experiment #16: Super Nasty Variant evolved in 1589 generations\n",
"Experiment #17: Super Nasty Variant evolved in 447 generations\n",
"Experiment #18: Super Nasty Variant evolved in 1154 generations\n",
"Experiment #19: Super Nasty Variant evolved in 2522 generations\n",
"Experiment #20: Super Nasty Variant evolved in 2864 generations\n",
"Experiment #21: Super Nasty Variant evolved in 479 generations\n",
"Experiment #22: Super Nasty Variant evolved in 2289 generations\n",
"Experiment #23: Super Nasty Variant evolved in 3444 generations\n",
"Experiment #24: Super Nasty Variant evolved in 1355 generations\n",
"Experiment #25: Super Nasty Variant evolved in 270 generations\n",
"Experiment #26: Super Nasty Variant evolved in 766 generations\n",
"Experiment #27: Super Nasty Variant evolved in 2741 generations\n",
"Experiment #28: Super Nasty Variant evolved in 548 generations\n",
"Experiment #29: Super Nasty Variant evolved in 1571 generations\n",
"Experiment #30: Super Nasty Variant evolved in 607 generations\n",
"Experiment #31: Super Nasty Variant evolved in 2030 generations\n",
"Experiment #32: Super Nasty Variant evolved in 1845 generations\n",
"Experiment #33: Super Nasty Variant evolved in 820 generations\n",
"Experiment #34: Super Nasty Variant evolved in 264 generations\n",
"Experiment #35: Super Nasty Variant evolved in 1435 generations\n",
"Experiment #36: Super Nasty Variant never evolved\n",
"Experiment #37: Super Nasty Variant evolved in 4584 generations\n",
"Experiment #38: Super Nasty Variant evolved in 960 generations\n",
"Experiment #39: Super Nasty Variant evolved in 878 generations\n",
"Experiment #40: Super Nasty Variant evolved in 306 generations\n",
"Experiment #41: Super Nasty Variant evolved in 988 generations\n",
"Experiment #42: Super Nasty Variant evolved in 352 generations\n",
"Experiment #43: Super Nasty Variant evolved in 486 generations\n",
"Experiment #44: Super Nasty Variant evolved in 892 generations\n",
"Experiment #45: Super Nasty Variant evolved in 658 generations\n",
"Experiment #46: Super Nasty Variant evolved in 4847 generations\n",
"Experiment #47: Super Nasty Variant evolved in 4615 generations\n",
"Experiment #48: Super Nasty Variant never evolved\n",
"Experiment #49: Super Nasty Variant evolved in 2146 generations\n",
"On average, the variant showed up at generation 1829.3\n"
]
}
],
"source": [
"run_many_experiments(fitness_normal, num_experiments=50)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"But if at least 2 mutations must occur together to get a fitness gain..."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"def fitness_new(virus):\n",
" num_mutations = 0\n",
" if virus[0] == \"B\": num_mutations += 1\n",
" if virus[1] == \"A\": num_mutations += 1\n",
" if virus[2] == \"D\": num_mutations += 1\n",
"\n",
" # now, without at least 2 mutations, it's no better than no mutations:\n",
" if num_mutations < 2: num_mutations = 0\n",
" \n",
" return BASE_FITNESS * pow(SINGLE_SUBSTITUTION_FITNESS_GAIN, num_mutations)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"... it's much rarer (and slower) for the variant to evolve in the first place, even though it's just as bad when it does show up."
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Experiment #0: Super Nasty Variant never evolved\n",
"Experiment #1: Super Nasty Variant evolved in 4135 generations\n",
"Experiment #2: Super Nasty Variant never evolved\n",
"Experiment #3: Super Nasty Variant never evolved\n",
"Experiment #4: Super Nasty Variant never evolved\n",
"Experiment #5: Super Nasty Variant never evolved\n",
"Experiment #6: Super Nasty Variant never evolved\n",
"Experiment #7: Super Nasty Variant evolved in 1162 generations\n",
"Experiment #8: Super Nasty Variant never evolved\n",
"Experiment #9: Super Nasty Variant never evolved\n",
"Experiment #10: Super Nasty Variant never evolved\n",
"Experiment #11: Super Nasty Variant never evolved\n",
"Experiment #12: Super Nasty Variant never evolved\n",
"Experiment #13: Super Nasty Variant never evolved\n",
"Experiment #14: Super Nasty Variant never evolved\n",
"Experiment #15: Super Nasty Variant evolved in 2569 generations\n",
"Experiment #16: Super Nasty Variant never evolved\n",
"Experiment #17: Super Nasty Variant evolved in 2209 generations\n",
"Experiment #18: Super Nasty Variant never evolved\n",
"Experiment #19: Super Nasty Variant evolved in 4961 generations\n",
"Experiment #20: Super Nasty Variant never evolved\n",
"Experiment #21: Super Nasty Variant never evolved\n",
"Experiment #22: Super Nasty Variant evolved in 4375 generations\n",
"Experiment #23: Super Nasty Variant never evolved\n",
"Experiment #24: Super Nasty Variant never evolved\n",
"Experiment #25: Super Nasty Variant evolved in 1390 generations\n",
"Experiment #26: Super Nasty Variant never evolved\n",
"Experiment #27: Super Nasty Variant never evolved\n",
"Experiment #28: Super Nasty Variant never evolved\n",
"Experiment #29: Super Nasty Variant never evolved\n",
"Experiment #30: Super Nasty Variant never evolved\n",
"Experiment #31: Super Nasty Variant evolved in 1398 generations\n",
"Experiment #32: Super Nasty Variant never evolved\n",
"Experiment #33: Super Nasty Variant never evolved\n",
"Experiment #34: Super Nasty Variant evolved in 2539 generations\n",
"Experiment #35: Super Nasty Variant never evolved\n",
"Experiment #36: Super Nasty Variant never evolved\n",
"Experiment #37: Super Nasty Variant never evolved\n",
"Experiment #38: Super Nasty Variant never evolved\n",
"Experiment #39: Super Nasty Variant never evolved\n",
"Experiment #40: Super Nasty Variant evolved in 2509 generations\n",
"Experiment #41: Super Nasty Variant never evolved\n",
"Experiment #42: Super Nasty Variant evolved in 4194 generations\n",
"Experiment #43: Super Nasty Variant never evolved\n",
"Experiment #44: Super Nasty Variant never evolved\n",
"Experiment #45: Super Nasty Variant never evolved\n",
"Experiment #46: Super Nasty Variant never evolved\n",
"Experiment #47: Super Nasty Variant never evolved\n",
"Experiment #48: Super Nasty Variant never evolved\n",
"Experiment #49: Super Nasty Variant never evolved\n",
"On average, the variant showed up at generation 4528.82\n"
]
}
],
"source": [
"run_many_experiments(fitness_new, num_experiments=50)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.1"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
Raw
variant_demo.md

Some setup first...

# ye olde imports
import math, random
from statistics import mean, geometric_mean

Imagine a virus which is, somehow, a single protein with only 3 "amino acids" (actually just uppercase letters here, oh well)

Currently, only one type is circulating, which is "XYZ".

EXISTING_TYPE = "XYZ"

But there's a possible variant, the Super Nasty Variant, "BAD", which escapes antibodies and is hard to even create good antibodies against (meaning even a vaccine targeted specifically at it has trouble):

SUPER_NASTY_TYPE = "BAD"

Now we'll run a comically oversimplified simulation of evolution: starting from a population of 100 copies of the existing virus (XYZ)...

POPULATION_SIZE = 100

def make_starting_population(): return [EXISTING_TYPE] * POPULATION_SIZE

Each generation, every virus makes a copy of itself (to form a population twice as big), possibly mutating in the process.

Then, each virus may die (in this case, be neutralized by antibodies or whatever); the odds of survival each generation is the virus's fitness.

Note that the steady-state here happens for viruses with fitness of 0.5 (they make a copy of themselves each generation, but on average the original or the copy dies).

def evolve(starting_population, fitness):
    population = starting_population

    new_population = [virus for virus in population] 
    
    
    # each virus makes a copy of itself, maybe mutating...
    for virus in population:
        new_population.append(maybe_mutate(virus))

    # but then some maybe die, based on their fitness:
    population = []
    
    for virus in new_population:
        if fitness(virus) > random.random():
            # virus survived
            population.append(virus)
            
    if not population:
        population = [EXISTING_TYPE] # goofy hack so that the virus never completely dies out

    return population
MAX_GENERATIONS = 5000 # timeout to keep things sensible
def run_experiment(fitness_fn, quiet=True):
    population = make_starting_population()

    if not quiet: print("Generation\tPop. size\tAvg. fitness\tMax. fitness")
    for generation in range(MAX_GENERATIONS):
        if generation % 100 == 0:
            fitnesses = [fitness_fn(virus) for virus in population]
            avg_fitness = geometric_mean(fitnesses)
            max_fitness = max(fitnesses)
            if not quiet: print("{:5}\t\t{:8}\t{:5.4f}\t\t{:5.4f}".format(generation, len(population), avg_fitness, max_fitness))

        population = evolve(population, fitness_fn)
        if SUPER_NASTY_TYPE in population:
            if not quiet: print("Super Nasty Variant evolved in {} generations!".format(generation))
            return generation
        
    return MAX_GENERATIONS # didn't evolve at all, time ran out

def run_many_experiments(fitness_fn, num_experiments):
    results = []
    for experiment in range(num_experiments):
        generations_to_nasty = run_experiment(fitness_fn, quiet=True)
        results.append(generations_to_nasty)
        if generations_to_nasty != MAX_GENERATIONS:
            print("Experiment #{}: Super Nasty Variant evolved in {} generations".format(experiment, generations_to_nasty))
        else:
            print("Experiment #{}: Super Nasty Variant never evolved".format(experiment))
    print("On average, the variant showed up at generation {}".format(mean(filter(lambda r: r is not None, results))))

In this model, "mutations" are just random amino acid substitutions:

ERROR_RATE = 1e-3 # 1/1000 chance per amino acid to replace it with a random one

def random_letter():
    return chr(ord("A")+random.randint(0, 26))

def maybe_mutate(virus):
    # random substitutions
    newvirus = virus
    
    for i in range(len(newvirus)):
        if random.random() < ERROR_RATE:
            # mutate this position
            newvirus = newvirus[:i] + random_letter() + newvirus[i+1:]
    return newvirus

If each of the individual 3 substitutions (X->B, Y->A, Z->D) required to get from the existing type to the Super Nasty Type confers a small advantage on its own...

SINGLE_SUBSTITUTION_FITNESS_GAIN = 1.05 # 5% advantage per substitution

BASE_FITNESS = 0.50001 # just a biiit above steady state...

def fitness_normal(virus):
    num_mutations = 0
    if virus[0] == "B": num_mutations += 1
    if virus[1] == "A": num_mutations += 1
    if virus[2] == "D": num_mutations += 1

    return BASE_FITNESS * pow(SINGLE_SUBSTITUTION_FITNESS_GAIN, num_mutations)

then within a few thousand generations, the Super Nasty Variant usually shows up:

run_many_experiments(fitness_normal, num_experiments=50)
Experiment #0: Super Nasty Variant evolved in 1241 generations
Experiment #1: Super Nasty Variant evolved in 442 generations
Experiment #2: Super Nasty Variant evolved in 2245 generations
Experiment #3: Super Nasty Variant evolved in 432 generations
Experiment #4: Super Nasty Variant evolved in 324 generations
Experiment #5: Super Nasty Variant evolved in 2128 generations
Experiment #6: Super Nasty Variant never evolved
Experiment #7: Super Nasty Variant never evolved
Experiment #8: Super Nasty Variant evolved in 437 generations
Experiment #9: Super Nasty Variant evolved in 435 generations
Experiment #10: Super Nasty Variant evolved in 2282 generations
Experiment #11: Super Nasty Variant evolved in 1179 generations
Experiment #12: Super Nasty Variant evolved in 2802 generations
Experiment #13: Super Nasty Variant never evolved
Experiment #14: Super Nasty Variant evolved in 1586 generations
Experiment #15: Super Nasty Variant evolved in 180 generations
Experiment #16: Super Nasty Variant evolved in 1589 generations
Experiment #17: Super Nasty Variant evolved in 447 generations
Experiment #18: Super Nasty Variant evolved in 1154 generations
Experiment #19: Super Nasty Variant evolved in 2522 generations
Experiment #20: Super Nasty Variant evolved in 2864 generations
Experiment #21: Super Nasty Variant evolved in 479 generations
Experiment #22: Super Nasty Variant evolved in 2289 generations
Experiment #23: Super Nasty Variant evolved in 3444 generations
Experiment #24: Super Nasty Variant evolved in 1355 generations
Experiment #25: Super Nasty Variant evolved in 270 generations
Experiment #26: Super Nasty Variant evolved in 766 generations
Experiment #27: Super Nasty Variant evolved in 2741 generations
Experiment #28: Super Nasty Variant evolved in 548 generations
Experiment #29: Super Nasty Variant evolved in 1571 generations
Experiment #30: Super Nasty Variant evolved in 607 generations
Experiment #31: Super Nasty Variant evolved in 2030 generations
Experiment #32: Super Nasty Variant evolved in 1845 generations
Experiment #33: Super Nasty Variant evolved in 820 generations
Experiment #34: Super Nasty Variant evolved in 264 generations
Experiment #35: Super Nasty Variant evolved in 1435 generations
Experiment #36: Super Nasty Variant never evolved
Experiment #37: Super Nasty Variant evolved in 4584 generations
Experiment #38: Super Nasty Variant evolved in 960 generations
Experiment #39: Super Nasty Variant evolved in 878 generations
Experiment #40: Super Nasty Variant evolved in 306 generations
Experiment #41: Super Nasty Variant evolved in 988 generations
Experiment #42: Super Nasty Variant evolved in 352 generations
Experiment #43: Super Nasty Variant evolved in 486 generations
Experiment #44: Super Nasty Variant evolved in 892 generations
Experiment #45: Super Nasty Variant evolved in 658 generations
Experiment #46: Super Nasty Variant evolved in 4847 generations
Experiment #47: Super Nasty Variant evolved in 4615 generations
Experiment #48: Super Nasty Variant never evolved
Experiment #49: Super Nasty Variant evolved in 2146 generations
On average, the variant showed up at generation 1829.3

But if at least 2 mutations must occur together to get a fitness gain...

def fitness_new(virus):
    num_mutations = 0
    if virus[0] == "B": num_mutations += 1
    if virus[1] == "A": num_mutations += 1
    if virus[2] == "D": num_mutations += 1

    # now, without at least 2 mutations, it's no better than no mutations:
    if num_mutations < 2: num_mutations = 0
        
    return BASE_FITNESS * pow(SINGLE_SUBSTITUTION_FITNESS_GAIN, num_mutations)

... it's much rarer (and slower) for the variant to evolve in the first place, even though it's just as bad when it does show up.

run_many_experiments(fitness_new, num_experiments=50)
Experiment #0: Super Nasty Variant never evolved
Experiment #1: Super Nasty Variant evolved in 4135 generations
Experiment #2: Super Nasty Variant never evolved
Experiment #3: Super Nasty Variant never evolved
Experiment #4: Super Nasty Variant never evolved
Experiment #5: Super Nasty Variant never evolved
Experiment #6: Super Nasty Variant never evolved
Experiment #7: Super Nasty Variant evolved in 1162 generations
Experiment #8: Super Nasty Variant never evolved
Experiment #9: Super Nasty Variant never evolved
Experiment #10: Super Nasty Variant never evolved
Experiment #11: Super Nasty Variant never evolved
Experiment #12: Super Nasty Variant never evolved
Experiment #13: Super Nasty Variant never evolved
Experiment #14: Super Nasty Variant never evolved
Experiment #15: Super Nasty Variant evolved in 2569 generations
Experiment #16: Super Nasty Variant never evolved
Experiment #17: Super Nasty Variant evolved in 2209 generations
Experiment #18: Super Nasty Variant never evolved
Experiment #19: Super Nasty Variant evolved in 4961 generations
Experiment #20: Super Nasty Variant never evolved
Experiment #21: Super Nasty Variant never evolved
Experiment #22: Super Nasty Variant evolved in 4375 generations
Experiment #23: Super Nasty Variant never evolved
Experiment #24: Super Nasty Variant never evolved
Experiment #25: Super Nasty Variant evolved in 1390 generations
Experiment #26: Super Nasty Variant never evolved
Experiment #27: Super Nasty Variant never evolved
Experiment #28: Super Nasty Variant never evolved
Experiment #29: Super Nasty Variant never evolved
Experiment #30: Super Nasty Variant never evolved
Experiment #31: Super Nasty Variant evolved in 1398 generations
Experiment #32: Super Nasty Variant never evolved
Experiment #33: Super Nasty Variant never evolved
Experiment #34: Super Nasty Variant evolved in 2539 generations
Experiment #35: Super Nasty Variant never evolved
Experiment #36: Super Nasty Variant never evolved
Experiment #37: Super Nasty Variant never evolved
Experiment #38: Super Nasty Variant never evolved
Experiment #39: Super Nasty Variant never evolved
Experiment #40: Super Nasty Variant evolved in 2509 generations
Experiment #41: Super Nasty Variant never evolved
Experiment #42: Super Nasty Variant evolved in 4194 generations
Experiment #43: Super Nasty Variant never evolved
Experiment #44: Super Nasty Variant never evolved
Experiment #45: Super Nasty Variant never evolved
Experiment #46: Super Nasty Variant never evolved
Experiment #47: Super Nasty Variant never evolved
Experiment #48: Super Nasty Variant never evolved
Experiment #49: Super Nasty Variant never evolved
On average, the variant showed up at generation 4528.82
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment