[yul-phaser] Mutations: Add two-point and uniform crossover operators

test/yulPhaser/Mutations.cpp

@@ -18,15 +18,17 @@
 #include <test/yulPhaser/TestHelpers.h>
 
 #include <tools/yulPhaser/Mutations.h>
-
 #include <tools/yulPhaser/SimulationRNG.h>
 
+#include <libsolutil/CommonIO.h>
+
 #include <boost/test/unit_test.hpp>
 
 #include <algorithm>
 #include <vector>
 
 using namespace std;
+using namespace solidity::util;
 
 namespace solidity::phaser::test
 {
@@ -434,6 +436,181 @@ BOOST_AUTO_TEST_CASE(fixedPointCrossover_should_always_use_position_zero_as_spli
 	BOOST_CHECK(crossover10(empty, splittable) == splittable);
 }
 
+BOOST_AUTO_TEST_CASE(randomTwoPointCrossover_should_swap_chromosome_parts_between_two_random_points)
+{
+	function<Crossover> crossover = randomTwoPointCrossover();
+
+	SimulationRNG::reset(1);
+	Chromosome result1 = crossover(Chromosome("aaaaaaaaaa"), Chromosome("cccccc"));
+	BOOST_TEST(result1 == Chromosome("aaacccaaaa"));
+
+	SimulationRNG::reset(1);
+	Chromosome result2 = crossover(Chromosome("cccccc"), Chromosome("aaaaaaaaaa"));
+	BOOST_TEST(result2 == Chromosome("cccaaa"));
+}
+
+BOOST_AUTO_TEST_CASE(symmetricRandomTwoPointCrossover_should_swap_chromosome_parts_at_random_point)
+{
+	function<SymmetricCrossover> crossover = symmetricRandomTwoPointCrossover();
+
+	SimulationRNG::reset(1);
+	tuple<Chromosome, Chromosome> result1 = crossover(Chromosome("aaaaaaaaaa"), Chromosome("cccccc"));
+	tuple<Chromosome, Chromosome> expectedPair1 = {Chromosome("aaacccaaaa"), Chromosome("cccaaa")};
+	BOOST_TEST(result1 == expectedPair1);
+
+	tuple<Chromosome, Chromosome> result2 = crossover(Chromosome("cccccc"), Chromosome("aaaaaaaaaa"));
+	tuple<Chromosome, Chromosome> expectedPair2 = {Chromosome("ccccca"), Chromosome("aaaaacaaaa")};
+	BOOST_TEST(result2 == expectedPair2);
+}
+
+BOOST_AUTO_TEST_CASE(randomTwoPointCrossover_should_only_consider_points_available_on_both_chromosomes)
+{
+	function<Crossover> crossover = randomTwoPointCrossover();
+
+	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("aaa") ||
+			result1 == Chromosome("Taa") ||
+			result1 == Chromosome("TTa") ||
+			result1 == Chromosome("TTT") ||
+			result1 == Chromosome("aTa") ||
+			result1 == Chromosome("aTT") ||
+			result1 == Chromosome("aaT")
+		));
+		BOOST_TEST((
+			result2 == Chromosome("TTTTTTTTTTTTTTTTTTTT") ||
+			result2 == Chromosome("aTTTTTTTTTTTTTTTTTTT") ||
+			result2 == Chromosome("aaTTTTTTTTTTTTTTTTTT") ||
+			result2 == Chromosome("aaaTTTTTTTTTTTTTTTTT") ||
+			result2 == Chromosome("TaTTTTTTTTTTTTTTTTTT") ||
+			result2 == Chromosome("TaaTTTTTTTTTTTTTTTTT") ||
+			result2 == Chromosome("TTaTTTTTTTTTTTTTTTTT")
+		));
+	}
+}
+
+BOOST_AUTO_TEST_CASE(uniformCrossover_should_swap_randomly_selected_genes)
+{
+	function<Crossover> crossover = uniformCrossover(0.7);
+
+	SimulationRNG::reset(1);
+	Chromosome result1 = crossover(Chromosome("aaaaaaaaaa"), Chromosome("cccccc"));
+	BOOST_TEST(result1 == Chromosome("caaacc"));
+
+	SimulationRNG::reset(1);
+	Chromosome result2 = crossover(Chromosome("cccccc"), Chromosome("aaaaaaaaaa"));
+	BOOST_TEST(result2 == Chromosome("acccaaaaaa"));
+}
+
+BOOST_AUTO_TEST_CASE(symmetricUniformCrossover_should_swap_randomly_selected_genes)
+{
+	function<SymmetricCrossover> crossover = symmetricUniformCrossover(0.7);
+
+	SimulationRNG::reset(1);
+	tuple<Chromosome, Chromosome> result1 = crossover(Chromosome("aaaaaaaaaa"), Chromosome("cccccc"));
+	tuple<Chromosome, Chromosome> expectedPair1 = {Chromosome("caaacc"), Chromosome("acccaaaaaa")};
+	BOOST_TEST(result1 == expectedPair1);
+
+	tuple<Chromosome, Chromosome> result2 = crossover(Chromosome("cccccc"), Chromosome("aaaaaaaaaa"));
+	tuple<Chromosome, Chromosome> expectedPair2 = {Chromosome("caaaaaaaaa"), Chromosome("accccc")};
+	BOOST_TEST(result2 == expectedPair2);
+}
+
+BOOST_AUTO_TEST_CASE(uniformCrossover_should_only_consider_points_available_on_both_chromosomes)
+{
+	function<Crossover> crossover = uniformCrossover(0.7);
+
+	set<string> expectedPatterns = {
+		"TTTTTTTTTTTTTTTTTTTT",
+		"aTTTTTTTTTTTTTTTTTTT",
+		"TaTTTTTTTTTTTTTTTTTT",
+		"TTaTTTTTTTTTTTTTTTTT",
+		"aaTTTTTTTTTTTTTTTTTT",
+		"TaaTTTTTTTTTTTTTTTTT",
+		"aTaTTTTTTTTTTTTTTTTT",
+		"aaaTTTTTTTTTTTTTTTTT",
+		"aaa",
+		"Taa",
+		"aTa",
+		"aaT",
+		"TTa",
+		"aTT",
+		"TaT",
+		"TTT",
+	};
+
+	for (size_t i = 0; i < 30; ++i)
+	{
+		Chromosome result1 = crossover(Chromosome("aaa"), Chromosome("TTTTTTTTTTTTTTTTTTTT"));
+		Chromosome result2 = crossover(Chromosome("TTTTTTTTTTTTTTTTTTTT"), Chromosome("aaa"));
+		BOOST_TEST(expectedPatterns.count(toString(result1)) == 1);
+		BOOST_TEST(expectedPatterns.count(toString(result2)) == 1);
+	}
+}
+
+BOOST_AUTO_TEST_CASE(uniformCrossover_should_not_swap_anything_if_chance_is_zero)
+{
+	BOOST_TEST(uniformCrossover(0.0)(Chromosome("aaaaaaaaaa"), Chromosome("cccccc")) == Chromosome("aaaaaaaaaa"));
+	BOOST_TEST(uniformCrossover(0.0)(Chromosome("cccccc"), Chromosome("aaaaaaaaaa")) == Chromosome("cccccc"));
+}
+
+BOOST_AUTO_TEST_CASE(uniformCrossover_should_swap_whole_chromosomes_if_chance_is_one)
+{
+	BOOST_TEST(uniformCrossover(1.0)(Chromosome("aaaaaaaaaa"), Chromosome("cccccc")) == Chromosome("cccccc"));
+	BOOST_TEST(uniformCrossover(1.0)(Chromosome("cccccc"), Chromosome("aaaaaaaaaa")) == Chromosome("aaaaaaaaaa"));
+}
+
+BOOST_AUTO_TEST_CASE(uniformCrossover_should_swap_genes_with_uniform_probability)
+{
+	constexpr size_t operationCount = 1000;
+	constexpr double swapChance = 0.8;
+	constexpr double relativeTolerance = 0.05;
+	double const expectedValue = swapChance;
+	double const variance = swapChance * (1 - swapChance);
+
+	function<Crossover> crossover = uniformCrossover(swapChance);
+	Chromosome chromosome1("aaaaaaaaaa");
+	Chromosome chromosome2("cccccccccc");
+
+	vector<size_t> bernoulliTrials;
+	for (size_t i = 0; i < operationCount; ++i)
+	{
+		string genes = toString(crossover(chromosome1, chromosome2));
+		for (size_t j = 0; j < chromosome1.length(); ++j)
+			bernoulliTrials.push_back(static_cast<size_t>(genes[j] == 'c'));
+	}
+
+	BOOST_TEST(abs(mean(bernoulliTrials) - expectedValue) < expectedValue * relativeTolerance);
+	BOOST_TEST(abs(meanSquaredError(bernoulliTrials, expectedValue) - variance) < variance * relativeTolerance);
+}
+
+BOOST_AUTO_TEST_CASE(uniformCrossover_should_swap_tail_with_uniform_probability)
+{
+	constexpr size_t operationCount = 1000;
+	constexpr double swapChance = 0.3;
+	constexpr double relativeTolerance = 0.05;
+	double const expectedValue = swapChance;
+	double const variance = swapChance * (1 - swapChance);
+
+	function<Crossover> crossover = uniformCrossover(swapChance);
+	Chromosome chromosome1("aaaaa");
+	Chromosome chromosome2("cccccccccc");
+
+	vector<size_t> bernoulliTrials;
+	for (size_t i = 0; i < operationCount; ++i)
+	{
+		string genes = toString(crossover(chromosome1, chromosome2));
+		BOOST_REQUIRE(genes.size() == 5 || genes.size() == 10);
+		bernoulliTrials.push_back(static_cast<size_t>(genes.size() == 10));
+	}
+
+	BOOST_TEST(abs(mean(bernoulliTrials) - expectedValue) < expectedValue * relativeTolerance);
+	BOOST_TEST(abs(meanSquaredError(bernoulliTrials, expectedValue) - variance) < variance * relativeTolerance);
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 BOOST_AUTO_TEST_SUITE_END()
 BOOST_AUTO_TEST_SUITE_END()

tools/yulPhaser/Mutations.cpp

@@ -180,3 +180,138 @@ function<Crossover> phaser::fixedPointCrossover(double _crossoverPoint)
 		return get<0>(fixedPointSwap(_chromosome1, _chromosome2, concretePoint));
 	};
 }
