Merge pull request #8328 from imapp-pl/yul-phaser-gewep-algorithm

[yul-phaser] GEWEP algorithm

test/CMakeLists.txt

@@ -145,6 +145,8 @@ set(yul_phaser_sources
     yulPhaser/Chromosome.cpp
     yulPhaser/FitnessMetrics.cpp
     yulPhaser/GeneticAlgorithms.cpp
+    yulPhaser/Mutations.cpp
+    yulPhaser/PairSelections.cpp
     yulPhaser/Population.cpp
     yulPhaser/Program.cpp
     yulPhaser/Selections.cpp
@@ -156,6 +158,8 @@ set(yul_phaser_sources
     ../tools/yulPhaser/Chromosome.cpp
     ../tools/yulPhaser/FitnessMetrics.cpp
     ../tools/yulPhaser/GeneticAlgorithms.cpp
+    ../tools/yulPhaser/Mutations.cpp
+    ../tools/yulPhaser/PairSelections.cpp
     ../tools/yulPhaser/Population.cpp
     ../tools/yulPhaser/Program.cpp
     ../tools/yulPhaser/Selections.cpp

test/yulPhaser/Common.cpp

@@ -24,6 +24,24 @@
 using namespace std;
 using namespace solidity;
 using namespace solidity::yul;
+using namespace solidity::phaser;
+
+function<Mutation> phaser::test::wholeChromosomeReplacement(Chromosome _newChromosome)
+{
+	return [_newChromosome = move(_newChromosome)](Chromosome const&) { return _newChromosome; };
+}
+
+function<Mutation> phaser::test::geneSubstitution(size_t _geneIndex, string _geneValue)
+{
+	return [=](Chromosome const& _chromosome)
+	{
+		vector<string> newGenes = _chromosome.optimisationSteps();
+		assert(_geneIndex < newGenes.size());
+		newGenes[_geneIndex] = _geneValue;
+
+		return Chromosome(newGenes);
+	};
+}
 
 vector<size_t> phaser::test::chromosomeLengths(Population const& _population)
 {
@@ -44,6 +62,15 @@ map<string, size_t> phaser::test::enumerateOptmisationSteps()
 	return stepIndices;
 }
 
+size_t phaser::test::countDifferences(Chromosome const& _chromosome1, Chromosome const& _chromosome2)
+{
+	size_t count = 0;
+	for (size_t i = 0; i < min(_chromosome1.length(), _chromosome2.length()); ++i)
+		count += static_cast<int>(_chromosome1.optimisationSteps()[i] != _chromosome2.optimisationSteps()[i]);
+
+	return count + abs(static_cast<int>(_chromosome1.length() - _chromosome2.length()));
+}
+
 string phaser::test::stripWhitespace(string const& input)
 {
 	regex whitespaceRegex("\\s+");

test/yulPhaser/Common.h

@@ -30,9 +30,11 @@
 
 #include <tools/yulPhaser/Chromosome.h>
 #include <tools/yulPhaser/FitnessMetrics.h>
+#include <tools/yulPhaser/Mutations.h>
 #include <tools/yulPhaser/Population.h>
 
 #include <cassert>
+#include <functional>
 #include <map>
 #include <string>
 #include <vector>
@@ -52,11 +54,26 @@ public:
 	size_t evaluate(Chromosome const& _chromosome) const override { return _chromosome.length(); }
 };
 
+// MUTATIONS
+
+/// Mutation that always replaces the whole chromosome with the one specified in the parameter.
+std::function<Mutation> wholeChromosomeReplacement(Chromosome _newChromosome);
+
+/// Mutation that always replaces the optimisation step at position @a _geneIndex with @a _geneValue.
+///
+/// The chromosome must be long enough for this position to exist.
+std::function<Mutation> geneSubstitution(size_t _geneIndex, std::string _geneValue);
+
 // CHROMOSOME AND POPULATION HELPERS
 
 /// Returns a vector containing lengths of all chromosomes in the population (in the same order).
 std::vector<size_t> chromosomeLengths(Population const& _population);
 
+/// Returns the number of genes that differ between two chromosomes.
+/// If the chromnosomes have different lengths, the positions that are present in only one of them
+/// are counted as mismatches.
+size_t countDifferences(Chromosome const& _chromosome1, Chromosome const& _chromosome2);
+
 /// Assigns indices from 0 to N to all optimisation steps available in the OptimiserSuite.
 /// This is a convenience helper to make it easier to test their distribution with tools made for
 /// integers.

test/yulPhaser/CommonTest.cpp

@@ -40,6 +40,23 @@ BOOST_AUTO_TEST_CASE(ChromosomeLengthMetric_evaluate_should_return_chromosome_le
 	BOOST_TEST(ChromosomeLengthMetric{}.evaluate(Chromosome("aaaaa")) == 5);
 }
 
+BOOST_AUTO_TEST_CASE(wholeChromosomeReplacement_should_replace_whole_chromosome_with_another)
+{
+	function<Mutation> mutation = wholeChromosomeReplacement(Chromosome("aaa"));
+	BOOST_TEST(mutation(Chromosome("ccc")) == Chromosome("aaa"));
+}
+
+BOOST_AUTO_TEST_CASE(geneSubstitution_should_change_a_single_gene_at_a_given_index)
+{
+	Chromosome chromosome("aaccff");
+
+	function<Mutation> mutation1 = geneSubstitution(0, chromosome.optimisationSteps()[5]);
+	BOOST_TEST(mutation1(chromosome) == Chromosome("faccff"));
+
+	function<Mutation> mutation2 = geneSubstitution(5, chromosome.optimisationSteps()[0]);
+	BOOST_TEST(mutation2(chromosome) == Chromosome("aaccfa"));
+}
+
 BOOST_AUTO_TEST_CASE(chromosomeLengths_should_return_lengths_of_all_chromosomes_in_a_population)
 {
 	shared_ptr<FitnessMetric> fitnessMetric = make_shared<ChromosomeLengthMetric>();
@@ -51,6 +68,34 @@ BOOST_AUTO_TEST_CASE(chromosomeLengths_should_return_lengths_of_all_chromosomes_
 	BOOST_TEST((chromosomeLengths(population2) == vector<size_t>{}));
 }
 
+BOOST_AUTO_TEST_CASE(countDifferences_should_return_zero_for_identical_chromosomes)
+{
+	BOOST_TEST(countDifferences(Chromosome(), Chromosome()) == 0);
+	BOOST_TEST(countDifferences(Chromosome("a"), Chromosome("a")) == 0);
+	BOOST_TEST(countDifferences(Chromosome("afxT"), Chromosome("afxT")) == 0);
+}
+
+BOOST_AUTO_TEST_CASE(countDifferences_should_count_mismatched_positions_in_chromosomes_of_the_same_length)
+{
+	BOOST_TEST(countDifferences(Chromosome("a"), Chromosome("f")) == 1);
+	BOOST_TEST(countDifferences(Chromosome("aa"), Chromosome("ac")) == 1);
+	BOOST_TEST(countDifferences(Chromosome("ac"), Chromosome("cc")) == 1);
+	BOOST_TEST(countDifferences(Chromosome("aa"), Chromosome("cc")) == 2);
+	BOOST_TEST(countDifferences(Chromosome("afxT"), Chromosome("Txfa")) == 4);
+}
+
+BOOST_AUTO_TEST_CASE(countDifferences_should_count_missing_characters_as_differences)
+{
+	BOOST_TEST(countDifferences(Chromosome(""), Chromosome("a")) == 1);
+	BOOST_TEST(countDifferences(Chromosome("a"), Chromosome("")) == 1);
+	BOOST_TEST(countDifferences(Chromosome("aa"), Chromosome("")) == 2);
+	BOOST_TEST(countDifferences(Chromosome("aaa"), Chromosome("")) == 3);
+
+	BOOST_TEST(countDifferences(Chromosome("aa"), Chromosome("aaaa")) == 2);
+	BOOST_TEST(countDifferences(Chromosome("aa"), Chromosome("aacc")) == 2);
+	BOOST_TEST(countDifferences(Chromosome("aa"), Chromosome("cccc")) == 4);
+}
+
 BOOST_AUTO_TEST_CASE(enumerateOptimisationSteps_should_assing_indices_to_all_available_optimisation_steps)
 {
 	map<string, char> stepsAndAbbreviations = OptimiserSuite::stepNameToAbbreviationMap();

test/yulPhaser/GeneticAlgorithms.cpp

@@ -29,6 +29,7 @@
 #include <boost/test/unit_test.hpp>
 #include <boost/test/tools/output_test_stream.hpp>
 
+#include <algorithm>
 #include <vector>
 
 using namespace std;
@@ -132,6 +133,107 @@ BOOST_FIXTURE_TEST_CASE(runNextRound_should_not_replace_any_chromosomes_if_whole
 	BOOST_TEST((chromosomeLengths(algorithm.population()) == vector<size_t>{3, 3, 3, 3, 5, 5, 5, 5}));
 }
 
+BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_SUITE(GenerationalElitistWithExclusivePoolsTest)
+
+BOOST_FIXTURE_TEST_CASE(runNextRound_should_preserve_elite_and_regenerate_rest_of_population, GeneticAlgorithmFixture)
+{
+	auto population = Population::makeRandom(m_fitnessMetric, 6, 3, 3) + Population::makeRandom(m_fitnessMetric, 4, 5, 5);
+
+	GenerationalElitistWithExclusivePools::Options options = {
+		/* mutationPoolSize = */ 0.2,
+		/* crossoverPoolSize = */ 0.2,
+		/* randomisationChance = */ 0.0,
+		/* deletionVsAdditionChance = */ 1.0,
+		/* percentGenesToRandomise = */ 0.0,
+		/* percentGenesToAddOrDelete = */ 1.0,
+	};
+	GenerationalElitistWithExclusivePools algorithm(population, m_output, options);
+	assert((chromosomeLengths(algorithm.population()) == vector<size_t>{3, 3, 3, 3, 3, 3, 5, 5, 5, 5}));
+
+	algorithm.runNextRound();
+
+	BOOST_TEST((chromosomeLengths(algorithm.population()) == vector<size_t>{0, 0, 3, 3, 3, 3, 3, 3, 3, 3}));
+}
+
+BOOST_FIXTURE_TEST_CASE(runNextRound_should_not_replace_elite_with_worse_individuals, GeneticAlgorithmFixture)
+{
+	auto population = Population::makeRandom(m_fitnessMetric, 6, 3, 3) + Population::makeRandom(m_fitnessMetric, 4, 5, 5);
+
+	GenerationalElitistWithExclusivePools::Options options = {
+		/* mutationPoolSize = */ 0.2,
+		/* crossoverPoolSize = */ 0.2,
+		/* randomisationChance = */ 0.0,
+		/* deletionVsAdditionChance = */ 0.0,
+		/* percentGenesToRandomise = */ 0.0,
+		/* percentGenesToAddOrDelete = */ 1.0,
+	};
+	GenerationalElitistWithExclusivePools algorithm(population, m_output, options);
+	assert(chromosomeLengths(algorithm.population()) == (vector<size_t>{3, 3, 3, 3, 3, 3, 5, 5, 5, 5}));
+
+	algorithm.runNextRound();
+
+	BOOST_TEST((chromosomeLengths(algorithm.population()) == vector<size_t>{3, 3, 3, 3, 3, 3, 3, 3, 7, 7}));
+}
+
+BOOST_FIXTURE_TEST_CASE(runNextRound_should_generate_individuals_in_the_crossover_pool_by_mutating_the_elite, GeneticAlgorithmFixture)
+{
+	auto population = Population::makeRandom(m_fitnessMetric, 20, 5, 5);
+
+	GenerationalElitistWithExclusivePools::Options options = {
+		/* mutationPoolSize = */ 0.8,
+		/* crossoverPoolSize = */ 0.0,
+		/* randomisationChance = */ 0.5,
+		/* deletionVsAdditionChance = */ 0.5,
+		/* percentGenesToRandomise = */ 1.0,
+		/* percentGenesToAddOrDelete = */ 1.0,
+	};
+	GenerationalElitistWithExclusivePools algorithm(population, m_output, options);
+
+	SimulationRNG::reset(1);
+	algorithm.runNextRound();
+
+	BOOST_TEST((
+		chromosomeLengths(algorithm.population()) ==
+		vector<size_t>{0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 11, 11, 11}
+	));
+}
+
+BOOST_FIXTURE_TEST_CASE(runNextRound_should_generate_individuals_in_the_crossover_pool_by_crossing_over_the_elite, GeneticAlgorithmFixture)
+{
+	auto population = (
+		Population(m_fitnessMetric, {Chromosome("aa"), Chromosome("ff")}) +
+		Population::makeRandom(m_fitnessMetric, 8, 6, 6)
+	);
+
+	GenerationalElitistWithExclusivePools::Options options = {
+		/* mutationPoolSize = */ 0.0,
+		/* crossoverPoolSize = */ 0.8,
+		/* randomisationChance = */ 0.0,
+		/* deletionVsAdditionChance = */ 0.0,
+		/* percentGenesToRandomise = */ 0.0,
+		/* percentGenesToAddOrDelete = */ 0.0,
+	};
+	GenerationalElitistWithExclusivePools algorithm(population, m_output, options);
+	assert((chromosomeLengths(algorithm.population()) == vector<size_t>{2, 2, 6, 6, 6, 6, 6, 6, 6, 6}));
+
+	SimulationRNG::reset(1);
+	algorithm.runNextRound();
+
+	vector<Individual> const& newIndividuals = algorithm.population().individuals();
+	BOOST_TEST((chromosomeLengths(algorithm.population()) == vector<size_t>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2}));
+	for (auto& individual: newIndividuals)
+		BOOST_TEST((
+			individual.chromosome == Chromosome("aa") ||
+			individual.chromosome == Chromosome("af") ||
+			individual.chromosome == Chromosome("fa") ||
+			individual.chromosome == Chromosome("ff")
+		));
+	BOOST_TEST(any_of(newIndividuals.begin() + 2, newIndividuals.end(), [](auto& individual){
+		return individual.chromosome != Chromosome("aa") && individual.chromosome != Chromosome("ff");
+	}));
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 BOOST_AUTO_TEST_SUITE_END()
 BOOST_AUTO_TEST_SUITE_END()

test/yulPhaser/Mutations.cpp

@@ -0,0 +1,394 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <test/yulPhaser/Common.h>
+
+#include <tools/yulPhaser/Mutations.h>
+
+#include <tools/yulPhaser/SimulationRNG.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <algorithm>
+#include <vector>
+
+using namespace std;
+
+namespace solidity::phaser::test
+{
+
+BOOST_AUTO_TEST_SUITE(Phaser)
+BOOST_AUTO_TEST_SUITE(MutationsTest)
+BOOST_AUTO_TEST_SUITE(GeneRandomisationTest)
+
+BOOST_AUTO_TEST_CASE(geneRandomisation_should_iterate_over_genes_and_replace_them_with_random_ones_with_given_probability)
+{
+	Chromosome chromosome("fcCUnDvejs");
+	function<Mutation> mutation01 = geneRandomisation(0.1);
+	function<Mutation> mutation05 = geneRandomisation(0.5);
+	function<Mutation> mutation10 = geneRandomisation(1.0);
+
+	SimulationRNG::reset(1);
+	BOOST_TEST(countDifferences(mutation01(chromosome), chromosome), 2);
+	BOOST_TEST(countDifferences(mutation05(chromosome), chromosome), 5);
+	BOOST_TEST(countDifferences(mutation10(chromosome), chromosome), 7);
+	SimulationRNG::reset(2);
+	BOOST_TEST(countDifferences(mutation01(chromosome), chromosome), 1);
+	BOOST_TEST(countDifferences(mutation05(chromosome), chromosome), 3);
+	BOOST_TEST(countDifferences(mutation10(chromosome), chromosome), 9);
+}
+
+BOOST_AUTO_TEST_CASE(geneRandomisation_should_return_identical_chromosome_if_probability_is_zero)
+{
+	Chromosome chromosome("fcCUnDvejsrmV");
+	function<Mutation> mutation = geneRandomisation(0.0);
+
+	BOOST_TEST(mutation(chromosome) == chromosome);
+}
+
+BOOST_AUTO_TEST_CASE(geneDeletion_should_iterate_over_genes_and_delete_them_with_given_probability)
+{
+	Chromosome chromosome("fcCUnDvejs");
+	function<Mutation> mutation01 = geneDeletion(0.1);
+	function<Mutation> mutation05 = geneDeletion(0.5);
+
+	SimulationRNG::reset(1);
+	//                                                               fcCUnDvejs
+	BOOST_TEST(mutation01(chromosome) == Chromosome(stripWhitespace("fcCU Dvejs")));
+	BOOST_TEST(mutation05(chromosome) == Chromosome(stripWhitespace("     D ejs")));
+	SimulationRNG::reset(2);
+	BOOST_TEST(mutation01(chromosome) == Chromosome(stripWhitespace("fcUnDvejs")));
+	BOOST_TEST(mutation05(chromosome) == Chromosome(stripWhitespace("  Un    s")));
+}
+
+BOOST_AUTO_TEST_CASE(geneDeletion_should_return_identical_chromosome_if_probability_is_zero)
+{
+	Chromosome chromosome("fcCUnDvejsrmV");
+	function<Mutation> mutation = geneDeletion(0.0);
+
+	BOOST_TEST(mutation(chromosome) == chromosome);
+}
+
+BOOST_AUTO_TEST_CASE(geneDeletion_should_delete_all_genes_if_probability_is_one)
+{
+	Chromosome chromosome("fcCUnDvejsrmV");
+	function<Mutation> mutation = geneDeletion(1.0);
+
+	BOOST_TEST(mutation(chromosome) == Chromosome(""));
+}
+
+BOOST_AUTO_TEST_CASE(geneAddition_should_iterate_over_gene_positions_and_insert_new_genes_with_given_probability)
+{
+	Chromosome chromosome("fcCUnDvejs");
+	function<Mutation> mutation01 = geneAddition(0.1);
+	function<Mutation> mutation05 = geneAddition(0.5);
+
+	SimulationRNG::reset(1);
+	//                                                                 f  c  C  U  n  D  v  e  j  s
+	BOOST_TEST(mutation01(chromosome) == Chromosome(stripWhitespace("  f  c  C  UC n  D  v  e  jx s")));  //  20% more
+	BOOST_TEST(mutation05(chromosome) == Chromosome(stripWhitespace("j f  cu C  U  ne D  v  eI j  sf"))); //  50% more
+	SimulationRNG::reset(2);
+	BOOST_TEST(mutation01(chromosome) == Chromosome(stripWhitespace("  f  cu C  U  n  D  v  e  j  s")));  //  10% more
+	BOOST_TEST(mutation05(chromosome) == Chromosome(stripWhitespace("L f  ce Cv U  n  D  v  e  jO s")));  //  40% more
+}
+
+BOOST_AUTO_TEST_CASE(geneAddition_should_be_able_to_insert_before_first_position)
+{
+	SimulationRNG::reset(7);
+	Chromosome chromosome("fcCUnDvejs");
+	function<Mutation> mutation = geneAddition(0.1);
+
+	Chromosome mutatedChromosome = mutation(chromosome);
+	BOOST_TEST(mutatedChromosome.length() > chromosome.length());
+
+	vector<string> suffix(
+		mutatedChromosome.optimisationSteps().end() - chromosome.length(),
+		mutatedChromosome.optimisationSteps().end()
+	);
+	BOOST_TEST(suffix == chromosome.optimisationSteps());
+}
+
+BOOST_AUTO_TEST_CASE(geneAddition_should_be_able_to_insert_after_last_position)
+{
+	SimulationRNG::reset(81);
+	Chromosome chromosome("fcCUnDvejs");
+	function<Mutation> mutation = geneAddition(0.1);
+
+	Chromosome mutatedChromosome = mutation(chromosome);
+	BOOST_TEST(mutatedChromosome.length() > chromosome.length());
+
+	vector<string> prefix(
+		mutatedChromosome.optimisationSteps().begin(),
+		mutatedChromosome.optimisationSteps().begin() + chromosome.length()
+	);
+	BOOST_TEST(prefix == chromosome.optimisationSteps());
+}
+
+BOOST_AUTO_TEST_CASE(geneAddition_should_return_identical_chromosome_if_probability_is_zero)
+{
+	Chromosome chromosome("fcCUnDvejsrmV");
+	function<Mutation> mutation = geneAddition(0.0);
+
+	BOOST_TEST(mutation(chromosome) == chromosome);
+}
+
+BOOST_AUTO_TEST_CASE(geneAddition_should_insert_genes_at_all_positions_if_probability_is_one)
+{
+	Chromosome chromosome("fcCUnDvejsrmV");
+	function<Mutation> mutation = geneAddition(1.0);
+
+	Chromosome mutatedChromosome = mutation(chromosome);
+	BOOST_TEST(mutatedChromosome.length() == chromosome.length() * 2 + 1);
+
+	vector<string> originalGenes;
+	for (size_t i = 0; i < mutatedChromosome.length() - 1; ++i)
+		if (i % 2 == 1)
+			originalGenes.push_back(mutatedChromosome.optimisationSteps()[i]);
+
+	BOOST_TEST(Chromosome(originalGenes) == chromosome);
+}
+
+BOOST_AUTO_TEST_CASE(alternativeMutations_should_choose_between_mutations_with_given_probability)
+{
+	SimulationRNG::reset(1);
+	Chromosome chromosome("a");
+	function<Mutation> mutation = alternativeMutations(
+		0.8,
+		wholeChromosomeReplacement(Chromosome("c")),
+		wholeChromosomeReplacement(Chromosome("f"))
+	);
+
+	size_t cCount = 0;
+	size_t fCount = 0;
+	for (size_t i = 0; i < 10; ++i)
+	{
+		Chromosome mutatedChromosome = mutation(chromosome);
+		cCount += static_cast<int>(mutatedChromosome == Chromosome("c"));
+		fCount += static_cast<int>(mutatedChromosome == Chromosome("f"));
+	}
+
+	// This particular seed results in 7 "c"s out of 10 which looks plausible given the 80% chance.
+	BOOST_TEST(cCount == 7);
+	BOOST_TEST(fCount == 3);
+}
+
+BOOST_AUTO_TEST_CASE(alternativeMutations_should_always_choose_first_mutation_if_probability_is_one)
+{
+	Chromosome chromosome("a");
+	function<Mutation> mutation = alternativeMutations(
+		1.0,
+		wholeChromosomeReplacement(Chromosome("c")),
+		wholeChromosomeReplacement(Chromosome("f"))
+	);
+
+	for (size_t i = 0; i < 10; ++i)
+		BOOST_TEST(mutation(chromosome) == Chromosome("c"));
+}
+
+BOOST_AUTO_TEST_CASE(alternativeMutations_should_always_choose_second_mutation_if_probability_is_zero)
+{
+	Chromosome chromosome("a");
+	function<Mutation> mutation = alternativeMutations(
+		0.0,
+		wholeChromosomeReplacement(Chromosome("c")),
+		wholeChromosomeReplacement(Chromosome("f"))
+	);
+
+	for (size_t i = 0; i < 10; ++i)
+		BOOST_TEST(mutation(chromosome) == Chromosome("f"));
+}
+
+BOOST_AUTO_TEST_CASE(randomPointCrossover_should_swap_chromosome_parts_at_random_point)
+{
+	function<Crossover> crossover = randomPointCrossover();
+
+	SimulationRNG::reset(1);
+	Chromosome result1 = crossover(Chromosome("aaaaaaaaaa"), Chromosome("cccccc"));
+	BOOST_TEST(result1 == Chromosome("aaaccc"));
+
+	SimulationRNG::reset(1);
+	Chromosome result2 = crossover(Chromosome("cccccc"), Chromosome("aaaaaaaaaa"));
+	BOOST_TEST(result2 == Chromosome("cccaaaaaaa"));
+}
+
+BOOST_AUTO_TEST_CASE(randomPointCrossover_should_only_consider_points_available_on_both_chromosomes)
+{
+	SimulationRNG::reset(1);
+	function<Crossover> crossover = randomPointCrossover();
+
+	for (size_t i = 0; i < 30; ++i)
+	{
+		Chromosome result1 = crossover(Chromosome("aaa"), Chromosome("TTTTTTTTTTTTTTTTTTTT"));
+		Chromosome result2 = crossover(Chromosome("TTTTTTTTTTTTTTTTTTTT"), Chromosome("aaa"));
+		BOOST_TEST((
+			result1 == Chromosome("TTTTTTTTTTTTTTTTTTTT") ||
+			result1 == Chromosome("aTTTTTTTTTTTTTTTTTTT") ||
+			result1 == Chromosome("aaTTTTTTTTTTTTTTTTTT") ||
+			result1 == Chromosome("aaaTTTTTTTTTTTTTTTTT")
+		));
+		BOOST_TEST((
+			result2 == Chromosome("aaa") ||
+			result2 == Chromosome("Taa") ||
+			result2 == Chromosome("TTa") ||
+			result2 == Chromosome("TTT")
+		));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(randomPointCrossover_should_never_split_at_position_zero_if_chromosomes_are_splittable)
+{
+	SimulationRNG::reset(1);
+	function<Crossover> crossover = randomPointCrossover();
+
+	for (size_t i = 0; i < 30; ++i)
+	{
+		Chromosome result1 = crossover(Chromosome("aa"), Chromosome("TTTTTTTTTTTTTTTTTTTT"));
+		Chromosome result2 = crossover(Chromosome("TTTTTTTTTTTTTTTTTTTT"), Chromosome("aa"));
+		BOOST_TEST(result1 != Chromosome("TTTTTTTTTTTTTTTTTTTT"));
+		BOOST_TEST(result2 != Chromosome("aa"));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(randomPointCrossover_should_never_split_at_position_zero_if_chromosomes_are_not_empty)
+{
+	SimulationRNG::reset(1);
+	function<Crossover> crossover = randomPointCrossover();
+
+	for (size_t i = 0; i < 30; ++i)
+	{
+		Chromosome result1 = crossover(Chromosome("a"), Chromosome("T"));
+		Chromosome result2 = crossover(Chromosome("T"), Chromosome("a"));
+		BOOST_TEST(result1 == Chromosome("a"));
+		BOOST_TEST(result2 == Chromosome("T"));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(randomPointCrossover_should_work_even_if_one_chromosome_is_unsplittable)
+{
+	function<Crossover> crossover = randomPointCrossover();
+
+	SimulationRNG::reset(1);
+	BOOST_CHECK(crossover(Chromosome("ff"), Chromosome("a")) == Chromosome("f"));
+	BOOST_CHECK(crossover(Chromosome("a"), Chromosome("ff")) == Chromosome("af"));
+}
+
+BOOST_AUTO_TEST_CASE(randomPointCrossover_should_split_at_position_zero_only_if_at_least_one_chromosome_is_empty)
+{
+	Chromosome empty("");
+	Chromosome unsplittable("a");
+	Chromosome splittable("aaaa");
+	function<Crossover> crossover = randomPointCrossover();
+
+	SimulationRNG::reset(1);
+	BOOST_CHECK(crossover(empty, empty) == empty);
+	BOOST_CHECK(crossover(unsplittable, empty) == empty);
+	BOOST_CHECK(crossover(empty, unsplittable) == unsplittable);
+	BOOST_CHECK(crossover(splittable, empty) == empty);
+	BOOST_CHECK(crossover(empty, splittable) == splittable);
+}
+
+BOOST_AUTO_TEST_CASE(fixedPointCrossover_should_swap_chromosome_parts_at_given_point)
+{
+	Chromosome result1 = fixedPointCrossover(0.8)(Chromosome("aaaaaaaaaa"), Chromosome("cccccccccc"));
+	Chromosome result2 = fixedPointCrossover(0.8)(Chromosome("cccccccccc"), Chromosome("aaaaaaaaaa"));
+	BOOST_TEST(result1 == Chromosome("aaaaaaaacc"));
+	BOOST_TEST(result2 == Chromosome("ccccccccaa"));
+}
+
+BOOST_AUTO_TEST_CASE(fixedPointCrossover_should_determine_crossover_point_based_on_length_of_shorter_chromosome)
+{
+	Chromosome result1 = fixedPointCrossover(0.4)(Chromosome("aaaaa"), Chromosome("cccccccccc"));
+	Chromosome result2 = fixedPointCrossover(0.4)(Chromosome("cccccccccc"), Chromosome("aaaaa"));
+	BOOST_TEST(result1 == Chromosome("aacccccccc"));
+	BOOST_TEST(result2 == Chromosome("ccaaa"));
+}
+
+BOOST_AUTO_TEST_CASE(fixedPointCrossover_should_round_split_point)
+{
+	Chromosome result1 = fixedPointCrossover(0.49)(Chromosome("aaaaa"), Chromosome("ccccc"));
+	Chromosome result2 = fixedPointCrossover(0.49)(Chromosome("ccccc"), Chromosome("aaaaa"));
+	BOOST_TEST(result1 == Chromosome("aaccc"));
+	BOOST_TEST(result2 == Chromosome("ccaaa"));
+
+	Chromosome result3 = fixedPointCrossover(0.50)(Chromosome("aaaaa"), Chromosome("ccccc"));
+	Chromosome result4 = fixedPointCrossover(0.50)(Chromosome("ccccc"), Chromosome("aaaaa"));
+	BOOST_TEST(result3 == Chromosome("aaacc"));
+	BOOST_TEST(result4 == Chromosome("cccaa"));
+
+	Chromosome result5 = fixedPointCrossover(0.51)(Chromosome("aaaaa"), Chromosome("ccccc"));
+	Chromosome result6 = fixedPointCrossover(0.51)(Chromosome("ccccc"), Chromosome("aaaaa"));
+	BOOST_TEST(result5 == Chromosome("aaacc"));
+	BOOST_TEST(result6 == Chromosome("cccaa"));
+}
+
+BOOST_AUTO_TEST_CASE(fixedPointCrossover_should_split_at_position_zero_if_explicitly_requested)
+{
+	Chromosome result1 = fixedPointCrossover(0.0)(Chromosome("aaaaa"), Chromosome("cccccccccc"));
+	Chromosome result2 = fixedPointCrossover(0.0)(Chromosome("cccccccccc"), Chromosome("aaaaa"));
+	BOOST_TEST(result1 == Chromosome("cccccccccc"));
+	BOOST_TEST(result2 == Chromosome("aaaaa"));
+}
+
+BOOST_AUTO_TEST_CASE(fixedPointCrossover_should_split_at_end_of_shorter_chromosome_if_crossover_point_is_after_last_position)
+{
+	Chromosome result1 = fixedPointCrossover(1.0)(Chromosome("aaaaa"), Chromosome("cccccccccc"));
+	Chromosome result2 = fixedPointCrossover(1.0)(Chromosome("cccccccccc"), Chromosome("aaaaa"));
+	BOOST_TEST(result1 == Chromosome("aaaaaccccc"));
+	BOOST_TEST(result2 == Chromosome("ccccc"));
+}
+
+BOOST_AUTO_TEST_CASE(fixedPointCrossover_should_select_correct_split_point_for_unsplittable_chromosomes)
+{
+	function<Crossover> crossover00 = fixedPointCrossover(0.0);
+	BOOST_CHECK(crossover00(Chromosome("fff"), Chromosome("a")) == Chromosome("a"));
+	BOOST_CHECK(crossover00(Chromosome("a"), Chromosome("fff")) == Chromosome("fff"));
+
+	BOOST_CHECK(crossover00(Chromosome("f"), Chromosome("a")) == Chromosome("a"));
+
+	function<Crossover> crossover10 = fixedPointCrossover(1.0);
+	BOOST_CHECK(crossover10(Chromosome("fff"), Chromosome("a")) == Chromosome("f"));
+	BOOST_CHECK(crossover10(Chromosome("a"), Chromosome("fff")) == Chromosome("aff"));
+
+	BOOST_CHECK(crossover10(Chromosome("f"), Chromosome("a")) == Chromosome("f"));
+}
+
+BOOST_AUTO_TEST_CASE(fixedPointCrossover_should_always_use_position_zero_as_split_point_when_chromosome_empty)
+{
+	Chromosome empty("");
+	Chromosome unsplittable("f");
+	Chromosome splittable("aaaa");
+
+	function<Crossover> crossover00 = fixedPointCrossover(0.0);
+	BOOST_CHECK(crossover00(empty, empty) == empty);
+	BOOST_CHECK(crossover00(unsplittable, empty) == empty);
+	BOOST_CHECK(crossover00(empty, unsplittable) == unsplittable);
+	BOOST_CHECK(crossover00(splittable, empty) == empty);
+	BOOST_CHECK(crossover00(empty, splittable) == splittable);
+
+	function<Crossover> crossover10 = fixedPointCrossover(1.0);
+	BOOST_CHECK(crossover10(empty, empty) == empty);
+	BOOST_CHECK(crossover10(unsplittable, empty) == empty);
+	BOOST_CHECK(crossover10(empty, unsplittable) == unsplittable);
+	BOOST_CHECK(crossover10(splittable, empty) == empty);
+	BOOST_CHECK(crossover10(empty, splittable) == splittable);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_SUITE_END()
+
+}

test/yulPhaser/PairSelections.cpp

@@ -0,0 +1,185 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <test/yulPhaser/Common.h>
+
+#include <tools/yulPhaser/PairSelections.h>
+#include <tools/yulPhaser/SimulationRNG.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <algorithm>
+#include <tuple>
+#include <vector>
+
+using namespace std;
+
+namespace solidity::phaser::test
+{
+
+BOOST_AUTO_TEST_SUITE(Phaser)
+BOOST_AUTO_TEST_SUITE(PairSelectionsTest)
+BOOST_AUTO_TEST_SUITE(RandomPairSelectionTest)
+
+BOOST_AUTO_TEST_CASE(materialise_should_return_random_values_with_equal_probabilities)
+{
+	constexpr int collectionSize = 10;
+	constexpr int selectionSize = 100;
+	constexpr double relativeTolerance = 0.1;
+	constexpr double expectedValue = (collectionSize - 1) / 2.0;
+	constexpr double variance = (collectionSize * collectionSize - 1) / 12.0;
+
+	SimulationRNG::reset(1);
+	vector<tuple<size_t, size_t>> pairs = RandomPairSelection(selectionSize).materialise(collectionSize);
+	vector<size_t> samples;
+	for (auto& [first, second]: pairs)
+	{
+		samples.push_back(first);
+		samples.push_back(second);
+	}
+
+	BOOST_TEST(abs(mean(samples) - expectedValue) < expectedValue * relativeTolerance);
+	BOOST_TEST(abs(meanSquaredError(samples, expectedValue) - variance) < variance * relativeTolerance);
+}
+
+BOOST_AUTO_TEST_CASE(materialise_should_return_only_values_that_can_be_used_as_collection_indices)
+{
+	const size_t collectionSize = 200;
+
+	vector<tuple<size_t, size_t>> pairs = RandomPairSelection(0.5).materialise(collectionSize);
+
+	BOOST_TEST(pairs.size() == 100);
+	BOOST_TEST(all_of(pairs.begin(), pairs.end(), [&](auto const& pair){ return get<0>(pair) <= collectionSize; }));
+	BOOST_TEST(all_of(pairs.begin(), pairs.end(), [&](auto const& pair){ return get<1>(pair) <= collectionSize; }));
+}
+
+BOOST_AUTO_TEST_CASE(materialise_should_never_return_a_pair_of_identical_indices)
+{
+	vector<tuple<size_t, size_t>> pairs = RandomPairSelection(0.5).materialise(100);
+
+	BOOST_TEST(pairs.size() == 50);
+	BOOST_TEST(all_of(pairs.begin(), pairs.end(), [](auto const& pair){ return get<0>(pair) != get<1>(pair); }));
+}
+
+BOOST_AUTO_TEST_CASE(materialise_should_return_number_of_pairs_thats_a_fraction_of_collection_size)
+{
+	BOOST_TEST(RandomPairSelection(0.0).materialise(10).size() == 0);
+	BOOST_TEST(RandomPairSelection(0.3).materialise(10).size() == 3);
+	BOOST_TEST(RandomPairSelection(0.5).materialise(10).size() == 5);
+	BOOST_TEST(RandomPairSelection(0.7).materialise(10).size() == 7);
+	BOOST_TEST(RandomPairSelection(1.0).materialise(10).size() == 10);
+}
+
+BOOST_AUTO_TEST_CASE(materialise_should_support_number_of_pairs_bigger_than_collection_size)
+{
+	BOOST_TEST(RandomPairSelection(2.0).materialise(5).size() == 10);
+	BOOST_TEST(RandomPairSelection(1.5).materialise(10).size() == 15);
+	BOOST_TEST(RandomPairSelection(10.0).materialise(10).size() == 100);
+}
+
+BOOST_AUTO_TEST_CASE(materialise_should_round_the_number_of_pairs_to_the_nearest_integer)
+{
+	BOOST_TEST(RandomPairSelection(0.49).materialise(3).size() == 1);
+	BOOST_TEST(RandomPairSelection(0.50).materialise(3).size() == 2);
+	BOOST_TEST(RandomPairSelection(0.51).materialise(3).size() == 2);
+
+	BOOST_TEST(RandomPairSelection(1.51).materialise(3).size() == 5);
+
+	BOOST_TEST(RandomPairSelection(0.01).materialise(2).size() == 0);
+	BOOST_TEST(RandomPairSelection(0.01).materialise(3).size() == 0);
+}
+
+BOOST_AUTO_TEST_CASE(materialise_should_return_no_pairs_if_collection_is_empty)
+{
+	BOOST_TEST(RandomPairSelection(0).materialise(0).empty());
+	BOOST_TEST(RandomPairSelection(0.5).materialise(0).empty());
+	BOOST_TEST(RandomPairSelection(1.0).materialise(0).empty());
+	BOOST_TEST(RandomPairSelection(2.0).materialise(0).empty());
+}
+
+BOOST_AUTO_TEST_CASE(materialise_should_return_no_pairs_if_collection_has_one_element)
+{
+	BOOST_TEST(RandomPairSelection(0).materialise(1).empty());
+	BOOST_TEST(RandomPairSelection(0.5).materialise(1).empty());
+	BOOST_TEST(RandomPairSelection(1.0).materialise(1).empty());
+	BOOST_TEST(RandomPairSelection(2.0).materialise(1).empty());
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_SUITE(PairMosaicSelectionTest)
+
+using IndexPairs = vector<tuple<size_t, size_t>>;
+
+BOOST_AUTO_TEST_CASE(materialise)
+{
+	BOOST_TEST(PairMosaicSelection({{1, 1}}, 0.5).materialise(4) == IndexPairs({{1, 1}, {1, 1}}));
+	BOOST_TEST(PairMosaicSelection({{1, 1}}, 1.0).materialise(4) == IndexPairs({{1, 1}, {1, 1}, {1, 1}, {1, 1}}));
+	BOOST_TEST(PairMosaicSelection({{1, 1}}, 2.0).materialise(4) == IndexPairs({{1, 1}, {1, 1}, {1, 1}, {1, 1}, {1, 1}, {1, 1}, {1, 1}, {1, 1}}));
+	BOOST_TEST(PairMosaicSelection({{1, 1}}, 1.0).materialise(2) == IndexPairs({{1, 1}, {1, 1}}));
+
+	IndexPairs pairs1{{0, 1}, {1, 0}};
+	BOOST_TEST(PairMosaicSelection(pairs1, 0.5).materialise(4) == IndexPairs({{0, 1}, {1, 0}}));
+	BOOST_TEST(PairMosaicSelection(pairs1, 1.0).materialise(4) == IndexPairs({{0, 1}, {1, 0}, {0, 1}, {1, 0}}));
+	BOOST_TEST(PairMosaicSelection(pairs1, 2.0).materialise(4) == IndexPairs({{0, 1}, {1, 0}, {0, 1}, {1, 0}, {0, 1}, {1, 0}, {0, 1}, {1, 0}}));
+	BOOST_TEST(PairMosaicSelection(pairs1, 1.0).materialise(2) == IndexPairs({{0, 1}, {1, 0}}));
+
+	IndexPairs pairs2{{3, 2}, {2, 3}, {1, 0}, {1, 1}};
+	BOOST_TEST(PairMosaicSelection(pairs2, 0.5).materialise(4) == IndexPairs({{3, 2}, {2, 3}}));
+	BOOST_TEST(PairMosaicSelection(pairs2, 1.0).materialise(4) == IndexPairs({{3, 2}, {2, 3}, {1, 0}, {1, 1}}));
+	BOOST_TEST(PairMosaicSelection(pairs2, 2.0).materialise(4) == IndexPairs({{3, 2}, {2, 3}, {1, 0}, {1, 1}, {3, 2}, {2, 3}, {1, 0}, {1, 1}}));
+
+	IndexPairs pairs3{{1, 0}, {1, 1}, {1, 0}, {1, 1}};
+	BOOST_TEST(PairMosaicSelection(pairs3, 1.0).materialise(2) == IndexPairs({{1, 0}, {1, 1}}));
+}
+
+BOOST_AUTO_TEST_CASE(materialise_should_round_indices)
+{
+	IndexPairs pairs{{4, 4}, {3, 3}, {2, 2}, {1, 1}, {0, 0}};
+	BOOST_TEST(PairMosaicSelection(pairs, 0.49).materialise(5) == IndexPairs({{4, 4}, {3, 3}}));
+	BOOST_TEST(PairMosaicSelection(pairs, 0.50).materialise(5) == IndexPairs({{4, 4}, {3, 3}, {2, 2}}));
+	BOOST_TEST(PairMosaicSelection(pairs, 0.51).materialise(5) == IndexPairs({{4, 4}, {3, 3}, {2, 2}}));
+}
+
+BOOST_AUTO_TEST_CASE(materialise_should_return_no_pairs_if_collection_is_empty)
+{
+	BOOST_TEST(PairMosaicSelection({{1, 1}}, 1.0).materialise(0).empty());
+	BOOST_TEST(PairMosaicSelection({{1, 1}, {3, 3}}, 2.0).materialise(0).empty());
+	BOOST_TEST(PairMosaicSelection({{5, 5}, {4, 4}, {3, 3}, {2, 2}}, 0.5).materialise(0).empty());
+}
+
+BOOST_AUTO_TEST_CASE(materialise_should_return_no_pairs_if_collection_has_one_element)
+{
+	IndexPairs pairs{{4, 4}, {3, 3}, {2, 2}, {1, 1}, {0, 0}};
+	BOOST_TEST(PairMosaicSelection(pairs, 0.0).materialise(1).empty());
+	BOOST_TEST(PairMosaicSelection(pairs, 0.5).materialise(1).empty());
+	BOOST_TEST(PairMosaicSelection(pairs, 1.0).materialise(1).empty());
+	BOOST_TEST(PairMosaicSelection(pairs, 7.0).materialise(1).empty());
+}
+
+BOOST_AUTO_TEST_CASE(materialise_should_clamp_indices_at_collection_size)
+{
+	IndexPairs pairs{{4, 4}, {3, 3}, {2, 2}, {1, 1}, {0, 0}};
+	BOOST_TEST(PairMosaicSelection(pairs, 1.0).materialise(4) == IndexPairs({{3, 3}, {3, 3}, {2, 2}, {1, 1}}));
+	BOOST_TEST(PairMosaicSelection(pairs, 2.0).materialise(3) == IndexPairs({{2, 2}, {2, 2}, {2, 2}, {1, 1}, {0, 0}, {2, 2}}));
+
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_SUITE_END()
+
+}

test/yulPhaser/Population.cpp

@@ -18,6 +18,7 @@
 #include <test/yulPhaser/Common.h>
 
 #include <tools/yulPhaser/Chromosome.h>
+#include <tools/yulPhaser/PairSelections.h>
 #include <tools/yulPhaser/Population.h>
 #include <tools/yulPhaser/Program.h>
 #include <tools/yulPhaser/Selections.h>
@@ -31,6 +32,7 @@
 
 #include <boost/test/unit_test.hpp>
 
+#include <cmath>
 #include <optional>
 #include <string>
 #include <sstream>
@@ -226,6 +228,70 @@ BOOST_FIXTURE_TEST_CASE(select_should_return_empty_population_if_selection_is_em
 	BOOST_TEST(population.select(selection).individuals().empty());
 }
 
+BOOST_FIXTURE_TEST_CASE(mutate_should_return_population_containing_individuals_indicated_by_selection_with_mutation_applied, PopulationFixture)
+{
+	Population population(m_fitnessMetric, {Chromosome("aa"), Chromosome("cc"), Chromosome("gg"), Chromosome("hh")});
+	RangeSelection selection(0.25, 0.75);
+	assert(selection.materialise(population.individuals().size()) == (vector<size_t>{1, 2}));
+
+	Population expectedPopulation(m_fitnessMetric, {Chromosome("fc"), Chromosome("fg")});
+
+	BOOST_TEST(population.mutate(selection, geneSubstitution(0, BlockFlattener::name)) == expectedPopulation);
+}
+
+BOOST_FIXTURE_TEST_CASE(mutate_should_include_duplicates_if_selection_contains_duplicates, PopulationFixture)
+{
+	Population population(m_fitnessMetric, {Chromosome("aa"), Chromosome("aa")});
+	RangeSelection selection(0.0, 1.0);
+	assert(selection.materialise(population.individuals().size()) == (vector<size_t>{0, 1}));
+
+	BOOST_TEST(
+		population.mutate(selection, geneSubstitution(0, BlockFlattener::name)) ==
+		Population(m_fitnessMetric, {Chromosome("fa"), Chromosome("fa")})
+	);
+}
+
+BOOST_FIXTURE_TEST_CASE(mutate_should_return_empty_population_if_selection_is_empty, PopulationFixture)
+{
+	Population population(m_fitnessMetric, {Chromosome("aa"), Chromosome("cc")});
+	RangeSelection selection(0.0, 0.0);
+	assert(selection.materialise(population.individuals().size()).empty());
+
+	BOOST_TEST(population.mutate(selection, geneSubstitution(0, BlockFlattener::name)).individuals().empty());
+}
+
+BOOST_FIXTURE_TEST_CASE(crossover_should_return_population_containing_individuals_indicated_by_selection_with_crossover_applied, PopulationFixture)
+{
+	Population population(m_fitnessMetric, {Chromosome("aa"), Chromosome("cc"), Chromosome("gg"), Chromosome("hh")});
+	PairMosaicSelection selection({{0, 1}, {2, 1}}, 1.0);
+	assert(selection.materialise(population.individuals().size()) == (vector<tuple<size_t, size_t>>{{0, 1}, {2, 1}, {0, 1}, {2, 1}}));
+
+	Population expectedPopulation(m_fitnessMetric, {Chromosome("ac"), Chromosome("ac"), Chromosome("gc"), Chromosome("gc")});
+
+	BOOST_TEST(population.crossover(selection, fixedPointCrossover(0.5)) == expectedPopulation);
+}
+
+BOOST_FIXTURE_TEST_CASE(crossover_should_include_duplicates_if_selection_contains_duplicates, PopulationFixture)
+{
+	Population population(m_fitnessMetric, {Chromosome("aa"), Chromosome("aa")});
+	PairMosaicSelection selection({{0, 0}, {1, 1}}, 2.0);
+	assert(selection.materialise(population.individuals().size()) == (vector<tuple<size_t, size_t>>{{0, 0}, {1, 1}, {0, 0}, {1, 1}}));
+
+	BOOST_TEST(
+		population.crossover(selection, fixedPointCrossover(0.5)) ==
+		Population(m_fitnessMetric, {Chromosome("aa"), Chromosome("aa"), Chromosome("aa"), Chromosome("aa")})
+	);
+}
+
+BOOST_FIXTURE_TEST_CASE(crossover_should_return_empty_population_if_selection_is_empty, PopulationFixture)
+{
+	Population population(m_fitnessMetric, {Chromosome("aa"), Chromosome("cc")});
+	PairMosaicSelection selection({}, 0.0);
+	assert(selection.materialise(population.individuals().size()).empty());
+
+	BOOST_TEST(population.crossover(selection, fixedPointCrossover(0.5)).individuals().empty());
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 BOOST_AUTO_TEST_SUITE_END()
 

tools/CMakeLists.txt

@@ -23,6 +23,10 @@ add_executable(yul-phaser
 	yulPhaser/FitnessMetrics.cpp
 	yulPhaser/Chromosome.h
 	yulPhaser/Chromosome.cpp
+	yulPhaser/Mutations.h
+	yulPhaser/Mutations.cpp
+	yulPhaser/PairSelections.h
+	yulPhaser/PairSelections.cpp
 	yulPhaser/Selections.h
 	yulPhaser/Selections.cpp
 	yulPhaser/Program.h

tools/yulPhaser/GeneticAlgorithms.cpp

@@ -16,7 +16,9 @@
 */
 
 #include <tools/yulPhaser/GeneticAlgorithms.h>
+#include <tools/yulPhaser/Mutations.h>
 #include <tools/yulPhaser/Selections.h>
+#include <tools/yulPhaser/PairSelections.h>
 
 using namespace std;
 using namespace solidity::phaser;
@@ -48,3 +50,28 @@ void RandomAlgorithm::runNextRound()
 			m_options.maxChromosomeLength
 		);
 }
+
+void GenerationalElitistWithExclusivePools::runNextRound()
+{
+	double elitePoolSize = 1.0 - (m_options.mutationPoolSize + m_options.crossoverPoolSize);
+	RangeSelection elite(0.0, elitePoolSize);
+
+	m_population =
+		m_population.select(elite) +
+		m_population.select(elite).mutate(
+			RandomSelection(m_options.mutationPoolSize / elitePoolSize),
+			alternativeMutations(
+				m_options.randomisationChance,
+				geneRandomisation(m_options.percentGenesToRandomise),
+				alternativeMutations(
+					m_options.deletionVsAdditionChance,
+					geneDeletion(m_options.percentGenesToAddOrDelete),
+					geneAddition(m_options.percentGenesToAddOrDelete)
+				)
+			)
+		) +
+		m_population.select(elite).crossover(
+			RandomPairSelection(m_options.crossoverPoolSize / elitePoolSize),
+			randomPointCrossover()
+		);
+}

tools/yulPhaser/GeneticAlgorithms.h

@@ -112,4 +112,57 @@ private:
 	Options m_options;
 };
 
+/**
+ * A generational, elitist genetic algorithm that replaces the population by mutating and crossing
+ * over chromosomes from the elite.
+ *
+ * The elite consists of individuals not included in the crossover and mutation pools.
+ * The crossover operator used is @a randomPointCrossover. The mutation operator is randomly chosen
+ * from three possibilities: @a geneRandomisation, @a geneDeletion or @a geneAddition (with
+ * configurable probabilities). Each mutation also has a parameter determining the chance of a gene
+ * being affected by it.
+ */
+class GenerationalElitistWithExclusivePools: public GeneticAlgorithm
+{
+public:
+	struct Options
+	{
+		double mutationPoolSize;          ///< Percentage of population to regenerate using mutations in each round.
+		double crossoverPoolSize;         ///< Percentage of population to regenerate using crossover in each round.
+		double randomisationChance;       ///< The chance of choosing @a geneRandomisation as the mutation to perform
+		double deletionVsAdditionChance;  ///< The chance of choosing @a geneDeletion as the mutation if randomisation was not chosen.
+		double percentGenesToRandomise;   ///< The chance of any given gene being mutated in gene randomisation.
+		double percentGenesToAddOrDelete; ///< The chance of a gene being added (or deleted) in gene addition (or deletion).
+
+		bool isValid() const
+		{
+			return (
+				0 <= mutationPoolSize && mutationPoolSize <= 1.0 &&
+				0 <= crossoverPoolSize && crossoverPoolSize <= 1.0 &&
+				0 <= randomisationChance && randomisationChance <= 1.0 &&
+				0 <= deletionVsAdditionChance && deletionVsAdditionChance <= 1.0 &&
+				0 <= percentGenesToRandomise && percentGenesToRandomise <= 1.0 &&
+				0 <= percentGenesToAddOrDelete && percentGenesToAddOrDelete <= 1.0 &&
+				mutationPoolSize + crossoverPoolSize <= 1.0
+			);
+		}
+	};
+
+	GenerationalElitistWithExclusivePools(
+		Population _initialPopulation,
+		std::ostream& _outputStream,
+		Options const& _options
+	):
+		GeneticAlgorithm(_initialPopulation, _outputStream),
+		m_options(_options)
+	{
+		assert(_options.isValid());
+	}
+
+	void runNextRound() override;
+
+private:
+	Options m_options;
+};
+
 }

tools/yulPhaser/Mutations.cpp

@@ -0,0 +1,147 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <tools/yulPhaser/Mutations.h>
+
+#include <tools/yulPhaser/SimulationRNG.h>
+
+#include <libsolutil/CommonData.h>
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <string>
+#include <vector>
+
+using namespace std;
+using namespace solidity;
+using namespace solidity::phaser;
+
+function<Mutation> phaser::geneRandomisation(double _chance)
+{
+	return [=](Chromosome const& _chromosome)
+	{
+		vector<string> optimisationSteps;
+		for (auto const& step: _chromosome.optimisationSteps())
+			optimisationSteps.push_back(
+				SimulationRNG::bernoulliTrial(_chance) ?
+				Chromosome::randomOptimisationStep() :
+				step
+			);
+
+		return Chromosome(move(optimisationSteps));
+	};
+}
+
+function<Mutation> phaser::geneDeletion(double _chance)
+{
+	return [=](Chromosome const& _chromosome)
+	{
+		vector<string> optimisationSteps;
+		for (auto const& step: _chromosome.optimisationSteps())
+			if (!SimulationRNG::bernoulliTrial(_chance))
+				optimisationSteps.push_back(step);
+
+		return Chromosome(move(optimisationSteps));
+	};
+}
+
+function<Mutation> phaser::geneAddition(double _chance)
+{
+	return [=](Chromosome const& _chromosome)
+	{
+		vector<string> optimisationSteps;
+
+		if (SimulationRNG::bernoulliTrial(_chance))
+			optimisationSteps.push_back(Chromosome::randomOptimisationStep());
+
+		for (auto const& step: _chromosome.optimisationSteps())
+		{
+			optimisationSteps.push_back(step);
+			if (SimulationRNG::bernoulliTrial(_chance))
+				optimisationSteps.push_back(Chromosome::randomOptimisationStep());
+		}
+
+		return Chromosome(move(optimisationSteps));
+	};
+}
+
+function<Mutation> phaser::alternativeMutations(
+	double _firstMutationChance,
+	function<Mutation> _mutation1,
+	function<Mutation> _mutation2
+)
+{
+	return [=](Chromosome const& _chromosome)
+	{
+		if (SimulationRNG::bernoulliTrial(_firstMutationChance))
+			return _mutation1(_chromosome);
+		else
+			return _mutation2(_chromosome);
+	};
+}
+
+namespace
+{
+
+Chromosome buildChromosomesBySwappingParts(
+	Chromosome const& _chromosome1,
+	Chromosome const& _chromosome2,
+	size_t _crossoverPoint
+)
+{
+	assert(_crossoverPoint <= _chromosome1.length());
+	assert(_crossoverPoint <= _chromosome2.length());
+
+	auto begin1 = _chromosome1.optimisationSteps().begin();
+	auto begin2 = _chromosome2.optimisationSteps().begin();
+
+	return Chromosome(
+		vector<string>(begin1, begin1 + _crossoverPoint) +
+		vector<string>(begin2 + _crossoverPoint, _chromosome2.optimisationSteps().end())
+	);
+}
+
+}
+
+function<Crossover> phaser::randomPointCrossover()
+{
+	return [=](Chromosome const& _chromosome1, Chromosome const& _chromosome2)
+	{
+		size_t minLength = min(_chromosome1.length(), _chromosome2.length());
+
+		// Don't use position 0 (because this just swaps the values) unless it's the only choice.
+		size_t minPoint = (minLength > 0? 1 : 0);
+		assert(minPoint <= minLength);
+
+		size_t randomPoint = SimulationRNG::uniformInt(minPoint, minLength);
+		return buildChromosomesBySwappingParts(_chromosome1, _chromosome2, randomPoint);
+	};
+}
+
+function<Crossover> phaser::fixedPointCrossover(double _crossoverPoint)
+{
+	assert(0.0 <= _crossoverPoint && _crossoverPoint <= 1.0);
+
+	return [=](Chromosome const& _chromosome1, Chromosome const& _chromosome2)
+	{
+		size_t minLength = min(_chromosome1.length(), _chromosome2.length());
+		size_t concretePoint = static_cast<size_t>(round(minLength * _crossoverPoint));
+
+		return buildChromosomesBySwappingParts(_chromosome1, _chromosome2, concretePoint);
+	};
+}

tools/yulPhaser/Mutations.h

@@ -0,0 +1,73 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * Mutation and crossover operators for use in genetic algorithms.
+ */
+
+#pragma once
+
+#include <tools/yulPhaser/Chromosome.h>
+
+#include <functional>
+#include <tuple>
+
+namespace solidity::phaser
+{
+
+using Mutation = Chromosome(Chromosome const&);
+using Crossover = Chromosome(Chromosome const&, Chromosome const&);
+
+// MUTATIONS
+
+/// Creates a mutation operator that iterates over all genes in a chromosome and with probability
+/// @a _chance replaces a gene with a random one (which could also be the same as the original).
+std::function<Mutation> geneRandomisation(double _chance);
+
+/// Creates a mutation operator that iterates over all genes in a chromosome and with probability
+/// @a _chance deletes it.
+std::function<Mutation> geneDeletion(double _chance);
+
+/// Creates a mutation operator that iterates over all positions in a chromosome (including spots
+/// at the beginning and at the end of the sequence) and with probability @a _chance insert a new,
+/// randomly chosen gene.
+std::function<Mutation> geneAddition(double _chance);
+
+/// Creates a mutation operator that always applies one of the mutations passed to it.
+/// The probability that the chosen mutation is the first one is @a _firstMutationChance.
+/// randomly chosen gene.
+std::function<Mutation> alternativeMutations(
+	double _firstMutationChance,
+	std::function<Mutation> _mutation1,
+	std::function<Mutation> _mutation2
+);
+
+// CROSSOVER
+
+/// Creates a crossover operator that randomly selects a number between 0 and 1 and uses it as the
+/// position at which to perform perform @a fixedPointCrossover.
+std::function<Crossover> randomPointCrossover();
+
+/// Creates a crossover operator that always chooses a point that lies at @a _crossoverPoint
+/// percent of the length of the shorter chromosome. Then creates a new chromosome by
+/// splitting both inputs at the crossover point and stitching output from the first half or first
+/// input and the second half of the second input.
+///
+/// Avoids selecting position 0 (since this just produces a chromosome identical to the second one)
+/// unless there is no other choice (i.e. one of the chromosomes is empty).
+std::function<Crossover> fixedPointCrossover(double _crossoverPoint);
+
+}

tools/yulPhaser/PairSelections.cpp

@@ -0,0 +1,65 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <tools/yulPhaser/PairSelections.h>
+
+#include <tools/yulPhaser/SimulationRNG.h>
+
+#include <cmath>
+
+using namespace std;
+using namespace solidity::phaser;
+
+vector<tuple<size_t, size_t>> RandomPairSelection::materialise(size_t _poolSize) const
+{
+	if (_poolSize < 2)
+		return {};
+
+	size_t count = static_cast<size_t>(round(_poolSize * m_selectionSize));
+
+	vector<tuple<size_t, size_t>> selection;
+	for (size_t i = 0; i < count; ++i)
+	{
+		size_t index1 = SimulationRNG::uniformInt(0, _poolSize - 1);
+		size_t index2;
+		do
+		{
+			index2 = SimulationRNG::uniformInt(0, _poolSize - 1);
+		} while (index1 == index2);
+
+		selection.push_back({index1, index2});
+	}
+
+	return selection;
+}
+
+vector<tuple<size_t, size_t>> PairMosaicSelection::materialise(size_t _poolSize) const
+{
+	if (_poolSize < 2)
+		return {};
+
+	size_t count = static_cast<size_t>(round(_poolSize * m_selectionSize));
+
+	vector<tuple<size_t, size_t>> selection;
+	for (size_t i = 0; i < count; ++i)
+	{
+		tuple<size_t, size_t> pair = m_pattern[i % m_pattern.size()];
+		selection.push_back({min(get<0>(pair), _poolSize - 1), min(get<1>(pair), _poolSize - 1)});
+	}
+
+	return selection;
+}

tools/yulPhaser/PairSelections.h

@@ -0,0 +1,99 @@
+/*
+	This file is part of solidity.
+
+	solidity is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	solidity is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * Contains an abstract base class representing a selection of pairs of elements from a collection
+ * and its concrete implementations.
+ */
+
+#pragma once
+
+#include <cassert>
+#include <tuple>
+#include <vector>
+
+namespace solidity::phaser
+{
+
+/**
+ * Abstract base class for selections of pairs elements from a collection.
+ *
+ * An instance of this class represents a specific method of selecting a set of pairs of elements
+ * from containers of arbitrary sizes. The selected pairs always point at a subset of the elements
+ * from the container but may indicate the same element more than once. The pairs themselves can
+ * repeat too. The selection may or may not be fixed - it's up to a specific implementation whether
+ * subsequent calls for the same container produce the same indices or not.
+ *
+ * Derived classes are meant to override the @a materialise() method.
+ * This method is expected to produce pairs of selected elements given the size of the collection.
+ */
+class PairSelection
+{
+public:
+	PairSelection() = default;
+	PairSelection(PairSelection const&) = delete;
+	PairSelection& operator=(PairSelection const&) = delete;
+	virtual ~PairSelection() = default;
+
+	virtual std::vector<std::tuple<size_t, size_t>> materialise(size_t _poolSize) const = 0;
+};
+
+/**
+ * A selection that selects pairs of random elements from a container. The resulting set of pairs
+ * may contain the same pair more than once but does not contain pairs of duplicates. Always
+ * selects as many pairs as the size of the container multiplied by @a _selectionSize (unless the
+ * container is empty).
+ */
+class RandomPairSelection: public PairSelection
+{
+public:
+	explicit RandomPairSelection(double _selectionSize):
+		m_selectionSize(_selectionSize) {}
+
+	std::vector<std::tuple<size_t, size_t>> materialise(size_t _poolSize) const override;
+
+private:
+	double m_selectionSize;
+};
+
+/**
+ * A selection that selects pairs of elements at specific, fixed positions indicated by a repeating
+ * "pattern". If the positions in the pattern exceed the size of the container, they are capped at
+ * the maximum available position. Always selects as many pairs as the size of the container
+ * multiplied by @a _selectionSize (unless the container is empty).
+ *
+ * E.g. if the pattern is {{0, 1}, {3, 9}} and collection size is 5, the selection will materialise
+ * into {{0, 1}, {3, 4}, {0, 1}, {3, 4}, {0, 1}}. If the size is 3, it will be
+ * {{0, 1}, {2, 2}, {0, 1}}.
+ */
+class PairMosaicSelection: public PairSelection
+{
+public:
+	explicit PairMosaicSelection(std::vector<std::tuple<size_t, size_t>> _pattern, double _selectionSize = 1.0):
+		m_pattern(move(_pattern)),
+		m_selectionSize(_selectionSize)
+	{
+		assert(m_pattern.size() > 0 || _selectionSize == 0.0);
+	}
+
+	std::vector<std::tuple<size_t, size_t>> materialise(size_t _poolSize) const override;
+
+private:
+	std::vector<std::tuple<size_t, size_t>> m_pattern;
+	double m_selectionSize;
+};
+
+}

tools/yulPhaser/Population.cpp

@@ -17,6 +17,7 @@
 
 #include <tools/yulPhaser/Population.h>
 
+#include <tools/yulPhaser/PairSelections.h>
 #include <tools/yulPhaser/Selections.h>
 
 #include <libsolutil/CommonData.h>
@@ -93,6 +94,30 @@ Population Population::select(Selection const& _selection) const
 	return Population(m_fitnessMetric, selectedIndividuals);
 }
 
+Population Population::mutate(Selection const& _selection, function<Mutation> _mutation) const
+{
+	vector<Individual> mutatedIndividuals;
+	for (size_t i: _selection.materialise(m_individuals.size()))
+		mutatedIndividuals.emplace_back(_mutation(m_individuals[i].chromosome), *m_fitnessMetric);
+
+	return Population(m_fitnessMetric, mutatedIndividuals);
+}
+
+Population Population::crossover(PairSelection const& _selection, function<Crossover> _crossover) const
+{
+	vector<Individual> crossedIndividuals;
+	for (auto const& [i, j]: _selection.materialise(m_individuals.size()))
+	{
+		auto childChromosome = _crossover(
+			m_individuals[i].chromosome,
+			m_individuals[j].chromosome
+		);
+		crossedIndividuals.emplace_back(move(childChromosome), *m_fitnessMetric);
+	}
+
+	return Population(m_fitnessMetric, crossedIndividuals);
+}
+
 Population operator+(Population _a, Population _b)
 {
 	// This operator is meant to be used only with populations sharing the same metric (and, to make

tools/yulPhaser/Population.h

@@ -19,6 +19,7 @@
 
 #include <tools/yulPhaser/Chromosome.h>
 #include <tools/yulPhaser/FitnessMetrics.h>
+#include <tools/yulPhaser/Mutations.h>
 #include <tools/yulPhaser/SimulationRNG.h>
 
 #include <optional>
@@ -39,6 +40,7 @@ solidity::phaser::Population operator+(solidity::phaser::Population _a, solidity
 namespace solidity::phaser
 {
 
+class PairSelection;
 class Selection;
 
 /**
@@ -104,6 +106,8 @@ public:
 	);
 
 	Population select(Selection const& _selection) const;
+	Population mutate(Selection const& _selection, std::function<Mutation> _mutation) const;
+	Population crossover(PairSelection const& _selection, std::function<Crossover> _crossover) const;
 	friend Population (::operator+)(Population _a, Population _b);
 
 	std::shared_ptr<FitnessMetric const> fitnessMetric() const { return m_fitnessMetric; }

tools/yulPhaser/main.cpp

@@ -39,6 +39,39 @@ using namespace solidity::util;
 
 namespace po = boost::program_options;
 
+enum class Algorithm
+{
+	Random,
+	GEWEP
+};
+
+istream& operator>>(istream& inputStream, Algorithm& algorithm)
+{
+	string value;
+	inputStream >> value;
+
+	if (value == "random")
+		algorithm = Algorithm::Random;
+	else if (value == "GEWEP")
+		algorithm = Algorithm::GEWEP;
+	else
+		inputStream.setstate(ios_base::failbit);
+
+	return inputStream;
+}
+
+ostream& operator<<(ostream& outputStream, Algorithm algorithm)
+{
+	if (algorithm == Algorithm::Random)
+		outputStream << "random";
+	else if (algorithm == Algorithm::GEWEP)
+		outputStream << "GEWEP";
+	else
+		outputStream.setstate(ios_base::failbit);
+
+	return outputStream;
+}
+
 namespace
 {
 
@@ -49,7 +82,7 @@ struct CommandLineParsingResult
 };
 
 
-void initializeRNG(po::variables_map const& arguments)
+void initialiseRNG(po::variables_map const& arguments)
 {
 	uint32_t seed;
 	if (arguments.count("seed") > 0)
@@ -69,7 +102,7 @@ CharStream loadSource(string const& _sourcePath)
 	return CharStream(sourceCode, _sourcePath);
 }
 
-void runAlgorithm(string const& _sourcePath)
+void runAlgorithm(string const& _sourcePath, Algorithm _algorithm)
 {
 	constexpr size_t populationSize = 20;
 	constexpr size_t minChromosomeLength = 12;
@@ -83,15 +116,41 @@ void runAlgorithm(string const& _sourcePath)
 		minChromosomeLength,
 		maxChromosomeLength
 	);
-	RandomAlgorithm(
+
-		population,
+	switch (_algorithm)
-		cout,
+	{
+		case Algorithm::Random:
 		{
-			/* elitePoolSize = */ 1.0 / populationSize,
+			RandomAlgorithm(
-			/* minChromosomeLength = */ minChromosomeLength,
+				population,
-			/* maxChromosomeLength = */ maxChromosomeLength,
+				cout,
+				{
+					/* elitePoolSize = */ 1.0 / populationSize,
+					/* minChromosomeLength = */ minChromosomeLength,
+					/* maxChromosomeLength = */ maxChromosomeLength,
+				}
+			).run();
+
+			break;
 		}
-	).run();
+		case Algorithm::GEWEP:
+		{
+			GenerationalElitistWithExclusivePools(
+				population,
+				cout,
+				{
+					/* mutationPoolSize = */ 0.25,
+					/* crossoverPoolSize = */ 0.25,
+					/* randomisationChance = */ 0.9,
+					/* deletionVsAdditionChance = */ 0.5,
+					/* percentGenesToRandomise = */ 1.0 / maxChromosomeLength,
+					/* percentGenesToAddOrDelete = */ 1.0 / maxChromosomeLength,
+				}
+			).run();
+
+			break;
+		}
+	}
 }
 
 CommandLineParsingResult parseCommandLine(int argc, char** argv)
@@ -114,6 +173,11 @@ CommandLineParsingResult parseCommandLine(int argc, char** argv)
 		("help", "Show help message and exit.")
 		("input-file", po::value<string>()->required(), "Input file")
 		("seed", po::value<uint32_t>(), "Seed for the random number generator")
+		(
+			"algorithm",
+			po::value<Algorithm>()->default_value(Algorithm::GEWEP),
+			"Algorithm"
+		)
 	;
 
 	po::positional_options_description positionalDescription;
@@ -156,11 +220,14 @@ int main(int argc, char** argv)
 	if (parsingResult.exitCode != 0)
 		return parsingResult.exitCode;
 
-	initializeRNG(parsingResult.arguments);
+	initialiseRNG(parsingResult.arguments);
 
 	try
 	{
-		runAlgorithm(parsingResult.arguments["input-file"].as<string>());
+		runAlgorithm(
+			parsingResult.arguments["input-file"].as<string>(),
+			parsingResult.arguments["algorithm"].as<Algorithm>()
+		);
 	}
 	catch (InvalidProgram const& _exception)
 	{