+
+namespace
+{
+
+ChromosomePair fixedTwoPointSwap(
+	Chromosome const& _chromosome1,
+	Chromosome const& _chromosome2,
+	size_t _crossoverPoint1,
+	size_t _crossoverPoint2
+)
+{
+	assert(_crossoverPoint1 <= _chromosome1.length());
+	assert(_crossoverPoint1 <= _chromosome2.length());
+	assert(_crossoverPoint2 <= _chromosome1.length());
+	assert(_crossoverPoint2 <= _chromosome2.length());
+
+	size_t lowPoint = min(_crossoverPoint1, _crossoverPoint2);
+	size_t highPoint = max(_crossoverPoint1, _crossoverPoint2);
+
+	auto begin1 = _chromosome1.optimisationSteps().begin();
+	auto begin2 = _chromosome2.optimisationSteps().begin();
+	auto end1 = _chromosome1.optimisationSteps().end();
+	auto end2 = _chromosome2.optimisationSteps().end();
+
+	return {
+		Chromosome(
+			vector<string>(begin1, begin1 + lowPoint) +
+			vector<string>(begin2 + lowPoint, begin2 + highPoint) +
+			vector<string>(begin1 + highPoint, end1)
+		),
+		Chromosome(
+			vector<string>(begin2, begin2 + lowPoint) +
+			vector<string>(begin1 + lowPoint, begin1 + highPoint) +
+			vector<string>(begin2 + highPoint, end2)
+		),
+	};
+}
+
+}
+
+function<Crossover> phaser::randomTwoPointCrossover()
+{
+	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 randomPoint1 = SimulationRNG::uniformInt(minPoint, minLength);
+		size_t randomPoint2 = SimulationRNG::uniformInt(randomPoint1, minLength);
+		return get<0>(fixedTwoPointSwap(_chromosome1, _chromosome2, randomPoint1, randomPoint2));
+	};
+}
+
+function<SymmetricCrossover> phaser::symmetricRandomTwoPointCrossover()
+{
+	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 randomPoint1 = SimulationRNG::uniformInt(minPoint, minLength);
+		size_t randomPoint2 = SimulationRNG::uniformInt(randomPoint1, minLength);
+		return fixedTwoPointSwap(_chromosome1, _chromosome2, randomPoint1, randomPoint2);
+	};
+}
+
+namespace
+{
+
+ChromosomePair uniformSwap(Chromosome const& _chromosome1, Chromosome const& _chromosome2, double _swapChance)
+{
+	vector<string> steps1;
+	vector<string> steps2;
+
+	size_t minLength = min(_chromosome1.length(), _chromosome2.length());
+	for (size_t i = 0; i < minLength; ++i)
+		if (SimulationRNG::bernoulliTrial(_swapChance))
+		{
+			steps1.push_back(_chromosome2.optimisationSteps()[i]);
+			steps2.push_back(_chromosome1.optimisationSteps()[i]);
+		}
+		else
+		{
+			steps1.push_back(_chromosome1.optimisationSteps()[i]);
+			steps2.push_back(_chromosome2.optimisationSteps()[i]);
+		}
+
+	auto begin1 = _chromosome1.optimisationSteps().begin();
+	auto begin2 = _chromosome2.optimisationSteps().begin();
+	auto end1 = _chromosome1.optimisationSteps().end();
+	auto end2 = _chromosome2.optimisationSteps().end();
+
+	bool swapTail = SimulationRNG::bernoulliTrial(_swapChance);
+	if (_chromosome1.length() > minLength)
+	{
+		if (swapTail)
+			steps2.insert(steps2.end(), begin1 + minLength, end1);
+		else
+			steps1.insert(steps1.end(), begin1 + minLength, end1);
+	}
+
+	if (_chromosome2.length() > minLength)
+	{
+		if (swapTail)
+			steps1.insert(steps1.end(), begin2 + minLength, end2);
+		else
+			steps2.insert(steps2.end(), begin2 + minLength, end2);
+	}
+
+	return {Chromosome(steps1), Chromosome(steps2)};
+}
+
+}
+
+function<Crossover> phaser::uniformCrossover(double _swapChance)
+{
+	return [=](Chromosome const& _chromosome1, Chromosome const& _chromosome2)
+	{
+		return get<0>(uniformSwap(_chromosome1, _chromosome2, _swapChance));
+	};
+}
+
+function<SymmetricCrossover> phaser::symmetricUniformCrossover(double _swapChance)
+{
+	return [=](Chromosome const& _chromosome1, Chromosome const& _chromosome2)
+	{
+		return uniformSwap(_chromosome1, _chromosome2, _swapChance);
+	};
+}

tools/yulPhaser/Mutations.h

@@ -80,4 +80,22 @@ std::function<SymmetricCrossover> symmetricRandomPointCrossover();
 /// unless there is no other choice (i.e. one of the chromosomes is empty).
 std::function<Crossover> fixedPointCrossover(double _crossoverPoint);
 
+/// Creates a crossover operator that randomly selects two points between 0 and 1 and swaps genes
+/// from the resulting interval. The interval may be empty in which case no genes are swapped.
+std::function<Crossover> randomTwoPointCrossover();
+
+/// Symmetric version of @a randomTwoPointCrossover(). Creates an operator that returns a pair
+/// containing both possible results for the same crossover points.
+std::function<SymmetricCrossover> symmetricRandomTwoPointCrossover();
+
+/// Creates a crossover operator that goes over the length of the shorter chromosomes and for
+/// each gene independently decides whether to swap it or not (with probability given by
+/// @a _swapChance). The tail of the longer chromosome (the part that's past the length of the
+/// shorter one) is treated as a single gene and can potentially be swapped too.
+std::function<Crossover> uniformCrossover(double _swapChance);
+
+/// Symmetric version of @a uniformCrossover(). Creates an operator that returns a pair
+/// containing both possible results for the same set or swap decisions.
+std::function<SymmetricCrossover> symmetricUniformCrossover(double _swapChance);
+
 }